Add files using upload-large-folder tool

.gitattributes

@@ -202,3 +202,7 @@ aobasis/siesta.DM filter=lfs diff=lfs merge=lfs -text
 1_data_prepare/data/disp-06/scf/diamond.save/charge-density.dat filter=lfs diff=lfs merge=lfs -text
 1_data_prepare/data/disp-10/scf/VSC filter=lfs diff=lfs merge=lfs -text
 1_data_prepare/data/disp-10/scf/diamond.save/charge-density.dat filter=lfs diff=lfs merge=lfs -text
+1_data_prepare/data/disp-12/scf/VSC filter=lfs diff=lfs merge=lfs -text
+1_data_prepare/data/disp-12/scf/diamond.save/charge-density.dat filter=lfs diff=lfs merge=lfs -text
+1_data_prepare/data/disp-27/scf/VSC filter=lfs diff=lfs merge=lfs -text
+1_data_prepare/data/disp-27/scf/diamond.save/charge-density.dat filter=lfs diff=lfs merge=lfs -text

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_se3_transformer/__init__.py

@@ -0,0 +1 @@
+from .representations import SphericalHarmonics

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_se3_transformer/license.txt

@@ -0,0 +1,24 @@
+The code in this folder was obtained from "https://github.com/mariogeiger/se3cnn/", which has the following license:
+
+
+MIT License
+
+Copyright (c) 2019 Mario Geiger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_se3_transformer/representations.py

@@ -0,0 +1,204 @@
+import torch
+import numpy as np
+
+
+def semifactorial(x):
+    """Compute the semifactorial function x!!.
+
+    x!! = x * (x-2) * (x-4) *...
+
+    Args:
+        x: positive int
+    Returns:
+        float for x!!
+    """
+    y = 1.
+    for n in range(x, 1, -2):
+        y *= n
+    return y
+
+
+def pochhammer(x, k):
+    """Compute the pochhammer symbol (x)_k.
+
+    (x)_k = x * (x+1) * (x+2) *...* (x+k-1)
+
+    Args:
+        x: positive int
+    Returns:
+        float for (x)_k
+    """
+    xf = float(x)
+    for n in range(x+1, x+k):
+        xf *= n
+    return xf
+
+def lpmv(l, m, x):
+    """Associated Legendre function including Condon-Shortley phase.
+
+    Args:
+        m: int order 
+        l: int degree
+        x: float argument tensor
+    Returns:
+        tensor of x-shape
+    """
+    m_abs = abs(m)
+    if m_abs > l:
+        return torch.zeros_like(x)
+
+    # Compute P_m^m
+    yold = ((-1)**m_abs * semifactorial(2*m_abs-1)) * torch.pow(1-x*x, m_abs/2)
+    
+    # Compute P_{m+1}^m
+    if m_abs != l:
+        y = x * (2*m_abs+1) * yold
+    else:
+        y = yold
+
+    # Compute P_{l}^m from recursion in P_{l-1}^m and P_{l-2}^m
+    for i in range(m_abs+2, l+1):
+        tmp = y
+        # Inplace speedup
+        y = ((2*i-1) / (i-m_abs)) * x * y
+        y -= ((i+m_abs-1)/(i-m_abs)) * yold
+        yold = tmp
+
+    if m < 0:
+        y *= ((-1)**m / pochhammer(l+m+1, -2*m))
+
+    return y
+
+def tesseral_harmonics(l, m, theta=0., phi=0.):
+    """Tesseral spherical harmonic with Condon-Shortley phase.
+
+    The Tesseral spherical harmonics are also known as the real spherical
+    harmonics.
+
+    Args:
+        l: int for degree
+        m: int for order, where -l <= m < l
+        theta: collatitude or polar angle
+        phi: longitude or azimuth
+    Returns:
+        tensor of shape theta
+    """
+    assert abs(m) <= l, "absolute value of order m must be <= degree l"
+
+    N = np.sqrt((2*l+1) / (4*np.pi))
+    leg = lpmv(l, abs(m), torch.cos(theta))
+    if m == 0:
+        return N*leg
+    elif m > 0:
+        Y = torch.cos(m*phi) * leg
+    else:
+        Y = torch.sin(abs(m)*phi) * leg
+    N *= np.sqrt(2. / pochhammer(l-abs(m)+1, 2*abs(m)))
+    Y *= N
+    return Y
+
+class SphericalHarmonics(object):
+    def __init__(self):
+        self.leg = {}
+
+    def clear(self):
+        self.leg = {}
+
+    def negative_lpmv(self, l, m, y):
+        """Compute negative order coefficients"""
+        if m < 0:
+            y *= ((-1)**m / pochhammer(l+m+1, -2*m))
+        return y
+
+    def lpmv(self, l, m, x):
+        """Associated Legendre function including Condon-Shortley phase.
+
+        Args:
+            m: int order 
+            l: int degree
+            x: float argument tensor
+        Returns:
+            tensor of x-shape
+        """
+        # Check memoized versions
+        m_abs = abs(m)
+        if (l,m) in self.leg:
+            return self.leg[(l,m)]
+        elif m_abs > l:
+            return None
+        elif l == 0:
+            self.leg[(l,m)] = torch.ones_like(x)
+            return self.leg[(l,m)]
+        
+        # Check if on boundary else recurse solution down to boundary
+        if m_abs == l:
+            # Compute P_m^m
+            y = (-1)**m_abs * semifactorial(2*m_abs-1)
+            y *= torch.pow(1-x*x, m_abs/2)
+            self.leg[(l,m)] = self.negative_lpmv(l, m, y)
+            return self.leg[(l,m)]
+        else:
+            # Recursively precompute lower degree harmonics
+            self.lpmv(l-1, m, x)
+
+        # Compute P_{l}^m from recursion in P_{l-1}^m and P_{l-2}^m
+        # Inplace speedup
+        y = ((2*l-1) / (l-m_abs)) * x * self.lpmv(l-1, m_abs, x)
+        if l - m_abs > 1:
+            y -= ((l+m_abs-1)/(l-m_abs)) * self.leg[(l-2, m_abs)]
+        #self.leg[(l, m_abs)] = y
+        
+        if m < 0:
+            y = self.negative_lpmv(l, m, y)
+        self.leg[(l,m)] = y
+
+        return self.leg[(l,m)]
+
+    def get_element(self, l, m, theta, phi):
+        """Tesseral spherical harmonic with Condon-Shortley phase.
+
+        The Tesseral spherical harmonics are also known as the real spherical
+        harmonics.
+
+        Args:
+            l: int for degree
+            m: int for order, where -l <= m < l
+            theta: collatitude or polar angle
+            phi: longitude or azimuth
+        Returns:
+            tensor of shape theta
+        """
+        assert abs(m) <= l, "absolute value of order m must be <= degree l"
+
+        N = np.sqrt((2*l+1) / (4*np.pi))
+        leg = self.lpmv(l, abs(m), torch.cos(theta))
+        if m == 0:
+            return N*leg
+        elif m > 0:
+            Y = torch.cos(m*phi) * leg
+        else:
+            Y = torch.sin(abs(m)*phi) * leg
+        N *= np.sqrt(2. / pochhammer(l-abs(m)+1, 2*abs(m)))
+        Y *= N
+        return Y
+
+    def get(self, l, theta, phi, refresh=True):
+        """Tesseral harmonic with Condon-Shortley phase.
+
+        The Tesseral spherical harmonics are also known as the real spherical
+        harmonics.
+
+        Args:
+            l: int for degree
+            theta: collatitude or polar angle
+            phi: longitude or azimuth
+        Returns:
+            tensor of shape [*theta.shape, 2*l+1]
+        """
+        results = []
+        if refresh:
+            self.clear()
+        for m in range(-l, l+1):
+            results.append(self.get_element(l, m, theta, phi))
+        return torch.stack(results, -1)
+

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/__init__.py

@@ -0,0 +1 @@
+from .pred_ham import predict, predict_with_grad

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/band_config.json

@@ -0,0 +1,8 @@
+{
+  "calc_job": "band",
+  "which_k": 0,
+  "fermi_level": -3.82373,
+  "max_iter": 300,
+  "num_band": 50,
+  "k_data": ["15 0 0 0 0.5 0.5 0 Γ M", "15 0.5 0.5 0 0.3333333333333333 0.6666666666666667 0 M K", "15 0.3333333333333333 0.6666666666666667 0 0 0 0 K Γ"]
+}

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/dense_calc.jl

@@ -0,0 +1,234 @@
+using DelimitedFiles, LinearAlgebra, JSON
+using HDF5
+using ArgParse
+using SparseArrays
+using Arpack
+using JLD
+# BLAS.set_num_threads(1)
+
+const ev2Hartree = 0.036749324533634074
+const Bohr2Ang = 0.529177249
+const default_dtype = Complex{Float64}
+
+
+function parse_commandline()
+    s = ArgParseSettings()
+    @add_arg_table! s begin
+        "--input_dir", "-i"
+            help = "path of rlat.dat, orbital_types.dat, site_positions.dat, hamiltonians_pred.h5, and overlaps.h5"
+            arg_type = String
+            default = "./"
+        "--output_dir", "-o"
+            help = "path of output openmx.Band"
+            arg_type = String
+            default = "./"
+        "--config"
+            help = "config file in the format of JSON"
+            arg_type = String
+        "--ill_project"
+            help = "projects out the eigenvectors of the overlap matrix that correspond to eigenvalues smaller than ill_threshold"
+            arg_type = Bool
+            default = true
+        "--ill_threshold"
+            help = "threshold for ill_project"
+            arg_type = Float64
+            default = 5e-4
+    end
+    return parse_args(s)
+end
+
+
+function _create_dict_h5(filename::String)
+    fid = h5open(filename, "r")
+    T = eltype(fid[keys(fid)[1]])
+    d_out = Dict{Array{Int64,1}, Array{T, 2}}()
+    for key in keys(fid)
+        data = read(fid[key])
+        nk = map(x -> parse(Int64, convert(String, x)), split(key[2 : length(key) - 1], ','))
+        d_out[nk] = permutedims(data)
+    end
+    close(fid)
+    return d_out
+end
+
+
+function genlist(x)
+    return collect(range(x[1], stop = x[2], length = Int64(x[3])))
+end
+
+
+function k_data2num_ks(kdata::AbstractString)
+    return parse(Int64,split(kdata)[1])
+end
+
+
+function k_data2kpath(kdata::AbstractString)
+    return map(x->parse(Float64,x), split(kdata)[2:7])
+end
+
+
+function std_out_array(a::AbstractArray)
+    return string(map(x->string(x," "),a)...)
+end
+
+
+function main()
+    parsed_args = parse_commandline()
+
+    println(parsed_args["config"])
+    config = JSON.parsefile(parsed_args["config"])
+    calc_job = config["calc_job"]
+
+    if isfile(joinpath(parsed_args["input_dir"],"info.json"))
+        spinful = JSON.parsefile(joinpath(parsed_args["input_dir"],"info.json"))["isspinful"]
+    else
+        spinful = false
+    end
+
+    site_positions = readdlm(joinpath(parsed_args["input_dir"], "site_positions.dat"))
+    nsites = size(site_positions, 2)
+
+    orbital_types_f = open(joinpath(parsed_args["input_dir"], "orbital_types.dat"), "r")
+    site_norbits = zeros(nsites)
+    orbital_types = Vector{Vector{Int64}}()
+    for index_site = 1:nsites
+        orbital_type = parse.(Int64, split(readline(orbital_types_f)))
+        push!(orbital_types, orbital_type)
+    end
+    site_norbits = (x->sum(x .* 2 .+ 1)).(orbital_types) * (1 + spinful)
+    norbits = sum(site_norbits)
+    site_norbits_cumsum = cumsum(site_norbits)
+
+    rlat = readdlm(joinpath(parsed_args["input_dir"], "rlat.dat"))
+
+
+    @info "read h5"
+    begin_time = time()
+    hamiltonians_pred = _create_dict_h5(joinpath(parsed_args["input_dir"], "hamiltonians_pred.h5"))
+    overlaps = _create_dict_h5(joinpath(parsed_args["input_dir"], "overlaps.h5"))
+    println("Time for reading h5: ", time() - begin_time, "s")
+
+    H_R = Dict{Vector{Int64}, Matrix{default_dtype}}()
+    S_R = Dict{Vector{Int64}, Matrix{default_dtype}}()
+
+    @info "construct Hamiltonian and overlap matrix in the real space"
+    begin_time = time()
+    for key in collect(keys(hamiltonians_pred))
+        hamiltonian_pred = hamiltonians_pred[key]
+        if (key ∈ keys(overlaps))
+            overlap = overlaps[key]
+        else
+            # continue
+            overlap = zero(hamiltonian_pred)
+        end
+        if spinful
+            overlap = vcat(hcat(overlap,zeros(size(overlap))),hcat(zeros(size(overlap)),overlap)) # the readout overlap matrix only contains the upper-left block # TODO maybe drop the zeros?
+        end
+        R = key[1:3]; atom_i=key[4]; atom_j=key[5]
+
+        @assert (site_norbits[atom_i], site_norbits[atom_j]) == size(hamiltonian_pred)
+        @assert (site_norbits[atom_i], site_norbits[atom_j]) == size(overlap)
+        if !(R ∈ keys(H_R))
+            H_R[R] = zeros(default_dtype, norbits, norbits)
+            S_R[R] = zeros(default_dtype, norbits, norbits)
+        end
+        for block_matrix_i in 1:site_norbits[atom_i]
+            for block_matrix_j in 1:site_norbits[atom_j]
+                index_i = site_norbits_cumsum[atom_i] - site_norbits[atom_i] + block_matrix_i
+                index_j = site_norbits_cumsum[atom_j] - site_norbits[atom_j] + block_matrix_j
+                H_R[R][index_i, index_j] = hamiltonian_pred[block_matrix_i, block_matrix_j]
+                S_R[R][index_i, index_j] = overlap[block_matrix_i, block_matrix_j]
+            end
+        end
+    end
+    println("Time for constructing Hamiltonian and overlap matrix in the real space: ", time() - begin_time, " s")
+
+
+    if calc_job == "band"
+        fermi_level = config["fermi_level"]
+        k_data = config["k_data"]
+
+        ill_project = parsed_args["ill_project"] || ("ill_project" in keys(config) && config["ill_project"])
+        ill_threshold = max(parsed_args["ill_threshold"], get(config, "ill_threshold", 0.))
+        
+        @info "calculate bands"
+        num_ks = k_data2num_ks.(k_data)
+        kpaths = k_data2kpath.(k_data)
+
+        egvals = zeros(Float64, norbits, sum(num_ks)[1])
+
+        begin_time = time()
+        idx_k = 1
+        for i = 1:size(kpaths, 1)
+            kpath = kpaths[i]
+            pnkpts = num_ks[i]
+            kxs = LinRange(kpath[1], kpath[4], pnkpts)
+            kys = LinRange(kpath[2], kpath[5], pnkpts)
+            kzs = LinRange(kpath[3], kpath[6], pnkpts)
+            for (kx, ky, kz) in zip(kxs, kys, kzs)
+                idx_k
+                H_k = zeros(default_dtype, norbits, norbits)
+                S_k = zeros(default_dtype, norbits, norbits)
+                for R in keys(H_R)
+                    H_k += H_R[R] * exp(im*2π*([kx, ky, kz]⋅R))
+                    S_k += S_R[R] * exp(im*2π*([kx, ky, kz]⋅R))
+                end
+                S_k = (S_k + S_k') / 2
+                H_k = (H_k + H_k') / 2
+                if ill_project
+                    (egval_S, egvec_S) = eigen(Hermitian(S_k))
+                    # egvec_S: shape (num_basis, num_bands)
+                    project_index = abs.(egval_S) .> ill_threshold
+                    if sum(project_index) != length(project_index)
+                        # egval_S = egval_S[project_index]
+                        egvec_S = egvec_S[:, project_index]
+                        @warn "ill-conditioned eigenvalues detected, projected out $(length(project_index) - sum(project_index)) eigenvalues"
+                        H_k = egvec_S' * H_k * egvec_S
+                        S_k = egvec_S' * S_k * egvec_S
+                        (egval, egvec) = eigen(Hermitian(H_k), Hermitian(S_k))
+                        egval = vcat(egval, fill(1e4, length(project_index) - sum(project_index)))
+                        egvec = egvec_S * egvec
+                    else
+                        (egval, egvec) = eigen(Hermitian(H_k), Hermitian(S_k))
+                    end
+                else
+                    (egval, egvec) = eigen(Hermitian(H_k), Hermitian(S_k))
+                end
+                egvals[:, idx_k] = egval
+                println("Time for solving No.$idx_k eigenvalues at k = ", [kx, ky, kz], ": ", time() - begin_time, " s")
+                idx_k += 1
+            end
+        end
+
+        # output in openmx band format
+        f = open(joinpath(parsed_args["output_dir"], "openmx.Band"),"w")
+        println(f, norbits, " ", 0, " ", ev2Hartree * fermi_level)
+        openmx_rlat = reshape((rlat .* Bohr2Ang), 1, :)
+        println(f, std_out_array(openmx_rlat))
+        println(f, length(k_data))
+        for line in k_data
+            println(f,line)
+        end
+        idx_k = 1
+        for i = 1:size(kpaths, 1)
+            pnkpts = num_ks[i]
+            kstart = kpaths[i][1:3]
+            kend = kpaths[i][4:6]
+            k_list = zeros(Float64,pnkpts,3)
+            for alpha = 1:3
+                k_list[:,alpha] = genlist([kstart[alpha],kend[alpha],pnkpts])
+            end
+            for j = 1:pnkpts
+                idx_k
+                kvec = k_list[j,:]
+                println(f, norbits, " ", std_out_array(kvec))
+                println(f, std_out_array(ev2Hartree * egvals[:, idx_k]))
+                idx_k += 1
+            end
+        end
+        close(f)
+    end
+end
+
+
+main()

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/dense_calc.py

@@ -0,0 +1,277 @@
+import json
+import argparse
+import h5py
+import numpy as np
+import os
+from time import time
+from scipy import linalg 
+import tqdm
+from pathos.multiprocessing import ProcessingPool as Pool
+
+def parse_commandline():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--input_dir", "-i", type=str, default="./",
+        help="path of rlat.dat, orbital_types.dat, site_positions.dat, hamiltonians_pred.h5, and overlaps.h5"
+    )
+    parser.add_argument(
+        "--output_dir", "-o", type=str, default="./",
+        help="path of output openmx.Band"
+    )
+    parser.add_argument(
+        "--config", type=str,
+        help="config file in the format of JSON"
+    )
+    parser.add_argument(
+        "--ill_project", type=bool,
+        help="projects out the eigenvectors of the overlap matrix that correspond to eigenvalues smaller than ill_threshold",
+        default=True
+    )
+    parser.add_argument(
+        "--ill_threshold", type=float,
+        help="threshold for ill_project",
+        default=5e-4
+    )
+    parser.add_argument(
+        "--multiprocessing", type=int,
+        help="multiprocessing for band calculation",
+        default=0
+    )
+    return parser.parse_args()
+
+parsed_args = parse_commandline()
+
+def _create_dict_h5(filename):
+    fid = h5py.File(filename, "r")
+    d_out = {}
+    for key in fid.keys():
+        data = np.array(fid[key])
+        nk = tuple(map(int, key[1:-1].split(',')))
+        # BS: 
+        # the matrix do not need be transposed in Python, 
+        # But the transpose should be done in Julia.
+        d_out[nk] = data # np.transpose(data)
+    fid.close()
+    return d_out
+
+
+ev2Hartree = 0.036749324533634074
+Bohr2Ang = 0.529177249
+
+
+def genlist(x):
+    return np.linspace(x[0], x[1], int(x[2]))
+
+
+def k_data2num_ks(kdata):
+    return int(kdata.split()[0])
+
+
+def k_data2kpath(kdata):
+    return [float(x) for x in kdata.split()[1:7]]
+
+
+def std_out_array(a):
+    return ''.join([str(x) + ' ' for x in a])
+
+
+default_dtype = np.complex128
+
+print(parsed_args.config)
+with open(parsed_args.config) as f:
+    config = json.load(f)
+calc_job = config["calc_job"]
+
+if os.path.isfile(os.path.join(parsed_args.input_dir, "info.json")):
+    with open(os.path.join(parsed_args.input_dir, "info.json")) as f:
+        spinful = json.load(f)["isspinful"]
+else:
+    spinful = False
+
+site_positions = np.loadtxt(os.path.join(parsed_args.input_dir, "site_positions.dat"))
+
+if len(site_positions.shape) == 2:
+    nsites = site_positions.shape[1]
+else:
+    nsites = 1
+    # in case of single atom
+
+
+with open(os.path.join(parsed_args.input_dir, "orbital_types.dat")) as f:
+    site_norbits = np.zeros(nsites, dtype=int)
+    orbital_types = []
+    for index_site in range(nsites):
+        orbital_type = list(map(int, f.readline().split()))
+        orbital_types.append(orbital_type)
+        site_norbits[index_site] = np.sum(np.array(orbital_type) * 2 + 1)
+    norbits = np.sum(site_norbits)
+    site_norbits_cumsum = np.cumsum(site_norbits)
+
+rlat = np.loadtxt(os.path.join(parsed_args.input_dir, "rlat.dat")).T
+# require transposition while reading rlat.dat in python
+
+
+print("read h5")
+begin_time = time()
+hamiltonians_pred = _create_dict_h5(os.path.join(parsed_args.input_dir, "hamiltonians_pred.h5"))
+overlaps = _create_dict_h5(os.path.join(parsed_args.input_dir, "overlaps.h5"))
+print("Time for reading h5: ", time() - begin_time, "s")
+
+H_R = {}
+S_R = {}
+
+print("construct Hamiltonian and overlap matrix in the real space")
+begin_time = time()
+
+# BS:
+# this is for debug python and julia
+# in julia, you can use 'sort(collect(keys(hamiltonians_pred)))'
+# for key in dict(sorted(hamiltonians_pred.items())).keys():
+for key in hamiltonians_pred.keys():
+
+    hamiltonian_pred = hamiltonians_pred[key]
+
+    if key in overlaps.keys():
+        overlap = overlaps[key]
+    else:
+        overlap = np.zeros_like(hamiltonian_pred)
+    if spinful:
+        overlap = np.vstack((np.hstack((overlap, np.zeros_like(overlap))), np.hstack((np.zeros_like(overlap), overlap))))
+    R = key[:3]
+    atom_i = key[3] - 1
+    atom_j = key[4] - 1
+
+    assert (site_norbits[atom_i], site_norbits[atom_j]) == hamiltonian_pred.shape
+    assert (site_norbits[atom_i], site_norbits[atom_j]) == overlap.shape
+
+    if R not in H_R.keys():
+        H_R[R] = np.zeros((norbits, norbits), dtype=default_dtype)
+        S_R[R] = np.zeros((norbits, norbits), dtype=default_dtype)
+
+    for block_matrix_i in range(1, site_norbits[atom_i]+1):
+        for block_matrix_j in range(1, site_norbits[atom_j]+1):
+            index_i = site_norbits_cumsum[atom_i] - site_norbits[atom_i] + block_matrix_i - 1
+            index_j = site_norbits_cumsum[atom_j] - site_norbits[atom_j] + block_matrix_j - 1
+            H_R[R][index_i, index_j] = hamiltonian_pred[block_matrix_i-1, block_matrix_j-1]
+            S_R[R][index_i, index_j] = overlap[block_matrix_i-1, block_matrix_j-1]
+
+
+print("Time for constructing Hamiltonian and overlap matrix in the real space: ", time() - begin_time, " s")
+
+if calc_job == "band":
+    fermi_level = config["fermi_level"]
+    k_data = config["k_data"]
+    ill_project = parsed_args.ill_project or ("ill_project" in config.keys() and config["ill_project"])
+    ill_threshold = max(parsed_args.ill_threshold, config["ill_threshold"] if ("ill_threshold" in config.keys()) else 0.)
+    multiprocessing = max(parsed_args.multiprocessing, config["multiprocessing"] if ("multiprocessing" in config.keys()) else 0)
+
+    print("calculate bands")
+    num_ks = [k_data2num_ks(k) for k in k_data]
+    kpaths = [k_data2kpath(k) for k in k_data]
+
+    egvals = np.zeros((norbits, sum(num_ks)))
+
+    begin_time = time()
+    idx_k = 0
+    # calculate total k points
+    total_num_ks = sum(num_ks)
+    list_index_kpath= []
+    list_index_kxyz=[]
+    for i in range(len(num_ks)):
+        list_index_kpath = list_index_kpath + ([i]*num_ks[i])
+        list_index_kxyz.extend(range(num_ks[i]))
+
+    def process_worker(k_point):
+        """ calculate band 
+
+        Args:
+            k_point (int): the index of k point of all calculated k points
+
+        Returns:
+            json: {
+                "k_point":k_point, 
+                "egval" (np array 1D) : eigen value , 
+                "num_projected_out" (int) :  ill-conditioned eigenvalues detected。 default is 0
+                }
+        """
+        index_kpath = list_index_kpath[k_point]
+        kpath = kpaths[index_kpath]
+        pnkpts = num_ks[index_kpath]
+        kx = np.linspace(kpath[0], kpath[3], pnkpts)[list_index_kxyz[k_point]]
+        ky = np.linspace(kpath[1], kpath[4], pnkpts)[list_index_kxyz[k_point]]
+        kz = np.linspace(kpath[2], kpath[5], pnkpts)[list_index_kxyz[k_point]]
+
+        H_k = np.matrix(np.zeros((norbits, norbits), dtype=default_dtype))
+        S_k = np.matrix(np.zeros((norbits, norbits), dtype=default_dtype))
+        for R in H_R.keys():
+            H_k += H_R[R] * np.exp(1j*2*np.pi*np.dot([kx, ky, kz], R))
+            S_k += S_R[R] * np.exp(1j*2*np.pi*np.dot([kx, ky, kz], R))
+            # print(H_k)
+        H_k = (H_k + H_k.getH())/2.
+        S_k = (S_k + S_k.getH())/2.
+        num_projected_out = 0
+        if ill_project:
+            egval_S, egvec_S = linalg.eig(S_k)
+            project_index = np.argwhere(abs(egval_S)> ill_threshold)
+            if len(project_index) != norbits:
+                egvec_S = np.matrix(egvec_S[:, project_index])
+                num_projected_out = norbits - len(project_index)
+                H_k = egvec_S.H @ H_k @ egvec_S
+                S_k = egvec_S.H @ S_k @ egvec_S
+                egval = linalg.eigvalsh(H_k, S_k, lower=False)
+                egval = np.concatenate([egval, np.full(num_projected_out, 1e4)])
+            else:
+                egval = linalg.eigvalsh(H_k, S_k, lower=False)
+        else:
+            #---------------------------------------------
+            # BS: only eigenvalues are needed in this part, 
+            # the upper matrix is used
+            egval = linalg.eigvalsh(H_k, S_k, lower=False) 
+
+        return {"k_point":k_point, "egval":egval, "num_projected_out":num_projected_out}
+    
+    # parallizing the band calculation
+    if multiprocessing == 0:
+        print(f'No use of multiprocessing')
+        data_list = [process_worker(k_point) for k_point in tqdm.tqdm(range(sum(num_ks)))]
+    else:
+        pool_dict = {} if multiprocessing < 0 else {'nodes': multiprocessing}
+
+        with Pool(**pool_dict) as pool:
+            nodes = pool.nodes
+            print(f'Use multiprocessing x {multiprocessing})')
+            data_list = list(tqdm.tqdm(pool.imap(process_worker, range(sum(num_ks))), total=sum(num_ks)))
+    
+    # post-process returned band data, and store them in egvals with the order k_point
+    projected_out = []
+    for data in data_list:
+        egvals[:, data["k_point"]] = data["egval"]
+        if data["num_projected_out"] > 0:
+            projected_out.append(data["num_projected_out"])
+    if len(projected_out) > 0:
+        print(f"There are {len(projected_out)} bands with ill-conditioned eigenvalues detected.")
+        print(f"Projected out {int(np.average(projected_out))} eigenvalues on average.")
+    print('Finish the calculation of %d k-points, have cost %d seconds' % (sum(num_ks), time() - begin_time))
+
+
+    # output in openmx band format
+    with open(os.path.join(parsed_args.output_dir, "openmx.Band"), "w") as f:
+        f.write("{} {} {}\n".format(norbits, 0, ev2Hartree * fermi_level))
+        openmx_rlat = np.reshape((rlat * Bohr2Ang), (1, -1))[0]
+        f.write(std_out_array(openmx_rlat) + "\n")
+        f.write(str(len(k_data)) + "\n")
+        for line in k_data:
+            f.write(line + "\n")
+        idx_k = 0
+        for i in range(len(kpaths)):
+            pnkpts = num_ks[i]
+            kstart = kpaths[i][:3]
+            kend = kpaths[i][3:]
+            k_list = np.zeros((pnkpts, 3))
+            for alpha in range(3):
+                k_list[:, alpha] = genlist([kstart[alpha], kend[alpha], pnkpts])
+            for j in range(pnkpts):
+                kvec = k_list[j, :]
+                f.write("{} {}\n".format(norbits, std_out_array(kvec)))
+                f.write(std_out_array(ev2Hartree * egvals[:, idx_k]) + "\n")
+                idx_k += 1

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/inference_default.ini

@@ -0,0 +1,23 @@
+[basic]
+work_dir = /your/own/path
+OLP_dir = /your/own/path
+interface = openmx
+trained_model_dir = ["/your/trained/model1", "/your/trained/model2"]
+task = [1, 2, 3, 4, 5]
+sparse_calc_config = /your/own/path
+eigen_solver = sparse_jl
+disable_cuda = True
+device = cuda:0
+huge_structure = True
+restore_blocks_py = True
+gen_rc_idx = False
+gen_rc_by_idx =
+with_grad = False
+
+[interpreter]
+julia_interpreter = julia
+python_interpreter = python
+
+[graph]
+radius = -1.0
+create_from_DFT = True

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/local_coordinate.jl

@@ -0,0 +1,79 @@
+using DelimitedFiles, LinearAlgebra
+using HDF5
+using ArgParse
+using StaticArrays
+
+
+function parse_commandline()
+    s = ArgParseSettings()
+    @add_arg_table! s begin
+        "--input_dir", "-i"
+            help = "path of site_positions.dat, lat.dat, element.dat, and R_list.dat (overlaps.h5)"
+            arg_type = String
+            default = "./"
+        "--output_dir", "-o"
+            help = "path of output rc.h5"
+            arg_type = String
+            default = "./"
+        "--radius", "-r"
+            help = "cutoff radius"
+            arg_type = Float64
+            default = 8.0
+        "--create_from_DFT"
+            help = "retain edges by DFT overlaps neighbour"
+            arg_type = Bool
+            default = true
+        "--output_text"
+            help = "an option without argument, i.e. a flag"
+            action = :store_true
+        "--Hop_dir"
+            help = "path of Hop.jl"
+            arg_type = String
+            default = "/home/lihe/DeepH/process_ham/Hop.jl/"
+    end
+    return parse_args(s)
+end
+parsed_args = parse_commandline()
+
+using Pkg
+Pkg.activate(parsed_args["Hop_dir"])
+using Hop
+
+
+site_positions = readdlm(joinpath(parsed_args["input_dir"], "site_positions.dat"))
+lat = readdlm(joinpath(parsed_args["input_dir"], "lat.dat"))
+R_list_read = convert(Matrix{Int64}, readdlm(joinpath(parsed_args["input_dir"], "R_list.dat")))
+num_R = size(R_list_read, 1)
+R_list = Vector{SVector{3, Int64}}()
+for index_R in 1:num_R
+    push!(R_list, SVector{3, Int64}(R_list_read[index_R, :]))
+end
+
+@info "get local coordinate"
+begin_time = time()
+rcoordinate = Hop.Deeph.rotate_system(site_positions, lat, R_list, parsed_args["radius"])
+println("time for calculating local coordinate is: ", time() - begin_time)
+
+if parsed_args["output_text"]
+    @info "output txt"
+    mkpath(joinpath(parsed_args["output_dir"], "rresult"))
+    mkpath(joinpath(parsed_args["output_dir"], "rresult/rc"))
+    for (R, coord) in rcoordinate
+        open(joinpath(parsed_args["output_dir"], "rresult/rc/", R, "_real.dat"), "w") do f
+            writedlm(f, coord)
+        end
+    end
+end
+
+@info "output h5"
+h5open(joinpath(parsed_args["input_dir"], "overlaps.h5"), "r") do fid_OLP
+    graph_key = Set(keys(fid_OLP))
+    h5open(joinpath(parsed_args["output_dir"], "rc.h5"), "w") do fid
+        for (key, coord) in rcoordinate
+            if (parsed_args["create_from_DFT"] == true) && (!(string(key) in graph_key))
+                continue
+            end
+            write(fid, string(key), permutedims(coord))
+        end
+    end
+end

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/pred_ham.py

@@ -0,0 +1,365 @@
+import json
+import os
+import time
+import warnings
+from typing import Union, List
+import sys
+
+import tqdm
+from configparser import ConfigParser
+import numpy as np
+from pymatgen.core.structure import Structure
+import torch
+import torch.autograd.forward_ad as fwAD
+import h5py
+
+from deeph import get_graph, DeepHKernel, collate_fn, write_ham_h5, load_orbital_types, Rotate, dtype_dict, get_rc
+
+
+def predict(input_dir: str, output_dir: str, disable_cuda: bool, device: str,
+            huge_structure: bool, restore_blocks_py: bool, trained_model_dirs: Union[str, List[str]]):
+    atom_num_orbital = load_orbital_types(os.path.join(input_dir, 'orbital_types.dat'))
+    if isinstance(trained_model_dirs, str):
+        trained_model_dirs = [trained_model_dirs]
+    assert isinstance(trained_model_dirs, list)
+    os.makedirs(output_dir, exist_ok=True)
+    predict_spinful = None
+
+    with torch.no_grad():
+        read_structure_flag = False
+        if restore_blocks_py:
+            hoppings_pred = {}
+        else:
+            index_model = 0
+            block_without_restoration = {}
+            os.makedirs(os.path.join(output_dir, 'block_without_restoration'), exist_ok=True)
+        for trained_model_dir in tqdm.tqdm(trained_model_dirs):
+            old_version = False
+            assert os.path.exists(os.path.join(trained_model_dir, 'config.ini'))
+            if os.path.exists(os.path.join(trained_model_dir, 'best_model.pt')) is False:
+                old_version = True
+                assert os.path.exists(os.path.join(trained_model_dir, 'best_model.pkl'))
+                assert os.path.exists(os.path.join(trained_model_dir, 'src'))
+
+            config = ConfigParser()
+            config.read(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'default.ini'))
+            config.read(os.path.join(trained_model_dir, 'config.ini'))
+            config.set('basic', 'save_dir', os.path.join(output_dir, 'pred_ham_std'))
+            config.set('basic', 'disable_cuda', str(disable_cuda))
+            config.set('basic', 'device', str(device))
+            config.set('basic', 'save_to_time_folder', 'False')
+            config.set('basic', 'tb_writer', 'False')
+            config.set('train', 'pretrained', '')
+            config.set('train', 'resume', '')
+
+            kernel = DeepHKernel(config)
+            if old_version is False:
+                checkpoint = kernel.build_model(trained_model_dir, old_version)
+            else:
+                warnings.warn('You are using the trained model with an old version')
+                checkpoint = torch.load(
+                    os.path.join(trained_model_dir, 'best_model.pkl'),
+                    map_location=kernel.device
+                )
+                for key in ['index_to_Z', 'Z_to_index', 'spinful']:
+                    if key in checkpoint:
+                        setattr(kernel, key, checkpoint[key])
+                if hasattr(kernel, 'index_to_Z') is False:
+                    kernel.index_to_Z = torch.arange(config.getint('basic', 'max_element') + 1)
+                if hasattr(kernel, 'Z_to_index') is False:
+                    kernel.Z_to_index = torch.arange(config.getint('basic', 'max_element') + 1)
+                if hasattr(kernel, 'spinful') is False:
+                    kernel.spinful = False
+                kernel.num_species = len(kernel.index_to_Z)
+                print("=> load best checkpoint (epoch {})".format(checkpoint['epoch']))
+                print(f"=> Atomic types: {kernel.index_to_Z.tolist()}, "
+                      f"spinful: {kernel.spinful}, the number of atomic types: {len(kernel.index_to_Z)}.")
+                kernel.build_model(trained_model_dir, old_version)
+                kernel.model.load_state_dict(checkpoint['state_dict'])
+
+            if predict_spinful is None:
+                predict_spinful = kernel.spinful
+            else:
+                assert predict_spinful == kernel.spinful, "Different models' spinful are not compatible"
+
+            if read_structure_flag is False:
+                read_structure_flag = True
+                structure = Structure(np.loadtxt(os.path.join(input_dir, 'lat.dat')).T,
+                                      np.loadtxt(os.path.join(input_dir, 'element.dat')),
+                                      np.loadtxt(os.path.join(input_dir, 'site_positions.dat')).T,
+                                      coords_are_cartesian=True,
+                                      to_unit_cell=False)
+                cart_coords = torch.tensor(structure.cart_coords, dtype=torch.get_default_dtype())
+                frac_coords = torch.tensor(structure.frac_coords, dtype=torch.get_default_dtype())
+                numbers = kernel.Z_to_index[torch.tensor(structure.atomic_numbers)]
+                structure.lattice.matrix.setflags(write=True)
+                lattice = torch.tensor(structure.lattice.matrix, dtype=torch.get_default_dtype())
+                inv_lattice = torch.inverse(lattice)
+
+                if os.path.exists(os.path.join(input_dir, 'graph.pkl')):
+                    data = torch.load(os.path.join(input_dir, 'graph.pkl'))
+                    print(f"Load processed graph from {os.path.join(input_dir, 'graph.pkl')}")
+                else:
+                    begin = time.time()
+                    data = get_graph(cart_coords, frac_coords, numbers, 0,
+                                     r=kernel.config.getfloat('graph', 'radius'),
+                                     max_num_nbr=kernel.config.getint('graph', 'max_num_nbr'),
+                                     numerical_tol=1e-8, lattice=lattice, default_dtype_torch=torch.get_default_dtype(),
+                                     tb_folder=input_dir, interface="h5_rc_only",
+                                     num_l=kernel.config.getint('network', 'num_l'),
+                                     create_from_DFT=kernel.config.getboolean('graph', 'create_from_DFT',
+                                                                              fallback=True),
+                                     if_lcmp_graph=kernel.config.getboolean('graph', 'if_lcmp_graph', fallback=True),
+                                     separate_onsite=kernel.separate_onsite,
+                                     target=kernel.config.get('basic', 'target'), huge_structure=huge_structure,
+                                     if_new_sp=kernel.config.getboolean('graph', 'new_sp', fallback=False),
+                                     )
+                    torch.save(data, os.path.join(input_dir, 'graph.pkl'))
+                    print(
+                        f"Save processed graph to {os.path.join(input_dir, 'graph.pkl')}, cost {time.time() - begin} seconds")
+                batch, subgraph = collate_fn([data])
+                sub_atom_idx, sub_edge_idx, sub_edge_ang, sub_index = subgraph
+
+            output = kernel.model(batch.x.to(kernel.device), batch.edge_index.to(kernel.device),
+                                  batch.edge_attr.to(kernel.device),
+                                  batch.batch.to(kernel.device),
+                                  sub_atom_idx.to(kernel.device), sub_edge_idx.to(kernel.device),
+                                  sub_edge_ang.to(kernel.device), sub_index.to(kernel.device),
+                                  huge_structure=huge_structure)
+            output = output.detach().cpu()
+            if restore_blocks_py:
+                for index in range(batch.edge_attr.shape[0]):
+                    R = torch.round(batch.edge_attr[index, 4:7] @ inv_lattice - batch.edge_attr[index, 7:10] @ inv_lattice).int().tolist()
+                    i, j = batch.edge_index[:, index]
+                    key_term = (*R, i.item() + 1, j.item() + 1)
+                    key_term = str(list(key_term))
+                    for index_orbital, orbital_dict in enumerate(kernel.orbital):
+                        if f'{kernel.index_to_Z[numbers[i]].item()} {kernel.index_to_Z[numbers[j]].item()}' not in orbital_dict:
+                            continue
+                        orbital_i, orbital_j = orbital_dict[f'{kernel.index_to_Z[numbers[i]].item()} {kernel.index_to_Z[numbers[j]].item()}']
+
+                        if not key_term in hoppings_pred:
+                            if kernel.spinful:
+                                hoppings_pred[key_term] = np.full((2 * atom_num_orbital[i], 2 * atom_num_orbital[j]), np.nan + np.nan * (1j))
+                            else:
+                                hoppings_pred[key_term] = np.full((atom_num_orbital[i], atom_num_orbital[j]), np.nan)
+                        if kernel.spinful:
+                            hoppings_pred[key_term][orbital_i, orbital_j] = output[index][index_orbital * 8 + 0] + output[index][index_orbital * 8 + 1] * 1j
+                            hoppings_pred[key_term][atom_num_orbital[i] + orbital_i, atom_num_orbital[j] + orbital_j] = output[index][index_orbital * 8 + 2] + output[index][index_orbital * 8 + 3] * 1j
+                            hoppings_pred[key_term][orbital_i, atom_num_orbital[j] + orbital_j] = output[index][index_orbital * 8 + 4] + output[index][index_orbital * 8 + 5] * 1j
+                            hoppings_pred[key_term][atom_num_orbital[i] + orbital_i, orbital_j] = output[index][index_orbital * 8 + 6] + output[index][index_orbital * 8 + 7] * 1j
+                        else:
+                            hoppings_pred[key_term][orbital_i, orbital_j] = output[index][index_orbital]  # about output shape w/ or w/o soc, see graph.py line 164, and kernel.py line 281.
+            else:
+                if 'edge_index' not in block_without_restoration:
+                    assert index_model == 0
+                    block_without_restoration['edge_index'] = batch.edge_index
+                    block_without_restoration['edge_attr'] = batch.edge_attr
+                block_without_restoration[f'output_{index_model}'] = output.numpy()
+                with open(os.path.join(output_dir, 'block_without_restoration', f'orbital_{index_model}.json'), 'w') as orbital_f:
+                    json.dump(kernel.orbital, orbital_f, indent=4)
+                index_model += 1
+            sys.stdout = sys.stdout.terminal
+            sys.stderr = sys.stderr.terminal
+
+        if restore_blocks_py:
+            for hamiltonian in hoppings_pred.values():
+                assert np.all(np.isnan(hamiltonian) == False)
+            write_ham_h5(hoppings_pred, path=os.path.join(output_dir, 'rh_pred.h5'))
+        else:
+            block_without_restoration['num_model'] = index_model
+            write_ham_h5(block_without_restoration, path=os.path.join(output_dir, 'block_without_restoration', 'block_without_restoration.h5'))
+        with open(os.path.join(output_dir, "info.json"), 'w') as info_f:
+            json.dump({
+                "isspinful": predict_spinful
+            }, info_f)
+
+
+def predict_with_grad(input_dir: str, output_dir: str, disable_cuda: bool, device: str,
+                      huge_structure: bool, trained_model_dirs: Union[str, List[str]]):
+    atom_num_orbital, orbital_types = load_orbital_types(os.path.join(input_dir, 'orbital_types.dat'), return_orbital_types=True)
+
+    if isinstance(trained_model_dirs, str):
+        trained_model_dirs = [trained_model_dirs]
+    assert isinstance(trained_model_dirs, list)
+    os.makedirs(output_dir, exist_ok=True)
+    predict_spinful = None
+
+    read_structure_flag = False
+    rh_dict = {}
+    hamiltonians_pred = {}
+    hamiltonians_grad_pred = {}
+
+    for trained_model_dir in tqdm.tqdm(trained_model_dirs):
+        old_version = False
+        assert os.path.exists(os.path.join(trained_model_dir, 'config.ini'))
+        if os.path.exists(os.path.join(trained_model_dir, 'best_model.pt')) is False:
+            old_version = True
+            assert os.path.exists(os.path.join(trained_model_dir, 'best_model.pkl'))
+            assert os.path.exists(os.path.join(trained_model_dir, 'src'))
+
+        config = ConfigParser()
+        config.read(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'default.ini'))
+        config.read(os.path.join(trained_model_dir, 'config.ini'))
+        config.set('basic', 'save_dir', os.path.join(output_dir, 'pred_ham_std'))
+        config.set('basic', 'disable_cuda', str(disable_cuda))
+        config.set('basic', 'device', str(device))
+        config.set('basic', 'save_to_time_folder', 'False')
+        config.set('basic', 'tb_writer', 'False')
+        config.set('train', 'pretrained', '')
+        config.set('train', 'resume', '')
+
+        kernel = DeepHKernel(config)
+        if old_version is False:
+            checkpoint = kernel.build_model(trained_model_dir, old_version)
+        else:
+            warnings.warn('You are using the trained model with an old version')
+            checkpoint = torch.load(
+                os.path.join(trained_model_dir, 'best_model.pkl'),
+                map_location=kernel.device
+            )
+            for key in ['index_to_Z', 'Z_to_index', 'spinful']:
+                if key in checkpoint:
+                    setattr(kernel, key, checkpoint[key])
+            if hasattr(kernel, 'index_to_Z') is False:
+                kernel.index_to_Z = torch.arange(config.getint('basic', 'max_element') + 1)
+            if hasattr(kernel, 'Z_to_index') is False:
+                kernel.Z_to_index = torch.arange(config.getint('basic', 'max_element') + 1)
+            if hasattr(kernel, 'spinful') is False:
+                kernel.spinful = False
+            kernel.num_species = len(kernel.index_to_Z)
+            print("=> load best checkpoint (epoch {})".format(checkpoint['epoch']))
+            print(f"=> Atomic types: {kernel.index_to_Z.tolist()}, "
+                  f"spinful: {kernel.spinful}, the number of atomic types: {len(kernel.index_to_Z)}.")
+            kernel.build_model(trained_model_dir, old_version)
+            kernel.model.load_state_dict(checkpoint['state_dict'])
+
+        if predict_spinful is None:
+            predict_spinful = kernel.spinful
+        else:
+            assert predict_spinful == kernel.spinful, "Different models' spinful are not compatible"
+
+        if read_structure_flag is False:
+            read_structure_flag = True
+            structure = Structure(np.loadtxt(os.path.join(input_dir, 'lat.dat')).T,
+                                  np.loadtxt(os.path.join(input_dir, 'element.dat')),
+                                  np.loadtxt(os.path.join(input_dir, 'site_positions.dat')).T,
+                                  coords_are_cartesian=True,
+                                  to_unit_cell=False)
+            cart_coords = torch.tensor(structure.cart_coords, dtype=torch.get_default_dtype(), requires_grad=True, device=kernel.device)
+            num_atom = cart_coords.shape[0]
+            frac_coords = torch.tensor(structure.frac_coords, dtype=torch.get_default_dtype())
+            numbers = kernel.Z_to_index[torch.tensor(structure.atomic_numbers)]
+            structure.lattice.matrix.setflags(write=True)
+            lattice = torch.tensor(structure.lattice.matrix, dtype=torch.get_default_dtype())
+            inv_lattice = torch.inverse(lattice)
+
+            fid_rc = get_rc(input_dir, None, radius=-1, create_from_DFT=True, if_require_grad=True, cart_coords=cart_coords)
+
+            assert kernel.config.getboolean('graph', 'new_sp', fallback=False)
+            data = get_graph(cart_coords.to(kernel.device), frac_coords, numbers, 0,
+                             r=kernel.config.getfloat('graph', 'radius'),
+                             max_num_nbr=kernel.config.getint('graph', 'max_num_nbr'),
+                             numerical_tol=1e-8, lattice=lattice, default_dtype_torch=torch.get_default_dtype(),
+                             tb_folder=input_dir, interface="h5_rc_only",
+                             num_l=kernel.config.getint('network', 'num_l'),
+                             create_from_DFT=kernel.config.getboolean('graph', 'create_from_DFT', fallback=True),
+                             if_lcmp_graph=kernel.config.getboolean('graph', 'if_lcmp_graph', fallback=True),
+                             separate_onsite=kernel.separate_onsite,
+                             target=kernel.config.get('basic', 'target'), huge_structure=huge_structure,
+                             if_new_sp=True, if_require_grad=True, fid_rc=fid_rc)
+            batch, subgraph = collate_fn([data])
+            sub_atom_idx, sub_edge_idx, sub_edge_ang, sub_index = subgraph
+
+            torch_dtype, torch_dtype_real, torch_dtype_complex = dtype_dict[torch.get_default_dtype()]
+            rotate_kernel = Rotate(torch_dtype, torch_dtype_real=torch_dtype_real,
+                                   torch_dtype_complex=torch_dtype_complex,
+                                   device=kernel.device, spinful=kernel.spinful)
+
+        output = kernel.model(batch.x, batch.edge_index.to(kernel.device),
+                              batch.edge_attr,
+                              batch.batch.to(kernel.device),
+                              sub_atom_idx.to(kernel.device), sub_edge_idx.to(kernel.device),
+                              sub_edge_ang, sub_index.to(kernel.device),
+                              huge_structure=huge_structure)
+
+        index_for_matrix_block_real_dict = {}  # key is atomic number pair
+        if kernel.spinful:
+            index_for_matrix_block_imag_dict = {}  # key is atomic number pair
+
+        for index in range(batch.edge_attr.shape[0]):
+            R = torch.round(batch.edge_attr[index, 4:7].cpu() @ inv_lattice - batch.edge_attr[index, 7:10].cpu() @ inv_lattice).int().tolist()
+            i, j = batch.edge_index[:, index]
+            key_tensor = torch.tensor([*R, i, j])
+            numbers_pair = (kernel.index_to_Z[numbers[i]].item(), kernel.index_to_Z[numbers[j]].item())
+            if numbers_pair not in index_for_matrix_block_real_dict:
+                if not kernel.spinful:
+                    index_for_matrix_block_real = torch.full((atom_num_orbital[i], atom_num_orbital[j]), -1)
+                else:
+                    index_for_matrix_block_real = torch.full((2 * atom_num_orbital[i], 2 * atom_num_orbital[j]), -1)
+                    index_for_matrix_block_imag = torch.full((2 * atom_num_orbital[i], 2 * atom_num_orbital[j]), -1)
+                for index_orbital, orbital_dict in enumerate(kernel.orbital):
+                    if f'{kernel.index_to_Z[numbers[i]].item()} {kernel.index_to_Z[numbers[j]].item()}' not in orbital_dict:
+                        continue
+                    orbital_i, orbital_j = orbital_dict[f'{kernel.index_to_Z[numbers[i]].item()} {kernel.index_to_Z[numbers[j]].item()}']
+                    if not kernel.spinful:
+                        index_for_matrix_block_real[orbital_i, orbital_j] = index_orbital
+                    else:
+                        index_for_matrix_block_real[orbital_i, orbital_j] = index_orbital * 8 + 0
+                        index_for_matrix_block_imag[orbital_i, orbital_j] = index_orbital * 8 + 1
+                        index_for_matrix_block_real[atom_num_orbital[i] + orbital_i, atom_num_orbital[j] + orbital_j] = index_orbital * 8 + 2
+                        index_for_matrix_block_imag[atom_num_orbital[i] + orbital_i, atom_num_orbital[j] + orbital_j] = index_orbital * 8 + 3
+                        index_for_matrix_block_real[orbital_i, atom_num_orbital[j] + orbital_j] = index_orbital * 8 + 4
+                        index_for_matrix_block_imag[orbital_i, atom_num_orbital[j] + orbital_j] = index_orbital * 8 + 5
+                        index_for_matrix_block_real[atom_num_orbital[i] + orbital_i, orbital_j] = index_orbital * 8 + 6
+                        index_for_matrix_block_imag[atom_num_orbital[i] + orbital_i, orbital_j] = index_orbital * 8 + 7
+                assert torch.all(index_for_matrix_block_real != -1), 'json string "orbital" should be complete for Hamiltonian grad'
+                if kernel.spinful:
+                    assert torch.all(index_for_matrix_block_imag != -1), 'json string "orbital" should be complete for Hamiltonian grad'
+
+                index_for_matrix_block_real_dict[numbers_pair] = index_for_matrix_block_real
+                if kernel.spinful:
+                    index_for_matrix_block_imag_dict[numbers_pair] = index_for_matrix_block_imag
+            else:
+                index_for_matrix_block_real = index_for_matrix_block_real_dict[numbers_pair]
+                if kernel.spinful:
+                    index_for_matrix_block_imag = index_for_matrix_block_imag_dict[numbers_pair]
+
+            if not kernel.spinful:
+                rh_dict[key_tensor] = output[index][index_for_matrix_block_real]
+            else:
+                rh_dict[key_tensor] = output[index][index_for_matrix_block_real] + 1j * output[index][index_for_matrix_block_imag]
+
+        sys.stdout = sys.stdout.terminal
+        sys.stderr = sys.stderr.terminal
+
+    print("=> Hamiltonian has been predicted, calculate the grad...")
+    for key_tensor, rotated_hamiltonian in tqdm.tqdm(rh_dict.items()):
+        atom_i = key_tensor[3]
+        atom_j = key_tensor[4]
+        assert atom_i >= 0
+        assert atom_i < num_atom
+        assert atom_j >= 0
+        assert atom_j < num_atom
+        key_str = str(list([key_tensor[0].item(), key_tensor[1].item(), key_tensor[2].item(), atom_i.item() + 1, atom_j.item() + 1]))
+        assert key_str in fid_rc, f'Can not found the key "{key_str}" in rc.h5'
+        # rotation_matrix = torch.tensor(fid_rc[key_str], dtype=torch_dtype_real, device=kernel.device).T
+        rotation_matrix = fid_rc[key_str].T
+        hamiltonian = rotate_kernel.rotate_openmx_H(rotated_hamiltonian, rotation_matrix, orbital_types[atom_i], orbital_types[atom_j])
+        hamiltonians_pred[key_str] = hamiltonian.detach().cpu()
+        assert kernel.spinful is False  # 检查soc时是否正确
+        assert len(hamiltonian.shape) == 2
+        dim_1, dim_2 = hamiltonian.shape[:]
+        assert key_str not in hamiltonians_grad_pred
+        if not kernel.spinful:
+            hamiltonians_grad_pred[key_str] = np.full((dim_1, dim_2, num_atom, 3), np.nan)
+        else:
+            hamiltonians_grad_pred[key_str] = np.full((2 * dim_1, 2 * dim_2, num_atom, 3), np.nan + 1j * np.nan)
+
+    write_ham_h5(hamiltonians_pred, path=os.path.join(output_dir, 'hamiltonians_pred.h5'))
+    write_ham_h5(hamiltonians_grad_pred, path=os.path.join(output_dir, 'hamiltonians_grad_pred.h5'))
+    with open(os.path.join(output_dir, "info.json"), 'w') as info_f:
+        json.dump({
+            "isspinful": predict_spinful
+        }, info_f)
+    fid_rc.close()

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/restore_blocks.jl

@@ -0,0 +1,115 @@
+using JSON
+using LinearAlgebra
+using DelimitedFiles
+using HDF5
+using ArgParse
+
+
+function parse_commandline()
+    s = ArgParseSettings()
+    @add_arg_table! s begin
+        "--input_dir", "-i"
+            help = "path of block_without_restoration, element.dat, site_positions.dat, orbital_types.dat, and info.json"
+            arg_type = String
+            default = "./"
+        "--output_dir", "-o"
+            help = "path of output rh_pred.h5"
+            arg_type = String
+            default = "./"
+    end
+    return parse_args(s)
+end
+parsed_args = parse_commandline()
+
+
+function _create_dict_h5(filename::String)
+    fid = h5open(filename, "r")
+    T = eltype(fid[keys(fid)[1]])
+    d_out = Dict{Array{Int64,1}, Array{T, 2}}()
+    for key in keys(fid)
+        data = read(fid[key])
+        nk = map(x -> parse(Int64, convert(String, x)), split(key[2 : length(key) - 1], ','))
+        d_out[nk] = permutedims(data)
+    end
+    close(fid)
+    return d_out
+end
+
+
+if isfile(joinpath(parsed_args["input_dir"],"info.json"))
+    spinful = JSON.parsefile(joinpath(parsed_args["input_dir"],"info.json"))["isspinful"]
+else
+    spinful = false
+end
+
+spinful = JSON.parsefile(joinpath(parsed_args["input_dir"],"info.json"))["isspinful"]
+numbers = readdlm(joinpath(parsed_args["input_dir"], "element.dat"), Int64)
+lattice = readdlm(joinpath(parsed_args["input_dir"], "lat.dat"))
+inv_lattice = inv(lattice)
+site_positions = readdlm(joinpath(parsed_args["input_dir"], "site_positions.dat"))
+nsites = size(site_positions, 2)
+orbital_types_f = open(joinpath(parsed_args["input_dir"], "orbital_types.dat"), "r")
+site_norbits = zeros(nsites)
+orbital_types = Vector{Vector{Int64}}()
+for index_site = 1:nsites
+    orbital_type = parse.(Int64, split(readline(orbital_types_f)))
+    push!(orbital_types, orbital_type)
+end
+site_norbits = (x->sum(x .* 2 .+ 1)).(orbital_types) * (1 + spinful)
+atom_num_orbital = (x->sum(x .* 2 .+ 1)).(orbital_types)
+
+fid = h5open(joinpath(parsed_args["input_dir"], "block_without_restoration", "block_without_restoration.h5"), "r")
+num_model = read(fid["num_model"])
+T_pytorch = eltype(fid["output_0"])
+if spinful
+    T_Hamiltonian = Complex{T_pytorch}
+else
+    T_Hamiltonian = T_pytorch
+end
+hoppings_pred = Dict{Array{Int64,1}, Array{T_Hamiltonian, 2}}()
+println("Found $num_model models, spinful:$spinful")
+edge_attr = read(fid["edge_attr"])
+edge_index = read(fid["edge_index"])
+for index_model in 0:(num_model-1)
+    output = read(fid["output_$index_model"])
+    orbital = JSON.parsefile(joinpath(parsed_args["input_dir"], "block_without_restoration", "orbital_$index_model.json"))
+    orbital = convert(Vector{Dict{String, Vector{Int}}}, orbital)
+    for index in 1:size(edge_index, 1)
+        R = Int.(round.(inv_lattice * edge_attr[5:7, index] - inv_lattice * edge_attr[8:10, index]))
+        i = edge_index[index, 1] + 1
+        j = edge_index[index, 2] + 1
+        key_term = cat(R, i, j, dims=1)
+        for (index_orbital, orbital_dict) in enumerate(orbital)
+            atomic_number_pair = "$(numbers[i]) $(numbers[j])"
+            if !(atomic_number_pair ∈ keys(orbital_dict))
+                continue
+            end
+            orbital_i, orbital_j = orbital_dict[atomic_number_pair]
+            orbital_i += 1
+            orbital_j += 1
+
+            if !(key_term ∈ keys(hoppings_pred))
+                if spinful
+                    hoppings_pred[key_term] = fill(NaN + NaN * im, 2 * atom_num_orbital[i], 2 * atom_num_orbital[j])
+                else
+                    hoppings_pred[key_term] = fill(NaN, atom_num_orbital[i], atom_num_orbital[j])
+                end
+            end
+            if spinful
+                hoppings_pred[key_term][orbital_i, orbital_j] = output[index_orbital * 8 - 7, index] + output[index_orbital * 8 - 6, index] * im
+                hoppings_pred[key_term][atom_num_orbital[i] + orbital_i, atom_num_orbital[j] + orbital_j] = output[index_orbital * 8 - 5, index] + output[index_orbital * 8 - 4, index] * im
+                hoppings_pred[key_term][orbital_i, atom_num_orbital[j] + orbital_j] = output[index_orbital * 8 - 3, index] + output[index_orbital * 8 - 2, index] * im
+                hoppings_pred[key_term][atom_num_orbital[i] + orbital_i, orbital_j] = output[index_orbital * 8 - 1, index] + output[index_orbital * 8, index] * im
+            else
+                hoppings_pred[key_term][orbital_i, orbital_j] = output[index_orbital, index]
+            end
+        end
+    end
+end
+close(fid)
+
+h5open(joinpath(parsed_args["output_dir"], "rh_pred.h5"), "w") do fid
+    for (key, rh_pred) in hoppings_pred
+        write(fid, string(key), permutedims(rh_pred))
+    end
+end

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/sparse_calc.jl

@@ -0,0 +1,412 @@
+using DelimitedFiles, LinearAlgebra, JSON
+using HDF5
+using ArgParse
+using SparseArrays
+using Pardiso, Arpack, LinearMaps
+using JLD
+# BLAS.set_num_threads(1)
+
+const ev2Hartree = 0.036749324533634074
+const Bohr2Ang = 0.529177249
+const default_dtype = Complex{Float64}
+
+
+function parse_commandline()
+    s = ArgParseSettings()
+    @add_arg_table! s begin
+        "--input_dir", "-i"
+            help = "path of rlat.dat, orbital_types.dat, site_positions.dat, hamiltonians_pred.h5, and overlaps.h5"
+            arg_type = String
+            default = "./"
+        "--output_dir", "-o"
+            help = "path of output openmx.Band"
+            arg_type = String
+            default = "./"
+        "--config"
+            help = "config file in the format of JSON"
+            arg_type = String
+        "--ill_project"
+            help = "projects out the eigenvectors of the overlap matrix that correspond to eigenvalues smaller than ill_threshold"
+            arg_type = Bool
+            default = true
+        "--ill_threshold"
+            help = "threshold for ill_project"
+            arg_type = Float64
+            default = 5e-4
+    end
+    return parse_args(s)
+end
+
+
+function _create_dict_h5(filename::String)
+    fid = h5open(filename, "r")
+    T = eltype(fid[keys(fid)[1]])
+    d_out = Dict{Array{Int64,1}, Array{T, 2}}()
+    for key in keys(fid)
+        data = read(fid[key])
+        nk = map(x -> parse(Int64, convert(String, x)), split(key[2 : length(key) - 1], ','))
+        d_out[nk] = permutedims(data)
+    end
+    close(fid)
+    return d_out
+end
+
+
+# The function construct_linear_map below is come from https://discourse.julialang.org/t/smallest-magnitude-eigenvalues-of-the-generalized-eigenvalue-equation-for-a-large-sparse-matrix/75485/11
+function construct_linear_map(H, S)
+    ps = MKLPardisoSolver()
+    set_matrixtype!(ps, Pardiso.COMPLEX_HERM_INDEF)
+    pardisoinit(ps)
+    fix_iparm!(ps, :N)
+    H_pardiso = get_matrix(ps, H, :N)
+    b = rand(ComplexF64, size(H, 1))
+    set_phase!(ps, Pardiso.ANALYSIS)
+    pardiso(ps, H_pardiso, b)
+    set_phase!(ps, Pardiso.NUM_FACT)
+    pardiso(ps, H_pardiso, b)
+    return (
+        LinearMap{ComplexF64}(
+            (y, x) -> begin
+                set_phase!(ps, Pardiso.SOLVE_ITERATIVE_REFINE)
+                pardiso(ps, y, H_pardiso, S * x)
+            end,
+            size(H, 1);
+            ismutating=true
+        ),
+        ps
+    )
+end
+
+
+function genlist(x)
+    return collect(range(x[1], stop = x[2], length = Int64(x[3])))
+end
+
+
+function k_data2num_ks(kdata::AbstractString)
+    return parse(Int64,split(kdata)[1])
+end
+
+
+function k_data2kpath(kdata::AbstractString)
+    return map(x->parse(Float64,x), split(kdata)[2:7])
+end
+
+
+function std_out_array(a::AbstractArray)
+    return string(map(x->string(x," "),a)...)
+end
+
+
+function constructmeshkpts(nkmesh::Vector{Int64}; offset::Vector{Float64}=[0.0, 0.0, 0.0],
+    k1::Vector{Float64}=[0.0, 0.0, 0.0], k2::Vector{Float64}=[1.0, 1.0, 1.0])
+    length(nkmesh) == 3 || throw(ArgumentError("nkmesh in wrong size."))
+    nkpts = prod(nkmesh)
+    kpts = zeros(3, nkpts)
+    ik = 1
+    for ikx in 1:nkmesh[1], iky in 1:nkmesh[2], ikz in 1:nkmesh[3]
+        kpts[:, ik] = [
+            (ikx-1)/nkmesh[1]*(k2[1]-k1[1])+k1[1],
+            (iky-1)/nkmesh[2]*(k2[2]-k1[2])+k1[2],
+            (ikz-1)/nkmesh[3]*(k2[3]-k1[3])+k1[3]
+        ]
+        ik += 1
+    end
+    return kpts.+offset
+end
+
+
+function main()
+    parsed_args = parse_commandline()
+
+    println(parsed_args["config"])
+    config = JSON.parsefile(parsed_args["config"])
+    calc_job = config["calc_job"]
+    ill_project = parsed_args["ill_project"]
+    ill_threshold = parsed_args["ill_threshold"]
+
+    if isfile(joinpath(parsed_args["input_dir"],"info.json"))
+        spinful = JSON.parsefile(joinpath(parsed_args["input_dir"],"info.json"))["isspinful"]
+    else
+        spinful = false
+    end
+
+    site_positions = readdlm(joinpath(parsed_args["input_dir"], "site_positions.dat"))
+    nsites = size(site_positions, 2)
+
+    orbital_types_f = open(joinpath(parsed_args["input_dir"], "orbital_types.dat"), "r")
+    site_norbits = zeros(nsites)
+    orbital_types = Vector{Vector{Int64}}()
+    for index_site = 1:nsites
+        orbital_type = parse.(Int64, split(readline(orbital_types_f)))
+        push!(orbital_types, orbital_type)
+    end
+    site_norbits = (x->sum(x .* 2 .+ 1)).(orbital_types) * (1 + spinful)
+    norbits = sum(site_norbits)
+    site_norbits_cumsum = cumsum(site_norbits)
+
+    rlat = readdlm(joinpath(parsed_args["input_dir"], "rlat.dat"))
+
+
+    if isfile(joinpath(parsed_args["input_dir"], "sparse_matrix.jld"))
+        @info string("read sparse matrix from ", parsed_args["input_dir"], "/sparse_matrix.jld")
+        H_R = load(joinpath(parsed_args["input_dir"], "sparse_matrix.jld"), "H_R")
+        S_R = load(joinpath(parsed_args["input_dir"], "sparse_matrix.jld"), "S_R")
+    else
+        @info "read h5"
+        begin_time = time()
+        hamiltonians_pred = _create_dict_h5(joinpath(parsed_args["input_dir"], "hamiltonians_pred.h5"))
+        overlaps = _create_dict_h5(joinpath(parsed_args["input_dir"], "overlaps.h5"))
+        println("Time for reading h5: ", time() - begin_time, "s")
+
+        I_R = Dict{Vector{Int64}, Vector{Int64}}()
+        J_R = Dict{Vector{Int64}, Vector{Int64}}()
+        H_V_R = Dict{Vector{Int64}, Vector{default_dtype}}()
+        S_V_R = Dict{Vector{Int64}, Vector{default_dtype}}()
+
+        @info "construct sparse matrix in the format of COO"
+        begin_time = time()
+        for key in collect(keys(hamiltonians_pred))
+            hamiltonian_pred = hamiltonians_pred[key]
+            if (key ∈ keys(overlaps))
+                overlap = overlaps[key]
+                if spinful
+                    overlap = vcat(hcat(overlap,zeros(size(overlap))),hcat(zeros(size(overlap)),overlap)) # the readout overlap matrix only contains the upper-left block # TODO maybe drop the zeros?
+                end
+            else
+                # continue
+                overlap = zero(hamiltonian_pred)
+            end
+            R = key[1:3]; atom_i=key[4]; atom_j=key[5]
+
+            @assert (site_norbits[atom_i], site_norbits[atom_j]) == size(hamiltonian_pred)
+            @assert (site_norbits[atom_i], site_norbits[atom_j]) == size(overlap)
+            if !(R ∈ keys(I_R))
+                I_R[R] = Vector{Int64}()
+                J_R[R] = Vector{Int64}()
+                H_V_R[R] = Vector{default_dtype}()
+                S_V_R[R] = Vector{default_dtype}()
+            end
+            for block_matrix_i in 1:site_norbits[atom_i]
+                for block_matrix_j in 1:site_norbits[atom_j]
+                    coo_i = site_norbits_cumsum[atom_i] - site_norbits[atom_i] + block_matrix_i
+                    coo_j = site_norbits_cumsum[atom_j] - site_norbits[atom_j] + block_matrix_j
+                    push!(I_R[R], coo_i)
+                    push!(J_R[R], coo_j)
+                    push!(H_V_R[R], hamiltonian_pred[block_matrix_i, block_matrix_j])
+                    push!(S_V_R[R], overlap[block_matrix_i, block_matrix_j])
+                end
+            end
+        end
+        println("Time for constructing sparse matrix in the format of COO: ", time() - begin_time, "s")
+
+        @info "convert sparse matrix to the format of CSC"
+        begin_time = time()
+        H_R = Dict{Vector{Int64}, SparseMatrixCSC{default_dtype, Int64}}()
+        S_R = Dict{Vector{Int64}, SparseMatrixCSC{default_dtype, Int64}}()
+
+        for R in keys(I_R)
+            H_R[R] = sparse(I_R[R], J_R[R], H_V_R[R], norbits, norbits)
+            S_R[R] = sparse(I_R[R], J_R[R], S_V_R[R], norbits, norbits)
+        end
+        println("Time for converting to the format of CSC: ", time() - begin_time, "s")
+
+        save(joinpath(parsed_args["input_dir"], "sparse_matrix.jld"), "H_R", H_R, "S_R", S_R)
+    end
+
+    if calc_job == "band"
+        which_k = config["which_k"] # which k point to calculate, start counting from 1, 0 for all k points
+        fermi_level = config["fermi_level"]
+        max_iter = config["max_iter"]
+        num_band = config["num_band"]
+        k_data = config["k_data"]
+
+        @info "calculate bands"
+        num_ks = k_data2num_ks.(k_data)
+        kpaths = k_data2kpath.(k_data)
+
+        egvals = zeros(Float64, num_band, sum(num_ks)[1])
+
+        begin_time = time()
+        idx_k = 1
+        for i = 1:size(kpaths, 1)
+            kpath = kpaths[i]
+            pnkpts = num_ks[i]
+            kxs = LinRange(kpath[1], kpath[4], pnkpts)
+            kys = LinRange(kpath[2], kpath[5], pnkpts)
+            kzs = LinRange(kpath[3], kpath[6], pnkpts)
+            for (kx, ky, kz) in zip(kxs, kys, kzs)
+                if which_k == 0 || which_k == idx_k
+                    H_k = spzeros(default_dtype, norbits, norbits)
+                    S_k = spzeros(default_dtype, norbits, norbits)
+                    for R in keys(H_R)
+                        H_k += H_R[R] * exp(im*2π*([kx, ky, kz]⋅R))
+                        S_k += S_R[R] * exp(im*2π*([kx, ky, kz]⋅R))
+                    end
+                    S_k = (S_k + S_k') / 2
+                    H_k = (H_k + H_k') / 2
+                    if ill_project
+                        lm, ps = construct_linear_map(Hermitian(H_k) - (fermi_level) * Hermitian(S_k), Hermitian(S_k))
+                        println("Time for No.$idx_k matrix factorization: ", time() - begin_time, "s")
+                        egval_sub_inv, egvec_sub = eigs(lm, nev=num_band, which=:LM, ritzvec=true, maxiter=max_iter)
+                        set_phase!(ps, Pardiso.RELEASE_ALL)
+                        pardiso(ps)
+                        egval_sub = real(1 ./ egval_sub_inv) .+ (fermi_level)
+
+                        # orthogonalize the eigenvectors
+                        egvec_sub_qr = qr(egvec_sub)
+                        egvec_sub = convert(Matrix{default_dtype}, egvec_sub_qr.Q)
+
+                        S_k_sub = egvec_sub' * S_k * egvec_sub
+                        (egval_S, egvec_S) = eigen(Hermitian(S_k_sub))
+                        # egvec_S: shape (num_basis, num_bands)
+                        project_index = abs.(egval_S) .> ill_threshold
+                        if sum(project_index) != length(project_index)
+                            H_k_sub = egvec_sub' * H_k * egvec_sub
+                            egvec_S = egvec_S[:, project_index]
+                            @warn "ill-conditioned eigenvalues detected, projected out $(length(project_index) - sum(project_index)) eigenvalues"
+                            H_k_sub = egvec_S' * H_k_sub * egvec_S
+                            S_k_sub = egvec_S' * S_k_sub * egvec_S
+                            (egval, egvec) = eigen(Hermitian(H_k_sub), Hermitian(S_k_sub))
+                            egval = vcat(egval, fill(1e4, length(project_index) - sum(project_index)))
+                            egvec = egvec_S * egvec
+                            egvec = egvec_sub * egvec
+                        else
+                            egval = egval_sub
+                        end
+                    else
+                        lm, ps = construct_linear_map(Hermitian(H_k) - (fermi_level) * Hermitian(S_k), Hermitian(S_k))
+                        println("Time for No.$idx_k matrix factorization: ", time() - begin_time, "s")
+                        egval_inv, egvec = eigs(lm, nev=num_band, which=:LM, ritzvec=false, maxiter=max_iter)
+                        set_phase!(ps, Pardiso.RELEASE_ALL)
+                        pardiso(ps)
+                        egval = real(1 ./ egval_inv) .+ (fermi_level)
+                        # egval = real(eigs(H_k, S_k, nev=num_band, sigma=(fermi_level + lowest_band), which=:LR, ritzvec=false, maxiter=max_iter)[1])
+                    end
+                    egvals[:, idx_k] = egval
+                    if which_k == 0
+                        # println(egval .- fermi_level)
+                    else
+                        open(joinpath(parsed_args["output_dir"], "kpoint.dat"), "w") do f
+                            writedlm(f, [kx, ky, kz])
+                        end
+                        open(joinpath(parsed_args["output_dir"], "egval.dat"), "w") do f
+                            writedlm(f, egval)
+                        end
+                    end
+                    egvals[:, idx_k] = egval
+                    println("Time for solving No.$idx_k eigenvalues at k = ", [kx, ky, kz], ": ", time() - begin_time, "s")
+                end
+                idx_k += 1
+            end
+        end
+
+        # output in openmx band format
+        f = open(joinpath(parsed_args["output_dir"], "openmx.Band"),"w")
+        println(f, num_band, " ", 0, " ", ev2Hartree * fermi_level)
+        openmx_rlat = reshape((rlat .* Bohr2Ang), 1, :)
+        println(f, std_out_array(openmx_rlat))
+        println(f, length(k_data))
+        for line in k_data
+            println(f,line)
+        end
+        idx_k = 1
+        for i = 1:size(kpaths, 1)
+            pnkpts = num_ks[i]
+            kstart = kpaths[i][1:3]
+            kend = kpaths[i][4:6]
+            k_list = zeros(Float64,pnkpts,3)
+            for alpha = 1:3
+                k_list[:,alpha] = genlist([kstart[alpha],kend[alpha],pnkpts])
+            end
+            for j = 1:pnkpts
+                kvec = k_list[j,:]
+                println(f, num_band, " ", std_out_array(kvec))
+                println(f, std_out_array(ev2Hartree * egvals[:, idx_k]))
+                idx_k += 1
+            end
+        end
+        close(f)
+    elseif calc_job == "dos"
+        fermi_level = config["fermi_level"]
+        max_iter = config["max_iter"]
+        num_band = config["num_band"]
+        nkmesh = convert(Array{Int64,1}, config["kmesh"])
+        ks = constructmeshkpts(nkmesh)
+        nks = size(ks, 2)
+
+        egvals = zeros(Float64, num_band, nks)
+        begin_time = time()
+        for idx_k in 1:nks
+            kx, ky, kz = ks[:, idx_k]
+
+            H_k = spzeros(default_dtype, norbits, norbits)
+            S_k = spzeros(default_dtype, norbits, norbits)
+            for R in keys(H_R)
+                H_k += H_R[R] * exp(im*2π*([kx, ky, kz]⋅R))
+                S_k += S_R[R] * exp(im*2π*([kx, ky, kz]⋅R))
+            end
+            S_k = (S_k + S_k') / 2
+            H_k = (H_k + H_k') / 2
+            if ill_project
+                lm, ps = construct_linear_map(Hermitian(H_k) - (fermi_level) * Hermitian(S_k), Hermitian(S_k))
+                println("Time for No.$idx_k matrix factorization: ", time() - begin_time, "s")
+                egval_sub_inv, egvec_sub = eigs(lm, nev=num_band, which=:LM, ritzvec=true, maxiter=max_iter)
+                set_phase!(ps, Pardiso.RELEASE_ALL)
+                pardiso(ps)
+                egval_sub = real(1 ./ egval_sub_inv) .+ (fermi_level)
+
+                # orthogonalize the eigenvectors
+                egvec_sub_qr = qr(egvec_sub)
+                egvec_sub = convert(Matrix{default_dtype}, egvec_sub_qr.Q)
+
+                S_k_sub = egvec_sub' * S_k * egvec_sub
+                (egval_S, egvec_S) = eigen(Hermitian(S_k_sub))
+                # egvec_S: shape (num_basis, num_bands)
+                project_index = abs.(egval_S) .> ill_threshold
+                if sum(project_index) != length(project_index)
+                    H_k_sub = egvec_sub' * H_k * egvec_sub
+                    egvec_S = egvec_S[:, project_index]
+                    @warn "ill-conditioned eigenvalues detected, projected out $(length(project_index) - sum(project_index)) eigenvalues"
+                    H_k_sub = egvec_S' * H_k_sub * egvec_S
+                    S_k_sub = egvec_S' * S_k_sub * egvec_S
+                    (egval, egvec) = eigen(Hermitian(H_k_sub), Hermitian(S_k_sub))
+                    egval = vcat(egval, fill(1e4, length(project_index) - sum(project_index)))
+                    egvec = egvec_S * egvec
+                    egvec = egvec_sub * egvec
+                else
+                    egval = egval_sub
+                end
+            else
+                lm, ps = construct_linear_map(Hermitian(H_k) - (fermi_level) * Hermitian(S_k), Hermitian(S_k))
+                println("Time for No.$idx_k matrix factorization: ", time() - begin_time, "s")
+                egval_inv, egvec = eigs(lm, nev=num_band, which=:LM, ritzvec=false, maxiter=max_iter)
+                set_phase!(ps, Pardiso.RELEASE_ALL)
+                pardiso(ps)
+                egval = real(1 ./ egval_inv) .+ (fermi_level)
+                # egval = real(eigs(H_k, S_k, nev=num_band, sigma=(fermi_level + lowest_band), which=:LR, ritzvec=false, maxiter=max_iter)[1])
+            end
+            egvals[:, idx_k] = egval
+            println("Time for solving No.$idx_k eigenvalues at k = ", [kx, ky, kz], ": ", time() - begin_time, "s")
+        end
+
+        open(joinpath(parsed_args["output_dir"], "egvals.dat"), "w") do f
+            writedlm(f, egvals)
+        end
+
+        ϵ = config["epsilon"]
+        ωs = genlist(config["omegas"])
+        nωs = length(ωs)
+        dos = zeros(nωs)
+        factor = 1/((2π)^3*ϵ*√π)
+        for idx_k in 1:nks, idx_band in 1:num_band, (idx_ω, ω) in enumerate(ωs)
+            dos[idx_ω] += exp(-(egvals[idx_band, idx_k] - ω - fermi_level) ^ 2 / ϵ ^ 2) * factor
+        end
+        open(joinpath(parsed_args["output_dir"], "dos.dat"), "w") do f
+            writedlm(f, [ωs dos])
+        end
+    end
+end
+
+
+main()

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/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

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/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

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/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()

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/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

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/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')

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/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"]

1_data_prepare/data/bands/uc/reconstruction/aohamiltonian/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()

1_data_prepare/data/bands/uc/scf/_ph0/diamond.phsave/control_ph.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Root>
+  <HEADER>
+    <FORMAT NAME="QEXML" VERSION="1.4.0"/>
+    <CREATOR NAME="PH" VERSION="7.2"/>
+  </HEADER>
+  <CONTROL>
+    <DISPERSION_RUN>false</DISPERSION_RUN>
+    <ELECTRIC_FIELD>false</ELECTRIC_FIELD>
+    <PHONON_RUN>true</PHONON_RUN>
+    <ELECTRON_PHONON>false</ELECTRON_PHONON>
+    <EFFECTIVE_CHARGE_EU>false</EFFECTIVE_CHARGE_EU>
+    <EFFECTIVE_CHARGE_PH>false</EFFECTIVE_CHARGE_PH>
+    <RAMAN_TENSOR>false</RAMAN_TENSOR>
+    <ELECTRO_OPTIC>false</ELECTRO_OPTIC>
+    <FREQUENCY_DEP_POL>false</FREQUENCY_DEP_POL>
+  </CONTROL>
+  <Q_POINTS>
+    <NUMBER_OF_Q_POINTS>
+                 1
+    </NUMBER_OF_Q_POINTS>
+    <UNITS_FOR_Q-POINT UNITS="2 pi / a"/>
+    <Q-POINT_COORDINATES>
+   0.000000000000000E+00   0.000000000000000E+00   0.000000000000000E+00
+    </Q-POINT_COORDINATES>
+  </Q_POINTS>
+</Root>

1_data_prepare/data/bands/uc/scf/_ph0/diamond.phsave/dynmat.1.0.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Root>
+  <PM_HEADER>
+    <DONE_IRR>true</DONE_IRR>
+  </PM_HEADER>
+  <PARTIAL_MATRIX>
+    <PARTIAL_DYN>
+   3.484598408489698E+01  -6.312196590787640E-18
+   8.690241036524503E-01   1.237663837087336E-17
+  -5.385920672984279E-01   6.576775186042414E-18
+   1.645097960512737E-07  -5.203867086925237E-15
+  -5.762795053931846E-07  -7.551703331487875E-16
+   3.263126217567525E-07  -2.035118353263037E-15
+   8.690241036524511E-01   1.237663837086976E-17
+   3.305386352685629E+01  -2.813197574806354E-17
+   2.463623983376761E+00   6.849623145749403E-18
+  -2.218325921036698E-07  -2.290442746813690E-15
+   2.613749412461175E-07  -1.616755177784139E-15
+  -2.976016570677142E-07  -3.921335226450931E-16
+  -5.385920672984271E-01   6.576775186046179E-18
+   2.463623983376761E+00   6.849623145749601E-18
+   3.603973651404256E+01  -1.692131618321098E-17
+   3.740880009017386E-08   5.839528743185681E-15
+  -1.120524914799415E-07   2.433841965816495E-15
+  -1.038040902262560E-07  -4.688344083003438E-15
+   1.645097958936039E-07   4.759059852946046E-15
+  -2.218325937345014E-07   2.556875221841142E-15
+   3.740879958350874E-08  -5.669694756094177E-15
+   2.958252466795426E+01  -2.591634630866419E-17
+   2.612829994789184E+00   7.516959013986452E-18
+   3.819367529809595E-01   3.218506276749747E-18
+  -5.762795122540761E-07   1.440365864553108E-15
+   2.613749429551507E-07   2.151239792358933E-15
+  -1.120524902698576E-07  -2.632619517081344E-15
+   2.612829994789187E+00   7.516959013983181E-18
+   3.184683488448889E+01  -2.797341935844423E-17
+   7.500919201974021E-01   2.238271310689798E-18
+   3.263126231132398E-07   2.347703528650676E-15
+  -2.976016542943300E-07  -2.326270571138094E-16
+  -1.038040897713584E-07   4.613877320823429E-15
+   3.819367529809614E-01   3.218506276756663E-18
+   7.500919201974042E-01   2.238271310689797E-18
+   3.200648607555012E+01   2.524277145046247E-18
+    </PARTIAL_DYN>
+  </PARTIAL_MATRIX>
+</Root>

1_data_prepare/data/bands/uc/scf/_ph0/diamond.phsave/dynmat.1.1.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Root>
+  <PM_HEADER>
+    <DONE_IRR>true</DONE_IRR>
+  </PM_HEADER>
+  <PARTIAL_MATRIX>
+    <PARTIAL_DYN>
+  -3.306486919995417E+01  -1.042601950876543E-09
+  -6.725039802939238E-01  -3.597035750345589E-08
+   4.921295639517659E-01   5.694226470855279E-08
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+  -6.722632765120149E-01   6.651886373546226E-08
+  -3.219606484374033E+01  -3.548476827872810E-09
+  -1.528301059085400E+00   1.061047381245662E-07
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   4.923909303130659E-01  -7.222033228776863E-08
+  -1.528984481778737E+00  -1.123971047650092E-07
+  -3.358477149299882E+01   1.543423634857984E-08
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+  -1.150299478933081E-07  -6.267280812380251E-01
+   1.454730519101499E-07   1.974358540447818E-01
+   2.271660257124886E-08   1.225472121031028E-01
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   4.550082372961617E-07   6.303626698451245E-01
+  -2.152013225398264E-07   4.997972445232625E-01
+   8.669489925949847E-08  -2.790580480328600E-01
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+  -1.944220450467160E-07   2.787254236595550E-01
+   2.183414124501404E-07  -7.151376098431174E-01
+   1.040674222803351E-07   2.425830690440389E-02
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+    </PARTIAL_DYN>
+  </PARTIAL_MATRIX>
+</Root>

1_data_prepare/data/bands/uc/scf/_ph0/diamond.phsave/dynmat.1.2.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Root>
+  <PM_HEADER>
+    <DONE_IRR>true</DONE_IRR>
+  </PM_HEADER>
+  <PARTIAL_MATRIX>
+    <PARTIAL_DYN>
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+  -9.415583422482665E-08   6.298774015069858E-01
+   4.610722772191433E-07  -6.217279782417344E-01
+  -2.002179043669727E-07  -2.810022781298951E-01
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   1.304664546120105E-07  -1.937638788646358E-01
+  -1.867054728738049E-07  -4.889481345626043E-01
+   2.253321559203547E-07   6.945487410994460E-01
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+  -1.926063114554566E-09  -1.209608496302796E-01
+   1.355494632995780E-07   2.751624153391077E-01
+   8.763397301575493E-08  -3.439717567817600E-02
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+  -2.968497440699806E+01  -5.554126422795463E-09
+  -2.310368801976090E+00  -2.371297053882148E-08
+  -2.850726562192887E-01  -1.242148251421532E-07
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+  -2.310372026282785E+00   1.481331674333662E-08
+  -3.172979080950947E+01  -5.556302032920791E-09
+  -6.752217519310538E-01   1.119612119611418E-07
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+   0.000000000000000E+00   0.000000000000000E+00
+  -2.850740374574177E-01   1.373887226060796E-07
+  -6.752197834214591E-01  -9.516342673711952E-08
+  -3.187559449718772E+01  -3.681011800046182E-09
+    </PARTIAL_DYN>
+  </PARTIAL_MATRIX>
+</Root>

1_data_prepare/data/bands/uc/scf/_ph0/diamond.phsave/patterns.1.xml

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Root>
+  <IRREPS_INFO>
+    <QPOINT_NUMBER>1</QPOINT_NUMBER>
+    <QPOINT_GROUP_RANK>48</QPOINT_GROUP_RANK>
+    <MINUS_Q_SYM>true</MINUS_Q_SYM>
+    <NUMBER_IRR_REP>2</NUMBER_IRR_REP>
+    <REPRESENTION.1>
+      <NUMBER_OF_PERTURBATIONS>3</NUMBER_OF_PERTURBATIONS>
+      <PERTURBATION.1>
+        <DISPLACEMENT_PATTERN>
+ -0.231855586862688       0.000000000000000E+000
+  0.281831072066113       0.000000000000000E+000
+ -0.605651907995529       0.000000000000000E+000
+  0.231855586862687       0.000000000000000E+000
+ -0.281831072066113       0.000000000000000E+000
+  0.605651907995529       0.000000000000000E+000
+        </DISPLACEMENT_PATTERN>
+      </PERTURBATION.1>
+      <PERTURBATION.2>
+        <DISPLACEMENT_PATTERN>
+ -9.881167931337864E-003  0.000000000000000E+000
+  0.639577945071490       0.000000000000000E+000
+  0.301400754309679       0.000000000000000E+000
+  9.881167931337864E-003  0.000000000000000E+000
+ -0.639577945071490       0.000000000000000E+000
+ -0.301400754309679       0.000000000000000E+000
+        </DISPLACEMENT_PATTERN>
+      </PERTURBATION.2>
+      <PERTURBATION.3>
+        <DISPLACEMENT_PATTERN>
+ -0.667941127166812       0.000000000000000E+000
+ -0.107290721855136       0.000000000000000E+000
+  0.205775002473411       0.000000000000000E+000
+  0.667941127166812       0.000000000000000E+000
+  0.107290721855136       0.000000000000000E+000
+ -0.205775002473411       0.000000000000000E+000
+        </DISPLACEMENT_PATTERN>
+      </PERTURBATION.3>
+    </REPRESENTION.1>
+    <REPRESENTION.2>
+      <NUMBER_OF_PERTURBATIONS>3</NUMBER_OF_PERTURBATIONS>
+      <PERTURBATION.1>
+        <DISPLACEMENT_PATTERN>
+ -0.567393140911867       0.000000000000000E+000
+ -0.421344493890803       0.000000000000000E+000
+  2.310500192748906E-002  0.000000000000000E+000
+ -0.567393140911866       0.000000000000000E+000
+ -0.421344493890803       0.000000000000000E+000
+  2.310500192748907E-002  0.000000000000000E+000
+        </DISPLACEMENT_PATTERN>
+      </PERTURBATION.1>
+      <PERTURBATION.2>
+        <DISPLACEMENT_PATTERN>
+ -0.197534969092956       0.000000000000000E+000
+  0.299421002187529       0.000000000000000E+000
+  0.609366063573006       0.000000000000000E+000
+ -0.197534969092956       0.000000000000000E+000
+  0.299421002187529       0.000000000000000E+000
+  0.609366063573006       0.000000000000000E+000
+        </DISPLACEMENT_PATTERN>
+      </PERTURBATION.2>
+      <PERTURBATION.3>
+        <DISPLACEMENT_PATTERN>
+ -0.372887328333387       0.000000000000000E+000
+  0.482509980121571       0.000000000000000E+000
+ -0.357965304815244       0.000000000000000E+000
+ -0.372887328333387       0.000000000000000E+000
+  0.482509980121571       0.000000000000000E+000
+ -0.357965304815244       0.000000000000000E+000
+        </DISPLACEMENT_PATTERN>
+      </PERTURBATION.3>
+    </REPRESENTION.2>
+  </IRREPS_INFO>
+</Root>

1_data_prepare/data/bands/uc/scf/_ph0/diamond.phsave/status_run.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Root>
+  <STATUS_PH>
+    <STOPPED_IN>dynmatrix.</STOPPED_IN>
+    <RECOVER_CODE>30</RECOVER_CODE>
+    <CURRENT_Q>1</CURRENT_Q>
+    <CURRENT_IU>1</CURRENT_IU>
+  </STATUS_PH>
+</Root>

1_data_prepare/data/bands/uc/scf/aohamiltonian/element.dat

@@ -0,0 +1,2 @@
+6  
+6  

1_data_prepare/data/bands/uc/scf/aohamiltonian/info.json

@@ -0,0 +1 @@
+{"isspinful": false, "fermi_level": 0.0}

1_data_prepare/data/bands/uc/scf/aohamiltonian/lat.dat

@@ -0,0 +1,3 @@
+0.000000000000000000e+00 1.783499998856923785e+00 1.783499998856923785e+00
+1.783499998856923785e+00 0.000000000000000000e+00 1.783499998856923785e+00
+1.783499998856923785e+00 1.783499998856923785e+00 0.000000000000000000e+00

1_data_prepare/data/bands/uc/scf/aohamiltonian/orbital_types.dat

@@ -0,0 +1,2 @@
+0 0 1 1 2
+0 0 1 1 2

1_data_prepare/data/bands/uc/scf/aohamiltonian/rlat.dat

@@ -0,0 +1,3 @@
+-1.761476117523574025e+00 1.761476117523574025e+00 1.761476117523574025e+00
+1.761476117523574025e+00 -1.761476117523574025e+00 1.761476117523574025e+00
+1.761476117523574025e+00 1.761476117523574025e+00 -1.761476117523574025e+00

1_data_prepare/data/bands/uc/scf/aohamiltonian/site_positions.dat

@@ -0,0 +1,3 @@
+0.000000000000000000e+00 8.917499994284623366e-01
+0.000000000000000000e+00 8.917499994284623366e-01
+0.000000000000000000e+00 8.917499994284623366e-01

1_data_prepare/data/bands/uc/scf/bands.dat

@@ -0,0 +1,994 @@
+ &plot nbnd=  20, nks=   331 /
+            0.000000  0.000000  0.000000
+   -8.131   13.365   13.365   13.365   18.998   18.998   18.998   26.673   32.650   40.213
+   40.213   40.988   40.988   40.988   48.164   60.690   60.690   60.690   81.531   81.531
+            0.000000  0.033333  0.000000
+   -8.121   13.321   13.321   13.339   18.990   19.051   19.051   26.682   32.668   39.552
+   40.226   41.012   41.012   41.621   48.255   60.656   60.656   60.675   81.428   81.428
+            0.000000  0.066667  0.000000
+   -8.090   13.193   13.193   13.268   18.965   19.205   19.205   26.707   32.724   38.615
+   40.265   41.084   41.084   42.473   48.532   60.552   60.552   60.630   81.149   81.149
+            0.000000  0.100000  0.000000
+   -8.039   12.997   12.997   13.146   18.925   19.447   19.447   26.741   32.815   37.678
+   40.330   41.205   41.205   43.256   49.011   60.381   60.381   60.557   80.759   80.759
+            0.000000  0.133333  0.000000
+   -7.967   12.749   12.749   12.976   18.870   19.761   19.761   26.777   32.940   36.777
+   40.421   41.374   41.374   43.934   49.695   60.142   60.142   60.459   80.322   80.322
+            0.000000  0.166667  0.000000
+   -7.875   12.458   12.458   12.761   18.804   20.130   20.130   26.800   33.096   35.937
+   40.538   41.590   41.590   44.506   50.575   59.841   59.841   60.348   79.357   79.880
+            0.000000  0.200000  0.000000
+   -7.763   12.142   12.142   12.502   18.721   20.542   20.542   26.792   33.279   35.177
+   40.681   41.853   41.853   44.995   51.618   59.476   59.476   60.199   77.966   79.462
+            0.000000  0.233333  0.000000
+   -7.630   11.810   11.810   12.207   18.633   20.986   20.986   26.734   33.488   34.521
+   40.851   42.163   42.163   45.430   52.791   59.055   59.055   60.055   76.595   79.088
+            0.000000  0.266667  0.000000
+   -7.477   11.473   11.473   11.877   18.536   21.453   21.453   26.606   33.717   33.986
+   41.046   42.518   42.518   45.838   54.062   58.578   58.578   59.902   75.247   78.767
+            0.000000  0.300000  0.000000
+   -7.303   11.132   11.132   11.516   18.436   21.939   21.939   26.392   33.588   33.964
+   41.267   42.917   42.917   46.242   55.406   58.062   58.062   59.757   73.923   78.503
+            0.000000  0.333333  0.000000
+   -7.110   10.796   10.796   11.128   18.336   22.438   22.438   26.087   33.329   34.226
+   41.514   43.360   43.360   46.655   56.806   57.513   57.513   59.629   72.623   78.301
+            0.000000  0.366667  0.000000
+   -6.897   10.464   10.464   10.714   18.232   22.945   22.945   25.698   33.200   34.495
+   41.787   43.842   43.842   47.087   56.931   56.931   58.248   59.508   71.347   78.152
+            0.000000  0.400000  0.000000
+   -6.664   10.140   10.140   10.276   18.130   23.458   23.458   25.242   33.180   34.768
+   42.087   44.360   44.360   47.548   56.330   56.330   59.409   59.721   70.096   78.056
+            0.000000  0.433333  0.000000
+   -6.411    9.817    9.827    9.827   18.032   23.974   23.974   24.741   33.247   35.041
+   42.412   44.910   44.910   48.041   55.722   55.722   59.338   61.213   68.870   78.009
+            0.000000  0.466667  0.000000
+   -6.139    9.338    9.526    9.526   17.937   24.211   24.488   24.488   33.375   35.303
+   42.763   45.483   45.483   48.571   55.119   55.119   59.295   62.710   67.668   78.000
+            0.000000  0.500000  0.000000
+   -5.848    8.842    9.239    9.239   17.850   23.674   25.002   25.002   33.552   35.561
+   43.140   46.069   46.069   49.142   54.542   54.542   59.295   64.204   66.492   78.019
+            0.000000  0.533333  0.000000
+   -5.537    8.332    8.968    8.968   17.771   23.139   25.512   25.512   33.760   35.805
+   43.543   46.649   46.649   49.754   54.015   54.015   59.338   65.342   65.672   78.035
+            0.000000  0.566667  0.000000
+   -5.208    7.808    8.712    8.712   17.702   22.616   26.015   26.015   33.987   36.032
+   43.973   47.191   47.191   50.410   53.572   53.572   59.428   64.216   67.086   77.969
+            0.000000  0.600000  0.000000
+   -4.861    7.272    8.472    8.472   17.644   22.112   26.510   26.510   34.226   36.238
+   44.428   47.648   47.648   51.110   53.267   53.267   59.569   63.116   68.402   77.613
+            0.000000  0.633333  0.000000
+   -4.495    6.726    8.249    8.249   17.598   21.629   26.989   26.989   34.461   36.420
+   44.909   47.957   47.957   51.854   53.167   53.167   59.763   62.041   69.550   76.791
+            0.000000  0.666667  0.000000
+   -4.112    6.172    8.042    8.042   17.564   21.173   27.451   27.451   34.700   36.572
+   45.416   48.063   48.063   52.643   53.327   53.327   60.011   60.992   70.448   75.681
+            0.000000  0.700000  0.000000
+   -3.711    5.614    7.856    7.856   17.548   20.747   27.900   27.900   34.944   36.710
+   45.949   47.978   47.978   53.476   53.752   53.752   59.969   60.317   71.009   74.461
+            0.000000  0.733333  0.000000
+   -3.294    5.050    7.688    7.688   17.544   20.348   28.323   28.323   35.178   36.801
+   46.508   47.750   47.750   54.351   54.390   54.390   58.971   60.673   71.168   73.186
+            0.000000  0.766667  0.000000
+   -2.860    4.482    7.540    7.540   17.556   19.980   28.719   28.719   35.404   36.871
+   47.093   47.444   47.444   55.185   55.185   55.266   57.999   61.080   70.976   71.885
+            0.000000  0.800000  0.000000
+   -2.410    3.914    7.410    7.410   17.586   19.640   29.081   29.081   35.620   36.913
+   47.111   47.111   47.704   56.089   56.089   56.221   57.052   61.530   70.531   70.573
+            0.000000  0.833333  0.000000
+   -1.945    3.346    7.301    7.301   17.634   19.329   29.403   29.403   35.819   36.920
+   46.786   46.786   48.341   56.131   57.075   57.075   57.212   62.013   69.260   69.260
+            0.000000  0.866667  0.000000
+   -1.466    2.781    7.211    7.211   17.701   19.047   29.679   29.679   36.011   36.906
+   46.492   46.492   49.003   55.236   58.122   58.122   58.234   62.504   67.953   67.953
+            0.000000  0.900000  0.000000
+   -0.972    2.221    7.141    7.141   17.789   18.792   29.902   29.902   36.189   36.866
+   46.246   46.246   49.692   54.366   59.216   59.216   59.280   62.949   66.661   66.661
+            0.000000  0.933333  0.000000
+   -0.466    1.668    7.092    7.092   17.898   18.564   30.067   30.067   36.356   36.808
+   46.064   46.064   50.406   53.523   60.339   60.343   60.343   63.208   65.395   65.395
+            0.000000  0.966667  0.000000
+    0.052    1.120    7.062    7.062   18.029   18.362   30.168   30.168   36.503   36.721
+   45.950   45.950   51.147   52.705   61.379   61.468   61.468   63.025   64.188   64.188
+            0.000000  1.000000  0.000000
+    0.581    0.581    7.050    7.050   18.182   18.182   30.194   30.194   36.613   36.613
+   45.908   45.908   51.913   51.913   62.234   62.234   62.332   62.332   63.391   63.391
+            0.016667  1.000000  0.000000
+    0.583    0.583    7.046    7.046   18.194   18.194   30.197   30.197   36.616   36.616
+   45.898   45.898   51.936   51.936   62.019   62.019   62.506   62.506   63.437   63.437
+            0.033333  1.000000  0.000000
+    0.588    0.588    7.029    7.029   18.226   18.226   30.182   30.182   36.596   36.596
+   45.861   45.861   52.004   52.004   61.739   61.739   62.657   62.657   63.568   63.568
+            0.050000  1.000000  0.000000
+    0.596    0.596    7.000    7.000   18.279   18.279   30.158   30.158   36.564   36.564
+   45.801   45.801   52.115   52.115   61.448   61.448   62.747   62.747   63.768   63.768
+            0.066667  1.000000  0.000000
+    0.608    0.608    6.961    6.961   18.353   18.353   30.123   30.123   36.520   36.520
+   45.723   45.723   52.266   52.266   61.155   61.155   62.797   62.797   64.006   64.006
+            0.083333  1.000000  0.000000
+    0.622    0.622    6.911    6.911   18.447   18.447   30.077   30.077   36.465   36.465
+   45.629   45.629   52.451   52.451   60.865   60.865   62.824   62.824   64.254   64.254
+            0.100000  1.000000  0.000000
+    0.640    0.640    6.851    6.851   18.559   18.559   30.021   30.021   36.396   36.396
+   45.523   45.523   52.666   52.666   60.580   60.580   62.837   62.837   64.494   64.494
+            0.116667  1.000000  0.000000
+    0.660    0.660    6.783    6.783   18.691   18.691   29.954   29.954   36.321   36.321
+   45.410   45.410   52.906   52.906   60.304   60.304   62.842   62.842   64.719   64.719
+            0.133333  1.000000  0.000000
+    0.684    0.684    6.707    6.707   18.840   18.840   29.875   29.875   36.238   36.238
+   45.293   45.293   53.168   53.168   60.037   60.037   62.841   62.841   64.924   64.924
+            0.150000  1.000000  0.000000
+    0.711    0.711    6.624    6.624   19.006   19.006   29.784   29.784   36.148   36.148
+   45.175   45.175   53.446   53.446   59.779   59.779   62.834   62.834   65.111   65.111
+            0.166667  1.000000  0.000000
+    0.739    0.739    6.535    6.535   19.187   19.187   29.680   29.680   36.049   36.049
+   45.057   45.057   53.737   53.737   59.533   59.533   62.821   62.821   65.282   65.282
+            0.183333  1.000000  0.000000
+    0.771    0.771    6.441    6.441   19.383   19.383   29.563   29.563   35.950   35.950
+   44.943   44.943   54.038   54.038   59.299   59.299   62.802   62.802   65.445   65.445
+            0.200000  1.000000  0.000000
+    0.805    0.805    6.344    6.344   19.593   19.593   29.433   29.433   35.848   35.848
+   44.833   44.833   54.345   54.345   59.077   59.077   62.776   62.776   65.602   65.602
+            0.216667  1.000000  0.000000
+    0.841    0.841    6.244    6.244   19.816   19.816   29.293   29.293   35.747   35.747
+   44.729   44.729   54.656   54.656   58.869   58.869   62.743   62.743   65.759   65.759
+            0.233333  1.000000  0.000000
+    0.879    0.879    6.142    6.142   20.050   20.050   29.136   29.136   35.644   35.644
+   44.630   44.630   54.966   54.966   58.676   58.676   62.703   62.703   65.918   65.918
+            0.250000  1.000000  0.000000
+    0.918    0.918    6.039    6.039   20.296   20.296   28.966   28.966   35.544   35.544
+   44.538   44.538   55.273   55.273   58.498   58.498   62.655   62.655   66.084   66.084
+            0.266667  1.000000  0.000000
+    0.959    0.959    5.936    5.936   20.550   20.550   28.780   28.780   35.447   35.447
+   44.453   44.453   55.572   55.572   58.338   58.338   62.600   62.600   66.254   66.254
+            0.283333  1.000000  0.000000
+    1.000    1.000    5.834    5.834   20.813   20.813   28.582   28.582   35.355   35.355
+   44.374   44.374   55.859   55.859   58.199   58.199   62.537   62.537   66.435   66.435
+            0.300000  1.000000  0.000000
+    1.042    1.042    5.735    5.735   21.085   21.085   28.371   28.371   35.268   35.268
+   44.304   44.304   56.127   56.127   58.087   58.087   62.467   62.467   66.629   66.629
+            0.316667  1.000000  0.000000
+    1.083    1.083    5.638    5.638   21.363   21.363   28.148   28.148   35.187   35.187
+   44.239   44.239   56.366   56.366   58.008   58.008   62.390   62.390   66.831   66.831
+            0.333333  1.000000  0.000000
+    1.124    1.124    5.546    5.546   21.646   21.646   27.917   27.917   35.112   35.112
+   44.180   44.180   56.563   56.563   57.974   57.974   62.307   62.307   67.049   67.049
+            0.350000  1.000000  0.000000
+    1.164    1.164    5.457    5.457   21.932   21.932   27.671   27.671   35.042   35.042
+   44.127   44.127   56.703   56.703   57.997   57.997   62.218   62.218   67.273   67.273
+            0.366667  1.000000  0.000000
+    1.202    1.202    5.375    5.375   22.220   22.220   27.418   27.418   34.979   34.979
+   44.081   44.081   56.782   56.782   58.080   58.080   62.123   62.123   67.506   67.506
+            0.383333  1.000000  0.000000
+    1.238    1.238    5.299    5.299   22.511   22.511   27.160   27.160   34.925   34.925
+   44.040   44.040   56.812   56.812   58.209   58.209   62.028   62.028   67.752   67.752
+            0.400000  1.000000  0.000000
+    1.270    1.270    5.232    5.232   22.800   22.800   26.898   26.898   34.878   34.878
+   44.006   44.006   56.811   56.811   58.363   58.363   61.932   61.932   68.006   68.006
+            0.416667  1.000000  0.000000
+    1.299    1.299    5.173    5.173   23.085   23.085   26.637   26.637   34.838   34.838
+   43.978   43.978   56.793   56.793   58.524   58.524   61.838   61.838   68.265   68.265
+            0.433333  1.000000  0.000000
+    1.324    1.324    5.124    5.124   23.359   23.359   26.380   26.380   34.806   34.806
+   43.954   43.954   56.770   56.770   58.675   58.675   61.751   61.751   68.524   68.524
+            0.450000  1.000000  0.000000
+    1.344    1.344    5.084    5.084   23.615   23.615   26.139   26.139   34.781   34.781
+   43.936   43.936   56.747   56.747   58.806   58.806   61.674   61.674   68.774   68.774
+            0.466667  1.000000  0.000000
+    1.359    1.359    5.056    5.056   23.835   23.835   25.928   25.928   34.763   34.763
+   43.924   43.924   56.729   56.729   58.908   58.908   61.614   61.614   68.999   68.999
+            0.483333  1.000000  0.000000
+    1.368    1.368    5.038    5.038   23.994   23.994   25.776   25.776   34.754   34.754
+   43.917   43.917   56.718   56.718   58.973   58.973   61.575   61.575   69.167   69.167
+            0.500000  1.000000  0.000000
+    1.371    1.371    5.033    5.033   24.055   24.055   25.720   25.720   34.753   34.753
+   43.914   43.914   56.715   56.715   58.995   58.995   61.564   61.564   69.234   69.234
+            0.508333  0.991667  0.000000
+    1.305    1.433    4.970    5.102   23.969   24.106   25.725   25.750   34.650   34.855
+   43.795   44.033   56.543   56.890   58.848   59.118   61.535   61.617   69.203   69.211
+            0.516667  0.983333  0.000000
+    1.242    1.488    4.909    5.180   23.828   24.148   25.786   25.788   34.542   34.959
+   43.669   44.156   56.381   57.061   58.658   59.244   61.506   61.703   69.096   69.170
+            0.525000  0.975000  0.000000
+    1.180    1.534    4.850    5.268   23.645   24.185   25.835   25.884   34.433   35.061
+   43.536   44.283   56.229   57.228   58.439   59.373   61.473   61.815   68.913   69.136
+            0.533333  0.966667  0.000000
+    1.121    1.573    4.793    5.366   23.437   24.214   25.891   26.011   34.324   35.167
+   43.398   44.414   56.088   57.389   58.202   59.504   61.443   61.944   68.695   69.101
+            0.541667  0.958333  0.000000
+    1.064    1.605    4.738    5.471   23.213   24.238   25.955   26.153   34.214   35.272
+   43.254   44.549   55.960   57.536   57.961   59.637   61.412   62.082   68.458   69.065
+            0.550000  0.950000  0.000000
+    1.010    1.630    4.684    5.584   22.980   24.255   26.027   26.307   34.103   35.380
+   43.104   44.687   55.843   57.587   57.802   59.772   61.379   62.227   68.212   69.028
+            0.558333  0.941667  0.000000
+    0.957    1.650    4.633    5.703   22.742   24.267   26.104   26.467   33.990   35.488
+   42.948   44.829   55.738   57.380   57.890   59.908   61.346   62.375   67.964   68.992
+            0.566667  0.933333  0.000000
+    0.907    1.665    4.583    5.828   22.501   24.275   26.187   26.631   33.878   35.596
+   42.787   44.973   55.645   57.120   58.021   60.046   61.310   62.527   67.716   68.956
+            0.575000  0.925000  0.000000
+    0.859    1.676    4.536    5.956   22.260   24.278   26.275   26.796   33.765   35.705
+   42.621   45.120   55.563   56.853   58.152   60.183   61.274   62.682   67.472   68.920
+            0.583333  0.916667  0.000000
+    0.814    1.683    4.490    6.089   22.021   24.279   26.367   26.962   33.654   35.814
+   42.452   45.270   55.492   56.586   58.277   60.321   61.236   62.841   67.233   68.886
+            0.591667  0.908333  0.000000
+    0.770    1.687    4.447    6.224   21.785   24.277   26.462   27.126   33.542   35.923
+   42.277   45.421   55.432   56.319   58.393   60.458   61.197   63.001   66.999   68.852
+            0.600000  0.900000  0.000000
+    0.729    1.688    4.406    6.361   21.553   24.273   26.559   27.289   33.431   36.033
+   42.100   45.575   55.382   56.054   58.502   60.593   61.158   63.166   66.774   68.821
+            0.608333  0.891667  0.000000
+    0.690    1.687    4.367    6.496   21.326   24.267   26.654   27.448   33.319   36.143
+   41.918   45.727   55.342   55.793   58.602   60.723   61.121   63.333   66.554   68.790
+            0.616667  0.883333  0.000000
+    0.653    1.684    4.329    6.632   21.104   24.260   26.752   27.603   33.209   36.253
+   41.735   45.882   55.310   55.537   58.693   60.838   61.096   63.505   66.343   68.761
+            0.625000  0.875000  0.000000
+    0.618    1.680    4.295    6.768   20.890   24.252   26.850   27.754   33.104   36.364
+   41.551   46.037   55.286   55.287   58.775   60.905   61.117   63.680   66.142   68.736
+            0.633333  0.866667  0.000000
+    0.586    1.675    4.262    6.899   20.683   24.244   26.944   27.899   32.999   36.474
+   41.365   46.190   55.040   55.271   58.850   60.900   61.206   63.857   65.947   68.711
+            0.641667  0.858333  0.000000
+    0.556    1.670    4.231    7.028   20.486   24.235   27.039   28.039   32.897   36.586
+   41.180   46.343   54.802   55.262   58.916   60.863   61.324   64.038   65.764   68.690
+            0.650000  0.850000  0.000000
+    0.528    1.663    4.203    7.153   20.297   24.226   27.131   28.171   32.799   36.697
+   40.995   46.493   54.572   55.259   58.975   60.817   61.448   64.219   65.591   68.672
+            0.658333  0.841667  0.000000
+    0.502    1.657    4.177    7.273   20.120   24.218   27.220   28.297   32.704   36.809
+   40.812   46.640   54.352   55.261   59.026   60.768   61.572   64.401   65.428   68.657
+            0.666667  0.833333  0.000000
+    0.479    1.651    4.153    7.386   19.954   24.210   27.306   28.418   32.617   36.924
+   40.633   46.784   54.142   55.268   59.071   60.718   61.694   64.581   65.275   68.647
+            0.675000  0.825000  0.000000
+    0.457    1.644    4.131    7.492   19.800   24.202   27.385   28.526   32.532   37.034
+   40.456   46.920   53.943   55.277   59.110   60.669   61.811   64.757   65.131   68.639
+            0.683333  0.816667  0.000000
+    0.438    1.638    4.112    7.590   19.659   24.195   27.460   28.625   32.454   37.144
+   40.285   47.051   53.758   55.288   59.143   60.621   61.923   64.928   65.000   68.635
+            0.691667  0.808333  0.000000
+    0.422    1.633    4.095    7.680   19.532   24.188   27.529   28.715   32.382   37.254
+   40.120   47.173   53.587   55.301   59.171   60.576   62.027   64.880   65.090   68.636
+            0.700000  0.800000  0.000000
+    0.407    1.628    4.080    7.759   19.420   24.183   27.591   28.793   32.318   37.360
+   39.965   47.285   53.433   55.314   59.195   60.534   62.124   64.772   65.241   68.640
+            0.708333  0.791667  0.000000
+    0.395    1.624    4.067    7.828   19.324   24.178   27.645   28.861   32.263   37.461
+   39.821   47.384   53.298   55.327   59.214   60.498   62.210   64.677   65.377   68.647
+            0.716667  0.783333  0.000000
+    0.385    1.620    4.057    7.885   19.244   24.174   27.690   28.917   32.216   37.554
+   39.692   47.469   53.184   55.339   59.229   60.466   62.285   64.597   65.495   68.657
+            0.725000  0.775000  0.000000
+    0.377    1.617    4.049    7.930   19.181   24.170   27.726   28.961   32.179   37.635
+   39.583   47.538   53.093   55.349   59.240   60.441   62.346   64.532   65.592   68.668
+            0.733333  0.766667  0.000000
+    0.371    1.615    4.043    7.963   19.136   24.168   27.753   28.992   32.152   37.699
+   39.498   47.589   53.026   55.356   59.248   60.422   62.392   64.484   65.663   68.678
+            0.741667  0.758333  0.000000
+    0.368    1.614    4.041    7.983   19.109   24.168   27.769   29.014   32.137   37.741
+   39.444   47.620   52.985   55.361   59.254   60.411   62.421   64.454   65.709   68.685
+            0.750000  0.750000  0.000000
+    0.367    1.614    4.041    7.991   19.100   24.169   27.779   29.023   32.133   37.757
+   39.426   47.633   52.974   55.363   59.256   60.408   62.432   64.447   65.726   68.687
+            0.725000  0.725000  0.000000
+    0.122    1.829    3.911    8.177   19.286   25.049   27.355   28.829   31.545   37.907
+   38.740   47.552   53.188   54.727   59.364   61.312   61.744   65.070   65.714   69.708
+            0.700000  0.700000  0.000000
+   -0.197    2.064    3.883    8.379   19.486   25.911   26.921   28.636   30.997   38.045
+   38.088   47.428   53.421   54.118   59.392   60.986   62.112   65.820   65.824   70.797
+            0.675000  0.675000  0.000000
+   -0.575    2.320    3.943    8.594   19.699   26.479   26.706   28.444   30.525   37.470
+   38.165   47.275   53.531   53.672   59.275   60.191   62.807   66.081   66.682   71.925
+            0.650000  0.650000  0.000000
+   -0.992    2.596    4.073    8.822   19.924   26.032   27.337   28.260   30.216   36.890
+   38.266   47.114   52.961   53.938   58.982   59.393   63.415   66.507   67.588   71.920
+            0.625000  0.625000  0.000000
+   -1.434    2.891    4.261    9.060   20.158   25.584   27.629   28.074   30.236   36.349
+   38.334   46.959   52.398   54.220   58.522   58.620   63.959   67.071   68.441   71.900
+            0.600000  0.600000  0.000000
+   -1.886    3.205    4.493    9.306   20.398   25.137   27.515   27.898   30.637   35.850
+   38.370   46.828   51.833   54.515   57.909   57.924   64.450   67.714   69.087   71.870
+            0.575000  0.575000  0.000000
+   -2.341    3.538    4.762    9.560   20.641   24.694   27.165   27.725   31.236   35.394
+   38.366   46.731   51.255   54.822   57.236   57.278   64.876   68.355   69.310   71.442
+            0.550000  0.550000  0.000000
+   -2.792    3.890    5.064    9.819   20.884   24.259   26.724   27.567   31.885   34.983
+   38.327   46.677   50.658   55.142   56.504   56.756   65.185   68.912   69.047   70.748
+            0.525000  0.525000  0.000000
+   -3.235    4.261    5.394   10.084   21.123   23.835   26.253   27.426   32.508   34.621
+   38.253   46.669   50.041   55.475   55.765   56.358   65.227   68.592   69.338   69.810
+            0.500000  0.500000  0.000000
+   -3.665    4.650    5.748   10.348   21.349   23.420   25.770   27.301   33.064   34.308
+   38.136   46.696   49.405   55.059   55.813   56.078   64.775   68.386   68.688   69.643
+            0.475000  0.475000  0.000000
+   -4.082    5.055    6.122   10.612   21.556   23.017   25.288   27.195   33.530   34.047
+   37.979   46.738   48.762   54.433   55.916   56.156   63.834   67.443   68.565   69.875
+            0.450000  0.450000  0.000000
+   -4.482    5.479    6.518   10.874   21.738   22.629   24.818   27.119   33.840   33.908
+   37.797   46.757   48.123   53.945   55.862   56.505   62.624   66.135   68.980   70.087
+            0.425000  0.425000  0.000000
+   -4.865    5.919    6.929   11.130   21.886   22.256   24.356   27.067   33.689   34.186
+   37.589   46.701   47.501   53.648   55.903   56.856   61.294   64.789   69.517   70.304
+            0.400000  0.400000  0.000000
+   -5.229    6.375    7.356   11.378   21.899   21.995   23.905   27.043   33.597   34.370
+   37.371   46.528   46.905   53.586   56.031   57.206   59.915   63.430   70.123   70.546
+            0.375000  0.375000  0.000000
+   -5.574    6.846    7.796   11.618   21.561   22.055   23.469   27.044   33.565   34.471
+   37.154   46.221   46.343   53.764   56.227   57.555   58.521   62.074   70.779   70.830
+            0.350000  0.350000  0.000000
+   -5.898    7.331    8.247   11.846   21.240   22.064   23.044   27.065   33.595   34.495
+   36.949   45.799   45.818   54.152   56.481   57.128   57.897   60.732   71.164   71.472
+            0.325000  0.325000  0.000000
+   -6.202    7.828    8.707   12.061   20.939   22.019   22.632   27.097   33.687   34.456
+   36.778   45.302   45.333   54.695   55.748   56.783   58.231   59.411   71.561   72.197
+            0.300000  0.300000  0.000000
+   -6.484    8.337    9.174   12.261   20.656   21.922   22.232   27.130   33.844   34.366
+   36.657   44.767   44.888   54.387   55.338   57.124   58.120   58.550   72.029   72.951
+            0.275000  0.275000  0.000000
+   -6.745    8.855    9.644   12.445   20.395   21.776   21.845   27.155   34.066   34.236
+   36.603   44.224   44.481   53.050   56.035   56.856   57.501   58.859   72.581   73.729
+            0.250000  0.250000  0.000000
+   -6.984    9.381   10.115   12.613   20.162   21.472   21.586   27.161   34.080   34.352
+   36.628   43.697   44.108   51.741   55.643   56.752   57.898   59.169   73.229   74.531
+            0.225000  0.225000  0.000000
+   -7.201    9.908   10.578   12.758   19.941   21.105   21.349   27.142   33.896   34.703
+   36.738   43.198   43.764   50.459   54.472   57.447   58.297   59.435   73.973   75.350
+            0.200000  0.200000  0.000000
+   -7.395   10.436   11.037   12.891   19.745   20.756   21.076   27.100   33.700   35.118
+   36.938   42.741   43.446   49.212   53.356   58.102   58.699   59.685   74.820   76.186
+            0.175000  0.175000  0.000000
+   -7.567   10.958   11.481   13.007   19.571   20.422   20.773   27.040   33.501   35.596
+   37.222   42.332   43.144   48.000   52.305   58.699   59.092   59.912   75.770   77.033
+            0.150000  0.150000  0.000000
+   -7.717   11.465   11.902   13.106   19.419   20.106   20.446   26.968   33.306   36.136
+   37.583   41.975   42.852   46.824   51.330   59.224   59.462   60.113   76.814   77.882
+            0.125000  0.125000  0.000000
+   -7.843   11.951   12.296   13.188   19.292   19.815   20.110   26.893   33.126   36.735
+   38.007   41.673   42.560   45.687   50.448   59.682   59.805   60.290   77.931   78.721
+            0.100000  0.100000  0.000000
+   -7.947   12.397   12.646   13.255   19.186   19.550   19.780   26.822   32.965   37.391
+   38.480   41.425   42.255   44.591   49.677   60.046   60.104   60.432   79.072   79.533
+            0.075000  0.075000  0.000000
+   -8.027   12.789   12.944   13.304   19.104   19.324   19.476   26.760   32.832   38.101
+   38.982   41.233   41.928   43.539   49.040   60.329   60.352   60.544   80.142   80.283
+            0.050000  0.050000  0.000000
+   -8.085   13.091   13.170   13.336   19.045   19.148   19.224   26.713   32.732   38.859
+   39.489   41.096   41.571   42.536   48.562   60.530   60.537   60.625   80.920   80.962
+            0.025000  0.025000  0.000000
+   -8.120   13.294   13.315   13.358   19.010   19.037   19.057   26.683   32.671   39.645
+   39.958   41.015   41.206   41.604   48.265   60.650   60.652   60.674   81.367   81.405
+            0.000000  0.000000  0.000000
+   -8.131   13.365   13.365   13.365   18.998   18.998   18.998   26.673   32.650   40.213
+   40.213   40.988   40.988   40.988   48.164   60.690   60.690   60.690   81.531   81.531
+            0.016667  0.016667  0.016667
+   -8.124   13.308   13.350   13.350   19.016   19.016   19.034   26.680   32.664   39.901
+   39.901   40.952   41.330   41.330   48.231   60.659   60.674   60.674   81.428   81.428
+            0.033333  0.033333  0.033333
+   -8.101   13.142   13.309   13.309   19.071   19.071   19.138   26.700   32.705   39.401
+   39.401   40.849   41.923   41.923   48.428   60.566   60.626   60.626   81.112   81.112
+            0.050000  0.050000  0.050000
+   -8.062   12.884   13.241   13.241   19.160   19.160   19.296   26.734   32.772   38.902
+   38.902   40.693   42.578   42.578   48.744   60.415   60.545   60.545   80.582   80.582
+            0.066667  0.066667  0.066667
+   -8.008   12.547   13.153   13.153   19.278   19.278   19.494   26.781   32.863   38.428
+   38.428   40.497   43.271   43.271   49.163   60.215   60.428   60.428   79.883   79.883
+            0.083333  0.083333  0.083333
+   -7.939   12.147   13.044   13.044   19.422   19.422   19.713   26.841   32.973   37.986
+   37.986   40.278   43.994   43.994   49.672   59.977   60.274   60.274   79.085   79.085
+            0.100000  0.100000  0.100000
+   -7.854   11.699   12.926   12.926   19.586   19.586   19.943   26.914   33.100   37.582
+   37.582   40.050   44.746   44.746   50.255   59.700   60.080   60.080   78.253   78.253
+            0.116667  0.116667  0.116667
+   -7.755   11.212   12.790   12.790   19.765   19.765   20.173   27.000   33.237   37.216
+   37.216   39.825   45.524   45.524   50.903   59.401   59.841   59.841   77.426   77.426
+            0.133333  0.133333  0.133333
+   -7.640   10.696   12.646   12.646   19.953   19.953   20.392   27.098   33.376   36.892
+   36.892   39.613   46.326   46.326   51.606   59.077   59.552   59.552   76.630   76.630
+            0.150000  0.150000  0.150000
+   -7.510   10.161   12.499   12.499   20.148   20.148   20.606   27.208   33.516   36.612
+   36.612   39.423   47.153   47.153   52.359   58.768   59.222   59.222   75.885   75.885
+            0.166667  0.166667  0.166667
+   -7.365    9.610   12.348   12.348   20.343   20.343   20.803   27.327   33.649   36.378
+   36.378   39.259   48.003   48.003   53.155   58.465   58.837   58.837   75.198   75.198
+            0.183333  0.183333  0.183333
+   -7.205    9.050   12.196   12.196   20.535   20.535   20.984   27.454   33.770   36.192
+   36.192   39.126   48.876   48.876   53.988   58.181   58.400   58.400   74.576   74.576
+            0.200000  0.200000  0.200000
+   -7.030    8.482   12.046   12.046   20.717   20.717   21.148   27.589   33.872   36.055
+   36.055   39.022   49.769   49.769   54.851   57.904   57.904   57.928   74.019   74.019
+            0.216667  0.216667  0.216667
+   -6.840    7.910   11.899   11.899   20.892   20.892   21.296   27.728   33.959   35.969
+   35.969   38.947   50.683   50.683   55.724   57.369   57.369   57.735   73.533   73.533
+            0.233333  0.233333  0.233333
+   -6.636    7.338   11.759   11.759   21.055   21.055   21.430   27.869   34.029   35.934
+   35.934   38.895   51.616   51.616   56.536   56.792   56.792   57.680   73.115   73.115
+            0.250000  0.250000  0.250000
+   -6.417    6.766   11.621   11.621   21.203   21.203   21.547   28.006   34.082   35.952
+   35.952   38.856   52.562   52.562   56.178   56.178   56.973   58.073   72.759   72.759
+            0.266667  0.266667  0.266667
+   -6.184    6.197   11.490   11.490   21.334   21.334   21.654   28.140   34.129   36.021
+   36.021   38.829   53.507   53.507   55.553   55.553   57.028   58.934   72.462   72.462
+            0.283333  0.283333  0.283333
+   -5.938    5.632   11.366   11.366   21.447   21.447   21.748   28.273   34.169   36.139
+   36.139   38.802   54.289   54.289   55.079   55.079   57.030   59.928   72.216   72.216
+            0.300000  0.300000  0.300000
+   -5.677    5.074   11.250   11.250   21.547   21.547   21.832   28.401   34.213   36.306
+   36.306   38.769   54.000   54.000   55.679   55.679   57.068   60.975   72.020   72.020
+            0.316667  0.316667  0.316667
+   -5.403    4.523   11.142   11.142   21.629   21.629   21.905   28.520   34.264   36.516
+   36.516   38.721   53.331   53.331   56.660   56.660   57.151   62.053   71.861   71.861
+            0.333333  0.333333  0.333333
+   -5.117    3.981   11.043   11.043   21.696   21.696   21.969   28.629   34.325   36.768
+   36.768   38.655   52.626   52.626   57.286   57.688   57.688   63.153   71.735   71.735
+            0.350000  0.350000  0.350000
+   -4.819    3.449   10.952   10.952   21.750   21.750   22.025   28.726   34.401   37.054
+   37.054   38.568   51.919   51.919   57.470   58.735   58.735   64.267   71.636   71.636
+            0.366667  0.366667  0.366667
+   -4.510    2.930   10.870   10.870   21.792   21.792   22.074   28.811   34.491   37.368
+   37.368   38.461   51.222   51.222   57.697   59.795   59.795   65.381   71.557   71.557
+            0.383333  0.383333  0.383333
+   -4.192    2.427   10.797   10.797   21.823   21.823   22.115   28.882   34.598   37.703
+   37.703   38.335   50.547   50.547   57.959   60.861   60.861   66.480   71.491   71.491
+            0.400000  0.400000  0.400000
+   -3.867    1.939   10.734   10.734   21.846   21.846   22.151   28.941   34.717   38.047
+   38.047   38.195   49.906   49.906   58.242   61.928   61.928   67.527   71.429   71.429
+            0.416667  0.416667  0.416667
+   -3.539    1.473   10.680   10.680   21.862   21.862   22.180   28.989   34.843   38.047
+   38.388   38.388   49.312   49.312   58.532   62.986   62.986   68.464   71.362   71.362
+            0.433333  0.433333  0.433333
+   -3.214    1.034   10.637   10.637   21.873   21.873   22.205   29.032   34.972   37.907
+   38.712   38.712   48.782   48.782   58.812   64.022   64.022   69.197   71.275   71.275
+            0.450000  0.450000  0.450000
+   -2.905    0.636   10.602   10.602   21.879   21.879   22.223   29.060   35.093   37.769
+   38.996   38.996   48.335   48.335   59.061   65.004   65.004   69.641   71.139   71.139
+            0.466667  0.466667  0.466667
+   -2.632    0.300   10.578   10.578   21.883   21.883   22.236   29.079   35.195   37.655
+   39.223   39.223   47.993   47.993   59.260   65.881   65.881   69.820   70.947   70.947
+            0.483333  0.483333  0.483333
+   -2.432    0.063   10.563   10.563   21.885   21.885   22.244   29.090   35.264   37.579
+   39.370   39.370   47.776   47.776   59.388   66.542   66.542   69.857   70.723   70.723
+            0.500000  0.500000  0.500000
+   -2.358   -0.028   10.558   10.558   21.884   21.884   22.245   29.091   35.272   37.549
+   39.419   39.419   47.702   47.702   59.432   66.802   66.802   69.857   70.606   70.606
+            0.491667  0.516667  0.491667
+   -2.354   -0.025   10.540   10.551   21.881   21.897   22.258   29.091   35.256   37.552
+   39.412   39.428   47.717   47.737   59.419   66.773   66.783   69.853   70.622   70.637
+            0.483333  0.533333  0.483333
+   -2.344   -0.013   10.487   10.532   21.868   21.937   22.299   29.092   35.210   37.560
+   39.393   39.453   47.762   47.842   59.382   66.691   66.728   69.840   70.672   70.723
+            0.475000  0.550000  0.475000
+   -2.327    0.005   10.399   10.499   21.837   22.000   22.372   29.093   35.127   37.571
+   39.357   39.495   47.835   48.014   59.319   66.564   66.639   69.818   70.737   70.845
+            0.466667  0.566667  0.466667
+   -2.303    0.030   10.278   10.454   21.789   22.087   22.479   29.093   35.018   37.587
+   39.309   39.562   47.936   48.247   59.231   66.404   66.525   69.787   70.808   70.988
+            0.458333  0.583333  0.458333
+   -2.272    0.062   10.126   10.397   21.725   22.197   22.617   29.088   34.872   37.604
+   39.250   39.657   48.064   48.536   59.118   66.221   66.390   69.743   70.866   71.126
+            0.450000  0.600000  0.450000
+   -2.235    0.101    9.945   10.330   21.645   22.329   22.784   29.077   34.698   37.622
+   39.181   39.786   48.216   48.874   58.980   66.024   66.241   69.686   70.890   71.225
+            0.441667  0.616667  0.441667
+   -2.191    0.146    9.741   10.253   21.553   22.482   22.978   29.059   34.499   37.642
+   39.105   39.952   48.390   49.256   58.819   65.824   66.083   69.614   70.858   71.248
+            0.433333  0.633333  0.433333
+   -2.140    0.199    9.512   10.168   21.450   22.655   23.194   29.031   34.280   37.663
+   39.023   40.155   48.585   49.675   58.635   65.618   65.920   69.526   70.756   71.177
+            0.425000  0.650000  0.425000
+   -2.082    0.258    9.264   10.075   21.339   22.845   23.431   28.991   34.047   37.686
+   38.937   40.394   48.797   50.126   58.431   65.412   65.756   69.420   70.578   71.038
+            0.416667  0.666667  0.416667
+   -2.018    0.324    8.998    9.976   21.222   23.052   23.686   28.935   33.804   37.709
+   38.850   40.669   49.026   50.604   58.208   65.203   65.594   69.295   70.329   70.867
+            0.408333  0.683333  0.408333
+   -1.947    0.396    8.716    9.870   21.099   23.273   23.955   28.859   33.557   37.730
+   38.763   40.978   49.268   51.104   57.968   64.991   65.433   69.153   70.014   70.690
+            0.400000  0.700000  0.400000
+   -1.869    0.474    8.422    9.761   20.973   23.507   24.238   28.766   33.312   37.756
+   38.679   41.318   49.521   51.622   57.718   64.773   65.281   68.999   69.644   70.521
+            0.391667  0.716667  0.391667
+   -1.785    0.558    8.117    9.649   20.843   23.750   24.531   28.651   33.072   37.778
+   38.597   41.686   49.784   52.152   57.458   64.546   65.135   68.837   69.224   70.364
+            0.383333  0.733333  0.383333
+   -1.695    0.648    7.805    9.537   20.715   24.005   24.833   28.514   32.843   37.802
+   38.523   42.081   50.053   52.690   57.198   64.309   65.000   68.673   68.767   70.225
+            0.375000  0.750000  0.375000
+   -1.597    0.743    7.486    9.422   20.586   24.266   25.142   28.354   32.628   37.825
+   38.456   42.497   50.328   53.230   56.945   64.060   64.873   68.277   68.510   70.101
+            0.366667  0.766667  0.366667
+   -1.494    0.843    7.162    9.307   20.459   24.534   25.456   28.173   32.431   37.852
+   38.399   42.934   50.605   53.759   56.711   63.799   64.755   67.763   68.349   69.996
+            0.358333  0.783333  0.358333
+   -1.384    0.948    6.837    9.193   20.333   24.804   25.772   27.971   32.253   37.875
+   38.352   43.385   50.881   54.254   56.521   63.525   64.647   67.231   68.188   69.910
+            0.350000  0.800000  0.350000
+   -1.268    1.056    6.510    9.079   20.211   25.077   26.084   27.754   32.094   37.896
+   38.319   43.846   51.155   54.672   56.424   63.244   64.545   66.692   68.019   69.849
+            0.341667  0.816667  0.341667
+   -1.145    1.166    6.185    8.967   20.092   25.350   26.388   27.524   31.955   37.913
+   38.299   44.314   51.424   54.919   56.508   62.953   64.442   66.157   67.844   69.815
+            0.333333  0.833333  0.333333
+   -1.018    1.277    5.863    8.858   19.976   25.619   26.650   27.311   31.836   37.927
+   38.295   44.780   51.684   54.964   56.808   62.659   64.324   65.648   67.651   69.811
+            0.325000  0.850000  0.325000
+   -0.884    1.388    5.550    8.751   19.865   25.885   26.739   27.262   31.740   37.937
+   38.309   45.241   51.932   54.893   57.244   62.372   64.151   65.210   67.451   69.840
+            0.316667  0.866667  0.316667
+   -0.745    1.495    5.246    8.648   19.758   26.144   26.554   27.464   31.664   37.943
+   38.342   45.685   52.166   54.786   57.732   62.094   63.861   64.909   67.232   69.900
+            0.308333  0.883333  0.308333
+   -0.601    1.595    4.956    8.548   19.656   26.284   26.394   27.725   31.611   37.941
+   38.395   46.105   52.379   54.690   58.221   61.839   63.449   64.755   66.997   69.991
+            0.300000  0.900000  0.300000
+   -0.454    1.683    4.689    8.453   19.559   25.990   26.635   27.992   31.584   37.931
+   38.470   46.490   52.570   54.625   58.679   61.629   62.975   64.690   66.756   70.109
+            0.291667  0.916667  0.291667
+   -0.303    1.751    4.451    8.363   19.468   25.688   26.864   28.242   31.588   37.920
+   38.568   46.829   52.734   54.614   59.061   61.500   62.488   64.671   66.514   70.254
+            0.283333  0.933333  0.283333
+   -0.150    1.791    4.254    8.277   19.383   25.381   27.078   28.468   31.621   37.900
+   38.690   47.113   52.864   54.660   59.316   61.496   62.010   64.669   66.278   70.419
+            0.275000  0.950000  0.275000
+    0.001    1.794    4.109    8.197   19.303   25.073   27.278   28.662   31.691   37.875
+   38.836   47.335   52.958   54.769   59.414   61.555   61.641   64.669   66.061   70.178
+            0.266667  0.966667  0.266667
+    0.145    1.759    4.026    8.122   19.230   24.769   27.465   28.822   31.802   37.845
+   39.008   47.495   53.012   54.935   59.395   61.132   61.896   64.650   65.881   69.590
+            0.258333  0.983333  0.258333
+    0.273    1.690    4.005    8.053   19.162   24.465   27.630   28.941   31.949   37.804
+   39.204   47.591   53.017   55.142   59.320   60.747   62.182   64.586   65.759   69.082
+            0.250000  1.000000  0.250000
+    0.367    1.614    4.041    7.991   19.100   24.169   27.779   29.023   32.133   37.757
+   39.426   47.633   52.974   55.363   59.256   60.408   62.432   64.447   65.726   68.687
+            0.258333  1.000000  0.241667
+    0.368    1.614    4.041    7.983   19.109   24.168   27.769   29.014   32.137   37.741
+   39.444   47.620   52.985   55.361   59.254   60.411   62.421   64.454   65.709   68.685
+            0.266667  1.000000  0.233333
+    0.371    1.615    4.043    7.963   19.136   24.168   27.753   28.992   32.152   37.699
+   39.498   47.589   53.026   55.356   59.248   60.422   62.392   64.484   65.663   68.678
+            0.275000  1.000000  0.225000
+    0.377    1.617    4.049    7.930   19.181   24.170   27.726   28.961   32.179   37.635
+   39.583   47.538   53.093   55.349   59.240   60.441   62.346   64.532   65.592   68.668
+            0.283333  1.000000  0.216667
+    0.385    1.620    4.057    7.885   19.244   24.174   27.690   28.917   32.216   37.554
+   39.692   47.469   53.184   55.339   59.229   60.466   62.285   64.597   65.495   68.657
+            0.291667  1.000000  0.208333
+    0.395    1.624    4.067    7.828   19.324   24.178   27.645   28.861   32.263   37.461
+   39.821   47.384   53.298   55.327   59.214   60.498   62.210   64.677   65.377   68.647
+            0.300000  1.000000  0.200000
+    0.407    1.628    4.080    7.759   19.420   24.183   27.591   28.793   32.318   37.360
+   39.965   47.285   53.433   55.314   59.195   60.534   62.124   64.772   65.241   68.640
+            0.308333  1.000000  0.191667
+    0.422    1.633    4.095    7.680   19.532   24.188   27.529   28.715   32.382   37.254
+   40.120   47.173   53.587   55.301   59.171   60.576   62.027   64.880   65.090   68.636
+            0.316667  1.000000  0.183333
+    0.438    1.638    4.112    7.590   19.659   24.195   27.460   28.625   32.454   37.144
+   40.285   47.051   53.758   55.288   59.143   60.621   61.923   64.928   65.000   68.635
+            0.325000  1.000000  0.175000
+    0.457    1.644    4.131    7.492   19.800   24.202   27.385   28.526   32.532   37.034
+   40.456   46.920   53.943   55.277   59.110   60.669   61.811   64.757   65.131   68.639
+            0.333333  1.000000  0.166667
+    0.479    1.651    4.153    7.386   19.954   24.210   27.306   28.418   32.617   36.924
+   40.633   46.784   54.142   55.268   59.071   60.718   61.694   64.581   65.275   68.647
+            0.341667  1.000000  0.158333
+    0.502    1.657    4.177    7.273   20.120   24.218   27.220   28.297   32.704   36.809
+   40.812   46.640   54.352   55.261   59.026   60.768   61.572   64.401   65.428   68.657
+            0.350000  1.000000  0.150000
+    0.528    1.663    4.203    7.153   20.297   24.226   27.131   28.171   32.799   36.697
+   40.995   46.493   54.572   55.259   58.975   60.817   61.448   64.219   65.591   68.672
+            0.358333  1.000000  0.141667
+    0.556    1.670    4.231    7.028   20.486   24.235   27.039   28.039   32.897   36.586
+   41.180   46.343   54.802   55.262   58.916   60.863   61.324   64.038   65.764   68.690
+            0.366667  1.000000  0.133333
+    0.586    1.675    4.262    6.899   20.683   24.244   26.944   27.899   32.999   36.474
+   41.365   46.190   55.040   55.271   58.850   60.900   61.206   63.857   65.947   68.711
+            0.375000  1.000000  0.125000
+    0.618    1.680    4.295    6.768   20.890   24.252   26.850   27.754   33.104   36.364
+   41.551   46.037   55.286   55.287   58.775   60.905   61.117   63.680   66.142   68.736
+            0.383333  1.000000  0.116667
+    0.653    1.684    4.329    6.632   21.104   24.260   26.752   27.603   33.209   36.253
+   41.735   45.882   55.310   55.537   58.693   60.838   61.096   63.505   66.343   68.761
+            0.391667  1.000000  0.108333
+    0.690    1.687    4.367    6.496   21.326   24.267   26.654   27.448   33.319   36.143
+   41.918   45.727   55.342   55.793   58.602   60.723   61.121   63.333   66.554   68.790
+            0.400000  1.000000  0.100000
+    0.729    1.688    4.406    6.361   21.553   24.273   26.559   27.289   33.431   36.033
+   42.100   45.575   55.382   56.054   58.502   60.593   61.158   63.166   66.774   68.821
+            0.408333  1.000000  0.091667
+    0.770    1.687    4.447    6.224   21.785   24.277   26.462   27.126   33.542   35.923
+   42.277   45.421   55.432   56.319   58.393   60.458   61.197   63.001   66.999   68.852
+            0.416667  1.000000  0.083333
+    0.814    1.683    4.490    6.089   22.021   24.279   26.367   26.962   33.654   35.814
+   42.452   45.270   55.492   56.586   58.277   60.321   61.236   62.841   67.233   68.886
+            0.425000  1.000000  0.075000
+    0.859    1.676    4.536    5.956   22.260   24.278   26.275   26.796   33.765   35.705
+   42.621   45.120   55.563   56.853   58.152   60.183   61.274   62.682   67.472   68.920
+            0.433333  1.000000  0.066667
+    0.907    1.665    4.583    5.828   22.501   24.275   26.187   26.631   33.878   35.596
+   42.787   44.973   55.645   57.120   58.021   60.046   61.310   62.527   67.716   68.956
+            0.441667  1.000000  0.058333
+    0.957    1.650    4.633    5.703   22.742   24.267   26.104   26.467   33.990   35.488
+   42.948   44.829   55.738   57.380   57.890   59.908   61.346   62.375   67.964   68.992
+            0.450000  1.000000  0.050000
+    1.010    1.630    4.684    5.584   22.980   24.255   26.027   26.307   34.103   35.380
+   43.104   44.687   55.843   57.587   57.802   59.772   61.379   62.227   68.212   69.028
+            0.458333  1.000000  0.041667
+    1.064    1.605    4.738    5.471   23.213   24.238   25.955   26.153   34.214   35.272
+   43.254   44.549   55.960   57.536   57.961   59.637   61.412   62.082   68.458   69.065
+            0.466667  1.000000  0.033333
+    1.121    1.573    4.793    5.366   23.437   24.214   25.891   26.011   34.324   35.167
+   43.398   44.414   56.088   57.389   58.202   59.504   61.443   61.944   68.695   69.101
+            0.475000  1.000000  0.025000
+    1.180    1.534    4.850    5.268   23.645   24.185   25.835   25.884   34.433   35.061
+   43.536   44.283   56.229   57.228   58.439   59.373   61.473   61.815   68.913   69.136
+            0.483333  1.000000  0.016667
+    1.242    1.488    4.909    5.180   23.828   24.148   25.786   25.788   34.542   34.959
+   43.669   44.156   56.381   57.061   58.658   59.244   61.506   61.703   69.096   69.170
+            0.491667  1.000000  0.008333
+    1.305    1.433    4.970    5.102   23.969   24.106   25.725   25.750   34.650   34.855
+   43.795   44.033   56.543   56.890   58.848   59.118   61.535   61.617   69.203   69.211
+            0.500000  1.000000  0.000000
+    1.371    1.371    5.033    5.033   24.055   24.055   25.720   25.720   34.753   34.753
+   43.914   43.914   56.715   56.715   58.995   58.995   61.564   61.564   69.234   69.234
+            0.500000  0.983333  0.016667
+    1.177    1.552    4.867    5.224   23.883   24.184   25.677   25.817   34.456   35.029
+   43.577   44.234   56.222   57.217   58.601   59.269   61.546   61.727   69.078   69.252
+            0.500000  0.966667  0.033333
+    0.975    1.712    4.735    5.435   23.687   24.247   25.708   25.949   34.142   35.290
+   43.234   44.527   55.748   57.715   58.137   59.395   61.631   62.055   68.801   69.180
+            0.500000  0.950000  0.050000
+    0.770    1.843    4.647    5.661   23.482   24.242   25.817   26.105   33.815   35.534
+   42.890   44.782   55.308   57.644   58.199   59.397   61.783   62.522   68.470   69.059
+            0.500000  0.933333  0.066667
+    0.565    1.934    4.611    5.898   23.276   24.182   25.987   26.275   33.476   35.761
+   42.551   44.984   54.912   57.145   58.632   59.338   61.984   63.075   68.142   68.916
+            0.500000  0.916667  0.083333
+    0.362    1.979    4.636    6.144   23.075   24.087   26.198   26.455   33.133   35.972
+   42.223   45.120   54.571   56.656   58.844   59.413   62.221   63.672   67.857   68.763
+            0.500000  0.900000  0.100000
+    0.163    1.977    4.722    6.396   22.881   23.972   26.423   26.642   32.787   36.169
+   41.908   45.179   54.290   56.193   58.701   59.762   62.489   64.275   67.642   68.607
+            0.500000  0.883333  0.116667
+   -0.032    1.932    4.863    6.652   22.696   23.844   26.647   26.829   32.446   36.346
+   41.605   45.150   54.060   55.774   58.418   60.170   62.783   64.851   67.522   68.451
+            0.500000  0.866667  0.133333
+   -0.221    1.853    5.051    6.912   22.525   23.714   26.856   27.020   32.127   36.512
+   41.319   45.035   53.856   55.432   58.065   60.574   63.100   65.366   67.526   68.305
+            0.500000  0.850000  0.150000
+   -0.404    1.751    5.277    7.172   22.365   23.582   27.029   27.211   31.842   36.662
+   41.051   44.838   53.628   55.211   57.654   60.962   63.435   65.792   67.667   68.172
+            0.500000  0.833333  0.166667
+   -0.580    1.633    5.531    7.431   22.220   23.451   27.147   27.399   31.613   36.799
+   40.799   44.568   53.337   55.140   57.191   61.331   63.780   66.127   67.927   68.058
+            0.500000  0.816667  0.183333
+   -0.748    1.506    5.808    7.689   22.090   23.327   27.190   27.586   31.463   36.928
+   40.570   44.242   52.987   55.208   56.688   61.683   64.130   66.409   67.975   68.263
+            0.500000  0.800000  0.200000
+   -0.910    1.374    6.099    7.943   21.975   23.203   27.138   27.766   31.405   37.042
+   40.356   43.871   52.597   55.376   56.146   62.018   64.471   66.670   67.930   68.607
+            0.500000  0.783333  0.216667
+   -1.063    1.242    6.405    8.192   21.876   23.085   26.993   27.943   31.448   37.148
+   40.161   43.472   52.191   55.577   55.614   62.342   64.792   66.946   67.939   68.933
+            0.500000  0.766667  0.233333
+   -1.209    1.112    6.720    8.435   21.793   22.972   26.759   28.111   31.581   37.241
+   39.983   43.057   51.779   54.985   55.895   62.657   65.074   67.232   68.016   69.224
+            0.500000  0.750000  0.250000
+   -1.346    0.985    7.041    8.670   21.726   22.864   26.456   28.266   31.784   37.323
+   39.824   42.637   51.369   54.377   56.203   62.967   65.304   67.532   68.173   69.477
+            0.500000  0.733333  0.266667
+   -1.475    0.863    7.366    8.896   21.676   22.762   26.107   28.413   32.043   37.399
+   39.684   42.222   50.968   53.763   56.528   63.275   65.479   67.841   68.412   69.701
+            0.500000  0.716667  0.283333
+   -1.596    0.746    7.693    9.112   21.641   22.666   25.725   28.549   32.337   37.465
+   39.561   41.821   50.578   53.145   56.859   63.582   65.606   68.147   68.723   69.899
+            0.500000  0.700000  0.300000
+   -1.708    0.636    8.018    9.316   21.619   22.576   25.326   28.668   32.653   37.516
+   39.457   41.439   50.202   52.529   57.187   63.890   65.699   68.444   69.087   70.079
+            0.500000  0.683333  0.316667
+   -1.811    0.534    8.339    9.507   21.613   22.492   24.922   28.773   32.982   37.560
+   39.371   41.083   49.844   51.922   57.509   64.200   65.774   68.721   69.486   70.247
+            0.500000  0.666667  0.333333
+   -1.905    0.439    8.654    9.685   21.620   22.415   24.521   28.862   33.313   37.592
+   39.305   40.759   49.505   51.329   57.817   64.511   65.845   68.971   69.898   70.408
+            0.500000  0.650000  0.350000
+   -1.991    0.352    8.958    9.848   21.639   22.344   24.131   28.936   33.638   37.617
+   39.259   40.470   49.189   50.756   58.108   64.822   65.920   69.185   70.309   70.559
+            0.500000  0.633333  0.366667
+   -2.067    0.274    9.249    9.994   21.666   22.278   23.759   28.993   33.951   37.631
+   39.233   40.218   48.896   50.208   58.375   65.130   66.006   69.363   70.691   70.693
+            0.500000  0.616667  0.383333
+   -2.135    0.204    9.522   10.125   21.699   22.218   23.412   29.035   34.243   37.633
+   39.227   40.005   48.630   49.692   58.617   65.434   66.107   69.504   70.798   71.008
+            0.500000  0.600000  0.400000
+   -2.194    0.144    9.772   10.239   21.736   22.163   23.097   29.064   34.508   37.626
+   39.239   39.831   48.393   49.215   58.831   65.726   66.221   69.614   70.859   71.200
+            0.500000  0.583333  0.416667
+   -2.244    0.092    9.998   10.337   21.774   22.110   22.822   29.082   34.740   37.613
+   39.267   39.693   48.188   48.787   59.014   66.007   66.348   69.698   70.870   71.213
+            0.500000  0.566667  0.433333
+   -2.285    0.049   10.191   10.416   21.811   22.057   22.596   29.090   34.928   37.595
+   39.305   39.588   48.016   48.416   59.164   66.261   66.478   69.760   70.831   71.088
+            0.500000  0.550000  0.450000
+   -2.316    0.016   10.348   10.478   21.842   22.001   22.428   29.093   35.082   37.578
+   39.347   39.513   47.880   48.114   59.281   66.481   66.601   69.805   70.763   70.917
+            0.500000  0.533333  0.466667
+   -2.339   -0.009   10.464   10.522   21.866   21.944   22.319   29.092   35.186   37.563
+   39.384   39.461   47.781   47.888   59.365   66.653   66.706   69.834   70.685   70.758
+            0.500000  0.516667  0.483333
+   -2.353   -0.023   10.534   10.549   21.880   21.901   22.262   29.091   35.250   37.553
+   39.410   39.431   47.722   47.749   59.415   66.764   66.777   69.852   70.629   70.648
+            0.500000  0.500000  0.500000
+   -2.358   -0.028   10.558   10.558   21.884   21.884   22.245   29.091   35.272   37.549
+   39.419   39.419   47.702   47.702   59.432   66.802   66.802   69.857   70.606   70.606
+            0.508333  0.508333  0.483333
+   -2.354   -0.025   10.540   10.551   21.881   21.897   22.258   29.091   35.256   37.552
+   39.412   39.428   47.717   47.737   59.419   66.773   66.783   69.853   70.622   70.637
+            0.516667  0.516667  0.466667
+   -2.344   -0.013   10.487   10.532   21.868   21.937   22.299   29.092   35.210   37.560
+   39.393   39.453   47.762   47.842   59.382   66.691   66.728   69.840   70.672   70.723
+            0.525000  0.525000  0.450000
+   -2.327    0.005   10.399   10.499   21.837   22.000   22.372   29.093   35.127   37.571
+   39.357   39.495   47.835   48.014   59.319   66.564   66.639   69.818   70.737   70.845
+            0.533333  0.533333  0.433333
+   -2.303    0.030   10.278   10.454   21.789   22.087   22.479   29.093   35.018   37.587
+   39.309   39.562   47.936   48.247   59.231   66.404   66.525   69.787   70.808   70.988
+            0.541667  0.541667  0.416667
+   -2.272    0.062   10.126   10.397   21.725   22.197   22.617   29.088   34.872   37.604
+   39.250   39.657   48.064   48.536   59.118   66.221   66.390   69.743   70.866   71.126
+            0.550000  0.550000  0.400000
+   -2.235    0.101    9.945   10.330   21.645   22.329   22.784   29.077   34.698   37.622
+   39.181   39.786   48.216   48.874   58.980   66.024   66.241   69.686   70.890   71.225
+            0.558333  0.558333  0.383333
+   -2.191    0.146    9.741   10.253   21.553   22.482   22.978   29.059   34.499   37.642
+   39.105   39.952   48.390   49.256   58.819   65.824   66.083   69.614   70.858   71.248
+            0.566667  0.566667  0.366667
+   -2.140    0.199    9.512   10.168   21.450   22.655   23.194   29.031   34.280   37.663
+   39.023   40.155   48.585   49.675   58.635   65.618   65.920   69.526   70.756   71.177
+            0.575000  0.575000  0.350000
+   -2.082    0.258    9.264   10.075   21.339   22.845   23.431   28.991   34.047   37.686
+   38.937   40.394   48.797   50.126   58.431   65.412   65.756   69.420   70.578   71.038
+            0.583333  0.583333  0.333333
+   -2.018    0.324    8.998    9.976   21.222   23.052   23.686   28.935   33.804   37.709
+   38.850   40.669   49.026   50.604   58.208   65.203   65.594   69.295   70.329   70.867
+            0.591667  0.591667  0.316667
+   -1.947    0.396    8.716    9.870   21.099   23.273   23.955   28.859   33.557   37.730
+   38.763   40.978   49.268   51.104   57.968   64.991   65.433   69.153   70.014   70.690
+            0.600000  0.600000  0.300000
+   -1.869    0.474    8.422    9.761   20.973   23.507   24.238   28.766   33.312   37.756
+   38.679   41.318   49.521   51.622   57.718   64.773   65.281   68.999   69.644   70.521
+            0.608333  0.608333  0.283333
+   -1.785    0.558    8.117    9.649   20.843   23.750   24.531   28.651   33.072   37.778
+   38.597   41.686   49.784   52.152   57.458   64.546   65.135   68.837   69.224   70.364
+            0.616667  0.616667  0.266667
+   -1.695    0.648    7.805    9.537   20.715   24.005   24.833   28.514   32.843   37.802
+   38.523   42.081   50.053   52.690   57.198   64.309   65.000   68.673   68.767   70.225
+            0.625000  0.625000  0.250000
+   -1.597    0.743    7.486    9.422   20.586   24.266   25.142   28.354   32.628   37.825
+   38.456   42.497   50.328   53.230   56.945   64.060   64.873   68.277   68.510   70.101
+            0.633333  0.633333  0.233333
+   -1.494    0.843    7.162    9.307   20.459   24.534   25.456   28.173   32.431   37.852
+   38.399   42.934   50.605   53.759   56.711   63.799   64.755   67.763   68.349   69.996
+            0.641667  0.641667  0.216667
+   -1.384    0.948    6.837    9.193   20.333   24.804   25.772   27.971   32.253   37.875
+   38.352   43.385   50.881   54.254   56.521   63.525   64.647   67.231   68.188   69.910
+            0.650000  0.650000  0.200000
+   -1.268    1.056    6.510    9.079   20.211   25.077   26.084   27.754   32.094   37.896
+   38.319   43.846   51.155   54.672   56.424   63.244   64.545   66.692   68.019   69.849
+            0.658333  0.658333  0.183333
+   -1.145    1.166    6.185    8.967   20.092   25.350   26.388   27.524   31.955   37.913
+   38.299   44.314   51.424   54.919   56.508   62.953   64.442   66.157   67.844   69.815
+            0.666667  0.666667  0.166667
+   -1.018    1.277    5.863    8.858   19.976   25.619   26.650   27.311   31.836   37.927
+   38.295   44.780   51.684   54.964   56.808   62.659   64.324   65.648   67.651   69.811
+            0.675000  0.675000  0.150000
+   -0.884    1.388    5.550    8.751   19.865   25.885   26.739   27.262   31.740   37.937
+   38.309   45.241   51.932   54.893   57.244   62.372   64.151   65.210   67.451   69.840
+            0.683333  0.683333  0.133333
+   -0.745    1.495    5.246    8.648   19.758   26.144   26.554   27.464   31.664   37.943
+   38.342   45.685   52.166   54.786   57.732   62.094   63.861   64.909   67.232   69.900
+            0.691667  0.691667  0.116667
+   -0.601    1.595    4.956    8.548   19.656   26.284   26.394   27.725   31.611   37.941
+   38.395   46.105   52.379   54.690   58.221   61.839   63.449   64.755   66.997   69.991
+            0.700000  0.700000  0.100000
+   -0.454    1.683    4.689    8.453   19.559   25.990   26.635   27.992   31.584   37.931
+   38.470   46.490   52.570   54.625   58.679   61.629   62.975   64.690   66.756   70.109
+            0.708333  0.708333  0.083333
+   -0.303    1.751    4.451    8.363   19.468   25.688   26.864   28.242   31.588   37.920
+   38.568   46.829   52.734   54.614   59.061   61.500   62.488   64.671   66.514   70.254
+            0.716667  0.716667  0.066667
+   -0.150    1.791    4.254    8.277   19.383   25.381   27.078   28.468   31.621   37.900
+   38.690   47.113   52.864   54.660   59.316   61.496   62.010   64.669   66.278   70.419
+            0.725000  0.725000  0.050000
+    0.001    1.794    4.109    8.197   19.303   25.073   27.278   28.662   31.691   37.875
+   38.836   47.335   52.958   54.769   59.414   61.555   61.641   64.669   66.061   70.178
+            0.733333  0.733333  0.033333
+    0.145    1.759    4.026    8.122   19.230   24.769   27.465   28.822   31.802   37.845
+   39.008   47.495   53.012   54.935   59.395   61.132   61.896   64.650   65.881   69.590
+            0.741667  0.741667  0.016667
+    0.273    1.690    4.005    8.053   19.162   24.465   27.630   28.941   31.949   37.804
+   39.204   47.591   53.017   55.142   59.320   60.747   62.182   64.586   65.759   69.082
+            0.750000  0.750000  0.000000
+    0.367    1.614    4.041    7.991   19.100   24.169   27.779   29.023   32.133   37.757
+   39.426   47.633   52.974   55.363   59.256   60.408   62.432   64.447   65.726   68.687
+            0.733333  0.758333  0.008333
+    0.328    1.651    4.018    8.006   19.151   24.316   27.690   28.969   32.048   37.746
+   39.355   47.593   53.029   55.249   59.279   60.578   62.297   64.545   65.696   68.860
+            0.716667  0.766667  0.016667
+    0.283    1.694    4.014    7.994   19.243   24.468   27.576   28.883   31.997   37.670
+   39.377   47.503   53.130   55.130   59.307   60.765   62.132   64.648   65.640   69.036
+            0.700000  0.775000  0.025000
+    0.234    1.736    4.029    7.956   19.376   24.623   27.429   28.766   31.977   37.547
+   39.471   47.366   53.265   55.011   59.335   60.939   61.977   64.748   65.567   69.198
+            0.683333  0.783333  0.033333
+    0.184    1.775    4.064    7.894   19.547   24.779   27.249   28.629   31.981   37.402
+   39.616   47.191   53.424   54.899   59.357   61.037   61.901   64.842   65.487   69.334
+            0.666667  0.791667  0.041667
+    0.136    1.809    4.117    7.810   19.753   24.933   27.034   28.478   32.001   37.248
+   39.793   46.987   53.596   54.801   59.366   60.995   61.972   64.938   65.409   69.440
+            0.650000  0.800000  0.050000
+    0.089    1.836    4.188    7.708   19.992   25.082   26.791   28.321   32.034   37.100
+   39.990   46.761   53.767   54.727   59.353   60.856   62.149   65.046   65.341   69.518
+            0.633333  0.808333  0.058333
+    0.046    1.857    4.273    7.592   20.259   25.217   26.532   28.162   32.073   36.963
+   40.200   46.521   53.916   54.695   59.306   60.697   62.354   65.180   65.283   69.563
+            0.616667  0.816667  0.066667
+    0.007    1.872    4.371    7.464   20.552   25.312   26.285   28.000   32.114   36.838
+   40.417   46.274   54.014   54.728   59.216   60.560   62.543   65.236   65.359   69.572
+            0.600000  0.825000  0.075000
+   -0.028    1.883    4.478    7.331   20.865   25.303   26.122   27.840   32.154   36.730
+   40.633   46.028   54.050   54.834   59.080   60.465   62.694   65.200   65.592   69.536
+            0.583333  0.833333  0.083333
+   -0.058    1.889    4.588    7.199   21.195   25.129   26.111   27.678   32.191   36.638
+   40.842   45.791   54.045   54.989   58.909   60.410   62.802   65.173   65.885   69.447
+            0.566667  0.841667  0.091667
+   -0.082    1.893    4.697    7.071   21.537   24.841   26.205   27.515   32.223   36.562
+   41.037   45.572   54.022   55.161   58.723   60.383   62.870   65.152   66.227   69.293
+            0.550000  0.850000  0.100000
+   -0.102    1.895    4.796    6.956   21.880   24.511   26.342   27.350   32.249   36.503
+   41.207   45.382   53.997   55.325   58.541   60.373   62.908   65.137   66.602   69.074
+            0.533333  0.858333  0.108333
+   -0.116    1.896    4.878    6.864   22.211   24.183   26.496   27.189   32.269   36.465
+   41.344   45.233   53.976   55.464   58.391   60.372   62.929   65.127   66.988   68.806
+            0.516667  0.866667  0.116667
+   -0.124    1.896    4.933    6.803   22.487   23.903   26.651   27.029   32.280   36.439
+   41.430   45.137   53.962   55.557   58.287   60.373   62.937   65.120   67.335   68.526
+            0.500000  0.875000  0.125000
+   -0.127    1.896    4.951    6.781   22.608   23.779   26.753   26.923   32.280   36.430
+   41.460   45.102   53.957   55.590   58.249   60.373   62.938   65.116   67.507   68.374
+            0.483333  0.883333  0.133333
+   -0.124    1.896    4.933    6.803   22.487   23.903   26.651   27.029   32.280   36.439
+   41.430   45.137   53.962   55.557   58.287   60.373   62.937   65.120   67.335   68.526
+            0.466667  0.891667  0.141667
+   -0.116    1.896    4.878    6.864   22.211   24.183   26.496   27.189   32.269   36.465
+   41.344   45.233   53.976   55.464   58.391   60.372   62.929   65.127   66.988   68.806
+            0.450000  0.900000  0.150000
+   -0.102    1.895    4.796    6.956   21.880   24.511   26.342   27.350   32.249   36.503
+   41.207   45.382   53.997   55.325   58.541   60.373   62.908   65.137   66.602   69.074
+            0.433333  0.908333  0.158333
+   -0.082    1.893    4.697    7.071   21.537   24.841   26.205   27.515   32.223   36.562
+   41.037   45.572   54.022   55.161   58.723   60.383   62.870   65.152   66.227   69.293
+            0.416667  0.916667  0.166667
+   -0.058    1.889    4.588    7.199   21.195   25.129   26.111   27.678   32.191   36.638
+   40.842   45.791   54.045   54.989   58.909   60.410   62.802   65.173   65.885   69.447
+            0.400000  0.925000  0.175000
+   -0.028    1.883    4.478    7.331   20.865   25.303   26.122   27.840   32.154   36.730
+   40.633   46.028   54.050   54.834   59.080   60.465   62.694   65.200   65.592   69.536
+            0.383333  0.933333  0.183333
+    0.007    1.872    4.371    7.464   20.552   25.312   26.285   28.000   32.114   36.838
+   40.417   46.274   54.014   54.728   59.216   60.560   62.543   65.236   65.359   69.572
+            0.366667  0.941667  0.191667
+    0.046    1.857    4.273    7.592   20.259   25.217   26.532   28.162   32.073   36.963
+   40.200   46.521   53.916   54.695   59.306   60.697   62.354   65.180   65.283   69.563
+            0.350000  0.950000  0.200000
+    0.089    1.836    4.188    7.708   19.992   25.082   26.791   28.321   32.034   37.100
+   39.990   46.761   53.767   54.727   59.353   60.856   62.149   65.046   65.341   69.518
+            0.333333  0.958333  0.208333
+    0.136    1.809    4.117    7.810   19.753   24.933   27.034   28.478   32.001   37.248
+   39.793   46.987   53.596   54.801   59.366   60.995   61.972   64.938   65.409   69.440
+            0.316667  0.966667  0.216667
+    0.184    1.775    4.064    7.894   19.547   24.779   27.249   28.629   31.981   37.402
+   39.616   47.191   53.424   54.899   59.357   61.037   61.901   64.842   65.487   69.334
+            0.300000  0.975000  0.225000
+    0.234    1.736    4.029    7.956   19.376   24.623   27.429   28.766   31.977   37.547
+   39.471   47.366   53.265   55.011   59.335   60.939   61.977   64.748   65.567   69.198
+            0.283333  0.983333  0.233333
+    0.283    1.694    4.014    7.994   19.243   24.468   27.576   28.883   31.997   37.670
+   39.377   47.503   53.130   55.130   59.307   60.765   62.132   64.648   65.640   69.036
+            0.266667  0.991667  0.241667
+    0.328    1.651    4.018    8.006   19.151   24.316   27.690   28.969   32.048   37.746
+   39.355   47.593   53.029   55.249   59.279   60.578   62.297   64.545   65.696   68.860
+            0.250000  1.000000  0.250000
+    0.367    1.614    4.041    7.991   19.100   24.169   27.779   29.023   32.133   37.757
+   39.426   47.633   52.974   55.363   59.256   60.408   62.432   64.447   65.726   68.687
+            0.241667  1.000000  0.241667
+    0.431    1.546    4.104    7.931   19.041   23.872   27.908   29.078   32.330   37.702
+   39.661   47.643   52.902   55.580   59.213   60.086   62.638   64.263   65.742   68.363
+            0.233333  1.000000  0.233333
+    0.486    1.481    4.180    7.873   18.985   23.578   28.043   29.140   32.531   37.648
+   39.899   47.647   52.836   55.801   59.172   59.757   62.834   64.094   65.766   68.047
+            0.225000  1.000000  0.225000
+    0.533    1.418    4.266    7.817   18.930   23.284   28.175   29.201   32.733   37.594
+   40.140   47.644   52.773   56.025   59.135   59.420   63.018   63.936   65.795   67.740
+            0.216667  1.000000  0.216667
+    0.572    1.357    4.363    7.763   18.876   22.994   28.304   29.262   32.935   37.540
+   40.384   47.631   52.712   56.253   59.078   59.104   63.189   63.790   65.826   67.442
+            0.208333  1.000000  0.208333
+    0.604    1.299    4.468    7.711   18.825   22.705   28.431   29.326   33.138   37.488
+   40.630   47.610   52.652   56.484   58.732   59.081   63.349   63.653   65.859   67.153
+            0.200000  1.000000  0.200000
+    0.629    1.243    4.581    7.661   18.776   22.420   28.556   29.385   33.340   37.433
+   40.879   47.580   52.595   56.718   58.382   59.066   63.493   63.525   65.892   66.873
+            0.191667  1.000000  0.191667
+    0.647    1.189    4.701    7.612   18.728   22.139   28.677   29.443   33.542   37.379
+   41.131   47.541   52.540   56.955   58.030   59.063   63.407   63.624   65.924   66.602
+            0.183333  1.000000  0.183333
+    0.661    1.137    4.827    7.564   18.682   21.862   28.795   29.493   33.740   37.325
+   41.384   47.492   52.488   57.194   57.677   59.071   63.295   63.740   65.954   66.340
+            0.175000  1.000000  0.175000
+    0.670    1.088    4.958    7.520   18.638   21.590   28.909   29.548   33.939   37.272
+   41.639   47.435   52.437   57.323   57.437   59.091   63.191   63.844   65.982   66.089
+            0.166667  1.000000  0.166667
+    0.675    1.041    5.093    7.477   18.597   21.323   29.020   29.604   34.136   37.221
+   41.896   47.372   52.389   56.970   57.683   59.124   63.095   63.936   65.847   66.007
+            0.158333  1.000000  0.158333
+    0.677    0.996    5.231    7.436   18.557   21.062   29.127   29.656   34.330   37.169
+   42.154   47.300   52.343   56.618   57.932   59.171   63.005   64.014   65.616   66.025
+            0.150000  1.000000  0.150000
+    0.677    0.954    5.369    7.397   18.519   20.808   29.230   29.707   34.522   37.118
+   42.413   47.219   52.299   56.268   58.183   59.230   62.921   64.080   65.395   66.033
+            0.141667  1.000000  0.141667
+    0.674    0.913    5.509    7.360   18.483   20.560   29.329   29.756   34.710   37.070
+   42.672   47.134   52.258   55.921   58.436   59.304   62.843   64.135   65.185   66.028
+            0.133333  1.000000  0.133333
+    0.669    0.875    5.649    7.325   18.449   20.321   29.424   29.803   34.893   37.023
+   42.931   47.043   52.219   55.578   58.692   59.391   62.770   64.178   64.985   66.002
+            0.125000  1.000000  0.125000
+    0.663    0.840    5.787    7.292   18.417   20.090   29.513   29.848   35.072   36.978
+   43.190   46.949   52.182   55.240   58.950   59.491   62.703   64.210   64.796   65.942
+            0.116667  1.000000  0.116667
+    0.657    0.806    5.923    7.262   18.387   19.868   29.598   29.891   35.245   36.935
+   43.447   46.852   52.148   54.908   59.209   59.604   62.641   64.232   64.619   65.833
+            0.108333  1.000000  0.108333
+    0.649    0.775    6.056    7.233   18.359   19.656   29.679   29.931   35.413   36.893
+   43.701   46.753   52.115   54.582   59.470   59.729   62.583   64.242   64.453   65.667
+            0.100000  1.000000  0.100000
+    0.641    0.747    6.185    7.206   18.333   19.455   29.754   29.970   35.573   36.855
+   43.952   46.654   52.086   54.264   59.732   59.867   62.531   64.241   64.298   65.455
+            0.091667  1.000000  0.091667
+    0.633    0.720    6.308    7.182   18.309   19.266   29.823   30.005   35.725   36.818
+   44.199   46.556   52.058   53.956   59.994   60.016   62.483   64.155   64.229   65.211
+            0.083333  1.000000  0.083333
+    0.626    0.696    6.425    7.159   18.287   19.089   29.887   30.038   35.868   36.784
+   44.439   46.460   52.033   53.659   60.176   60.256   62.439   64.024   64.204   64.951
+            0.075000  1.000000  0.075000
+    0.618    0.674    6.535    7.139   18.267   18.925   29.946   30.069   36.002   36.753
+   44.672   46.368   52.010   53.375   60.347   60.517   62.400   63.905   64.165   64.681
+            0.066667  1.000000  0.066667
+    0.611    0.654    6.637    7.121   18.250   18.776   29.999   30.096   36.125   36.725
+   44.894   46.281   51.990   53.107   60.528   60.776   62.365   63.798   64.113   64.407
+            0.058333  1.000000  0.058333
+    0.604    0.638    6.730    7.105   18.235   18.642   30.046   30.121   36.237   36.706
+   45.103   46.202   51.972   52.856   60.719   61.032   62.335   63.703   64.046   64.134
+            0.050000  1.000000  0.050000
+    0.599    0.623    6.813    7.091   18.221   18.523   30.087   30.142   36.336   36.684
+   45.296   46.129   51.956   52.627   60.919   61.282   62.308   63.621   63.860   63.963
+            0.041667  1.000000  0.041667
+    0.593    0.610    6.884    7.079   18.210   18.421   30.122   30.160   36.421   36.665
+   45.470   46.065   51.943   52.423   61.127   61.525   62.286   63.551   63.588   63.864
+            0.033333  1.000000  0.033333
+    0.589    0.600    6.944    7.069   18.200   18.336   30.151   30.175   36.492   36.649
+   45.621   46.011   51.932   52.247   61.344   61.757   62.268   63.319   63.494   63.753
+            0.025000  1.000000  0.025000
+    0.586    0.592    6.991    7.062   18.193   18.270   30.173   30.187   36.549   36.637
+   45.744   45.968   51.924   52.105   61.568   61.970   62.254   63.054   63.450   63.634
+            0.016667  1.000000  0.016667
+    0.583    0.586    7.025    7.056   18.188   18.222   30.189   30.195   36.589   36.629
+   45.835   45.936   51.918   52.000   61.799   62.152   62.244   62.794   63.418   63.519
+            0.008333  1.000000  0.008333
+    0.582    0.582    7.045    7.053   18.184   18.193   30.197   30.200   36.609   36.619
+   45.891   45.917   51.914   51.935   62.035   62.237   62.283   62.540   63.398   63.428
+            0.000000  1.000000  0.000000
+    0.581    0.581    7.050    7.050   18.182   18.182   30.194   30.194   36.613   36.613
+   45.908   45.908   51.913   51.913   62.234   62.234   62.332   62.332   63.391   63.391

1_data_prepare/data/bands/uc/scf/bands.dat.gnu

@@ -0,0 +1,1216 @@
+    0.0000   -8.1313
+    0.0333   -8.1211
+    0.0667   -8.0903
+    0.1000   -8.0389
+    0.1333   -7.9671
+    0.1667   -7.8749
+    0.2000   -7.7626
+    0.2333   -7.6296
+    0.2667   -7.4768
+    0.3000   -7.3035
+    0.3333   -7.1100
+    0.3667   -6.8967
+    0.4000   -6.6636
+    0.4333   -6.4109
+    0.4667   -6.1393
+    0.5000   -5.8479
+    0.5333   -5.5375
+    0.5667   -5.2083
+    0.6000   -4.8606
+    0.6333   -4.4948
+    0.6667   -4.1120
+    0.7000   -3.7110
+    0.7333   -3.2941
+    0.7667   -2.8600
+    0.8000   -2.4100
+    0.8333   -1.9454
+    0.8667   -1.4658
+    0.9000   -0.9724
+    0.9333   -0.4660
+    0.9667    0.0522
+    1.0000    0.5808
+    1.0167    0.5829
+    1.0333    0.5878
+    1.0500    0.5960
+    1.0667    0.6075
+    1.0833    0.6221
+    1.1000    0.6396
+    1.1167    0.6604
+    1.1333    0.6841
+    1.1500    0.7106
+    1.1667    0.7395
+    1.1833    0.7711
+    1.2000    0.8051
+    1.2167    0.8412
+    1.2333    0.8790
+    1.2500    0.9183
+    1.2667    0.9586
+    1.2833    0.9999
+    1.3000    1.0417
+    1.3167    1.0833
+    1.3333    1.1243
+    1.3500    1.1640
+    1.3667    1.2018
+    1.3833    1.2375
+    1.4000    1.2702
+    1.4167    1.2993
+    1.4333    1.3241
+    1.4500    1.3440
+    1.4667    1.3587
+    1.4833    1.3678
+    1.5000    1.3709
+    1.5118    1.3052
+    1.5236    1.2417
+    1.5354    1.1802
+    1.5471    1.1212
+    1.5589    1.0643
+    1.5707    1.0097
+    1.5825    0.9573
+    1.5943    0.9071
+    1.6061    0.8591
+    1.6179    0.8135
+    1.6296    0.7700
+    1.6414    0.7290
+    1.6532    0.6898
+    1.6650    0.6529
+    1.6768    0.6184
+    1.6886    0.5860
+    1.7003    0.5558
+    1.7121    0.5278
+    1.7239    0.5021
+    1.7357    0.4787
+    1.7475    0.4574
+    1.7593    0.4384
+    1.7711    0.4216
+    1.7828    0.4071
+    1.7946    0.3948
+    1.8064    0.3847
+    1.8182    0.3769
+    1.8300    0.3713
+    1.8418    0.3680
+    1.8536    0.3675
+    1.8889    0.1219
+    1.9243   -0.1972
+    1.9596   -0.5747
+    1.9950   -0.9922
+    2.0303   -1.4336
+    2.0657   -1.8859
+    2.1010   -2.3411
+    2.1364   -2.7924
+    2.1718   -3.2346
+    2.2071   -3.6655
+    2.2425   -4.0821
+    2.2778   -4.4821
+    2.3132   -4.8650
+    2.3485   -5.2291
+    2.3839   -5.5736
+    2.4192   -5.8982
+    2.4546   -6.2019
+    2.4899   -6.4844
+    2.5253   -6.7454
+    2.5607   -6.9836
+    2.5960   -7.2006
+    2.6314   -7.3952
+    2.6667   -7.5673
+    2.7021   -7.7167
+    2.7374   -7.8430
+    2.7728   -7.9467
+    2.8081   -8.0274
+    2.8435   -8.0851
+    2.8789   -8.1198
+    2.9142   -8.1313
+    2.9431   -8.1236
+    2.9719   -8.1005
+    3.0008   -8.0620
+    3.0297   -8.0082
+    3.0586   -7.9389
+    3.0874   -7.8544
+    3.1163   -7.7547
+    3.1452   -7.6401
+    3.1740   -7.5100
+    3.2029   -7.3648
+    3.2318   -7.2046
+    3.2606   -7.0300
+    3.2895   -6.8403
+    3.3184   -6.6359
+    3.3472   -6.4174
+    3.3761   -6.1844
+    3.4050   -5.9377
+    3.4338   -5.6771
+    3.4627   -5.4034
+    3.4916   -5.1170
+    3.5204   -4.8188
+    3.5493   -4.5098
+    3.5782   -4.1916
+    3.6070   -3.8666
+    3.6359   -3.5387
+    3.6648   -3.2142
+    3.6936   -2.9050
+    3.7225   -2.6318
+    3.7514   -2.4324
+    3.7802   -2.3576
+ 
+    0.0000   13.3647
+    0.0333   13.3206
+    0.0667   13.1934
+    0.1000   12.9970
+    0.1333   12.7487
+    0.1667   12.4585
+    0.2000   12.1421
+    0.2333   11.8105
+    0.2667   11.4727
+    0.3000   11.1316
+    0.3333   10.7963
+    0.3667   10.4638
+    0.4000   10.1401
+    0.4333    9.8167
+    0.4667    9.3375
+    0.5000    8.8425
+    0.5333    8.3321
+    0.5667    7.8081
+    0.6000    7.2724
+    0.6333    6.7259
+    0.6667    6.1719
+    0.7000    5.6144
+    0.7333    5.0495
+    0.7667    4.4820
+    0.8000    3.9138
+    0.8333    3.3461
+    0.8667    2.7814
+    0.9000    2.2210
+    0.9333    1.6677
+    0.9667    1.1201
+    1.0000    0.5808
+    1.0167    0.5829
+    1.0333    0.5878
+    1.0500    0.5960
+    1.0667    0.6075
+    1.0833    0.6221
+    1.1000    0.6396
+    1.1167    0.6604
+    1.1333    0.6841
+    1.1500    0.7106
+    1.1667    0.7395
+    1.1833    0.7711
+    1.2000    0.8051
+    1.2167    0.8412
+    1.2333    0.8790
+    1.2500    0.9183
+    1.2667    0.9586
+    1.2833    0.9999
+    1.3000    1.0417
+    1.3167    1.0833
+    1.3333    1.1243
+    1.3500    1.1640
+    1.3667    1.2018
+    1.3833    1.2375
+    1.4000    1.2702
+    1.4167    1.2993
+    1.4333    1.3241
+    1.4500    1.3440
+    1.4667    1.3587
+    1.4833    1.3678
+    1.5000    1.3709
+    1.5118    1.4335
+    1.5236    1.4878
+    1.5354    1.5339
+    1.5471    1.5728
+    1.5589    1.6046
+    1.5707    1.6303
+    1.5825    1.6504
+    1.5943    1.6655
+    1.6061    1.6762
+    1.6179    1.6832
+    1.6296    1.6870
+    1.6414    1.6883
+    1.6532    1.6871
+    1.6650    1.6844
+    1.6768    1.6804
+    1.6886    1.6753
+    1.7003    1.6696
+    1.7121    1.6634
+    1.7239    1.6570
+    1.7357    1.6507
+    1.7475    1.6444
+    1.7593    1.6384
+    1.7711    1.6329
+    1.7828    1.6279
+    1.7946    1.6235
+    1.8064    1.6198
+    1.8182    1.6169
+    1.8300    1.6148
+    1.8418    1.6137
+    1.8536    1.6138
+    1.8889    1.8286
+    1.9243    2.0644
+    1.9596    2.3201
+    1.9950    2.5956
+    2.0303    2.8908
+    2.0657    3.2054
+    2.1010    3.5376
+    2.1364    3.8899
+    2.1718    4.2611
+    2.2071    4.6500
+    2.2425    5.0552
+    2.2778    5.4788
+    2.3132    5.9188
+    2.3485    6.3751
+    2.3839    6.8459
+    2.4192    7.3306
+    2.4546    7.8279
+    2.4899    8.3369
+    2.5253    8.8552
+    2.5607    9.3809
+    2.5960    9.9081
+    2.6314   10.4357
+    2.6667   10.9575
+    2.7021   11.4653
+    2.7374   11.9509
+    2.7728   12.3971
+    2.8081   12.7888
+    2.8435   13.0905
+    2.8789   13.2937
+    2.9142   13.3647
+    2.9431   13.3076
+    2.9719   13.1417
+    3.0008   12.8839
+    3.0297   12.5472
+    3.0586   12.1470
+    3.0874   11.6990
+    3.1163   11.2115
+    3.1452   10.6959
+    3.1740   10.1607
+    3.2029    9.6105
+    3.2318    9.0499
+    3.2606    8.4822
+    3.2895    7.9104
+    3.3184    7.3381
+    3.3472    6.7664
+    3.3761    6.1969
+    3.4050    5.6315
+    3.4338    5.0736
+    3.4627    4.5227
+    3.4916    3.9808
+    3.5204    3.4493
+    3.5493    2.9300
+    3.5782    2.4268
+    3.6070    1.9389
+    3.6359    1.4726
+    3.6648    1.0344
+    3.6936    0.6364
+    3.7225    0.2999
+    3.7514    0.0625
+    3.7802   -0.0282
+ 
+    0.0000   13.3647
+    0.0333   13.3206
+    0.0667   13.1934
+    0.1000   12.9970
+    0.1333   12.7487
+    0.1667   12.4585
+    0.2000   12.1421
+    0.2333   11.8105
+    0.2667   11.4727
+    0.3000   11.1316
+    0.3333   10.7963
+    0.3667   10.4638
+    0.4000   10.1401
+    0.4333    9.8272
+    0.4667    9.5261
+    0.5000    9.2394
+    0.5333    8.9676
+    0.5667    8.7116
+    0.6000    8.4723
+    0.6333    8.2487
+    0.6667    8.0419
+    0.7000    7.8558
+    0.7333    7.6882
+    0.7667    7.5397
+    0.8000    7.4104
+    0.8333    7.3007
+    0.8667    7.2107
+    0.9000    7.1406
+    0.9333    7.0922
+    0.9667    7.0620
+    1.0000    7.0497
+    1.0167    7.0462
+    1.0333    7.0289
+    1.0500    7.0003
+    1.0667    6.9608
+    1.0833    6.9111
+    1.1000    6.8511
+    1.1167    6.7831
+    1.1333    6.7072
+    1.1500    6.6244
+    1.1667    6.5350
+    1.1833    6.4414
+    1.2000    6.3439
+    1.2167    6.2440
+    1.2333    6.1418
+    1.2500    6.0390
+    1.2667    5.9356
+    1.2833    5.8337
+    1.3000    5.7350
+    1.3167    5.6381
+    1.3333    5.5460
+    1.3500    5.4575
+    1.3667    5.3746
+    1.3833    5.2994
+    1.4000    5.2319
+    1.4167    5.1730
+    1.4333    5.1235
+    1.4500    5.0843
+    1.4667    5.0558
+    1.4833    5.0385
+    1.5000    5.0329
+    1.5118    4.9703
+    1.5236    4.9093
+    1.5354    4.8502
+    1.5471    4.7930
+    1.5589    4.7377
+    1.5707    4.6843
+    1.5825    4.6329
+    1.5943    4.5834
+    1.6061    4.5359
+    1.6179    4.4905
+    1.6296    4.4471
+    1.6414    4.4060
+    1.6532    4.3666
+    1.6650    4.3295
+    1.6768    4.2948
+    1.6886    4.2617
+    1.7003    4.2312
+    1.7121    4.2028
+    1.7239    4.1767
+    1.7357    4.1531
+    1.7475    4.1313
+    1.7593    4.1119
+    1.7711    4.0948
+    1.7828    4.0799
+    1.7946    4.0673
+    1.8064    4.0570
+    1.8182    4.0490
+    1.8300    4.0432
+    1.8418    4.0410
+    1.8536    4.0409
+    1.8889    3.9111
+    1.9243    3.8832
+    1.9596    3.9426
+    1.9950    4.0733
+    2.0303    4.2607
+    2.0657    4.4931
+    2.1010    4.7620
+    2.1364    5.0641
+    2.1718    5.3944
+    2.2071    5.7480
+    2.2425    6.1220
+    2.2778    6.5175
+    2.3132    6.9290
+    2.3485    7.3557
+    2.3839    7.7957
+    2.4192    8.2469
+    2.4546    8.7070
+    2.4899    9.1739
+    2.5253    9.6441
+    2.5607   10.1152
+    2.5960   10.5784
+    2.6314   11.0366
+    2.6667   11.4807
+    2.7021   11.9023
+    2.7374   12.2955
+    2.7728   12.6464
+    2.8081   12.9442
+    2.8435   13.1701
+    2.8789   13.3149
+    2.9142   13.3647
+    2.9431   13.3504
+    2.9719   13.3085
+    3.0008   13.2410
+    3.0297   13.1528
+    3.0586   13.0437
+    3.0874   12.9255
+    3.1163   12.7896
+    3.1452   12.6456
+    3.1740   12.4989
+    3.2029   12.3476
+    3.2318   12.1962
+    3.2606   12.0461
+    3.2895   11.8994
+    3.3184   11.7587
+    3.3472   11.6209
+    3.3761   11.4901
+    3.4050   11.3662
+    3.4338   11.2504
+    3.4627   11.1424
+    3.4916   11.0429
+    3.5204   10.9521
+    3.5493   10.8704
+    3.5782   10.7970
+    3.6070   10.7338
+    3.6359   10.6802
+    3.6648   10.6370
+    3.6936   10.6025
+    3.7225   10.5779
+    3.7514   10.5632
+    3.7802   10.5580
+ 
+    0.0000   13.3647
+    0.0333   13.3391
+    0.0667   13.2682
+    0.1000   13.1455
+    0.1333   12.9757
+    0.1667   12.7606
+    0.2000   12.5024
+    0.2333   12.2067
+    0.2667   11.8774
+    0.3000   11.5165
+    0.3333   11.1284
+    0.3667   10.7136
+    0.4000   10.2757
+    0.4333    9.8272
+    0.4667    9.5261
+    0.5000    9.2394
+    0.5333    8.9676
+    0.5667    8.7116
+    0.6000    8.4723
+    0.6333    8.2487
+    0.6667    8.0419
+    0.7000    7.8558
+    0.7333    7.6882
+    0.7667    7.5397
+    0.8000    7.4104
+    0.8333    7.3007
+    0.8667    7.2107
+    0.9000    7.1406
+    0.9333    7.0922
+    0.9667    7.0620
+    1.0000    7.0497
+    1.0167    7.0462
+    1.0333    7.0289
+    1.0500    7.0003
+    1.0667    6.9608
+    1.0833    6.9111
+    1.1000    6.8511
+    1.1167    6.7831
+    1.1333    6.7072
+    1.1500    6.6244
+    1.1667    6.5350
+    1.1833    6.4414
+    1.2000    6.3439
+    1.2167    6.2440
+    1.2333    6.1418
+    1.2500    6.0390
+    1.2667    5.9356
+    1.2833    5.8337
+    1.3000    5.7350
+    1.3167    5.6381
+    1.3333    5.5460
+    1.3500    5.4575
+    1.3667    5.3746
+    1.3833    5.2994
+    1.4000    5.2319
+    1.4167    5.1730
+    1.4333    5.1235
+    1.4500    5.0843
+    1.4667    5.0558
+    1.4833    5.0385
+    1.5000    5.0329
+    1.5118    5.1015
+    1.5236    5.1803
+    1.5354    5.2684
+    1.5471    5.3657
+    1.5589    5.4712
+    1.5707    5.5840
+    1.5825    5.7031
+    1.5943    5.8275
+    1.6061    5.9564
+    1.6179    6.0892
+    1.6296    6.2239
+    1.6414    6.3614
+    1.6532    6.4962
+    1.6650    6.6323
+    1.6768    6.7676
+    1.6886    6.8993
+    1.7003    7.0283
+    1.7121    7.1531
+    1.7239    7.2726
+    1.7357    7.3864
+    1.7475    7.4923
+    1.7593    7.5904
+    1.7711    7.6797
+    1.7828    7.7590
+    1.7946    7.8277
+    1.8064    7.8851
+    1.8182    7.9304
+    1.8300    7.9631
+    1.8418    7.9830
+    1.8536    7.9914
+    1.8889    8.1767
+    1.9243    8.3789
+    1.9596    8.5942
+    1.9950    8.8219
+    2.0303    9.0597
+    2.0657    9.3064
+    2.1010    9.5599
+    2.1364    9.8194
+    2.1718   10.0837
+    2.2071   10.3484
+    2.2425   10.6121
+    2.2778   10.8737
+    2.3132   11.1297
+    2.3485   11.3784
+    2.3839   11.6183
+    2.4192   11.8462
+    2.4546   12.0610
+    2.4899   12.2611
+    2.5253   12.4455
+    2.5607   12.6133
+    2.5960   12.7579
+    2.6314   12.8910
+    2.6667   13.0069
+    2.7021   13.1059
+    2.7374   13.1884
+    2.7728   13.2546
+    2.8081   13.3037
+    2.8435   13.3362
+    2.8789   13.3576
+    2.9142   13.3647
+    2.9431   13.3504
+    2.9719   13.3085
+    3.0008   13.2410
+    3.0297   13.1528
+    3.0586   13.0437
+    3.0874   12.9255
+    3.1163   12.7896
+    3.1452   12.6456
+    3.1740   12.4989
+    3.2029   12.3476
+    3.2318   12.1962
+    3.2606   12.0461
+    3.2895   11.8994
+    3.3184   11.7587
+    3.3472   11.6209
+    3.3761   11.4901
+    3.4050   11.3662
+    3.4338   11.2504
+    3.4627   11.1424
+    3.4916   11.0429
+    3.5204   10.9521
+    3.5493   10.8704
+    3.5782   10.7970
+    3.6070   10.7338
+    3.6359   10.6802
+    3.6648   10.6370
+    3.6936   10.6025
+    3.7225   10.5779
+    3.7514   10.5632
+    3.7802   10.5580
+ 
+    0.0000   18.9980
+    0.0333   18.9897
+    0.0667   18.9649
+    0.1000   18.9245
+    0.1333   18.8696
+    0.1667   18.8038
+    0.2000   18.7208
+    0.2333   18.6326
+    0.2667   18.5358
+    0.3000   18.4359
+    0.3333   18.3356
+    0.3667   18.2323
+    0.4000   18.1305
+    0.4333   18.0319
+    0.4667   17.9370
+    0.5000   17.8501
+    0.5333   17.7714
+    0.5667   17.7022
+    0.6000   17.6439
+    0.6333   17.5976
+    0.6667   17.5642
+    0.7000   17.5479
+    0.7333   17.5435
+    0.7667   17.5561
+    0.8000   17.5860
+    0.8333   17.6339
+    0.8667   17.7012
+    0.9000   17.7887
+    0.9333   17.8984
+    0.9667   18.0289
+    1.0000   18.1822
+    1.0167   18.1943
+    1.0333   18.2263
+    1.0500   18.2793
+    1.0667   18.3529
+    1.0833   18.4466
+    1.1000   18.5592
+    1.1167   18.6908
+    1.1333   18.8400
+    1.1500   19.0059
+    1.1667   19.1869
+    1.1833   19.3832
+    1.2000   19.5932
+    1.2167   19.8161
+    1.2333   20.0504
+    1.2500   20.2956
+    1.2667   20.5501
+    1.2833   20.8135
+    1.3000   21.0849
+    1.3167   21.3626
+    1.3333   21.6457
+    1.3500   21.9320
+    1.3667   22.2203
+    1.3833   22.5111
+    1.4000   22.8005
+    1.4167   23.0850
+    1.4333   23.3594
+    1.4500   23.6148
+    1.4667   23.8353
+    1.4833   23.9941
+    1.5000   24.0554
+    1.5118   23.9693
+    1.5236   23.8279
+    1.5354   23.6445
+    1.5471   23.4372
+    1.5589   23.2134
+    1.5707   22.9802
+    1.5825   22.7417
+    1.5943   22.5009
+    1.6061   22.2599
+    1.6179   22.0212
+    1.6296   21.7847
+    1.6414   21.5534
+    1.6532   21.3255
+    1.6650   21.1041
+    1.6768   20.8900
+    1.6886   20.6834
+    1.7003   20.4855
+    1.7121   20.2973
+    1.7239   20.1195
+    1.7357   19.9538
+    1.7475   19.7995
+    1.7593   19.6587
+    1.7711   19.5319
+    1.7828   19.4200
+    1.7946   19.3239
+    1.8064   19.2441
+    1.8182   19.1815
+    1.8300   19.1363
+    1.8418   19.1093
+    1.8536   19.1005
+    1.8889   19.2858
+    1.9243   19.4859
+    1.9596   19.6991
+    1.9950   19.9239
+    2.0303   20.1578
+    2.0657   20.3982
+    2.1010   20.6410
+    2.1364   20.8842
+    2.1718   21.1231
+    2.2071   21.3494
+    2.2425   21.5562
+    2.2778   21.7382
+    2.3132   21.8863
+    2.3485   21.8989
+    2.3839   21.5608
+    2.4192   21.2402
+    2.4546   20.9389
+    2.4899   20.6561
+    2.5253   20.3953
+    2.5607   20.1615
+    2.5960   19.9410
+    2.6314   19.7446
+    2.6667   19.5705
+    2.7021   19.4191
+    2.7374   19.2920
+    2.7728   19.1862
+    2.8081   19.1039
+    2.8435   19.0451
+    2.8789   19.0098
+    2.9142   18.9980
+    2.9431   19.0165
+    2.9719   19.0712
+    3.0008   19.1595
+    3.0297   19.2778
+    3.0586   19.4217
+    3.0874   19.5861
+    3.1163   19.7652
+    3.1452   19.9530
+    3.1740   20.1480
+    3.2029   20.3432
+    3.2318   20.5351
+    3.2606   20.7174
+    3.2895   20.8923
+    3.3184   21.0552
+    3.3472   21.2028
+    3.3761   21.3345
+    3.4050   21.4475
+    3.4338   21.5470
+    3.4627   21.6293
+    3.4916   21.6965
+    3.5204   21.7500
+    3.5493   21.7916
+    3.5782   21.8228
+    3.6070   21.8457
+    3.6359   21.8619
+    3.6648   21.8731
+    3.6936   21.8786
+    3.7225   21.8829
+    3.7514   21.8853
+    3.7802   21.8839
+ 
+    0.0000   18.9980
+    0.0333   19.0509
+    0.0667   19.2048
+    0.1000   19.4466
+    0.1333   19.7606
+    0.1667   20.1301
+    0.2000   20.5417
+    0.2333   20.9855
+    0.2667   21.4531
+    0.3000   21.9387
+    0.3333   22.4379
+    0.3667   22.9450
+    0.4000   23.4579
+    0.4333   23.9736
+    0.4667   24.2110
+    0.5000   23.6735
+    0.5333   23.1389
+    0.5667   22.6162
+    0.6000   22.1122
+    0.6333   21.6294
+    0.6667   21.1734
+    0.7000   20.7466
+    0.7333   20.3485
+    0.7667   19.9797
+    0.8000   19.6402
+    0.8333   19.3288
+    0.8667   19.0466
+    0.9000   18.7919
+    0.9333   18.5642
+    0.9667   18.3622
+    1.0000   18.1822
+    1.0167   18.1943
+    1.0333   18.2263
+    1.0500   18.2793
+    1.0667   18.3529
+    1.0833   18.4466
+    1.1000   18.5592
+    1.1167   18.6908
+    1.1333   18.8400
+    1.1500   19.0059
+    1.1667   19.1869
+    1.1833   19.3832
+    1.2000   19.5932
+    1.2167   19.8161
+    1.2333   20.0504
+    1.2500   20.2956
+    1.2667   20.5501
+    1.2833   20.8135
+    1.3000   21.0849
+    1.3167   21.3626
+    1.3333   21.6457
+    1.3500   21.9320
+    1.3667   22.2203
+    1.3833   22.5111
+    1.4000   22.8005
+    1.4167   23.0850
+    1.4333   23.3594
+    1.4500   23.6148
+    1.4667   23.8353
+    1.4833   23.9941
+    1.5000   24.0554
+    1.5118   24.1063
+    1.5236   24.1483
+    1.5354   24.1845
+    1.5471   24.2144
+    1.5589   24.2378
+    1.5707   24.2551
+    1.5825   24.2672
+    1.5943   24.2746
+    1.6061   24.2781
+    1.6179   24.2794
+    1.6296   24.2770
+    1.6414   24.2727
+    1.6532   24.2666
+    1.6650   24.2595
+    1.6768   24.2519
+    1.6886   24.2435
+    1.7003   24.2349
+    1.7121   24.2263
+    1.7239   24.2179
+    1.7357   24.2102
+    1.7475   24.2021
+    1.7593   24.1950
+    1.7711   24.1885
+    1.7828   24.1827
+    1.7946   24.1777
+    1.8064   24.1736
+    1.8182   24.1703
+    1.8300   24.1680
+    1.8418   24.1680
+    1.8536   24.1685
+    1.8889   25.0494
+    1.9243   25.9115
+    1.9596   26.4789
+    1.9950   26.0321
+    2.0303   25.5839
+    2.0657   25.1374
+    2.1010   24.6942
+    2.1364   24.2591
+    2.1718   23.8352
+    2.2071   23.4199
+    2.2425   23.0169
+    2.2778   22.6287
+    2.3132   22.2555
+    2.3485   21.9946
+    2.3839   22.0553
+    2.4192   22.0635
+    2.4546   22.0190
+    2.4899   21.9224
+    2.5253   21.7762
+    2.5607   21.4719
+    2.5960   21.1051
+    2.6314   20.7563
+    2.6667   20.4224
+    2.7021   20.1061
+    2.7374   19.8145
+    2.7728   19.5497
+    2.8081   19.3237
+    2.8435   19.1483
+    2.8789   19.0365
+    2.9142   18.9980
+    2.9431   19.0165
+    2.9719   19.0712
+    3.0008   19.1595
+    3.0297   19.2778
+    3.0586   19.4217
+    3.0874   19.5861
+    3.1163   19.7652
+    3.1452   19.9530
+    3.1740   20.1480
+    3.2029   20.3432
+    3.2318   20.5351
+    3.2606   20.7174
+    3.2895   20.8923
+    3.3184   21.0552
+    3.3472   21.2028
+    3.3761   21.3345
+    3.4050   21.4475
+    3.4338   21.5470
+    3.4627   21.6293
+    3.4916   21.6965
+    3.5204   21.7500
+    3.5493   21.7916
+    3.5782   21.8228
+    3.6070   21.8457
+    3.6359   21.8619
+    3.6648   21.8731
+    3.6936   21.8786
+    3.7225   21.8829
+    3.7514   21.8853
+    3.7802   21.8839
+ 
+    0.0000   18.9980
+    0.0333   19.0509
+    0.0667   19.2048
+    0.1000   19.4466
+    0.1333   19.7606
+    0.1667   20.1301
+    0.2000   20.5417
+    0.2333   20.9855
+    0.2667   21.4531
+    0.3000   21.9387
+    0.3333   22.4379
+    0.3667   22.9450
+    0.4000   23.4579
+    0.4333   23.9736
+    0.4667   24.4876
+    0.5000   25.0018
+    0.5333   25.5118
+    0.5667   26.0152
+    0.6000   26.5095
+    0.6333   26.9889
+    0.6667   27.4508
+    0.7000   27.8995
+    0.7333   28.3231
+    0.7667   28.7189
+    0.8000   29.0810
+    0.8333   29.4032
+    0.8667   29.6790
+    0.9000   29.9021
+    0.9333   30.0669
+    0.9667   30.1678
+    1.0000   30.1935
+    1.0167   30.1970
+    1.0333   30.1823
+    1.0500   30.1575
+    1.0667   30.1226
+    1.0833   30.0773
+    1.1000   30.0210
+    1.1167   29.9537
+    1.1333   29.8747
+    1.1500   29.7837
+    1.1667   29.6798
+    1.1833   29.5633
+    1.2000   29.4334
+    1.2167   29.2930
+    1.2333   29.1356
+    1.2500   28.9659
+    1.2667   28.7798
+    1.2833   28.5816
+    1.3000   28.3708
+    1.3167   28.1478
+    1.3333   27.9166
+    1.3500   27.6714
+    1.3667   27.4179
+    1.3833   27.1599
+    1.4000   26.8982
+    1.4167   26.6365
+    1.4333   26.3804
+    1.4500   26.1391
+    1.4667   25.9284
+    1.4833   25.7763
+    1.5000   25.7198
+    1.5118   25.7253
+    1.5236   25.7856
+    1.5354   25.8355
+    1.5471   25.8915
+    1.5589   25.9554
+    1.5707   26.0265
+    1.5825   26.1040
+    1.5943   26.1870
+    1.6061   26.2746
+    1.6179   26.3674
+    1.6296   26.4615
+    1.6414   26.5589
+    1.6532   26.6544
+    1.6650   26.7521
+    1.6768   26.8498
+    1.6886   26.9444
+    1.7003   27.0391
+    1.7121   27.1313
+    1.7239   27.2204
+    1.7357   27.3058
+    1.7475   27.3850
+    1.7593   27.4602
+    1.7711   27.5291
+    1.7828   27.5909
+    1.7946   27.6449
+    1.8064   27.6903
+    1.8182   27.7263
+    1.8300   27.7525
+    1.8418   27.7693
+    1.8536   27.7794
+    1.8889   27.3547
+    1.9243   26.9211
+    1.9596   26.7062
+    1.9950   27.3367
+    2.0303   27.6286
+    2.0657   27.5146
+    2.1010   27.1651
+    2.1364   26.7241
+    2.1718   26.2531
+    2.2071   25.7701
+    2.2425   25.2883
+    2.2778   24.8183
+    2.3132   24.3557
+    2.3485   23.9053
+    2.3839   23.4690
+    2.4192   23.0441
+    2.4546   22.6321
+    2.4899   22.2319
+    2.5253   21.8449
+    2.5607   21.5862
+    2.5960   21.3492
+    2.6314   21.0763
+    2.6667   20.7725
+    2.7021   20.4463
+    2.7374   20.1103
+    2.7728   19.7796
+    2.8081   19.4756
+    2.8435   19.2243
+    2.8789   19.0571
+    2.9142   18.9980
+    2.9431   19.0342
+    2.9719   19.1378
+    3.0008   19.2963
+    3.0297   19.4936
+    3.0586   19.7133
+    3.0874   19.9434
+    3.1163   20.1726
+    3.1452   20.3919
+    3.1740   20.6059
+    3.2029   20.8026
+    3.2318   20.9835
+    3.2606   21.1476
+    3.2895   21.2964
+    3.3184   21.4302
+    3.3472   21.5475
+    3.3761   21.6535
+    3.4050   21.7476
+    3.4338   21.8316
+    3.4627   21.9048
+    3.4916   21.9690
+    3.5204   22.0251
+    3.5493   22.0736
+    3.5782   22.1153
+    3.6070   22.1506
+    3.6359   22.1799
+    3.6648   22.2054
+    3.6936   22.2233
+    3.7225   22.2359
+    3.7514   22.2436
+    3.7802   22.2452
+ 
+    0.0000   26.6730
+    0.0333   26.6818
+    0.0667   26.7065
+    0.1000   26.7413
+    0.1333   26.7769
+    0.1667   26.7995
+    0.2000   26.7921
+    0.2333   26.7344
+    0.2667   26.6062
+    0.3000   26.3920
+    0.3333   26.0868
+    0.3667   25.6979
+    0.4000   25.2422
+    0.4333   24.7406
+    0.4667   24.4876
+    0.5000   25.0018
+    0.5333   25.5118
+    0.5667   26.0152
+    0.6000   26.5095
+    0.6333   26.9889
+    0.6667   27.4508
+    0.7000   27.8995
+    0.7333   28.3231
+    0.7667   28.7189
+    0.8000   29.0810
+    0.8333   29.4032
+    0.8667   29.6790
+    0.9000   29.9021
+    0.9333   30.0669
+    0.9667   30.1678
+    1.0000   30.1935
+    1.0167   30.1970
+    1.0333   30.1823
+    1.0500   30.1575
+    1.0667   30.1226
+    1.0833   30.0773
+    1.1000   30.0210
+    1.1167   29.9537
+    1.1333   29.8747
+    1.1500   29.7837
+    1.1667   29.6798
+    1.1833   29.5633
+    1.2000   29.4334
+    1.2167   29.2930
+    1.2333   29.1356
+    1.2500   28.9659
+    1.2667   28.7798
+    1.2833   28.5816
+    1.3000   28.3708
+    1.3167   28.1478
+    1.3333   27.9166
+    1.3500   27.6714
+    1.3667   27.4179
+    1.3833   27.1599
+    1.4000   26.8982
+    1.4167   26.6365
+    1.4333   26.3804
+    1.4500   26.1391
+    1.4667   25.9284
+    1.4833   25.7763
+    1.5000   25.7198
+    1.5118   25.7500
+    1.5236   25.7882
+    1.5354   25.8843
+    1.5471   26.0108
+    1.5589   26.1533
+    1.5707   26.3071
+    1.5825   26.4671
+    1.5943   26.6308
+    1.6061   26.7961
+    1.6179   26.9616
+    1.6296   27.1258
+    1.6414   27.2887
+    1.6532   27.4476
+    1.6650   27.6030
+    1.6768   27.7543
+    1.6886   27.8990
+    1.7003   28.0386
+    1.7121   28.1715
+    1.7239   28.2969
+    1.7357   28.4177
+    1.7475   28.5262
+    1.7593   28.6254
+    1.7711   28.7146
+    1.7828   28.7933
+    1.7946   28.8608
+    1.8064   28.9167
+    1.8182   28.9607
+    1.8300   28.9923
+    1.8418   29.0137
+    1.8536   29.0227
+    1.8889   28.8295
+    1.9243   28.6364
+    1.9596   28.4436
+    1.9950   28.2602
+    2.0303   28.0738
+    2.0657   27.8982
+    2.1010   27.7254
+    2.1364   27.5671
+    2.1718   27.4257
+    2.2071   27.3006
+    2.2425   27.1955
+    2.2778   27.1193
+    2.3132   27.0673
+    2.3485   27.0429
+    2.3839   27.0444
+    2.4192   27.0649
+    2.4546   27.0966
+    2.4899   27.1300
+    2.5253   27.1549
+    2.5607   27.1612
+    2.5960   27.1419
+    2.6314   27.1001
+    2.6667   27.0400
+    2.7021   26.9684
+    2.7374   26.8931
+    2.7728   26.8216
+    2.8081   26.7600
+    2.8435   26.7126
+    2.8789   26.6831
+    2.9142   26.6730
+    2.9431   26.6797
+    2.9719   26.6999
+    3.0008   26.7336
+    3.0297   26.7807
+    3.0586   26.8410
+    3.0874   26.9145
+    3.1163   27.0004
+    3.1452   27.0984
+    3.1740   27.2076
+    3.2029   27.3268
+    3.2318   27.4545
+    3.2606   27.5889
+    3.2895   27.7275
+    3.3184   27.8694
+    3.3472   28.0062
+    3.3761   28.1405
+    3.4050   28.2726
+    3.4338   28.4007
+    3.4627   28.5201
+    3.4916   28.6290
+    3.5204   28.7263
+    3.5493   28.8110
+    3.5782   28.8816
+    3.6070   28.9412
+    3.6359   28.9892
+    3.6648   29.0324
+    3.6936   29.0600
+    3.7225   29.0788
+    3.7514   29.0898
+    3.7802   29.0910
+