2b011e550cd872dfc87718b96b1b620c064ee96eb04a49c8e4e7537092f3869d

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+example/diamond/1_data_prepare/data/bands/sc/scf/VSC filter=lfs diff=lfs merge=lfs -text

example/diamond/1_data_prepare/data/bands/sc/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.

example/diamond/1_data_prepare/data/bands/sc/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)
+

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/graph.py

@@ -0,0 +1,934 @@
+import collections
+import itertools
+import os
+import json
+import warnings
+import math
+
+import torch
+import torch_geometric
+from torch_geometric.data import Data, Batch
+import numpy as np
+import h5py
+
+from .model import get_spherical_from_cartesian, SphericalHarmonics
+from .from_pymatgen import find_neighbors, _one_to_three, _compute_cube_index, _three_to_one
+
+
+"""
+The function _spherical_harmonics below is come from "https://github.com/e3nn/e3nn", which has the MIT License below
+
+---------------------------------------------------------------------------
+MIT License
+
+Euclidean neural networks (e3nn) Copyright (c) 2020, The Regents of the
+University of California, through Lawrence Berkeley National Laboratory
+(subject to receipt of any required approvals from the U.S. Dept. of Energy), 
+Ecole Polytechnique Federale de Lausanne (EPFL), Free University of Berlin 
+and Kostiantyn Lapchevskyi. All rights reserved.
+
+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.
+"""
+def _spherical_harmonics(lmax: int, x: torch.Tensor, y: torch.Tensor, z: torch.Tensor) -> torch.Tensor:
+    sh_0_0 = torch.ones_like(x)
+    if lmax == 0:
+        return torch.stack([
+            sh_0_0,
+        ], dim=-1)
+
+    sh_1_0 = x
+    sh_1_1 = y
+    sh_1_2 = z
+    if lmax == 1:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2
+        ], dim=-1)
+
+    sh_2_0 = math.sqrt(3.0) * x * z
+    sh_2_1 = math.sqrt(3.0) * x * y
+    y2 = y.pow(2)
+    x2z2 = x.pow(2) + z.pow(2)
+    sh_2_2 = y2 - 0.5 * x2z2
+    sh_2_3 = math.sqrt(3.0) * y * z
+    sh_2_4 = math.sqrt(3.0) / 2.0 * (z.pow(2) - x.pow(2))
+
+    if lmax == 2:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4
+        ], dim=-1)
+
+    sh_3_0 = math.sqrt(5.0 / 6.0) * (sh_2_0 * z + sh_2_4 * x)
+    sh_3_1 = math.sqrt(5.0) * sh_2_0 * y
+    sh_3_2 = math.sqrt(3.0 / 8.0) * (4.0 * y2 - x2z2) * x
+    sh_3_3 = 0.5 * y * (2.0 * y2 - 3.0 * x2z2)
+    sh_3_4 = math.sqrt(3.0 / 8.0) * z * (4.0 * y2 - x2z2)
+    sh_3_5 = math.sqrt(5.0) * sh_2_4 * y
+    sh_3_6 = math.sqrt(5.0 / 6.0) * (sh_2_4 * z - sh_2_0 * x)
+
+    if lmax == 3:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+            sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6
+        ], dim=-1)
+
+    sh_4_0 = 0.935414346693485*sh_3_0*z + 0.935414346693485*sh_3_6*x
+    sh_4_1 = 0.661437827766148*sh_3_0*y + 0.810092587300982*sh_3_1*z + 0.810092587300983*sh_3_5*x
+    sh_4_2 = -0.176776695296637*sh_3_0*z + 0.866025403784439*sh_3_1*y + 0.684653196881458*sh_3_2*z + 0.684653196881457*sh_3_4*x + 0.176776695296637*sh_3_6*x
+    sh_4_3 = -0.306186217847897*sh_3_1*z + 0.968245836551855*sh_3_2*y + 0.790569415042095*sh_3_3*x + 0.306186217847897*sh_3_5*x
+    sh_4_4 = -0.612372435695795*sh_3_2*x + sh_3_3*y - 0.612372435695795*sh_3_4*z
+    sh_4_5 = -0.306186217847897*sh_3_1*x + 0.790569415042096*sh_3_3*z + 0.968245836551854*sh_3_4*y - 0.306186217847897*sh_3_5*z
+    sh_4_6 = -0.176776695296637*sh_3_0*x - 0.684653196881457*sh_3_2*x + 0.684653196881457*sh_3_4*z + 0.866025403784439*sh_3_5*y - 0.176776695296637*sh_3_6*z
+    sh_4_7 = -0.810092587300982*sh_3_1*x + 0.810092587300982*sh_3_5*z + 0.661437827766148*sh_3_6*y
+    sh_4_8 = -0.935414346693485*sh_3_0*x + 0.935414346693486*sh_3_6*z
+    if lmax == 4:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+            sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6,
+            sh_4_0, sh_4_1, sh_4_2, sh_4_3, sh_4_4, sh_4_5, sh_4_6, sh_4_7, sh_4_8
+        ], dim=-1)
+
+    sh_5_0 = 0.948683298050513*sh_4_0*z + 0.948683298050513*sh_4_8*x
+    sh_5_1 = 0.6*sh_4_0*y + 0.848528137423857*sh_4_1*z + 0.848528137423858*sh_4_7*x
+    sh_5_2 = -0.14142135623731*sh_4_0*z + 0.8*sh_4_1*y + 0.748331477354788*sh_4_2*z + 0.748331477354788*sh_4_6*x + 0.14142135623731*sh_4_8*x
+    sh_5_3 = -0.244948974278318*sh_4_1*z + 0.916515138991168*sh_4_2*y + 0.648074069840786*sh_4_3*z + 0.648074069840787*sh_4_5*x + 0.244948974278318*sh_4_7*x
+    sh_5_4 = -0.346410161513776*sh_4_2*z + 0.979795897113272*sh_4_3*y + 0.774596669241484*sh_4_4*x + 0.346410161513776*sh_4_6*x
+    sh_5_5 = -0.632455532033676*sh_4_3*x + sh_4_4*y - 0.632455532033676*sh_4_5*z
+    sh_5_6 = -0.346410161513776*sh_4_2*x + 0.774596669241483*sh_4_4*z + 0.979795897113273*sh_4_5*y - 0.346410161513776*sh_4_6*z
+    sh_5_7 = -0.244948974278318*sh_4_1*x - 0.648074069840787*sh_4_3*x + 0.648074069840786*sh_4_5*z + 0.916515138991169*sh_4_6*y - 0.244948974278318*sh_4_7*z
+    sh_5_8 = -0.141421356237309*sh_4_0*x - 0.748331477354788*sh_4_2*x + 0.748331477354788*sh_4_6*z + 0.8*sh_4_7*y - 0.141421356237309*sh_4_8*z
+    sh_5_9 = -0.848528137423857*sh_4_1*x + 0.848528137423857*sh_4_7*z + 0.6*sh_4_8*y
+    sh_5_10 = -0.948683298050513*sh_4_0*x + 0.948683298050513*sh_4_8*z
+    if lmax == 5:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+            sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6,
+            sh_4_0, sh_4_1, sh_4_2, sh_4_3, sh_4_4, sh_4_5, sh_4_6, sh_4_7, sh_4_8,
+            sh_5_0, sh_5_1, sh_5_2, sh_5_3, sh_5_4, sh_5_5, sh_5_6, sh_5_7, sh_5_8, sh_5_9, sh_5_10
+        ], dim=-1)
+
+    sh_6_0 = 0.957427107756337*sh_5_0*z + 0.957427107756338*sh_5_10*x
+    sh_6_1 = 0.552770798392565*sh_5_0*y + 0.874007373475125*sh_5_1*z + 0.874007373475125*sh_5_9*x
+    sh_6_2 = -0.117851130197757*sh_5_0*z + 0.745355992499929*sh_5_1*y + 0.117851130197758*sh_5_10*x + 0.790569415042094*sh_5_2*z + 0.790569415042093*sh_5_8*x
+    sh_6_3 = -0.204124145231931*sh_5_1*z + 0.866025403784437*sh_5_2*y + 0.707106781186546*sh_5_3*z + 0.707106781186547*sh_5_7*x + 0.204124145231931*sh_5_9*x
+    sh_6_4 = -0.288675134594813*sh_5_2*z + 0.942809041582062*sh_5_3*y + 0.623609564462323*sh_5_4*z + 0.623609564462322*sh_5_6*x + 0.288675134594812*sh_5_8*x
+    sh_6_5 = -0.372677996249965*sh_5_3*z + 0.986013297183268*sh_5_4*y + 0.763762615825972*sh_5_5*x + 0.372677996249964*sh_5_7*x
+    sh_6_6 = -0.645497224367901*sh_5_4*x + sh_5_5*y - 0.645497224367902*sh_5_6*z
+    sh_6_7 = -0.372677996249964*sh_5_3*x + 0.763762615825972*sh_5_5*z + 0.986013297183269*sh_5_6*y - 0.372677996249965*sh_5_7*z
+    sh_6_8 = -0.288675134594813*sh_5_2*x - 0.623609564462323*sh_5_4*x + 0.623609564462323*sh_5_6*z + 0.942809041582062*sh_5_7*y - 0.288675134594812*sh_5_8*z
+    sh_6_9 = -0.20412414523193*sh_5_1*x - 0.707106781186546*sh_5_3*x + 0.707106781186547*sh_5_7*z + 0.866025403784438*sh_5_8*y - 0.204124145231931*sh_5_9*z
+    sh_6_10 = -0.117851130197757*sh_5_0*x - 0.117851130197757*sh_5_10*z - 0.790569415042094*sh_5_2*x + 0.790569415042093*sh_5_8*z + 0.745355992499929*sh_5_9*y
+    sh_6_11 = -0.874007373475124*sh_5_1*x + 0.552770798392566*sh_5_10*y + 0.874007373475125*sh_5_9*z
+    sh_6_12 = -0.957427107756337*sh_5_0*x + 0.957427107756336*sh_5_10*z
+    if lmax == 6:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+            sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6,
+            sh_4_0, sh_4_1, sh_4_2, sh_4_3, sh_4_4, sh_4_5, sh_4_6, sh_4_7, sh_4_8,
+            sh_5_0, sh_5_1, sh_5_2, sh_5_3, sh_5_4, sh_5_5, sh_5_6, sh_5_7, sh_5_8, sh_5_9, sh_5_10,
+            sh_6_0, sh_6_1, sh_6_2, sh_6_3, sh_6_4, sh_6_5, sh_6_6, sh_6_7, sh_6_8, sh_6_9, sh_6_10, sh_6_11, sh_6_12
+        ], dim=-1)
+
+    sh_7_0 = 0.963624111659433*sh_6_0*z + 0.963624111659432*sh_6_12*x
+    sh_7_1 = 0.515078753637713*sh_6_0*y + 0.892142571199771*sh_6_1*z + 0.892142571199771*sh_6_11*x
+    sh_7_2 = -0.101015254455221*sh_6_0*z + 0.699854212223765*sh_6_1*y + 0.82065180664829*sh_6_10*x + 0.101015254455222*sh_6_12*x + 0.82065180664829*sh_6_2*z
+    sh_7_3 = -0.174963553055942*sh_6_1*z + 0.174963553055941*sh_6_11*x + 0.82065180664829*sh_6_2*y + 0.749149177264394*sh_6_3*z + 0.749149177264394*sh_6_9*x
+    sh_7_4 = 0.247435829652697*sh_6_10*x - 0.247435829652697*sh_6_2*z + 0.903507902905251*sh_6_3*y + 0.677630927178938*sh_6_4*z + 0.677630927178938*sh_6_8*x
+    sh_7_5 = -0.31943828249997*sh_6_3*z + 0.95831484749991*sh_6_4*y + 0.606091526731326*sh_6_5*z + 0.606091526731326*sh_6_7*x + 0.31943828249997*sh_6_9*x
+    sh_7_6 = -0.391230398217976*sh_6_4*z + 0.989743318610787*sh_6_5*y + 0.755928946018454*sh_6_6*x + 0.391230398217975*sh_6_8*x
+    sh_7_7 = -0.654653670707977*sh_6_5*x + sh_6_6*y - 0.654653670707978*sh_6_7*z
+    sh_7_8 = -0.391230398217976*sh_6_4*x + 0.755928946018455*sh_6_6*z + 0.989743318610787*sh_6_7*y - 0.391230398217975*sh_6_8*z
+    sh_7_9 = -0.31943828249997*sh_6_3*x - 0.606091526731327*sh_6_5*x + 0.606091526731326*sh_6_7*z + 0.95831484749991*sh_6_8*y - 0.31943828249997*sh_6_9*z
+    sh_7_10 = -0.247435829652697*sh_6_10*z - 0.247435829652697*sh_6_2*x - 0.677630927178938*sh_6_4*x + 0.677630927178938*sh_6_8*z + 0.903507902905251*sh_6_9*y
+    sh_7_11 = -0.174963553055942*sh_6_1*x + 0.820651806648289*sh_6_10*y - 0.174963553055941*sh_6_11*z - 0.749149177264394*sh_6_3*x + 0.749149177264394*sh_6_9*z
+    sh_7_12 = -0.101015254455221*sh_6_0*x + 0.82065180664829*sh_6_10*z + 0.699854212223766*sh_6_11*y - 0.101015254455221*sh_6_12*z - 0.82065180664829*sh_6_2*x
+    sh_7_13 = -0.892142571199772*sh_6_1*x + 0.892142571199772*sh_6_11*z + 0.515078753637713*sh_6_12*y
+    sh_7_14 = -0.963624111659431*sh_6_0*x + 0.963624111659433*sh_6_12*z
+    if lmax == 7:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+            sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6,
+            sh_4_0, sh_4_1, sh_4_2, sh_4_3, sh_4_4, sh_4_5, sh_4_6, sh_4_7, sh_4_8,
+            sh_5_0, sh_5_1, sh_5_2, sh_5_3, sh_5_4, sh_5_5, sh_5_6, sh_5_7, sh_5_8, sh_5_9, sh_5_10,
+            sh_6_0, sh_6_1, sh_6_2, sh_6_3, sh_6_4, sh_6_5, sh_6_6, sh_6_7, sh_6_8, sh_6_9, sh_6_10, sh_6_11, sh_6_12,
+            sh_7_0, sh_7_1, sh_7_2, sh_7_3, sh_7_4, sh_7_5, sh_7_6, sh_7_7, sh_7_8, sh_7_9, sh_7_10, sh_7_11, sh_7_12, sh_7_13, sh_7_14
+        ], dim=-1)
+
+    sh_8_0 = 0.968245836551854*sh_7_0*z + 0.968245836551853*sh_7_14*x
+    sh_8_1 = 0.484122918275928*sh_7_0*y + 0.90571104663684*sh_7_1*z + 0.90571104663684*sh_7_13*x
+    sh_8_2 = -0.0883883476483189*sh_7_0*z + 0.661437827766148*sh_7_1*y + 0.843171097702002*sh_7_12*x + 0.088388347648318*sh_7_14*x + 0.843171097702003*sh_7_2*z
+    sh_8_3 = -0.153093108923948*sh_7_1*z + 0.7806247497998*sh_7_11*x + 0.153093108923949*sh_7_13*x + 0.7806247497998*sh_7_2*y + 0.780624749799799*sh_7_3*z
+    sh_8_4 = 0.718070330817253*sh_7_10*x + 0.21650635094611*sh_7_12*x - 0.21650635094611*sh_7_2*z + 0.866025403784439*sh_7_3*y + 0.718070330817254*sh_7_4*z
+    sh_8_5 = 0.279508497187474*sh_7_11*x - 0.279508497187474*sh_7_3*z + 0.927024810886958*sh_7_4*y + 0.655505530106345*sh_7_5*z + 0.655505530106344*sh_7_9*x
+    sh_8_6 = 0.342326598440729*sh_7_10*x - 0.342326598440729*sh_7_4*z + 0.968245836551854*sh_7_5*y + 0.592927061281572*sh_7_6*z + 0.592927061281571*sh_7_8*x
+    sh_8_7 = -0.405046293650492*sh_7_5*z + 0.992156741649221*sh_7_6*y + 0.75*sh_7_7*x + 0.405046293650492*sh_7_9*x
+    sh_8_8 = -0.661437827766148*sh_7_6*x + sh_7_7*y - 0.661437827766148*sh_7_8*z
+    sh_8_9 = -0.405046293650492*sh_7_5*x + 0.75*sh_7_7*z + 0.992156741649221*sh_7_8*y - 0.405046293650491*sh_7_9*z
+    sh_8_10 = -0.342326598440728*sh_7_10*z - 0.342326598440729*sh_7_4*x - 0.592927061281571*sh_7_6*x + 0.592927061281571*sh_7_8*z + 0.968245836551855*sh_7_9*y
+    sh_8_11 = 0.927024810886958*sh_7_10*y - 0.279508497187474*sh_7_11*z - 0.279508497187474*sh_7_3*x - 0.655505530106345*sh_7_5*x + 0.655505530106345*sh_7_9*z
+    sh_8_12 = 0.718070330817253*sh_7_10*z + 0.866025403784439*sh_7_11*y - 0.216506350946109*sh_7_12*z - 0.216506350946109*sh_7_2*x - 0.718070330817254*sh_7_4*x
+    sh_8_13 = -0.153093108923948*sh_7_1*x + 0.7806247497998*sh_7_11*z + 0.7806247497998*sh_7_12*y - 0.153093108923948*sh_7_13*z - 0.780624749799799*sh_7_3*x
+    sh_8_14 = -0.0883883476483179*sh_7_0*x + 0.843171097702002*sh_7_12*z + 0.661437827766147*sh_7_13*y - 0.088388347648319*sh_7_14*z - 0.843171097702002*sh_7_2*x
+    sh_8_15 = -0.90571104663684*sh_7_1*x + 0.90571104663684*sh_7_13*z + 0.484122918275927*sh_7_14*y
+    sh_8_16 = -0.968245836551853*sh_7_0*x + 0.968245836551855*sh_7_14*z
+    if lmax == 8:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+            sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6,
+            sh_4_0, sh_4_1, sh_4_2, sh_4_3, sh_4_4, sh_4_5, sh_4_6, sh_4_7, sh_4_8,
+            sh_5_0, sh_5_1, sh_5_2, sh_5_3, sh_5_4, sh_5_5, sh_5_6, sh_5_7, sh_5_8, sh_5_9, sh_5_10,
+            sh_6_0, sh_6_1, sh_6_2, sh_6_3, sh_6_4, sh_6_5, sh_6_6, sh_6_7, sh_6_8, sh_6_9, sh_6_10, sh_6_11, sh_6_12,
+            sh_7_0, sh_7_1, sh_7_2, sh_7_3, sh_7_4, sh_7_5, sh_7_6, sh_7_7, sh_7_8, sh_7_9, sh_7_10, sh_7_11, sh_7_12, sh_7_13, sh_7_14,
+            sh_8_0, sh_8_1, sh_8_2, sh_8_3, sh_8_4, sh_8_5, sh_8_6, sh_8_7, sh_8_8, sh_8_9, sh_8_10, sh_8_11, sh_8_12, sh_8_13, sh_8_14, sh_8_15, sh_8_16
+        ], dim=-1)
+
+    sh_9_0 = 0.97182531580755*sh_8_0*z + 0.971825315807551*sh_8_16*x
+    sh_9_1 = 0.458122847290851*sh_8_0*y + 0.916245694581702*sh_8_1*z + 0.916245694581702*sh_8_15*x
+    sh_9_2 = -0.078567420131839*sh_8_0*z + 0.62853936105471*sh_8_1*y + 0.86066296582387*sh_8_14*x + 0.0785674201318385*sh_8_16*x + 0.860662965823871*sh_8_2*z
+    sh_9_3 = -0.136082763487955*sh_8_1*z + 0.805076485899413*sh_8_13*x + 0.136082763487954*sh_8_15*x + 0.74535599249993*sh_8_2*y + 0.805076485899413*sh_8_3*z
+    sh_9_4 = 0.749485420179558*sh_8_12*x + 0.192450089729875*sh_8_14*x - 0.192450089729876*sh_8_2*z + 0.831479419283099*sh_8_3*y + 0.749485420179558*sh_8_4*z
+    sh_9_5 = 0.693888666488711*sh_8_11*x + 0.248451997499977*sh_8_13*x - 0.248451997499976*sh_8_3*z + 0.895806416477617*sh_8_4*y + 0.69388866648871*sh_8_5*z
+    sh_9_6 = 0.638284738504225*sh_8_10*x + 0.304290309725092*sh_8_12*x - 0.304290309725092*sh_8_4*z + 0.942809041582063*sh_8_5*y + 0.638284738504225*sh_8_6*z
+    sh_9_7 = 0.360041149911548*sh_8_11*x - 0.360041149911548*sh_8_5*z + 0.974996043043569*sh_8_6*y + 0.582671582316751*sh_8_7*z + 0.582671582316751*sh_8_9*x
+    sh_9_8 = 0.415739709641549*sh_8_10*x - 0.415739709641549*sh_8_6*z + 0.993807989999906*sh_8_7*y + 0.74535599249993*sh_8_8*x
+    sh_9_9 = -0.66666666666666666667*sh_8_7*x + sh_8_8*y - 0.66666666666666666667*sh_8_9*z
+    sh_9_10 = -0.415739709641549*sh_8_10*z - 0.415739709641549*sh_8_6*x + 0.74535599249993*sh_8_8*z + 0.993807989999906*sh_8_9*y
+    sh_9_11 = 0.974996043043568*sh_8_10*y - 0.360041149911547*sh_8_11*z - 0.360041149911548*sh_8_5*x - 0.582671582316751*sh_8_7*x + 0.582671582316751*sh_8_9*z
+    sh_9_12 = 0.638284738504225*sh_8_10*z + 0.942809041582063*sh_8_11*y - 0.304290309725092*sh_8_12*z - 0.304290309725092*sh_8_4*x - 0.638284738504225*sh_8_6*x
+    sh_9_13 = 0.693888666488711*sh_8_11*z + 0.895806416477617*sh_8_12*y - 0.248451997499977*sh_8_13*z - 0.248451997499977*sh_8_3*x - 0.693888666488711*sh_8_5*x
+    sh_9_14 = 0.749485420179558*sh_8_12*z + 0.831479419283098*sh_8_13*y - 0.192450089729875*sh_8_14*z - 0.192450089729875*sh_8_2*x - 0.749485420179558*sh_8_4*x
+    sh_9_15 = -0.136082763487954*sh_8_1*x + 0.805076485899413*sh_8_13*z + 0.745355992499929*sh_8_14*y - 0.136082763487955*sh_8_15*z - 0.805076485899413*sh_8_3*x
+    sh_9_16 = -0.0785674201318389*sh_8_0*x + 0.86066296582387*sh_8_14*z + 0.628539361054709*sh_8_15*y - 0.0785674201318387*sh_8_16*z - 0.860662965823871*sh_8_2*x
+    sh_9_17 = -0.9162456945817*sh_8_1*x + 0.916245694581702*sh_8_15*z + 0.458122847290851*sh_8_16*y
+    sh_9_18 = -0.97182531580755*sh_8_0*x + 0.97182531580755*sh_8_16*z
+    if lmax == 9:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+            sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6,
+            sh_4_0, sh_4_1, sh_4_2, sh_4_3, sh_4_4, sh_4_5, sh_4_6, sh_4_7, sh_4_8,
+            sh_5_0, sh_5_1, sh_5_2, sh_5_3, sh_5_4, sh_5_5, sh_5_6, sh_5_7, sh_5_8, sh_5_9, sh_5_10,
+            sh_6_0, sh_6_1, sh_6_2, sh_6_3, sh_6_4, sh_6_5, sh_6_6, sh_6_7, sh_6_8, sh_6_9, sh_6_10, sh_6_11, sh_6_12,
+            sh_7_0, sh_7_1, sh_7_2, sh_7_3, sh_7_4, sh_7_5, sh_7_6, sh_7_7, sh_7_8, sh_7_9, sh_7_10, sh_7_11, sh_7_12, sh_7_13, sh_7_14,
+            sh_8_0, sh_8_1, sh_8_2, sh_8_3, sh_8_4, sh_8_5, sh_8_6, sh_8_7, sh_8_8, sh_8_9, sh_8_10, sh_8_11, sh_8_12, sh_8_13, sh_8_14, sh_8_15, sh_8_16,
+            sh_9_0, sh_9_1, sh_9_2, sh_9_3, sh_9_4, sh_9_5, sh_9_6, sh_9_7, sh_9_8, sh_9_9, sh_9_10, sh_9_11, sh_9_12, sh_9_13, sh_9_14, sh_9_15, sh_9_16, sh_9_17, sh_9_18
+        ], dim=-1)
+
+    sh_10_0 = 0.974679434480897*sh_9_0*z + 0.974679434480897*sh_9_18*x
+    sh_10_1 = 0.435889894354067*sh_9_0*y + 0.924662100445347*sh_9_1*z + 0.924662100445347*sh_9_17*x
+    sh_10_2 = -0.0707106781186546*sh_9_0*z + 0.6*sh_9_1*y + 0.874642784226796*sh_9_16*x + 0.070710678118655*sh_9_18*x + 0.874642784226795*sh_9_2*z
+    sh_10_3 = -0.122474487139159*sh_9_1*z + 0.824621125123533*sh_9_15*x + 0.122474487139159*sh_9_17*x + 0.714142842854285*sh_9_2*y + 0.824621125123533*sh_9_3*z
+    sh_10_4 = 0.774596669241484*sh_9_14*x + 0.173205080756887*sh_9_16*x - 0.173205080756888*sh_9_2*z + 0.8*sh_9_3*y + 0.774596669241483*sh_9_4*z
+    sh_10_5 = 0.724568837309472*sh_9_13*x + 0.223606797749979*sh_9_15*x - 0.223606797749979*sh_9_3*z + 0.866025403784438*sh_9_4*y + 0.724568837309472*sh_9_5*z
+    sh_10_6 = 0.674536878161602*sh_9_12*x + 0.273861278752583*sh_9_14*x - 0.273861278752583*sh_9_4*z + 0.916515138991168*sh_9_5*y + 0.674536878161602*sh_9_6*z
+    sh_10_7 = 0.62449979983984*sh_9_11*x + 0.324037034920393*sh_9_13*x - 0.324037034920393*sh_9_5*z + 0.953939201416946*sh_9_6*y + 0.62449979983984*sh_9_7*z
+    sh_10_8 = 0.574456264653803*sh_9_10*x + 0.374165738677394*sh_9_12*x - 0.374165738677394*sh_9_6*z + 0.979795897113272*sh_9_7*y + 0.574456264653803*sh_9_8*z
+    sh_10_9 = 0.424264068711928*sh_9_11*x - 0.424264068711929*sh_9_7*z + 0.99498743710662*sh_9_8*y + 0.741619848709567*sh_9_9*x
+    sh_10_10 = -0.670820393249937*sh_9_10*z - 0.670820393249937*sh_9_8*x + sh_9_9*y
+    sh_10_11 = 0.99498743710662*sh_9_10*y - 0.424264068711929*sh_9_11*z - 0.424264068711929*sh_9_7*x + 0.741619848709567*sh_9_9*z
+    sh_10_12 = 0.574456264653803*sh_9_10*z + 0.979795897113272*sh_9_11*y - 0.374165738677395*sh_9_12*z - 0.374165738677394*sh_9_6*x - 0.574456264653803*sh_9_8*x
+    sh_10_13 = 0.62449979983984*sh_9_11*z + 0.953939201416946*sh_9_12*y - 0.324037034920393*sh_9_13*z - 0.324037034920393*sh_9_5*x - 0.62449979983984*sh_9_7*x
+    sh_10_14 = 0.674536878161602*sh_9_12*z + 0.916515138991168*sh_9_13*y - 0.273861278752583*sh_9_14*z - 0.273861278752583*sh_9_4*x - 0.674536878161603*sh_9_6*x
+    sh_10_15 = 0.724568837309472*sh_9_13*z + 0.866025403784439*sh_9_14*y - 0.223606797749979*sh_9_15*z - 0.223606797749979*sh_9_3*x - 0.724568837309472*sh_9_5*x
+    sh_10_16 = 0.774596669241484*sh_9_14*z + 0.8*sh_9_15*y - 0.173205080756888*sh_9_16*z - 0.173205080756887*sh_9_2*x - 0.774596669241484*sh_9_4*x
+    sh_10_17 = -0.12247448713916*sh_9_1*x + 0.824621125123532*sh_9_15*z + 0.714142842854285*sh_9_16*y - 0.122474487139158*sh_9_17*z - 0.824621125123533*sh_9_3*x
+    sh_10_18 = -0.0707106781186548*sh_9_0*x + 0.874642784226796*sh_9_16*z + 0.6*sh_9_17*y - 0.0707106781186546*sh_9_18*z - 0.874642784226796*sh_9_2*x
+    sh_10_19 = -0.924662100445348*sh_9_1*x + 0.924662100445347*sh_9_17*z + 0.435889894354068*sh_9_18*y
+    sh_10_20 = -0.974679434480898*sh_9_0*x + 0.974679434480896*sh_9_18*z
+    if lmax == 10:
+        return torch.stack([
+            sh_0_0,
+            sh_1_0, sh_1_1, sh_1_2,
+            sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+            sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6,
+            sh_4_0, sh_4_1, sh_4_2, sh_4_3, sh_4_4, sh_4_5, sh_4_6, sh_4_7, sh_4_8,
+            sh_5_0, sh_5_1, sh_5_2, sh_5_3, sh_5_4, sh_5_5, sh_5_6, sh_5_7, sh_5_8, sh_5_9, sh_5_10,
+            sh_6_0, sh_6_1, sh_6_2, sh_6_3, sh_6_4, sh_6_5, sh_6_6, sh_6_7, sh_6_8, sh_6_9, sh_6_10, sh_6_11, sh_6_12,
+            sh_7_0, sh_7_1, sh_7_2, sh_7_3, sh_7_4, sh_7_5, sh_7_6, sh_7_7, sh_7_8, sh_7_9, sh_7_10, sh_7_11, sh_7_12, sh_7_13, sh_7_14,
+            sh_8_0, sh_8_1, sh_8_2, sh_8_3, sh_8_4, sh_8_5, sh_8_6, sh_8_7, sh_8_8, sh_8_9, sh_8_10, sh_8_11, sh_8_12, sh_8_13, sh_8_14, sh_8_15, sh_8_16,
+            sh_9_0, sh_9_1, sh_9_2, sh_9_3, sh_9_4, sh_9_5, sh_9_6, sh_9_7, sh_9_8, sh_9_9, sh_9_10, sh_9_11, sh_9_12, sh_9_13, sh_9_14, sh_9_15, sh_9_16, sh_9_17, sh_9_18,
+            sh_10_0, sh_10_1, sh_10_2, sh_10_3, sh_10_4, sh_10_5, sh_10_6, sh_10_7, sh_10_8, sh_10_9, sh_10_10, sh_10_11, sh_10_12, sh_10_13, sh_10_14, sh_10_15, sh_10_16, sh_10_17, sh_10_18, sh_10_19, sh_10_20
+        ], dim=-1)
+
+    sh_11_0 = 0.977008420918394*sh_10_0*z + 0.977008420918394*sh_10_20*x
+    sh_11_1 = 0.416597790450531*sh_10_0*y + 0.9315409787236*sh_10_1*z + 0.931540978723599*sh_10_19*x
+    sh_11_2 = -0.0642824346533223*sh_10_0*z + 0.574959574576069*sh_10_1*y + 0.88607221316445*sh_10_18*x + 0.886072213164452*sh_10_2*z + 0.0642824346533226*sh_10_20*x
+    sh_11_3 = -0.111340442853781*sh_10_1*z + 0.84060190949577*sh_10_17*x + 0.111340442853781*sh_10_19*x + 0.686348585024614*sh_10_2*y + 0.840601909495769*sh_10_3*z
+    sh_11_4 = 0.795129803842541*sh_10_16*x + 0.157459164324444*sh_10_18*x - 0.157459164324443*sh_10_2*z + 0.771389215839871*sh_10_3*y + 0.795129803842541*sh_10_4*z
+    sh_11_5 = 0.74965556829412*sh_10_15*x + 0.203278907045435*sh_10_17*x - 0.203278907045436*sh_10_3*z + 0.838140405208444*sh_10_4*y + 0.74965556829412*sh_10_5*z
+    sh_11_6 = 0.70417879021953*sh_10_14*x + 0.248964798865985*sh_10_16*x - 0.248964798865985*sh_10_4*z + 0.890723542830247*sh_10_5*y + 0.704178790219531*sh_10_6*z
+    sh_11_7 = 0.658698943008611*sh_10_13*x + 0.294579122654903*sh_10_15*x - 0.294579122654903*sh_10_5*z + 0.9315409787236*sh_10_6*y + 0.658698943008611*sh_10_7*z
+    sh_11_8 = 0.613215343783275*sh_10_12*x + 0.340150671524904*sh_10_14*x - 0.340150671524904*sh_10_6*z + 0.962091385841669*sh_10_7*y + 0.613215343783274*sh_10_8*z
+    sh_11_9 = 0.567727090763491*sh_10_11*x + 0.385694607919935*sh_10_13*x - 0.385694607919935*sh_10_7*z + 0.983332166035633*sh_10_8*y + 0.56772709076349*sh_10_9*z
+    sh_11_10 = 0.738548945875997*sh_10_10*x + 0.431219680932052*sh_10_12*x - 0.431219680932052*sh_10_8*z + 0.995859195463938*sh_10_9*y
+    sh_11_11 = sh_10_10*y - 0.674199862463242*sh_10_11*z - 0.674199862463243*sh_10_9*x
+    sh_11_12 = 0.738548945875996*sh_10_10*z + 0.995859195463939*sh_10_11*y - 0.431219680932052*sh_10_12*z - 0.431219680932053*sh_10_8*x
+    sh_11_13 = 0.567727090763491*sh_10_11*z + 0.983332166035634*sh_10_12*y - 0.385694607919935*sh_10_13*z - 0.385694607919935*sh_10_7*x - 0.567727090763491*sh_10_9*x
+    sh_11_14 = 0.613215343783275*sh_10_12*z + 0.96209138584167*sh_10_13*y - 0.340150671524904*sh_10_14*z - 0.340150671524904*sh_10_6*x - 0.613215343783274*sh_10_8*x
+    sh_11_15 = 0.658698943008611*sh_10_13*z + 0.9315409787236*sh_10_14*y - 0.294579122654903*sh_10_15*z - 0.294579122654903*sh_10_5*x - 0.65869894300861*sh_10_7*x
+    sh_11_16 = 0.70417879021953*sh_10_14*z + 0.890723542830246*sh_10_15*y - 0.248964798865985*sh_10_16*z - 0.248964798865985*sh_10_4*x - 0.70417879021953*sh_10_6*x
+    sh_11_17 = 0.749655568294121*sh_10_15*z + 0.838140405208444*sh_10_16*y - 0.203278907045436*sh_10_17*z - 0.203278907045435*sh_10_3*x - 0.749655568294119*sh_10_5*x
+    sh_11_18 = 0.79512980384254*sh_10_16*z + 0.77138921583987*sh_10_17*y - 0.157459164324443*sh_10_18*z - 0.157459164324444*sh_10_2*x - 0.795129803842541*sh_10_4*x
+    sh_11_19 = -0.111340442853782*sh_10_1*x + 0.84060190949577*sh_10_17*z + 0.686348585024614*sh_10_18*y - 0.111340442853781*sh_10_19*z - 0.840601909495769*sh_10_3*x
+    sh_11_20 = -0.0642824346533226*sh_10_0*x + 0.886072213164451*sh_10_18*z + 0.57495957457607*sh_10_19*y - 0.886072213164451*sh_10_2*x - 0.0642824346533228*sh_10_20*z
+    sh_11_21 = -0.9315409787236*sh_10_1*x + 0.931540978723599*sh_10_19*z + 0.416597790450531*sh_10_20*y
+    sh_11_22 = -0.977008420918393*sh_10_0*x + 0.977008420918393*sh_10_20*z
+    return torch.stack([
+        sh_0_0,
+        sh_1_0, sh_1_1, sh_1_2,
+        sh_2_0, sh_2_1, sh_2_2, sh_2_3, sh_2_4,
+        sh_3_0, sh_3_1, sh_3_2, sh_3_3, sh_3_4, sh_3_5, sh_3_6,
+        sh_4_0, sh_4_1, sh_4_2, sh_4_3, sh_4_4, sh_4_5, sh_4_6, sh_4_7, sh_4_8,
+        sh_5_0, sh_5_1, sh_5_2, sh_5_3, sh_5_4, sh_5_5, sh_5_6, sh_5_7, sh_5_8, sh_5_9, sh_5_10,
+        sh_6_0, sh_6_1, sh_6_2, sh_6_3, sh_6_4, sh_6_5, sh_6_6, sh_6_7, sh_6_8, sh_6_9, sh_6_10, sh_6_11, sh_6_12,
+        sh_7_0, sh_7_1, sh_7_2, sh_7_3, sh_7_4, sh_7_5, sh_7_6, sh_7_7, sh_7_8, sh_7_9, sh_7_10, sh_7_11, sh_7_12, sh_7_13, sh_7_14,
+        sh_8_0, sh_8_1, sh_8_2, sh_8_3, sh_8_4, sh_8_5, sh_8_6, sh_8_7, sh_8_8, sh_8_9, sh_8_10, sh_8_11, sh_8_12, sh_8_13, sh_8_14, sh_8_15, sh_8_16,
+        sh_9_0, sh_9_1, sh_9_2, sh_9_3, sh_9_4, sh_9_5, sh_9_6, sh_9_7, sh_9_8, sh_9_9, sh_9_10, sh_9_11, sh_9_12, sh_9_13, sh_9_14, sh_9_15, sh_9_16, sh_9_17, sh_9_18,
+        sh_10_0, sh_10_1, sh_10_2, sh_10_3, sh_10_4, sh_10_5, sh_10_6, sh_10_7, sh_10_8, sh_10_9, sh_10_10, sh_10_11, sh_10_12, sh_10_13, sh_10_14, sh_10_15, sh_10_16, sh_10_17, sh_10_18, sh_10_19, sh_10_20,
+        sh_11_0, sh_11_1, sh_11_2, sh_11_3, sh_11_4, sh_11_5, sh_11_6, sh_11_7, sh_11_8, sh_11_9, sh_11_10, sh_11_11, sh_11_12, sh_11_13, sh_11_14, sh_11_15, sh_11_16, sh_11_17, sh_11_18, sh_11_19, sh_11_20, sh_11_21, sh_11_22
+    ], dim=-1)
+
+
+def collate_fn(graph_list):
+    return Collater(if_lcmp=True)(graph_list)
+
+
+class Collater:
+    def __init__(self, if_lcmp):
+        self.if_lcmp = if_lcmp
+        self.flag_pyg2 = (torch_geometric.__version__[0] == '2')
+
+    def __call__(self, graph_list):
+        if self.if_lcmp:
+            flag_dict = hasattr(graph_list[0], 'subgraph_dict')
+            if self.flag_pyg2:
+                assert flag_dict, 'Please generate the graph file with the current version of PyG'
+            batch = Batch.from_data_list(graph_list)
+
+            subgraph_atom_idx_batch = []
+            subgraph_edge_idx_batch = []
+            subgraph_edge_ang_batch = []
+            subgraph_index_batch = []
+            if flag_dict:
+                for index_batch in range(len(graph_list)):
+                    (subgraph_atom_idx, subgraph_edge_idx, subgraph_edge_ang,
+                     subgraph_index) = graph_list[index_batch].subgraph_dict.values()
+                    if self.flag_pyg2:
+                        subgraph_atom_idx_batch.append(subgraph_atom_idx + batch._slice_dict['x'][index_batch])
+                        subgraph_edge_idx_batch.append(subgraph_edge_idx + batch._slice_dict['edge_attr'][index_batch])
+                        subgraph_index_batch.append(subgraph_index + batch._slice_dict['edge_attr'][index_batch] * 2)
+                    else:
+                        subgraph_atom_idx_batch.append(subgraph_atom_idx + batch.__slices__['x'][index_batch])
+                        subgraph_edge_idx_batch.append(subgraph_edge_idx + batch.__slices__['edge_attr'][index_batch])
+                        subgraph_index_batch.append(subgraph_index + batch.__slices__['edge_attr'][index_batch] * 2)
+                    subgraph_edge_ang_batch.append(subgraph_edge_ang)
+            else:
+                for index_batch, (subgraph_atom_idx, subgraph_edge_idx,
+                                  subgraph_edge_ang, subgraph_index) in enumerate(batch.subgraph):
+                    subgraph_atom_idx_batch.append(subgraph_atom_idx + batch.__slices__['x'][index_batch])
+                    subgraph_edge_idx_batch.append(subgraph_edge_idx + batch.__slices__['edge_attr'][index_batch])
+                    subgraph_edge_ang_batch.append(subgraph_edge_ang)
+                    subgraph_index_batch.append(subgraph_index + batch.__slices__['edge_attr'][index_batch] * 2)
+
+            subgraph_atom_idx_batch = torch.cat(subgraph_atom_idx_batch, dim=0)
+            subgraph_edge_idx_batch = torch.cat(subgraph_edge_idx_batch, dim=0)
+            subgraph_edge_ang_batch = torch.cat(subgraph_edge_ang_batch, dim=0)
+            subgraph_index_batch = torch.cat(subgraph_index_batch, dim=0)
+
+            subgraph = (subgraph_atom_idx_batch, subgraph_edge_idx_batch, subgraph_edge_ang_batch, subgraph_index_batch)
+
+            return batch, subgraph
+        else:
+            return Batch.from_data_list(graph_list)
+
+
+def load_orbital_types(path, return_orbital_types=False):
+    orbital_types = []
+    with open(path) as f:
+        line = f.readline()
+        while line:
+            orbital_types.append(list(map(int, line.split())))
+            line = f.readline()
+    atom_num_orbital = [sum(map(lambda x: 2 * x + 1,atom_orbital_types)) for atom_orbital_types in orbital_types]
+    if return_orbital_types:
+        return atom_num_orbital, orbital_types
+    else:
+        return atom_num_orbital
+
+
+"""
+The function get_graph below is extended from "https://github.com/materialsproject/pymatgen", which has the MIT License below
+
+---------------------------------------------------------------------------
+The MIT License (MIT)
+Copyright (c) 2011-2012 MIT & The Regents of the University of California, through Lawrence Berkeley National Laboratory
+
+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.
+"""
+def get_graph(cart_coords, frac_coords, numbers, stru_id, r, max_num_nbr, numerical_tol, lattice,
+              default_dtype_torch, tb_folder, interface, num_l, create_from_DFT, if_lcmp_graph,
+              separate_onsite, target='hamiltonian', huge_structure=False, only_get_R_list=False, if_new_sp=False,
+              if_require_grad=False, fid_rc=None, **kwargs):
+    assert target in ['hamiltonian', 'phiVdphi', 'density_matrix', 'O_ij', 'E_ij', 'E_i']
+    if target == 'density_matrix' or target == 'O_ij':
+        assert interface == 'h5' or interface == 'h5_rc_only'
+    if target == 'E_ij':
+        assert interface == 'h5'
+        assert create_from_DFT is True
+        assert separate_onsite is True
+    if target == 'E_i':
+        assert interface == 'h5'
+        assert if_lcmp_graph is False
+        assert separate_onsite is True
+    if create_from_DFT:
+        assert tb_folder is not None
+        assert max_num_nbr == 0
+        if interface == 'h5_rc_only' and target == 'E_ij':
+            raise NotImplementedError
+        elif interface == 'h5' or (interface == 'h5_rc_only' and target != 'E_ij'):
+            key_atom_list = [[] for _ in range(len(numbers))]
+            edge_idx, edge_fea, edge_idx_first = [], [], []
+            if if_lcmp_graph:
+                atom_idx_connect, edge_idx_connect = [], []
+                edge_idx_connect_cursor = 0
+            if target == 'E_ij':
+                fid = h5py.File(os.path.join(tb_folder, 'E_delta_ee_ij.h5'), 'r')
+            else:
+                if if_require_grad:
+                    fid = fid_rc
+                else:
+                    fid = h5py.File(os.path.join(tb_folder, 'rc.h5'), 'r')
+            for k in fid.keys():
+                key = json.loads(k)
+                key_tensor = torch.tensor([key[0], key[1], key[2], key[3] - 1, key[4] - 1]) # (R, i, j) i and j is 0-based index
+                if separate_onsite:
+                    if key[0] == 0 and key[1] == 0 and key[2] == 0 and key[3] == key[4]:
+                        continue
+                key_atom_list[key[3] - 1].append(key_tensor)
+            if target != 'E_ij' and not if_require_grad:
+                fid.close()
+
+            for index_first, (cart_coord, keys_tensor) in enumerate(zip(cart_coords, key_atom_list)):
+                keys_tensor = torch.stack(keys_tensor)
+                cart_coords_j = cart_coords[keys_tensor[:, 4]] + keys_tensor[:, :3].type(default_dtype_torch).to(cart_coords.device) @ lattice.to(cart_coords.device)
+                dist = torch.norm(cart_coords_j - cart_coord[None, :], dim=1)
+                len_nn = keys_tensor.shape[0]
+                edge_idx_first.extend([index_first] * len_nn)
+                edge_idx.extend(keys_tensor[:, 4].tolist())
+
+                edge_fea_single = torch.cat([dist.view(-1, 1), cart_coord.view(1, 3).expand(len_nn, 3)], dim=-1)
+                edge_fea_single = torch.cat([edge_fea_single, cart_coords_j, cart_coords[keys_tensor[:, 4]]], dim=-1)
+                edge_fea.append(edge_fea_single)
+
+                if if_lcmp_graph:
+                    atom_idx_connect.append(keys_tensor[:, 4])
+                    edge_idx_connect.append(range(edge_idx_connect_cursor, edge_idx_connect_cursor + len_nn))
+                    edge_idx_connect_cursor += len_nn
+
+            edge_fea = torch.cat(edge_fea).type(default_dtype_torch)
+            edge_idx = torch.stack([torch.LongTensor(edge_idx_first), torch.LongTensor(edge_idx)])
+        else:
+            raise NotImplemented
+    else:
+        cart_coords_np = cart_coords.detach().numpy()
+        frac_coords_np = frac_coords.detach().numpy()
+        lattice_np = lattice.detach().numpy()
+        num_atom = cart_coords.shape[0]
+
+        center_coords_min = np.min(cart_coords_np, axis=0)
+        center_coords_max = np.max(cart_coords_np, axis=0)
+        global_min = center_coords_min - r - numerical_tol
+        global_max = center_coords_max + r + numerical_tol
+        global_min_torch = torch.tensor(global_min)
+        global_max_torch = torch.tensor(global_max)
+
+        reciprocal_lattice = np.linalg.inv(lattice_np).T * 2 * np.pi
+        recp_len = np.sqrt(np.sum(reciprocal_lattice ** 2, axis=1))
+        maxr = np.ceil((r + 0.15) * recp_len / (2 * np.pi))
+        nmin = np.floor(np.min(frac_coords_np, axis=0)) - maxr
+        nmax = np.ceil(np.max(frac_coords_np, axis=0)) + maxr
+        all_ranges = [np.arange(x, y, dtype='int64') for x, y in zip(nmin, nmax)]
+        images = torch.tensor(list(itertools.product(*all_ranges))).type_as(lattice)
+
+        if only_get_R_list:
+            return images
+
+        coords = (images @ lattice)[:, None, :] + cart_coords[None, :, :]
+        indices = torch.arange(num_atom).unsqueeze(0).expand(images.shape[0], num_atom)
+        valid_index_bool = coords.gt(global_min_torch) * coords.lt(global_max_torch)
+        valid_index_bool = valid_index_bool.all(dim=-1)
+        valid_coords = coords[valid_index_bool]
+        valid_indices = indices[valid_index_bool]
+
+
+        valid_coords_np = valid_coords.detach().numpy()
+        all_cube_index = _compute_cube_index(valid_coords_np, global_min, r)
+        nx, ny, nz = _compute_cube_index(global_max, global_min, r) + 1
+        all_cube_index = _three_to_one(all_cube_index, ny, nz)
+        site_cube_index = _three_to_one(_compute_cube_index(cart_coords_np, global_min, r), ny, nz)
+        cube_to_coords_index = collections.defaultdict(list)  # type: Dict[int, List]
+
+        for index, cart_coord in enumerate(all_cube_index.ravel()):
+            cube_to_coords_index[cart_coord].append(index)
+
+        site_neighbors = find_neighbors(site_cube_index, nx, ny, nz)
+
+        edge_idx, edge_fea, edge_idx_first = [], [], []
+        if if_lcmp_graph:
+            atom_idx_connect, edge_idx_connect = [], []
+            edge_idx_connect_cursor = 0
+        for index_first, (cart_coord, j) in enumerate(zip(cart_coords, site_neighbors)):
+            l1 = np.array(_three_to_one(j, ny, nz), dtype=int).ravel()
+            ks = [k for k in l1 if k in cube_to_coords_index]
+            nn_coords_index = np.concatenate([cube_to_coords_index[k] for k in ks], axis=0)
+            nn_coords = valid_coords[nn_coords_index]
+            nn_indices = valid_indices[nn_coords_index]
+            dist = torch.norm(nn_coords - cart_coord[None, :], dim=1)
+
+            if separate_onsite is False:
+                nn_coords = nn_coords.squeeze()
+                nn_indices = nn_indices.squeeze()
+                dist = dist.squeeze()
+            else:
+                nonzero_index = dist.nonzero(as_tuple=False)
+                nn_coords = nn_coords[nonzero_index]
+                nn_coords = nn_coords.squeeze(1)
+                nn_indices = nn_indices[nonzero_index].view(-1)
+                dist = dist[nonzero_index].view(-1)
+
+            if max_num_nbr > 0:
+                if len(dist) >= max_num_nbr:
+                    dist_top, index_top = dist.topk(max_num_nbr, largest=False, sorted=True)
+                    edge_idx.extend(nn_indices[index_top])
+                    if if_lcmp_graph:
+                        atom_idx_connect.append(nn_indices[index_top])
+                    edge_idx_first.extend([index_first] * len(index_top))
+                    edge_fea_single = torch.cat([dist_top.view(-1, 1), cart_coord.view(1, 3).expand(len(index_top), 3)], dim=-1)
+                    edge_fea_single = torch.cat([edge_fea_single, nn_coords[index_top], cart_coords[nn_indices[index_top]]], dim=-1)
+                    edge_fea.append(edge_fea_single)
+                else:
+                    warnings.warn("Can not find a number of max_num_nbr atoms within radius")
+                    edge_idx.extend(nn_indices)
+                    if if_lcmp_graph:
+                        atom_idx_connect.append(nn_indices)
+                    edge_idx_first.extend([index_first] * len(nn_indices))
+                    edge_fea_single = torch.cat([dist.view(-1, 1), cart_coord.view(1, 3).expand(len(nn_indices), 3)], dim=-1)
+                    edge_fea_single = torch.cat([edge_fea_single, nn_coords, cart_coords[nn_indices]], dim=-1)
+                    edge_fea.append(edge_fea_single)
+            else:
+                index_top = dist.lt(r + numerical_tol)
+                edge_idx.extend(nn_indices[index_top])
+                if if_lcmp_graph:
+                    atom_idx_connect.append(nn_indices[index_top])
+                edge_idx_first.extend([index_first] * len(nn_indices[index_top]))
+                edge_fea_single = torch.cat([dist[index_top].view(-1, 1), cart_coord.view(1, 3).expand(len(nn_indices[index_top]), 3)], dim=-1)
+                edge_fea_single = torch.cat([edge_fea_single, nn_coords[index_top], cart_coords[nn_indices[index_top]]], dim=-1)
+                edge_fea.append(edge_fea_single)
+            if if_lcmp_graph:
+                edge_idx_connect.append(range(edge_idx_connect_cursor, edge_idx_connect_cursor + len(atom_idx_connect[-1])))
+                edge_idx_connect_cursor += len(atom_idx_connect[-1])
+
+
+        edge_fea = torch.cat(edge_fea).type(default_dtype_torch)
+        edge_idx_first = torch.LongTensor(edge_idx_first)
+        edge_idx = torch.stack([edge_idx_first, torch.LongTensor(edge_idx)])
+
+
+    if tb_folder is not None:
+        if target == 'E_ij':
+            read_file_list = ['E_ij.h5', 'E_delta_ee_ij.h5', 'E_xc_ij.h5']
+            graph_key_list = ['E_ij', 'E_delta_ee_ij', 'E_xc_ij']
+            read_terms_dict = {}
+            for read_file, graph_key in zip(read_file_list, graph_key_list):
+                read_terms = {}
+                fid = h5py.File(os.path.join(tb_folder, read_file), 'r')
+                for k, v in fid.items():
+                    key = json.loads(k)
+                    key = (key[0], key[1], key[2], key[3] - 1, key[4] - 1)
+                    read_terms[key] = torch.tensor(v[...], dtype=default_dtype_torch)
+                read_terms_dict[graph_key] = read_terms
+                fid.close()
+
+            local_rotation_dict = {}
+            if if_require_grad:
+                fid = fid_rc
+            else:
+                fid = h5py.File(os.path.join(tb_folder, 'rc.h5'), 'r')
+            for k, v in fid.items():
+                key = json.loads(k)
+                key = (key[0], key[1], key[2], key[3] - 1, key[4] - 1)  # (R, i, j) i and j is 0-based index
+                if if_require_grad:
+                    local_rotation_dict[key] = v
+                else:
+                    local_rotation_dict[key] = torch.tensor(v, dtype=default_dtype_torch)
+            if not if_require_grad:
+                fid.close()
+        elif target == 'E_i':
+            read_file_list = ['E_i.h5']
+            graph_key_list = ['E_i']
+            read_terms_dict = {}
+            for read_file, graph_key in zip(read_file_list, graph_key_list):
+                read_terms = {}
+                fid = h5py.File(os.path.join(tb_folder, read_file), 'r')
+                for k, v in fid.items():
+                    index_i = int(k)  # index_i is 0-based index
+                    read_terms[index_i] = torch.tensor(v[...], dtype=default_dtype_torch)
+                fid.close()
+                read_terms_dict[graph_key] = read_terms
+        else:
+            if interface == 'h5' or interface == 'h5_rc_only':
+                atom_num_orbital = load_orbital_types(os.path.join(tb_folder, 'orbital_types.dat'))
+
+                if interface == 'h5':
+                    with open(os.path.join(tb_folder, 'info.json'), 'r') as info_f:
+                        info_dict = json.load(info_f)
+                        spinful = info_dict["isspinful"]
+
+                if interface == 'h5':
+                    if target == 'hamiltonian':
+                        read_file_list = ['rh.h5']
+                        graph_key_list = ['term_real']
+                    elif target == 'phiVdphi':
+                        read_file_list = ['rphiVdphi.h5']
+                        graph_key_list = ['term_real']
+                    elif target == 'density_matrix':
+                        read_file_list = ['rdm.h5']
+                        graph_key_list = ['term_real']
+                    elif target == 'O_ij':
+                        read_file_list = ['rh.h5', 'rdm.h5', 'rvna.h5', 'rvdee.h5', 'rvxc.h5']
+                        graph_key_list = ['rh', 'rdm', 'rvna', 'rvdee', 'rvxc']
+                    else:
+                        raise ValueError('Unknown prediction target: {}'.format(target))
+                    read_terms_dict = {}
+                    for read_file, graph_key in zip(read_file_list, graph_key_list):
+                        read_terms = {}
+                        fid = h5py.File(os.path.join(tb_folder, read_file), 'r')
+                        for k, v in fid.items():
+                            key = json.loads(k)
+                            key = (key[0], key[1], key[2], key[3] - 1, key[4] - 1)
+                            if spinful:
+                                num_orbital_row = atom_num_orbital[key[3]]
+                                num_orbital_column = atom_num_orbital[key[4]]
+                                # soc block order:
+                                # 1 3
+                                # 4 2
+                                if target == 'phiVdphi':
+                                    raise NotImplementedError
+                                else:
+                                    read_value = torch.stack([
+                                        torch.tensor(v[:num_orbital_row, :num_orbital_column].real, dtype=default_dtype_torch),
+                                        torch.tensor(v[:num_orbital_row, :num_orbital_column].imag, dtype=default_dtype_torch),
+                                        torch.tensor(v[num_orbital_row:, num_orbital_column:].real, dtype=default_dtype_torch),
+                                        torch.tensor(v[num_orbital_row:, num_orbital_column:].imag, dtype=default_dtype_torch),
+                                        torch.tensor(v[:num_orbital_row, num_orbital_column:].real, dtype=default_dtype_torch),
+                                        torch.tensor(v[:num_orbital_row, num_orbital_column:].imag, dtype=default_dtype_torch),
+                                        torch.tensor(v[num_orbital_row:, :num_orbital_column].real, dtype=default_dtype_torch),
+                                        torch.tensor(v[num_orbital_row:, :num_orbital_column].imag, dtype=default_dtype_torch)
+                                    ], dim=-1)
+                                read_terms[key] = read_value
+                            else:
+                                read_terms[key] = torch.tensor(v[...], dtype=default_dtype_torch)
+                        read_terms_dict[graph_key] = read_terms
+                        fid.close()
+
+                local_rotation_dict = {}
+                if if_require_grad:
+                    fid = fid_rc
+                else:
+                    fid = h5py.File(os.path.join(tb_folder, 'rc.h5'), 'r')
+                for k, v in fid.items():
+                    key = json.loads(k)
+                    key = (key[0], key[1], key[2], key[3] - 1, key[4] - 1)  # (R, i, j) i and j is 0-based index
+                    if if_require_grad:
+                        local_rotation_dict[key] = v
+                    else:
+                        local_rotation_dict[key] = torch.tensor(v[...], dtype=default_dtype_torch)
+                if not if_require_grad:
+                    fid.close()
+
+                max_num_orbital = max(atom_num_orbital)
+
+            elif interface == 'npz' or interface == 'npz_rc_only':
+                spinful = False
+                atom_num_orbital = load_orbital_types(os.path.join(tb_folder, 'orbital_types.dat'))
+
+                if interface == 'npz':
+                    graph_key_list = ['term_real']
+                    read_terms_dict = {'term_real': {}}
+                    hopping_dict_read = np.load(os.path.join(tb_folder, 'rh.npz'))
+                    for k, v in hopping_dict_read.items():
+                        key = json.loads(k)
+                        key = (key[0], key[1], key[2], key[3] - 1, key[4] - 1)  # (R, i, j) i and j is 0-based index
+                        read_terms_dict['term_real'][key] = torch.tensor(v, dtype=default_dtype_torch)
+
+                local_rotation_dict = {}
+                local_rotation_dict_read = np.load(os.path.join(tb_folder, 'rc.npz'))
+                for k, v in local_rotation_dict_read.items():
+                    key = json.loads(k)
+                    key = (key[0], key[1], key[2], key[3] - 1, key[4] - 1)
+                    local_rotation_dict[key] = torch.tensor(v, dtype=default_dtype_torch)
+
+                max_num_orbital = max(atom_num_orbital)
+            else:
+                raise ValueError(f'Unknown interface: {interface}')
+
+        if target == 'E_i':
+            term_dict = {}
+            onsite_term_dict = {}
+            for graph_key in graph_key_list:
+                term_dict[graph_key] = torch.full([numbers.shape[0], 1], np.nan, dtype=default_dtype_torch)
+            for index_atom in range(numbers.shape[0]):
+                assert index_atom in read_terms_dict[graph_key_list[0]]
+                for graph_key in graph_key_list:
+                    term_dict[graph_key][index_atom] = read_terms_dict[graph_key][index_atom]
+            subgraph = None
+        else:
+            if interface == 'h5_rc_only' or interface == 'npz_rc_only':
+                local_rotation = []
+            else:
+                term_dict = {}
+                onsite_term_dict = {}
+                if target == 'E_ij':
+                    for graph_key in graph_key_list:
+                        term_dict[graph_key] = torch.full([edge_fea.shape[0], 1], np.nan, dtype=default_dtype_torch)
+                    local_rotation = []
+                    if separate_onsite is True:
+                        for graph_key in graph_key_list:
+                            onsite_term_dict['onsite_' + graph_key] = torch.full([numbers.shape[0], 1], np.nan, dtype=default_dtype_torch)
+                else:
+                    term_mask = torch.zeros(edge_fea.shape[0], dtype=torch.bool)
+                    for graph_key in graph_key_list:
+                        if spinful:
+                            term_dict[graph_key] = torch.full([edge_fea.shape[0], max_num_orbital, max_num_orbital, 8],
+                                                              np.nan, dtype=default_dtype_torch)
+                        else:
+                            if target == 'phiVdphi':
+                                term_dict[graph_key] = torch.full([edge_fea.shape[0], max_num_orbital, max_num_orbital, 3],
+                                                                  np.nan, dtype=default_dtype_torch)
+                            else:
+                                term_dict[graph_key] = torch.full([edge_fea.shape[0], max_num_orbital, max_num_orbital],
+                                                                  np.nan, dtype=default_dtype_torch)
+                    local_rotation = []
+                    if separate_onsite is True:
+                        for graph_key in graph_key_list:
+                            if spinful:
+                                onsite_term_dict['onsite_' + graph_key] = torch.full(
+                                    [numbers.shape[0], max_num_orbital, max_num_orbital, 8],
+                                    np.nan, dtype=default_dtype_torch)
+                            else:
+                                if target == 'phiVdphi':
+                                    onsite_term_dict['onsite_' + graph_key] = torch.full(
+                                        [numbers.shape[0], max_num_orbital, max_num_orbital, 3],
+                                        np.nan, dtype=default_dtype_torch)
+                                else:
+                                    onsite_term_dict['onsite_' + graph_key] = torch.full(
+                                        [numbers.shape[0], max_num_orbital, max_num_orbital],
+                                        np.nan, dtype=default_dtype_torch)
+
+            inv_lattice = torch.inverse(lattice).type(default_dtype_torch)
+            for index_edge in range(edge_fea.shape[0]):
+                # h_{i0, jR} i and j is 0-based index
+                R = torch.round(edge_fea[index_edge, 4:7].cpu() @ inv_lattice - edge_fea[index_edge, 7:10].cpu() @ inv_lattice).int().tolist()
+                i, j = edge_idx[:, index_edge]
+
+                key_term = (*R, i.item(), j.item())
+                if interface == 'h5_rc_only' or interface == 'npz_rc_only':
+                    local_rotation.append(local_rotation_dict[key_term])
+                else:
+                    if key_term in read_terms_dict[graph_key_list[0]]:
+                        for graph_key in graph_key_list:
+                            if target == 'E_ij':
+                                term_dict[graph_key][index_edge] = read_terms_dict[graph_key][key_term]
+                            else:
+                                term_mask[index_edge] = True
+                                if spinful:
+                                    term_dict[graph_key][index_edge, :atom_num_orbital[i], :atom_num_orbital[j], :] = read_terms_dict[graph_key][key_term]
+                                else:
+                                    term_dict[graph_key][index_edge, :atom_num_orbital[i], :atom_num_orbital[j]] = read_terms_dict[graph_key][key_term]
+                        local_rotation.append(local_rotation_dict[key_term])
+                    else:
+                        raise NotImplementedError(
+                            "Not yet have support for graph radius including hopping without calculation")
+
+            if separate_onsite is True and interface != 'h5_rc_only' and interface != 'npz_rc_only':
+                for index_atom in range(numbers.shape[0]):
+                    key_term = (0, 0, 0, index_atom, index_atom)
+                    assert key_term in read_terms_dict[graph_key_list[0]]
+                    for graph_key in graph_key_list:
+                        if target == 'E_ij':
+                            onsite_term_dict['onsite_' + graph_key][index_atom] = read_terms_dict[graph_key][key_term]
+                        else:
+                            if spinful:
+                                onsite_term_dict['onsite_' + graph_key][index_atom, :atom_num_orbital[i], :atom_num_orbital[j], :] = \
+                                read_terms_dict[graph_key][key_term]
+                            else:
+                                onsite_term_dict['onsite_' + graph_key][index_atom, :atom_num_orbital[i], :atom_num_orbital[j]] = \
+                                read_terms_dict[graph_key][key_term]
+
+            if if_lcmp_graph:
+                local_rotation = torch.stack(local_rotation, dim=0)
+                assert local_rotation.shape[0] == edge_fea.shape[0]
+                r_vec = edge_fea[:, 1:4] - edge_fea[:, 4:7]
+                r_vec = r_vec.unsqueeze(1)
+                if huge_structure is False:
+                    r_vec = torch.matmul(r_vec[:, None, :, :], local_rotation[None, :, :, :].to(r_vec.device)).reshape(-1, 3)
+                    if if_new_sp:
+                        r_vec = torch.nn.functional.normalize(r_vec, dim=-1)
+                        angular_expansion = _spherical_harmonics(num_l - 1, -r_vec[..., 2], r_vec[..., 0],
+                                                                 r_vec[..., 1])
+                        angular_expansion.mul_(torch.cat([
+                            (math.sqrt(2 * l + 1) / math.sqrt(4 * math.pi)) * torch.ones(2 * l + 1,
+                                                                                         dtype=angular_expansion.dtype,
+                                                                                         device=angular_expansion.device)
+                            for l in range(num_l)
+                        ]))
+                        angular_expansion = angular_expansion.reshape(edge_fea.shape[0], edge_fea.shape[0], -1)
+                    else:
+                        r_vec_sp = get_spherical_from_cartesian(r_vec)
+                        sph_harm_func = SphericalHarmonics()
+                        angular_expansion = []
+                        for l in range(num_l):
+                            angular_expansion.append(sph_harm_func.get(l, r_vec_sp[:, 0], r_vec_sp[:, 1]))
+                        angular_expansion = torch.cat(angular_expansion, dim=-1).reshape(edge_fea.shape[0], edge_fea.shape[0], -1)
+
+                subgraph_atom_idx_list = []
+                subgraph_edge_idx_list = []
+                subgraph_edge_ang_list = []
+                subgraph_index = []
+                index_cursor = 0
+
+                for index in range(edge_fea.shape[0]):
+                    # h_{i0, jR}
+                    i, j = edge_idx[:, index]
+                    subgraph_atom_idx = torch.stack([i.repeat(len(atom_idx_connect[i])), atom_idx_connect[i]]).T
+                    subgraph_edge_idx = torch.LongTensor(edge_idx_connect[i])
+                    if huge_structure:
+                        r_vec_tmp = torch.matmul(r_vec[subgraph_edge_idx, :, :], local_rotation[index, :, :].to(r_vec.device)).reshape(-1, 3)
+                        if if_new_sp:
+                            r_vec_tmp = torch.nn.functional.normalize(r_vec_tmp, dim=-1)
+                            subgraph_edge_ang = _spherical_harmonics(num_l - 1, -r_vec_tmp[..., 2], r_vec_tmp[..., 0], r_vec_tmp[..., 1])
+                            subgraph_edge_ang.mul_(torch.cat([
+                                (math.sqrt(2 * l + 1) / math.sqrt(4 * math.pi)) * torch.ones(2 * l + 1,
+                                                                                             dtype=subgraph_edge_ang.dtype,
+                                                                                             device=subgraph_edge_ang.device)
+                                for l in range(num_l)
+                            ]))
+                        else:
+                            r_vec_sp = get_spherical_from_cartesian(r_vec_tmp)
+                            sph_harm_func = SphericalHarmonics()
+                            angular_expansion = []
+                            for l in range(num_l):
+                                angular_expansion.append(sph_harm_func.get(l, r_vec_sp[:, 0], r_vec_sp[:, 1]))
+                            subgraph_edge_ang = torch.cat(angular_expansion, dim=-1).reshape(-1, num_l ** 2)
+                    else:
+                        subgraph_edge_ang = angular_expansion[subgraph_edge_idx, index, :]
+
+                    subgraph_atom_idx_list.append(subgraph_atom_idx)
+                    subgraph_edge_idx_list.append(subgraph_edge_idx)
+                    subgraph_edge_ang_list.append(subgraph_edge_ang)
+                    subgraph_index += [index_cursor] * len(atom_idx_connect[i])
+                    index_cursor += 1
+
+                    subgraph_atom_idx = torch.stack([j.repeat(len(atom_idx_connect[j])), atom_idx_connect[j]]).T
+                    subgraph_edge_idx = torch.LongTensor(edge_idx_connect[j])
+                    if huge_structure:
+                        r_vec_tmp = torch.matmul(r_vec[subgraph_edge_idx, :, :], local_rotation[index, :, :].to(r_vec.device)).reshape(-1, 3)
+                        if if_new_sp:
+                            r_vec_tmp = torch.nn.functional.normalize(r_vec_tmp, dim=-1)
+                            subgraph_edge_ang = _spherical_harmonics(num_l - 1, -r_vec_tmp[..., 2], r_vec_tmp[..., 0], r_vec_tmp[..., 1])
+                            subgraph_edge_ang.mul_(torch.cat([
+                                (math.sqrt(2 * l + 1) / math.sqrt(4 * math.pi)) * torch.ones(2 * l + 1,
+                                                                                             dtype=subgraph_edge_ang.dtype,
+                                                                                             device=subgraph_edge_ang.device)
+                                for l in range(num_l)
+                            ]))
+                        else:
+                            r_vec_sp = get_spherical_from_cartesian(r_vec_tmp)
+                            sph_harm_func = SphericalHarmonics()
+                            angular_expansion = []
+                            for l in range(num_l):
+                                angular_expansion.append(sph_harm_func.get(l, r_vec_sp[:, 0], r_vec_sp[:, 1]))
+                            subgraph_edge_ang = torch.cat(angular_expansion, dim=-1).reshape(-1, num_l ** 2)
+                    else:
+                        subgraph_edge_ang = angular_expansion[subgraph_edge_idx, index, :]
+                    subgraph_atom_idx_list.append(subgraph_atom_idx)
+                    subgraph_edge_idx_list.append(subgraph_edge_idx)
+                    subgraph_edge_ang_list.append(subgraph_edge_ang)
+                    subgraph_index += [index_cursor] * len(atom_idx_connect[j])
+                    index_cursor += 1
+                subgraph =  {"subgraph_atom_idx":torch.cat(subgraph_atom_idx_list, dim=0),
+                             "subgraph_edge_idx":torch.cat(subgraph_edge_idx_list, dim=0),
+                             "subgraph_edge_ang":torch.cat(subgraph_edge_ang_list, dim=0),
+                             "subgraph_index":torch.LongTensor(subgraph_index)}
+            else:
+                subgraph = None
+
+        if interface == 'h5_rc_only' or interface == 'npz_rc_only':
+            data = Data(x=numbers, edge_index=edge_idx, edge_attr=edge_fea, stru_id=stru_id, term_mask=None,
+                        term_real=None, onsite_term_real=None,
+                        atom_num_orbital=torch.tensor(atom_num_orbital),
+                        subgraph_dict=subgraph,
+                        **kwargs)
+        else:
+            if target == 'E_ij' or target == 'E_i':
+                data = Data(x=numbers, edge_index=edge_idx, edge_attr=edge_fea, stru_id=stru_id,
+                            **term_dict, **onsite_term_dict,
+                            subgraph_dict=subgraph,
+                            spinful=False,
+                            **kwargs)
+            else:
+                data = Data(x=numbers, edge_index=edge_idx, edge_attr=edge_fea, stru_id=stru_id, term_mask=term_mask,
+                            **term_dict, **onsite_term_dict,
+                            atom_num_orbital=torch.tensor(atom_num_orbital),
+                            subgraph_dict=subgraph,
+                            spinful=spinful,
+                            **kwargs)
+    else:
+        data = Data(x=numbers, edge_index=edge_idx, edge_attr=edge_fea, stru_id=stru_id, **kwargs)
+    return data

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/inference/__init__.py

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

example/diamond/1_data_prepare/data/bands/sc/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 Γ"]
+}

example/diamond/1_data_prepare/data/bands/sc/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()

example/diamond/1_data_prepare/data/bands/sc/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

example/diamond/1_data_prepare/data/bands/sc/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

example/diamond/1_data_prepare/data/bands/sc/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

example/diamond/1_data_prepare/data/bands/sc/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()

example/diamond/1_data_prepare/data/bands/sc/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

example/diamond/1_data_prepare/data/bands/sc/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()

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/kernel.py

@@ -0,0 +1,844 @@
+import json
+import os
+from inspect import signature
+import time
+import csv
+import sys
+import shutil
+import random
+import warnings
+from math import sqrt
+from itertools import islice
+from configparser import ConfigParser
+
+import torch
+import torch.optim as optim
+from torch import package
+from torch.nn import MSELoss
+from torch.optim.lr_scheduler import MultiStepLR, ReduceLROnPlateau, CyclicLR
+from torch.utils.data import SubsetRandomSampler, DataLoader
+from torch.nn.utils import clip_grad_norm_
+from torch.utils.tensorboard import SummaryWriter
+from torch_scatter import scatter_add
+import numpy as np
+from psutil import cpu_count
+
+from .data import HData
+from .graph import Collater
+from .utils import Logger, save_model, LossRecord, MaskMSELoss, Transform
+
+
+class DeepHKernel:
+    def __init__(self, config: ConfigParser):
+        self.config = config
+
+        # basic config
+        if config.getboolean('basic', 'save_to_time_folder'):
+            config.set('basic', 'save_dir',
+                       os.path.join(config.get('basic', 'save_dir'),
+                                    str(time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime(time.time())))))
+            assert not os.path.exists(config.get('basic', 'save_dir'))
+        os.makedirs(config.get('basic', 'save_dir'), exist_ok=True)
+
+        sys.stdout = Logger(os.path.join(config.get('basic', 'save_dir'), "result.txt"))
+        sys.stderr = Logger(os.path.join(config.get('basic', 'save_dir'), "stderr.txt"))
+        self.if_tensorboard = config.getboolean('basic', 'tb_writer')
+        if self.if_tensorboard:
+            self.tb_writer = SummaryWriter(os.path.join(config.get('basic', 'save_dir'), "tensorboard"))
+        src_dir = os.path.join(config.get('basic', 'save_dir'), "src")
+        os.makedirs(src_dir, exist_ok=True)
+        try:
+            shutil.copytree(os.path.dirname(__file__), os.path.join(src_dir, 'deeph'))
+        except:
+            warnings.warn("Unable to copy scripts")
+        if not config.getboolean('basic', 'disable_cuda'):
+            self.device = torch.device(config.get('basic', 'device') if torch.cuda.is_available() else 'cpu')
+        else:
+            self.device = torch.device('cpu')
+        config.set('basic', 'device', str(self.device))
+        if config.get('hyperparameter', 'dtype') == 'float32':
+            default_dtype_torch = torch.float32
+        elif config.get('hyperparameter', 'dtype') == 'float16':
+            default_dtype_torch = torch.float16
+        elif config.get('hyperparameter', 'dtype') == 'float64':
+            default_dtype_torch = torch.float64
+        else:
+            raise ValueError('Unknown dtype: {}'.format(config.get('hyperparameter', 'dtype')))
+        np.seterr(all='raise')
+        np.seterr(under='warn')
+        np.set_printoptions(precision=8, linewidth=160)
+        torch.set_default_dtype(default_dtype_torch)
+        torch.set_printoptions(precision=8, linewidth=160, threshold=np.inf)
+        np.random.seed(config.getint('basic', 'seed'))
+        torch.manual_seed(config.getint('basic', 'seed'))
+        torch.cuda.manual_seed_all(config.getint('basic', 'seed'))
+        random.seed(config.getint('basic', 'seed'))
+        torch.backends.cudnn.benchmark = False
+        torch.backends.cudnn.deterministic = True
+        torch.cuda.empty_cache()
+        
+        if config.getint('basic', 'num_threads', fallback=-1) == -1:
+            if torch.cuda.device_count() == 0:
+                torch.set_num_threads(cpu_count(logical=False))
+            else:
+                torch.set_num_threads(cpu_count(logical=False) // torch.cuda.device_count())
+        else:
+            torch.set_num_threads(config.getint('basic', 'num_threads'))
+
+        print('====== CONFIG ======')
+        for section_k, section_v in islice(config.items(), 1, None):
+            print(f'[{section_k}]')
+            for k, v in section_v.items():
+                print(f'{k}={v}')
+            print('')
+        config.write(open(os.path.join(config.get('basic', 'save_dir'), 'config.ini'), "w"))
+
+        self.if_lcmp = self.config.getboolean('network', 'if_lcmp', fallback=True)
+        self.if_lcmp_graph = self.config.getboolean('graph', 'if_lcmp_graph', fallback=True)
+        self.new_sp = self.config.getboolean('graph', 'new_sp', fallback=False)
+        self.separate_onsite = self.config.getboolean('graph', 'separate_onsite', fallback=False)
+        if self.if_lcmp == True:
+            assert self.if_lcmp_graph == True
+        self.target = self.config.get('basic', 'target')
+        if self.target == 'O_ij':
+            self.O_component = config['basic']['O_component']
+        if self.target != 'E_ij' and self.target != 'E_i':
+            self.orbital = json.loads(config.get('basic', 'orbital'))
+            self.num_orbital = len(self.orbital)
+        else:
+            self.energy_component = config['basic']['energy_component']
+        # early_stopping
+        self.early_stopping_loss_epoch = json.loads(self.config.get('train', 'early_stopping_loss_epoch'))
+
+    def build_model(self, model_pack_dir: str = None, old_version=None):
+        if model_pack_dir is not None:
+            assert old_version is not None
+            if old_version is True:
+                print(f'import HGNN from {model_pack_dir}')
+                sys.path.append(model_pack_dir)
+                from src.deeph import HGNN
+            else:
+                imp = package.PackageImporter(os.path.join(model_pack_dir, 'best_model.pt'))
+                checkpoint = imp.load_pickle('checkpoint', 'model.pkl', map_location=self.device)
+                self.model = checkpoint['model']
+                self.model.to(self.device)
+                self.index_to_Z = checkpoint["index_to_Z"]
+                self.Z_to_index = checkpoint["Z_to_index"]
+                self.spinful = checkpoint["spinful"]
+                print("=> load best checkpoint (epoch {})".format(checkpoint['epoch']))
+                print(f"=> Atomic types: {self.index_to_Z.tolist()}, "
+                      f"spinful: {self.spinful}, the number of atomic types: {len(self.index_to_Z)}.")
+                if self.target != 'E_ij':
+                    if self.spinful:
+                        self.out_fea_len = self.num_orbital * 8
+                    else:
+                        self.out_fea_len = self.num_orbital
+                else:
+                    if self.energy_component == 'both':
+                        self.out_fea_len = 2
+                    elif self.energy_component in ['xc', 'delta_ee', 'summation']:
+                        self.out_fea_len = 1
+                    else:
+                        raise ValueError('Unknown energy_component: {}'.format(self.energy_component))
+                return checkpoint
+        else:
+            from .model import HGNN
+
+        if self.spinful:
+            if self.target == 'phiVdphi':
+                raise NotImplementedError("Not yet have support for phiVdphi")
+            else:
+                self.out_fea_len = self.num_orbital * 8
+        else:
+            if self.target == 'phiVdphi':
+                self.out_fea_len = self.num_orbital * 3
+            else:
+                self.out_fea_len = self.num_orbital
+
+        print(f'Output features length of single edge: {self.out_fea_len}')
+        model_kwargs = dict(
+            n_elements=self.num_species,
+            num_species=self.num_species,
+            in_atom_fea_len=self.config.getint('network', 'atom_fea_len'),
+            in_vfeats=self.config.getint('network', 'atom_fea_len'),
+            in_edge_fea_len=self.config.getint('network', 'edge_fea_len'),
+            in_efeats=self.config.getint('network', 'edge_fea_len'),
+            out_edge_fea_len=self.out_fea_len,
+            out_efeats=self.out_fea_len,
+            num_orbital=self.out_fea_len,
+            distance_expansion=self.config.get('network', 'distance_expansion'),
+            gauss_stop=self.config.getfloat('network', 'gauss_stop'),
+            cutoff=self.config.getfloat('network', 'gauss_stop'),
+            if_exp=self.config.getboolean('network', 'if_exp'),
+            if_MultipleLinear=self.config.getboolean('network', 'if_MultipleLinear'),
+            if_edge_update=self.config.getboolean('network', 'if_edge_update'),
+            if_lcmp=self.if_lcmp,
+            normalization=self.config.get('network', 'normalization'),
+            atom_update_net=self.config.get('network', 'atom_update_net', fallback='CGConv'),
+            separate_onsite=self.separate_onsite,
+            num_l=self.config.getint('network', 'num_l'),
+            trainable_gaussians=self.config.getboolean('network', 'trainable_gaussians', fallback=False),
+            type_affine=self.config.getboolean('network', 'type_affine', fallback=False),
+            if_fc_out=False,
+        )
+        parameter_list = list(signature(HGNN.__init__).parameters.keys())
+        current_parameter_list = list(model_kwargs.keys())
+        for k in current_parameter_list:
+            if k not in parameter_list:
+                model_kwargs.pop(k)
+        if 'num_elements' in parameter_list:
+            model_kwargs['num_elements'] = self.config.getint('basic', 'max_element') + 1
+        self.model = HGNN(
+            **model_kwargs
+        )
+
+        model_parameters = filter(lambda p: p.requires_grad, self.model.parameters())
+        params = sum([np.prod(p.size()) for p in model_parameters])
+        print("The model you built has: %d parameters" % params)
+        self.model.to(self.device)
+        self.load_pretrained()
+
+    def set_train(self):
+        self.criterion_name = self.config.get('hyperparameter', 'criterion', fallback='MaskMSELoss')
+        if self.target == "E_i":
+            self.criterion = MSELoss()
+        elif self.target == "E_ij":
+            self.criterion = MSELoss()
+            self.retain_edge_fea = self.config.getboolean('hyperparameter', 'retain_edge_fea')
+            self.lambda_Eij = self.config.getfloat('hyperparameter', 'lambda_Eij')
+            self.lambda_Ei = self.config.getfloat('hyperparameter', 'lambda_Ei')
+            self.lambda_Etot = self.config.getfloat('hyperparameter', 'lambda_Etot')
+            if self.retain_edge_fea is False:
+                assert self.lambda_Eij == 0.0
+        else:
+            if self.criterion_name == 'MaskMSELoss':
+                self.criterion = MaskMSELoss()
+            else:
+                raise ValueError(f'Unknown criterion: {self.criterion_name}')
+
+        learning_rate = self.config.getfloat('hyperparameter', 'learning_rate')
+        momentum = self.config.getfloat('hyperparameter', 'momentum')
+        weight_decay = self.config.getfloat('hyperparameter', 'weight_decay')
+
+        model_parameters = filter(lambda p: p.requires_grad, self.model.parameters())
+        if self.config.get('hyperparameter', 'optimizer') == 'sgd':
+            self.optimizer = optim.SGD(model_parameters, lr=learning_rate, weight_decay=weight_decay)
+        elif self.config.get('hyperparameter', 'optimizer') == 'sgdm':
+            self.optimizer = optim.SGD(model_parameters, lr=learning_rate, momentum=momentum, weight_decay=weight_decay)
+        elif self.config.get('hyperparameter', 'optimizer') == 'adam':
+            self.optimizer = optim.Adam(model_parameters, lr=learning_rate, betas=(0.9, 0.999))
+        elif self.config.get('hyperparameter', 'optimizer') == 'adamW':
+            self.optimizer = optim.AdamW(model_parameters, lr=learning_rate, betas=(0.9, 0.999))
+        elif self.config.get('hyperparameter', 'optimizer') == 'adagrad':
+            self.optimizer = optim.Adagrad(model_parameters, lr=learning_rate)
+        elif self.config.get('hyperparameter', 'optimizer') == 'RMSprop':
+            self.optimizer = optim.RMSprop(model_parameters, lr=learning_rate)
+        elif self.config.get('hyperparameter', 'optimizer') == 'lbfgs':
+            self.optimizer = optim.LBFGS(model_parameters, lr=0.1)
+        else:
+            raise ValueError(f'Unknown optimizer: {self.optimizer}')
+
+        if self.config.get('hyperparameter', 'lr_scheduler') == '':
+            pass
+        elif self.config.get('hyperparameter', 'lr_scheduler') == 'MultiStepLR':
+            lr_milestones = json.loads(self.config.get('hyperparameter', 'lr_milestones'))
+            self.scheduler = MultiStepLR(self.optimizer, milestones=lr_milestones, gamma=0.2)
+        elif self.config.get('hyperparameter', 'lr_scheduler') == 'ReduceLROnPlateau':
+            self.scheduler = ReduceLROnPlateau(self.optimizer, mode='min', factor=0.2, patience=10,
+                                               verbose=True, threshold=1e-4, threshold_mode='rel', min_lr=0)
+        elif self.config.get('hyperparameter', 'lr_scheduler') == 'CyclicLR':
+            self.scheduler = CyclicLR(self.optimizer, base_lr=learning_rate * 0.1, max_lr=learning_rate,
+                                      mode='triangular', step_size_up=50, step_size_down=50, cycle_momentum=False)
+        else:
+            raise ValueError('Unknown lr_scheduler: {}'.format(self.config.getfloat('hyperparameter', 'lr_scheduler')))
+        self.load_resume()
+
+    def load_pretrained(self):
+        pretrained = self.config.get('train', 'pretrained')
+        if pretrained:
+            if os.path.isfile(pretrained):
+                checkpoint = torch.load(pretrained, map_location=self.device)
+                pretrained_dict = checkpoint['state_dict']
+                model_dict = self.model.state_dict()
+
+                transfer_dict = {}
+                for k, v in pretrained_dict.items():
+                    if v.shape == model_dict[k].shape:
+                        transfer_dict[k] = v
+                        print('Use pretrained parameters:', k)
+
+                model_dict.update(transfer_dict)
+                self.model.load_state_dict(model_dict)
+                print(f'=> loaded pretrained model at "{pretrained}" (epoch {checkpoint["epoch"]})')
+            else:
+                print(f'=> no checkpoint found at "{pretrained}"')
+
+    def load_resume(self):
+        resume = self.config.get('train', 'resume')
+        if resume:
+            if os.path.isfile(resume):
+                checkpoint = torch.load(resume, map_location=self.device)
+                self.model.load_state_dict(checkpoint['state_dict'])
+                self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+                print(f'=> loaded model at "{resume}" (epoch {checkpoint["epoch"]})')
+            else:
+                print(f'=> no checkpoint found at "{resume}"')
+
+    def get_dataset(self, only_get_graph=False):
+        dataset = HData(
+            raw_data_dir=self.config.get('basic', 'raw_dir'),
+            graph_dir=self.config.get('basic', 'graph_dir'),
+            interface=self.config.get('basic', 'interface'),
+            target=self.target,
+            dataset_name=self.config.get('basic', 'dataset_name'),
+            multiprocessing=self.config.getint('basic', 'multiprocessing', fallback=0),
+            radius=self.config.getfloat('graph', 'radius'),
+            max_num_nbr=self.config.getint('graph', 'max_num_nbr'),
+            num_l=self.config.getint('network', 'num_l'),
+            max_element=self.config.getint('basic', 'max_element'),
+            create_from_DFT=self.config.getboolean('graph', 'create_from_DFT', fallback=True),
+            if_lcmp_graph=self.if_lcmp_graph,
+            separate_onsite=self.separate_onsite,
+            new_sp=self.new_sp,
+            default_dtype_torch=torch.get_default_dtype(),
+        )
+        if only_get_graph:
+            return None, None, None, None
+        self.spinful = dataset.info["spinful"]
+        self.index_to_Z = dataset.info["index_to_Z"]
+        self.Z_to_index = dataset.info["Z_to_index"]
+        self.num_species = len(dataset.info["index_to_Z"])
+        if self.target != 'E_ij' and self.target != 'E_i':
+            dataset = self.make_mask(dataset)
+
+        dataset_size = len(dataset)
+        train_size = int(self.config.getfloat('train', 'train_ratio') * dataset_size)
+        val_size = int(self.config.getfloat('train', 'val_ratio') * dataset_size)
+        test_size = int(self.config.getfloat('train', 'test_ratio') * dataset_size)
+        assert train_size + val_size + test_size <= dataset_size
+
+        indices = list(range(dataset_size))
+        np.random.shuffle(indices)
+        print(f'number of train set: {len(indices[:train_size])}')
+        print(f'number of val set: {len(indices[train_size:train_size + val_size])}')
+        print(f'number of test set: {len(indices[train_size + val_size:train_size + val_size + test_size])}')
+        train_sampler = SubsetRandomSampler(indices[:train_size])
+        val_sampler = SubsetRandomSampler(indices[train_size:train_size + val_size])
+        test_sampler = SubsetRandomSampler(indices[train_size + val_size:train_size + val_size + test_size])
+        train_loader = DataLoader(dataset, batch_size=self.config.getint('hyperparameter', 'batch_size'),
+                                  shuffle=False, sampler=train_sampler,
+                                  collate_fn=Collater(self.if_lcmp))
+        val_loader = DataLoader(dataset, batch_size=self.config.getint('hyperparameter', 'batch_size'),
+                                shuffle=False, sampler=val_sampler,
+                                collate_fn=Collater(self.if_lcmp))
+        test_loader = DataLoader(dataset, batch_size=self.config.getint('hyperparameter', 'batch_size'),
+                                 shuffle=False, sampler=test_sampler,
+                                 collate_fn=Collater(self.if_lcmp))
+
+        if self.config.getboolean('basic', 'statistics'):
+            sample_label = torch.cat([dataset[i].label for i in range(len(dataset))])
+            sample_mask = torch.cat([dataset[i].mask for i in range(len(dataset))])
+            mean_value = abs(sample_label).sum(dim=0) / sample_mask.sum(dim=0)
+            import matplotlib.pyplot as plt
+            len_matrix = int(sqrt(self.out_fea_len))
+            if len_matrix ** 2 != self.out_fea_len:
+                raise ValueError
+            mean_value = mean_value.reshape(len_matrix, len_matrix)
+            im = plt.imshow(mean_value, cmap='Blues')
+            plt.colorbar(im)
+            plt.xticks(range(len_matrix), range(len_matrix))
+            plt.yticks(range(len_matrix), range(len_matrix))
+            plt.xlabel(r'Orbital $\beta$')
+            plt.ylabel(r'Orbital $\alpha$')
+            plt.title(r'Mean of abs($H^\prime_{i\alpha, j\beta}$)')
+            plt.tight_layout()
+            plt.savefig(os.path.join(self.config.get('basic', 'save_dir'), 'mean.png'), dpi=800)
+            np.savetxt(os.path.join(self.config.get('basic', 'save_dir'), 'mean.dat'), mean_value.numpy())
+
+            print(f"The statistical results are saved to {os.path.join(self.config.get('basic', 'save_dir'), 'mean.dat')}")
+
+        normalizer = self.config.getboolean('basic', 'normalizer')
+        boxcox = self.config.getboolean('basic', 'boxcox')
+        if normalizer == False and boxcox == False:
+            transform = Transform()
+        else:
+            sample_label = torch.cat([dataset[i].label for i in range(len(dataset))])
+            sample_mask = torch.cat([dataset[i].mask for i in range(len(dataset))])
+            transform = Transform(sample_label, mask=sample_mask, normalizer=normalizer, boxcox=boxcox)
+        print(transform.state_dict())
+
+        return train_loader, val_loader, test_loader, transform
+
+    def make_mask(self, dataset):
+        dataset_mask = []
+        for data in dataset:
+            if self.target == 'hamiltonian' or self.target == 'phiVdphi' or self.target == 'density_matrix':
+                Oij_value = data.term_real
+                if data.term_real is not None:
+                    if_only_rc = False
+                else:
+                    if_only_rc = True
+            elif self.target == 'O_ij':
+                if self.O_component == 'H_minimum':
+                    Oij_value = data.rvdee + data.rvxc
+                elif self.O_component == 'H_minimum_withNA':
+                    Oij_value = data.rvna + data.rvdee + data.rvxc
+                elif self.O_component == 'H':
+                    Oij_value = data.rh
+                elif self.O_component == 'Rho':
+                    Oij_value = data.rdm
+                else:
+                    raise ValueError(f'Unknown O_component: {self.O_component}')
+                if_only_rc = False
+            else:
+                raise ValueError(f'Unknown target: {self.target}')
+            if if_only_rc == False:
+                if not torch.all(data.term_mask):
+                    raise NotImplementedError("Not yet have support for graph radius including hopping without calculation")
+
+            if self.spinful:
+                if self.target == 'phiVdphi':
+                    raise NotImplementedError("Not yet have support for phiVdphi")
+                else:
+                    out_fea_len = self.num_orbital * 8
+            else:
+                if self.target == 'phiVdphi':
+                    out_fea_len = self.num_orbital * 3
+                else:
+                    out_fea_len = self.num_orbital
+            mask = torch.zeros(data.edge_attr.shape[0], out_fea_len, dtype=torch.int8)
+            label = torch.zeros(data.edge_attr.shape[0], out_fea_len, dtype=torch.get_default_dtype())
+
+            atomic_number_edge_i = self.index_to_Z[data.x[data.edge_index[0]]]
+            atomic_number_edge_j = self.index_to_Z[data.x[data.edge_index[1]]]
+
+            for index_out, orbital_dict in enumerate(self.orbital):
+                for N_M_str, a_b in orbital_dict.items():
+                    # N_M, a_b means: H_{ia, jb} when the atomic number of atom i is N and the atomic number of atom j is M
+                    condition_atomic_number_i, condition_atomic_number_j = map(lambda x: int(x), N_M_str.split())
+                    condition_orbital_i, condition_orbital_j = a_b
+
+                    if self.spinful:
+                        if self.target == 'phiVdphi':
+                            raise NotImplementedError("Not yet have support for phiVdphi")
+                        else:
+                            mask[:, 8 * index_out:8 * (index_out + 1)] = torch.where(
+                                (atomic_number_edge_i == condition_atomic_number_i)
+                                & (atomic_number_edge_j == condition_atomic_number_j),
+                                1,
+                                0
+                            )[:, None].repeat(1, 8)
+                    else:
+                        if self.target == 'phiVdphi':
+                            mask[:, 3 * index_out:3 * (index_out + 1)] += torch.where(
+                                (atomic_number_edge_i == condition_atomic_number_i)
+                                & (atomic_number_edge_j == condition_atomic_number_j),
+                                1,
+                                0
+                            )[:, None].repeat(1, 3)
+                        else:
+                            mask[:, index_out] += torch.where(
+                                (atomic_number_edge_i == condition_atomic_number_i)
+                                & (atomic_number_edge_j == condition_atomic_number_j),
+                                1,
+                                0
+                            )
+
+                    if if_only_rc == False:
+                        if self.spinful:
+                            if self.target == 'phiVdphi':
+                                raise NotImplementedError
+                            else:
+                                label[:, 8 * index_out:8 * (index_out + 1)] = torch.where(
+                                    (atomic_number_edge_i == condition_atomic_number_i)
+                                    & (atomic_number_edge_j == condition_atomic_number_j),
+                                    Oij_value[:, condition_orbital_i, condition_orbital_j].t(),
+                                    torch.zeros(8, data.edge_attr.shape[0], dtype=torch.get_default_dtype())
+                                ).t()
+                        else:
+                            if self.target == 'phiVdphi':
+                                label[:, 3 * index_out:3 * (index_out + 1)] = torch.where(
+                                    (atomic_number_edge_i == condition_atomic_number_i)
+                                    & (atomic_number_edge_j == condition_atomic_number_j),
+                                    Oij_value[:, condition_orbital_i, condition_orbital_j].t(),
+                                    torch.zeros(3, data.edge_attr.shape[0], dtype=torch.get_default_dtype())
+                                ).t()
+                            else:
+                                label[:, index_out] += torch.where(
+                                    (atomic_number_edge_i == condition_atomic_number_i)
+                                    & (atomic_number_edge_j == condition_atomic_number_j),
+                                    Oij_value[:, condition_orbital_i, condition_orbital_j],
+                                    torch.zeros(data.edge_attr.shape[0], dtype=torch.get_default_dtype())
+                                )
+            assert len(torch.where((mask != 1) & (mask != 0))[0]) == 0
+            mask = mask.bool()
+            data.mask = mask
+            del data.term_mask
+            if if_only_rc == False:
+                data.label = label
+                if self.target == 'hamiltonian' or self.target == 'density_matrix':
+                    del data.term_real
+                elif self.target == 'O_ij':
+                    del data.rh
+                    del data.rdm
+                    del data.rvdee
+                    del data.rvxc
+                    del data.rvna
+            dataset_mask.append(data)
+        return dataset_mask
+
+    def train(self, train_loader, val_loader, test_loader):
+        begin_time = time.time()
+        self.best_val_loss = 1e10
+        if self.config.getboolean('train', 'revert_then_decay'):
+            lr_step = 0
+
+        revert_decay_epoch = json.loads(self.config.get('train', 'revert_decay_epoch'))
+        revert_decay_gamma = json.loads(self.config.get('train', 'revert_decay_gamma'))
+        assert len(revert_decay_epoch) == len(revert_decay_gamma)
+        lr_step_num = len(revert_decay_epoch)
+
+        try:
+            for epoch in range(self.config.getint('train', 'epochs')):
+                if self.config.getboolean('train', 'switch_sgd') and epoch == self.config.getint('train', 'switch_sgd_epoch'):
+                    model_parameters = filter(lambda p: p.requires_grad, self.model.parameters())
+                    self.optimizer = optim.SGD(model_parameters, lr=self.config.getfloat('train', 'switch_sgd_lr'))
+                    print(f"Switch to sgd (epoch: {epoch})")
+
+                learning_rate = self.optimizer.param_groups[0]['lr']
+                if self.if_tensorboard:
+                    self.tb_writer.add_scalar('Learning rate', learning_rate, global_step=epoch)
+
+                # train
+                train_losses = self.kernel_fn(train_loader, 'TRAIN')
+                if self.if_tensorboard:
+                    self.tb_writer.add_scalars('loss', {'Train loss': train_losses.avg}, global_step=epoch)
+
+                # val
+                with torch.no_grad():
+                    val_losses = self.kernel_fn(val_loader, 'VAL')
+                if val_losses.avg > self.config.getfloat('train', 'revert_threshold') * self.best_val_loss:
+                    print(f'Epoch #{epoch:01d} \t| '
+                          f'Learning rate: {learning_rate:0.2e} \t| '
+                          f'Epoch time: {time.time() - begin_time:.2f} \t| '
+                          f'Train loss: {train_losses.avg:.8f} \t| '
+                          f'Val loss: {val_losses.avg:.8f} \t| '
+                          f'Best val loss: {self.best_val_loss:.8f}.'
+                          )
+                    best_checkpoint = torch.load(os.path.join(self.config.get('basic', 'save_dir'), 'best_state_dict.pkl'))
+                    self.model.load_state_dict(best_checkpoint['state_dict'])
+                    self.optimizer.load_state_dict(best_checkpoint['optimizer_state_dict'])
+                    if self.config.getboolean('train', 'revert_then_decay'):
+                        if lr_step < lr_step_num:
+                            for param_group in self.optimizer.param_groups:
+                                param_group['lr'] = learning_rate * revert_decay_gamma[lr_step]
+                            lr_step += 1
+                    with torch.no_grad():
+                        val_losses = self.kernel_fn(val_loader, 'VAL')
+                    print(f"Revert (threshold: {self.config.getfloat('train', 'revert_threshold')}) to epoch {best_checkpoint['epoch']} \t| Val loss: {val_losses.avg:.8f}")
+                    if self.if_tensorboard:
+                        self.tb_writer.add_scalars('loss', {'Validation loss': val_losses.avg}, global_step=epoch)
+
+                    if self.config.get('hyperparameter', 'lr_scheduler') == 'MultiStepLR':
+                        self.scheduler.step()
+                    elif self.config.get('hyperparameter', 'lr_scheduler') == 'ReduceLROnPlateau':
+                        self.scheduler.step(val_losses.avg)
+                    elif self.config.get('hyperparameter', 'lr_scheduler') == 'CyclicLR':
+                        self.scheduler.step()
+                    continue
+                if self.if_tensorboard:
+                    self.tb_writer.add_scalars('loss', {'Validation loss': val_losses.avg}, global_step=epoch)
+
+                if self.config.getboolean('train', 'revert_then_decay'):
+                    if lr_step < lr_step_num and epoch >= revert_decay_epoch[lr_step]:
+                        for param_group in self.optimizer.param_groups:
+                            param_group['lr'] *= revert_decay_gamma[lr_step]
+                        lr_step += 1
+
+                is_best = val_losses.avg < self.best_val_loss
+                self.best_val_loss = min(val_losses.avg, self.best_val_loss)
+
+                save_complete = False
+                while not save_complete:
+                    try:
+                        save_model({
+                            'epoch': epoch + 1,
+                            'optimizer_state_dict': self.optimizer.state_dict(),
+                            'best_val_loss': self.best_val_loss,
+                            'spinful': self.spinful,
+                            'Z_to_index': self.Z_to_index,
+                            'index_to_Z': self.index_to_Z,
+                        }, {'model': self.model}, {'state_dict': self.model.state_dict()},
+                            path=self.config.get('basic', 'save_dir'), is_best=is_best)
+                        save_complete = True
+                    except KeyboardInterrupt:
+                        print('\nKeyboardInterrupt while saving model to disk')
+
+                if self.config.get('hyperparameter', 'lr_scheduler') == 'MultiStepLR':
+                    self.scheduler.step()
+                elif self.config.get('hyperparameter', 'lr_scheduler') == 'ReduceLROnPlateau':
+                    self.scheduler.step(val_losses.avg)
+                elif self.config.get('hyperparameter', 'lr_scheduler') == 'CyclicLR':
+                    self.scheduler.step()
+
+                print(f'Epoch #{epoch:01d} \t| '
+                      f'Learning rate: {learning_rate:0.2e} \t| '
+                      f'Epoch time: {time.time() - begin_time:.2f} \t| '
+                      f'Train loss: {train_losses.avg:.8f} \t| '
+                      f'Val loss: {val_losses.avg:.8f} \t| '
+                      f'Best val loss: {self.best_val_loss:.8f}.'
+                      )
+
+                if val_losses.avg < self.config.getfloat('train', 'early_stopping_loss'):
+                    print(f"Early stopping because the target accuracy (validation loss < {self.config.getfloat('train', 'early_stopping_loss')}) is achieved at eopch #{epoch:01d}")
+                    break
+                if epoch > self.early_stopping_loss_epoch[1] and val_losses.avg < self.early_stopping_loss_epoch[0]:
+                    print(f"Early stopping because the target accuracy (validation loss < {self.early_stopping_loss_epoch[0]} and epoch > {self.early_stopping_loss_epoch[1]}) is achieved at eopch #{epoch:01d}")
+                    break
+
+                begin_time = time.time()
+        except KeyboardInterrupt:
+            print('\nKeyboardInterrupt')
+
+        print('---------Evaluate Model on Test Set---------------')
+        best_checkpoint = torch.load(os.path.join(self.config.get('basic', 'save_dir'), 'best_state_dict.pkl'))
+        self.model.load_state_dict(best_checkpoint['state_dict'])
+        print("=> load best checkpoint (epoch {})".format(best_checkpoint['epoch']))
+        with torch.no_grad():
+            test_csv_name = 'test_results.csv'
+            train_csv_name = 'train_results.csv'
+            val_csv_name = 'val_results.csv'
+
+            if self.config.getboolean('basic', 'save_csv'):
+                tmp = 'TEST'
+            else:
+                tmp = 'VAL'
+            test_losses = self.kernel_fn(test_loader, tmp, test_csv_name, output_E=True)
+            print(f'Test loss: {test_losses.avg:.8f}.')
+            if self.if_tensorboard:
+                self.tb_writer.add_scalars('loss', {'Test loss': test_losses.avg}, global_step=epoch)
+            test_losses = self.kernel_fn(train_loader, tmp, train_csv_name, output_E=True)
+            print(f'Train loss: {test_losses.avg:.8f}.')
+            test_losses = self.kernel_fn(val_loader, tmp, val_csv_name, output_E=True)
+            print(f'Val loss: {test_losses.avg:.8f}.')
+
+    def predict(self, hamiltonian_dirs):
+        raise NotImplementedError
+
+    def kernel_fn(self, loader, task: str, save_name=None, output_E=False):
+        assert task in ['TRAIN', 'VAL', 'TEST']
+
+        losses = LossRecord()
+        if task == 'TRAIN':
+            self.model.train()
+        else:
+            self.model.eval()
+        if task == 'TEST':
+            assert save_name != None
+            if self.target == "E_i" or self.target == "E_ij":
+                test_targets = []
+                test_preds = []
+                test_ids = []
+                test_atom_ids = []
+                test_atomic_numbers = []
+            else:
+                test_targets = []
+                test_preds = []
+                test_ids = []
+                test_atom_ids = []
+                test_atomic_numbers = []
+                test_edge_infos = []
+
+        if task != 'TRAIN' and (self.out_fea_len != 1):
+            losses_each_out = [LossRecord() for _ in range(self.out_fea_len)]
+        for step, batch_tuple in enumerate(loader):
+            if self.if_lcmp:
+                batch, subgraph = batch_tuple
+                sub_atom_idx, sub_edge_idx, sub_edge_ang, sub_index = subgraph
+                output = self.model(
+                    batch.x.to(self.device),
+                    batch.edge_index.to(self.device),
+                    batch.edge_attr.to(self.device),
+                    batch.batch.to(self.device),
+                    sub_atom_idx.to(self.device),
+                    sub_edge_idx.to(self.device),
+                    sub_edge_ang.to(self.device),
+                    sub_index.to(self.device)
+                )
+            else:
+                batch = batch_tuple
+                output = self.model(
+                    batch.x.to(self.device),
+                    batch.edge_index.to(self.device),
+                    batch.edge_attr.to(self.device),
+                    batch.batch.to(self.device)
+                )
+            if self.target == 'E_ij':
+                if self.energy_component == 'E_ij':
+                    label_non_onsite = batch.E_ij.to(self.device)
+                    label_onsite = batch.onsite_E_ij.to(self.device)
+                elif self.energy_component == 'summation':
+                    label_non_onsite = batch.E_delta_ee_ij.to(self.device) + batch.E_xc_ij.to(self.device)
+                    label_onsite = batch.onsite_E_delta_ee_ij.to(self.device) + batch.onsite_E_xc_ij.to(self.device)
+                elif self.energy_component == 'delta_ee':
+                    label_non_onsite = batch.E_delta_ee_ij.to(self.device)
+                    label_onsite = batch.onsite_E_delta_ee_ij.to(self.device)
+                elif self.energy_component == 'xc':
+                    label_non_onsite = batch.E_xc_ij.to(self.device)
+                    label_onsite = batch.onsite_E_xc_ij.to(self.device)
+                elif self.energy_component == 'both':
+                    raise NotImplementedError
+                output_onsite, output_non_onsite = output
+                if self.retain_edge_fea is False:
+                    output_non_onsite = output_non_onsite * 0
+
+            elif self.target == 'E_i':
+                label = batch.E_i.to(self.device)
+                output = output.reshape(label.shape)
+            else:
+                label = batch.label.to(self.device)
+                output = output.reshape(label.shape)
+
+            if self.target == 'E_i':
+                loss = self.criterion(output, label)
+            elif self.target == 'E_ij':
+                loss_Eij = self.criterion(torch.cat([output_onsite, output_non_onsite], dim=0),
+                                          torch.cat([label_onsite, label_non_onsite], dim=0))
+                output_non_onsite_Ei = scatter_add(output_non_onsite, batch.edge_index.to(self.device)[0, :], dim=0)
+                label_non_onsite_Ei = scatter_add(label_non_onsite, batch.edge_index.to(self.device)[0, :], dim=0)
+                output_Ei = output_non_onsite_Ei + output_onsite
+                label_Ei = label_non_onsite_Ei + label_onsite
+                loss_Ei = self.criterion(output_Ei, label_Ei)
+                loss_Etot = self.criterion(scatter_add(output_Ei, batch.batch.to(self.device), dim=0),
+                                           scatter_add(label_Ei, batch.batch.to(self.device), dim=0))
+                loss = loss_Eij * self.lambda_Eij + loss_Ei * self.lambda_Ei + loss_Etot * self.lambda_Etot
+            else:
+                if self.criterion_name == 'MaskMSELoss':
+                    mask = batch.mask.to(self.device)
+                    loss = self.criterion(output, label, mask)
+                else:
+                    raise ValueError(f'Unknown criterion: {self.criterion_name}')
+            if task == 'TRAIN':
+                if self.config.get('hyperparameter', 'optimizer') == 'lbfgs':
+                    def closure():
+                        self.optimizer.zero_grad()
+                        if self.if_lcmp:
+                            output = self.model(
+                                batch.x.to(self.device),
+                                batch.edge_index.to(self.device),
+                                batch.edge_attr.to(self.device),
+                                batch.batch.to(self.device),
+                                sub_atom_idx.to(self.device),
+                                sub_edge_idx.to(self.device),
+                                sub_edge_ang.to(self.device),
+                                sub_index.to(self.device)
+                            )
+                        else:
+                            output = self.model(
+                                batch.x.to(self.device),
+                                batch.edge_index.to(self.device),
+                                batch.edge_attr.to(self.device),
+                                batch.batch.to(self.device)
+                            )
+                        loss = self.criterion(output, label.to(self.device), mask)
+                        loss.backward()
+                        return loss
+
+                    self.optimizer.step(closure)
+                else:
+                    self.optimizer.zero_grad()
+                    loss.backward()
+                    if self.config.getboolean('train', 'clip_grad'):
+                        clip_grad_norm_(self.model.parameters(), self.config.getfloat('train', 'clip_grad_value'))
+                    self.optimizer.step()
+
+            if self.target == "E_i" or self.target == "E_ij":
+                losses.update(loss.item(), batch.num_nodes)
+            else:
+                if self.criterion_name == 'MaskMSELoss':
+                    losses.update(loss.item(), mask.sum())
+                if task != 'TRAIN' and self.out_fea_len != 1:
+                    if self.criterion_name == 'MaskMSELoss':
+                        se_each_out = torch.pow(output - label.to(self.device), 2)
+                        for index_out, losses_each_out_for in enumerate(losses_each_out):
+                            count = mask[:, index_out].sum().item()
+                            if count == 0:
+                                losses_each_out_for.update(-1, 1)
+                            else:
+                                losses_each_out_for.update(
+                                    torch.masked_select(se_each_out[:, index_out], mask[:, index_out]).mean().item(),
+                                    count
+                                )
+            if task == 'TEST':
+                if self.target == "E_ij":
+                    test_targets += torch.squeeze(label_Ei.detach().cpu()).tolist()
+                    test_preds += torch.squeeze(output_Ei.detach().cpu()).tolist()
+                    test_ids += np.array(batch.stru_id)[torch.squeeze(batch.batch).numpy()].tolist()
+                    test_atom_ids += torch.squeeze(
+                        torch.tensor(range(batch.num_nodes)) - torch.tensor(batch.__slices__['x'])[
+                            batch.batch]).tolist()
+                    test_atomic_numbers += torch.squeeze(self.index_to_Z[batch.x]).tolist()
+                elif self.target == "E_i":
+                    test_targets = torch.squeeze(label.detach().cpu()).tolist()
+                    test_preds = torch.squeeze(output.detach().cpu()).tolist()
+                    test_ids = np.array(batch.stru_id)[torch.squeeze(batch.batch).numpy()].tolist()
+                    test_atom_ids += torch.squeeze(torch.tensor(range(batch.num_nodes)) - torch.tensor(batch.__slices__['x'])[batch.batch]).tolist()
+                    test_atomic_numbers += torch.squeeze(self.index_to_Z[batch.x]).tolist()
+                else:
+                    edge_stru_index = torch.squeeze(batch.batch[batch.edge_index[0]]).numpy()
+                    edge_slices = torch.tensor(batch.__slices__['x'])[edge_stru_index].view(-1, 1)
+                    test_preds += torch.squeeze(output.detach().cpu()).tolist()
+                    test_targets += torch.squeeze(label.detach().cpu()).tolist()
+                    test_ids += np.array(batch.stru_id)[edge_stru_index].tolist()
+                    test_atom_ids += torch.squeeze(batch.edge_index.T - edge_slices).tolist()
+                    test_atomic_numbers += torch.squeeze(self.index_to_Z[batch.x[batch.edge_index.T]]).tolist()
+                    test_edge_infos += torch.squeeze(batch.edge_attr[:, :7].detach().cpu()).tolist()
+            if output_E is True:
+                if self.target == 'E_ij':
+                    output_non_onsite_Ei = scatter_add(output_non_onsite, batch.edge_index.to(self.device)[1, :], dim=0)
+                    label_non_onsite_Ei = scatter_add(label_non_onsite, batch.edge_index.to(self.device)[1, :], dim=0)
+                    output_Ei = output_non_onsite_Ei + output_onsite
+                    label_Ei = label_non_onsite_Ei + label_onsite
+                    Etot_error = abs(scatter_add(output_Ei, batch.batch.to(self.device), dim=0)
+                                     - scatter_add(label_Ei, batch.batch.to(self.device), dim=0)).reshape(-1).tolist()
+                    for test_stru_id, test_error in zip(batch.stru_id, Etot_error):
+                        print(f'{test_stru_id}: {test_error * 1000:.2f} meV / unit_cell')
+                elif self.target == 'E_i':
+                    Etot_error = abs(scatter_add(output, batch.batch.to(self.device), dim=0)
+                                     - scatter_add(label, batch.batch.to(self.device), dim=0)).reshape(-1).tolist()
+                    for test_stru_id, test_error in zip(batch.stru_id, Etot_error):
+                        print(f'{test_stru_id}: {test_error * 1000:.2f} meV / unit_cell')
+
+        if task != 'TRAIN' and (self.out_fea_len != 1):
+            print('%s loss each out:' % task)
+            loss_list = list(map(lambda x: f'{x.avg:0.1e}', losses_each_out))
+            print('[' + ', '.join(loss_list) + ']')
+            loss_list = list(map(lambda x: x.avg, losses_each_out))
+            print(f'max orbital: {max(loss_list):0.1e} (0-based index: {np.argmax(loss_list)})')
+        if task == 'TEST':
+            with open(os.path.join(self.config.get('basic', 'save_dir'), save_name), 'w', newline='') as f:
+                writer = csv.writer(f)
+                if self.target == "E_i" or self.target == "E_ij":
+                    writer.writerow(['stru_id', 'atom_id', 'atomic_number'] +
+                                    ['target'] * self.out_fea_len + ['pred'] * self.out_fea_len)
+                    for stru_id, atom_id, atomic_number, target, pred in zip(test_ids, test_atom_ids,
+                                                                             test_atomic_numbers,
+                                                                             test_targets, test_preds):
+                        if self.out_fea_len == 1:
+                            writer.writerow((stru_id, atom_id, atomic_number, target, pred))
+                        else:
+                            writer.writerow((stru_id, atom_id, atomic_number, *target, *pred))
+
+                else:
+                    writer.writerow(['stru_id', 'atom_id', 'atomic_number', 'dist', 'atom1_x', 'atom1_y', 'atom1_z',
+                                     'atom2_x', 'atom2_y', 'atom2_z']
+                                    + ['target'] * self.out_fea_len + ['pred'] * self.out_fea_len)
+                    for stru_id, atom_id, atomic_number, edge_info, target, pred in zip(test_ids, test_atom_ids,
+                                                                                        test_atomic_numbers,
+                                                                                        test_edge_infos, test_targets,
+                                                                                        test_preds):
+                        if self.out_fea_len == 1:
+                            writer.writerow((stru_id, atom_id, atomic_number, *edge_info, target, pred))
+                        else:
+                            writer.writerow((stru_id, atom_id, atomic_number, *edge_info, *target, *pred))
+        return losses

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/model.py

@@ -0,0 +1,676 @@
+import os
+from typing import Union, Tuple
+from math import ceil, sqrt
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch_geometric.nn.conv import MessagePassing
+from torch_geometric.nn.norm import LayerNorm, PairNorm, InstanceNorm
+from torch_geometric.typing import PairTensor, Adj, OptTensor, Size
+from torch_geometric.nn.inits import glorot, zeros
+from torch_geometric.utils import softmax
+from torch_geometric.nn.models.dimenet import BesselBasisLayer
+from torch_scatter import scatter_add, scatter
+import numpy as np
+from scipy.special import comb
+
+from .from_se3_transformer import SphericalHarmonics
+from .from_schnetpack import GaussianBasis
+from .from_PyG_future import GraphNorm, DiffGroupNorm
+from .from_HermNet import RBF, cosine_cutoff, ShiftedSoftplus, _eps
+
+
+class ExpBernsteinBasis(nn.Module):
+    def __init__(self, K, gamma, cutoff, trainable=True):
+        super(ExpBernsteinBasis, self).__init__()
+        self.K = K
+        if trainable:
+            self.gamma = nn.Parameter(torch.tensor(gamma))
+        else:
+            self.gamma = torch.tensor(gamma)
+        self.register_buffer('cutoff', torch.tensor(cutoff))
+        self.register_buffer('comb_k', torch.Tensor(comb(K - 1, np.arange(K))))
+
+    def forward(self, distances):
+        f_zero = torch.zeros_like(distances)
+        f_cut = torch.where(distances < self.cutoff, torch.exp(
+            -(distances ** 2) / (self.cutoff ** 2 - distances ** 2)), f_zero)
+        x = torch.exp(-self.gamma * distances)
+        out = []
+        for k in range(self.K):
+            out.append((x ** k) * ((1 - x) ** (self.K - 1 - k)))
+        out = torch.stack(out, dim=-1)
+        out = out * self.comb_k[None, :] * f_cut[:, None]
+        return out
+
+
+def get_spherical_from_cartesian(cartesian, cartesian_x=1, cartesian_y=2, cartesian_z=0):
+    spherical = torch.zeros_like(cartesian[..., 0:2])
+    r_xy = cartesian[..., cartesian_x] ** 2 + cartesian[..., cartesian_y] ** 2
+    spherical[..., 0] = torch.atan2(torch.sqrt(r_xy), cartesian[..., cartesian_z])
+    spherical[..., 1] = torch.atan2(cartesian[..., cartesian_y], cartesian[..., cartesian_x])
+    return spherical
+
+
+class SphericalHarmonicsBasis(nn.Module):
+    def __init__(self, num_l=5):
+        super(SphericalHarmonicsBasis, self).__init__()
+        self.num_l = num_l
+
+    def forward(self, edge_attr):
+        r_vec = edge_attr[:, 1:4] - edge_attr[:, 4:7]
+        r_vec_sp = get_spherical_from_cartesian(r_vec)
+        sph_harm_func = SphericalHarmonics()
+
+        angular_expansion = []
+        for l in range(self.num_l):
+            angular_expansion.append(sph_harm_func.get(l, r_vec_sp[:, 0], r_vec_sp[:, 1]))
+        angular_expansion = torch.cat(angular_expansion, dim=-1)
+
+        return angular_expansion
+
+
+"""
+The class CGConv below is extended from "https://github.com/rusty1s/pytorch_geometric", which has the MIT License below
+
+---------------------------------------------------------------------------
+Copyright (c) 2020 Matthias Fey <matthias.fey@tu-dortmund.de>
+
+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.
+"""
+class CGConv(MessagePassing):
+    def __init__(self, channels: Union[int, Tuple[int, int]], dim: int = 0,
+                 aggr: str = 'add', normalization: str = None,
+                 bias: bool = True, if_exp: bool = False, **kwargs):
+        super(CGConv, self).__init__(aggr=aggr, flow="source_to_target", **kwargs)
+        self.channels = channels
+        self.dim = dim
+        self.normalization = normalization
+        self.if_exp = if_exp
+
+        if isinstance(channels, int):
+            channels = (channels, channels)
+
+        self.lin_f = nn.Linear(sum(channels) + dim, channels[1], bias=bias)
+        self.lin_s = nn.Linear(sum(channels) + dim, channels[1], bias=bias)
+        if self.normalization == 'BatchNorm':
+            self.bn = nn.BatchNorm1d(channels[1], track_running_stats=True)
+        elif self.normalization == 'LayerNorm':
+            self.ln = LayerNorm(channels[1])
+        elif self.normalization == 'PairNorm':
+            self.pn = PairNorm(channels[1])
+        elif self.normalization == 'InstanceNorm':
+            self.instance_norm = InstanceNorm(channels[1])
+        elif self.normalization == 'GraphNorm':
+            self.gn = GraphNorm(channels[1])
+        elif self.normalization == 'DiffGroupNorm':
+            self.group_norm = DiffGroupNorm(channels[1], 128)
+        elif self.normalization is None:
+            pass
+        else:
+            raise ValueError('Unknown normalization function: {}'.format(normalization))
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        self.lin_f.reset_parameters()
+        self.lin_s.reset_parameters()
+        if self.normalization == 'BatchNorm':
+            self.bn.reset_parameters()
+
+    def forward(self, x: Union[torch.Tensor, PairTensor], edge_index: Adj,
+                edge_attr: OptTensor, batch, distance, size: Size = None) -> torch.Tensor:
+        """"""
+        if isinstance(x, torch.Tensor):
+            x: PairTensor = (x, x)
+
+        # propagate_type: (x: PairTensor, edge_attr: OptTensor)
+        out = self.propagate(edge_index, x=x, edge_attr=edge_attr, distance=distance, size=size)
+        if self.normalization == 'BatchNorm':
+            out = self.bn(out)
+        elif self.normalization == 'LayerNorm':
+            out = self.ln(out, batch)
+        elif self.normalization == 'PairNorm':
+            out = self.pn(out, batch)
+        elif self.normalization == 'InstanceNorm':
+            out = self.instance_norm(out, batch)
+        elif self.normalization == 'GraphNorm':
+            out = self.gn(out, batch)
+        elif self.normalization == 'DiffGroupNorm':
+            out = self.group_norm(out)
+        out += x[1]
+        return out
+
+    def message(self, x_i, x_j, edge_attr: OptTensor, distance) -> torch.Tensor:
+        z = torch.cat([x_i, x_j, edge_attr], dim=-1)
+        out = self.lin_f(z).sigmoid() * F.softplus(self.lin_s(z))
+        if self.if_exp:
+            sigma = 3
+            n = 2
+            out = out * torch.exp(-distance ** n / sigma ** n / 2).view(-1, 1)
+        return out
+
+    def __repr__(self):
+        return '{}({}, dim={})'.format(self.__class__.__name__, self.channels, self.dim)
+
+
+class GAT_Crystal(MessagePassing):
+    def __init__(self, in_features, out_features, edge_dim, heads, concat=False, normalization: str = None,
+                 dropout=0, bias=True, **kwargs):
+        super(GAT_Crystal, self).__init__(node_dim=0, aggr='add', flow='target_to_source', **kwargs)
+        self.in_features = in_features
+        self.out_features = out_features
+        self.heads = heads
+        self.concat = concat
+        self.dropout = dropout
+        self.neg_slope = 0.2
+        self.prelu = nn.PReLU()
+        self.bn1 = nn.BatchNorm1d(heads)
+        self.W = nn.Parameter(torch.Tensor(in_features + edge_dim, heads * out_features))
+        self.att = nn.Parameter(torch.Tensor(1, heads, 2 * out_features))
+
+        if bias and concat:
+            self.bias = nn.Parameter(torch.Tensor(heads * out_features))
+        elif bias and not concat:
+            self.bias = nn.Parameter(torch.Tensor(out_features))
+        else:
+            self.register_parameter('bias', None)
+
+        self.normalization = normalization
+        if self.normalization == 'BatchNorm':
+            self.bn = nn.BatchNorm1d(out_features, track_running_stats=True)
+        elif self.normalization == 'LayerNorm':
+            self.ln = LayerNorm(out_features)
+        elif self.normalization == 'PairNorm':
+            self.pn = PairNorm(out_features)
+        elif self.normalization == 'InstanceNorm':
+            self.instance_norm = InstanceNorm(out_features)
+        elif self.normalization == 'GraphNorm':
+            self.gn = GraphNorm(out_features)
+        elif self.normalization == 'DiffGroupNorm':
+            self.group_norm = DiffGroupNorm(out_features, 128)
+        elif self.normalization is None:
+            pass
+        else:
+            raise ValueError('Unknown normalization function: {}'.format(normalization))
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        glorot(self.W)
+        glorot(self.att)
+        zeros(self.bias)
+
+    def forward(self, x, edge_index, edge_attr, batch, distance):
+        out = self.propagate(edge_index, x=x, edge_attr=edge_attr)
+
+        if self.normalization == 'BatchNorm':
+            out = self.bn(out)
+        elif self.normalization == 'LayerNorm':
+            out = self.ln(out, batch)
+        elif self.normalization == 'PairNorm':
+            out = self.pn(out, batch)
+        elif self.normalization == 'InstanceNorm':
+            out = self.instance_norm(out, batch)
+        elif self.normalization == 'GraphNorm':
+            out = self.gn(out, batch)
+        elif self.normalization == 'DiffGroupNorm':
+            out = self.group_norm(out)
+        return out
+
+    def message(self, edge_index_i, x_i, x_j, size_i, index, ptr: OptTensor, edge_attr):
+        x_i = torch.cat([x_i, edge_attr], dim=-1)
+        x_j = torch.cat([x_j, edge_attr], dim=-1)
+
+        x_i = F.softplus(torch.matmul(x_i, self.W))
+        x_j = F.softplus(torch.matmul(x_j, self.W))
+        x_i = x_i.view(-1, self.heads, self.out_features)
+        x_j = x_j.view(-1, self.heads, self.out_features)
+
+        alpha = F.softplus((torch.cat([x_i, x_j], dim=-1) * self.att).sum(dim=-1))
+        alpha = F.softplus(self.bn1(alpha))
+
+        alpha = softmax(alpha, index, ptr, size_i)
+
+        alpha = F.dropout(alpha, p=self.dropout, training=self.training)
+
+        return x_j * alpha.view(-1, self.heads, 1)
+
+    def update(self, aggr_out, x):
+        if self.concat is True:
+            aggr_out = aggr_out.view(-1, self.heads * self.out_features)
+        else:
+            aggr_out = aggr_out.mean(dim=1)
+        if self.bias is not None:  aggr_out = aggr_out + self.bias
+        return aggr_out
+
+
+class PaninnNodeFea():
+    def __init__(self, node_fea_s, node_fea_v=None):
+        self.node_fea_s = node_fea_s
+        if node_fea_v == None:
+            self.node_fea_v = torch.zeros(node_fea_s.shape[0], node_fea_s.shape[1], 3, dtype=node_fea_s.dtype,
+                                          device=node_fea_s.device)
+        else:
+            self.node_fea_v = node_fea_v
+
+    def __add__(self, other):
+        return PaninnNodeFea(self.node_fea_s + other.node_fea_s, self.node_fea_v + other.node_fea_v)
+
+
+class PAINN(nn.Module):
+    def __init__(self, in_features, edge_dim, rc: float, l: int, normalization):
+        super(PAINN, self).__init__()
+        self.ms1 = nn.Linear(in_features, in_features)
+        self.ssp = ShiftedSoftplus()
+        self.ms2 = nn.Linear(in_features, in_features * 3)
+
+        self.rbf = RBF(rc, l)
+        self.mv = nn.Linear(l, in_features * 3)
+        self.fc = cosine_cutoff(rc)
+
+        self.us1 = nn.Linear(in_features * 2, in_features)
+        self.us2 = nn.Linear(in_features, in_features * 3)
+
+        self.normalization = normalization
+        if self.normalization == 'BatchNorm':
+            self.bn = nn.BatchNorm1d(in_features, track_running_stats=True)
+        elif self.normalization == 'LayerNorm':
+            self.ln = LayerNorm(in_features)
+        elif self.normalization == 'PairNorm':
+            self.pn = PairNorm(in_features)
+        elif self.normalization == 'InstanceNorm':
+            self.instance_norm = InstanceNorm(in_features)
+        elif self.normalization == 'GraphNorm':
+            self.gn = GraphNorm(in_features)
+        elif self.normalization == 'DiffGroupNorm':
+            self.group_norm = DiffGroupNorm(in_features, 128)
+        elif self.normalization is None or self.normalization == 'None':
+            pass
+        else:
+            raise ValueError('Unknown normalization function: {}'.format(normalization))
+
+    def forward(self, x: Union[torch.Tensor, PairTensor], edge_index: Adj,
+                edge_attr: OptTensor, batch, edge_vec) -> torch.Tensor:
+        r = torch.sqrt((edge_vec ** 2).sum(dim=-1) + _eps).unsqueeze(-1)
+        sj = x.node_fea_s[edge_index[1, :]]
+        vj = x.node_fea_v[edge_index[1, :]]
+
+        phi = self.ms2(self.ssp(self.ms1(sj)))
+        w = self.fc(r) * self.mv(self.rbf(r))
+        v_, s_, r_ = torch.chunk(phi * w, 3, dim=-1)
+
+        ds_update = s_
+        dv_update = vj * v_.unsqueeze(-1) + r_.unsqueeze(-1) * (edge_vec / r).unsqueeze(1)
+
+        ds = scatter(ds_update, edge_index[0], dim=0, dim_size=x.node_fea_s.shape[0], reduce='mean')
+        dv = scatter(dv_update, edge_index[0], dim=0, dim_size=x.node_fea_s.shape[0], reduce='mean')
+        x = x + PaninnNodeFea(ds, dv)
+
+        sj = x.node_fea_s[edge_index[1, :]]
+        vj = x.node_fea_v[edge_index[1, :]]
+        norm = torch.sqrt((vj ** 2).sum(dim=-1) + _eps)
+        s = torch.cat([norm, sj], dim=-1)
+        sj = self.us2(self.ssp(self.us1(s)))
+
+        uv = scatter(vj, edge_index[0], dim=0, dim_size=x.node_fea_s.shape[0], reduce='mean')
+        norm = torch.sqrt((uv ** 2).sum(dim=-1) + _eps).unsqueeze(-1)
+        s_ = scatter(sj, edge_index[0], dim=0, dim_size=x.node_fea_s.shape[0], reduce='mean')
+        avv, asv, ass = torch.chunk(s_, 3, dim=-1)
+
+        ds = ((uv / norm) ** 2).sum(dim=-1) * asv + ass
+        dv = uv * avv.unsqueeze(-1)
+
+        if self.normalization == 'BatchNorm':
+            ds = self.bn(ds)
+        elif self.normalization == 'LayerNorm':
+            ds = self.ln(ds, batch)
+        elif self.normalization == 'PairNorm':
+            ds = self.pn(ds, batch)
+        elif self.normalization == 'InstanceNorm':
+            ds = self.instance_norm(ds, batch)
+        elif self.normalization == 'GraphNorm':
+            ds = self.gn(ds, batch)
+        elif self.normalization == 'DiffGroupNorm':
+            ds = self.group_norm(ds)
+
+        x = x + PaninnNodeFea(ds, dv)
+
+        return x
+
+
+class MPLayer(nn.Module):
+    def __init__(self, in_atom_fea_len, in_edge_fea_len, out_edge_fea_len, if_exp, if_edge_update, normalization,
+                 atom_update_net, gauss_stop, output_layer=False):
+        super(MPLayer, self).__init__()
+        if atom_update_net == 'CGConv':
+            self.cgconv = CGConv(channels=in_atom_fea_len,
+                                 dim=in_edge_fea_len,
+                                 aggr='add',
+                                 normalization=normalization,
+                                 if_exp=if_exp)
+        elif atom_update_net == 'GAT':
+            self.cgconv = GAT_Crystal(
+                in_features=in_atom_fea_len,
+                out_features=in_atom_fea_len,
+                edge_dim=in_edge_fea_len,
+                heads=3,
+                normalization=normalization
+            )
+        elif atom_update_net == 'PAINN':
+            self.cgconv = PAINN(
+                in_features=in_atom_fea_len,
+                edge_dim=in_edge_fea_len,
+                rc=gauss_stop,
+                l=64,
+                normalization=normalization
+            )
+
+        self.if_edge_update = if_edge_update
+        self.atom_update_net = atom_update_net
+        if if_edge_update:
+            if output_layer:
+                self.e_lin = nn.Sequential(nn.Linear(in_edge_fea_len + in_atom_fea_len * 2, 128),
+                                           nn.SiLU(),
+                                           nn.Linear(128, out_edge_fea_len),
+                                           )
+            else:
+                self.e_lin = nn.Sequential(nn.Linear(in_edge_fea_len + in_atom_fea_len * 2, 128),
+                                           nn.SiLU(),
+                                           nn.Linear(128, out_edge_fea_len),
+                                           nn.SiLU(),
+                                           )
+
+    def forward(self, atom_fea, edge_idx, edge_fea, batch, distance, edge_vec):
+        if self.atom_update_net == 'PAINN':
+            atom_fea = self.cgconv(atom_fea, edge_idx, edge_fea, batch, edge_vec)
+            atom_fea_s = atom_fea.node_fea_s
+        else:
+            atom_fea = self.cgconv(atom_fea, edge_idx, edge_fea, batch, distance)
+            atom_fea_s = atom_fea
+        if self.if_edge_update:
+            row, col = edge_idx
+            edge_fea = self.e_lin(torch.cat([atom_fea_s[row], atom_fea_s[col], edge_fea], dim=-1))
+            return atom_fea, edge_fea
+        else:
+            return atom_fea
+
+
+class LCMPLayer(nn.Module):
+    def __init__(self, in_atom_fea_len, in_edge_fea_len, out_edge_fea_len, num_l,
+                 normalization: str = None, bias: bool = True, if_exp: bool = False):
+        super(LCMPLayer, self).__init__()
+        self.in_atom_fea_len = in_atom_fea_len
+        self.normalization = normalization
+        self.if_exp = if_exp
+
+        self.lin_f = nn.Linear(in_atom_fea_len * 2 + in_edge_fea_len, in_atom_fea_len, bias=bias)
+        self.lin_s = nn.Linear(in_atom_fea_len * 2 + in_edge_fea_len, in_atom_fea_len, bias=bias)
+        self.bn = nn.BatchNorm1d(in_atom_fea_len, track_running_stats=True)
+
+        self.e_lin = nn.Sequential(nn.Linear(in_edge_fea_len + in_atom_fea_len * 2 - num_l ** 2, 128),
+                                   nn.SiLU(),
+                                   nn.Linear(128, out_edge_fea_len)
+                                   )
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        self.lin_f.reset_parameters()
+        self.lin_s.reset_parameters()
+        if self.normalization == 'BatchNorm':
+            self.bn.reset_parameters()
+
+    def forward(self, atom_fea, edge_fea, sub_atom_idx, sub_edge_idx, sub_edge_ang, sub_index, distance,
+                huge_structure, output_final_layer_neuron):
+        if huge_structure:
+            sub_graph_batch_num = 8
+
+            sub_graph_num = sub_atom_idx.shape[0]
+            sub_graph_batch_size = ceil(sub_graph_num / sub_graph_batch_num)
+
+            num_edge = edge_fea.shape[0]
+            vf_update = torch.zeros((num_edge * 2, self.in_atom_fea_len)).type(torch.get_default_dtype()).to(atom_fea.device)
+            for sub_graph_batch_index in range(sub_graph_batch_num):
+                if sub_graph_batch_index == sub_graph_batch_num - 1:
+                    sub_graph_idx = slice(sub_graph_batch_size * sub_graph_batch_index, sub_graph_num)
+                else:
+                    sub_graph_idx = slice(sub_graph_batch_size * sub_graph_batch_index,
+                                          sub_graph_batch_size * (sub_graph_batch_index + 1))
+
+                sub_atom_idx_batch = sub_atom_idx[sub_graph_idx]
+                sub_edge_idx_batch = sub_edge_idx[sub_graph_idx]
+                sub_edge_ang_batch = sub_edge_ang[sub_graph_idx]
+                sub_index_batch = sub_index[sub_graph_idx]
+
+                z = torch.cat([atom_fea[sub_atom_idx_batch][:, 0, :], atom_fea[sub_atom_idx_batch][:, 1, :],
+                               edge_fea[sub_edge_idx_batch], sub_edge_ang_batch], dim=-1)
+                out = self.lin_f(z).sigmoid() * F.softplus(self.lin_s(z))
+
+                if self.if_exp:
+                    sigma = 3
+                    n = 2
+                    out = out * torch.exp(-distance[sub_edge_idx_batch] ** n / sigma ** n / 2).view(-1, 1)
+
+                vf_update += scatter_add(out, sub_index_batch, dim=0, dim_size=num_edge * 2)
+
+            if self.normalization == 'BatchNorm':
+                vf_update = self.bn(vf_update)
+            vf_update = vf_update.reshape(num_edge, 2, -1)
+            if output_final_layer_neuron != '':
+                final_layer_neuron = torch.cat([vf_update[:, 0, :], vf_update[:, 1, :], edge_fea],
+                                               dim=-1).detach().cpu().numpy()
+                np.save(os.path.join(output_final_layer_neuron, 'final_layer_neuron.npy'), final_layer_neuron)
+            out = self.e_lin(torch.cat([vf_update[:, 0, :], vf_update[:, 1, :], edge_fea], dim=-1))
+
+            return out
+
+        num_edge = edge_fea.shape[0]
+        z = torch.cat(
+            [atom_fea[sub_atom_idx][:, 0, :], atom_fea[sub_atom_idx][:, 1, :], edge_fea[sub_edge_idx], sub_edge_ang],
+            dim=-1)
+        out = self.lin_f(z).sigmoid() * F.softplus(self.lin_s(z))
+
+        if self.if_exp:
+            sigma = 3
+            n = 2
+            out = out * torch.exp(-distance[sub_edge_idx] ** n / sigma ** n / 2).view(-1, 1)
+
+        out = scatter_add(out, sub_index, dim=0)
+        if self.normalization == 'BatchNorm':
+            out = self.bn(out)
+        out = out.reshape(num_edge, 2, -1)
+        if output_final_layer_neuron != '':
+            final_layer_neuron = torch.cat([out[:, 0, :], out[:, 1, :], edge_fea], dim=-1).detach().cpu().numpy()
+            np.save(os.path.join(output_final_layer_neuron, 'final_layer_neuron.npy'), final_layer_neuron)
+        out = self.e_lin(torch.cat([out[:, 0, :], out[:, 1, :], edge_fea], dim=-1))
+        return out
+
+
+class MultipleLinear(nn.Module):
+    def __init__(self, num_linear: int, in_fea_len: int, out_fea_len: int, bias: bool = True) -> None:
+        super(MultipleLinear, self).__init__()
+        self.num_linear = num_linear
+        self.out_fea_len = out_fea_len
+        self.weight = nn.Parameter(torch.Tensor(num_linear, in_fea_len, out_fea_len))
+        if bias:
+            self.bias = nn.Parameter(torch.Tensor(num_linear, out_fea_len))
+        else:
+            self.register_parameter('bias', None)
+        # self.ln = LayerNorm(num_linear * out_fea_len)
+        # self.gn = GraphNorm(out_fea_len)
+        self.reset_parameters()
+
+    def reset_parameters(self) -> None:
+        nn.init.kaiming_uniform_(self.weight, a=sqrt(5))
+        if self.bias is not None:
+            fan_in, _ = nn.init._calculate_fan_in_and_fan_out(self.weight)
+            bound = 1 / sqrt(fan_in)
+            nn.init.uniform_(self.bias, -bound, bound)
+
+    def forward(self, input: torch.Tensor, batch_edge: torch.Tensor) -> torch.Tensor:
+        output = torch.matmul(input, self.weight)
+
+        if self.bias is not None:
+            output += self.bias[:, None, :]
+        return output
+
+
+class HGNN(nn.Module):
+    def __init__(self, num_species, in_atom_fea_len, in_edge_fea_len, num_orbital,
+                 distance_expansion, gauss_stop, if_exp, if_MultipleLinear, if_edge_update, if_lcmp,
+                 normalization, atom_update_net, separate_onsite,
+                 trainable_gaussians, type_affine, num_l=5):
+        super(HGNN, self).__init__()
+        self.num_species = num_species
+        self.embed = nn.Embedding(num_species + 5, in_atom_fea_len)
+
+        # pair-type aware affine
+        if type_affine:
+            self.type_affine = nn.Embedding(
+                num_species ** 2, 2,
+                _weight=torch.stack([torch.ones(num_species ** 2), torch.zeros(num_species ** 2)], dim=-1)
+            )
+        else:
+            self.type_affine = None
+
+        if if_edge_update or (if_edge_update is False and if_lcmp is False):
+            distance_expansion_len = in_edge_fea_len
+        else:
+            distance_expansion_len = in_edge_fea_len - num_l ** 2
+        if distance_expansion == 'GaussianBasis':
+            self.distance_expansion = GaussianBasis(
+                0.0, gauss_stop, distance_expansion_len, trainable=trainable_gaussians
+            )
+        elif distance_expansion == 'BesselBasis':
+            self.distance_expansion = BesselBasisLayer(distance_expansion_len, gauss_stop, envelope_exponent=5)
+        elif distance_expansion == 'ExpBernsteinBasis':
+            self.distance_expansion = ExpBernsteinBasis(K=distance_expansion_len, gamma=0.5, cutoff=gauss_stop,
+                                                        trainable=True)
+        else:
+            raise ValueError('Unknown distance expansion function: {}'.format(distance_expansion))
+
+        self.if_MultipleLinear = if_MultipleLinear
+        self.if_edge_update = if_edge_update
+        self.if_lcmp = if_lcmp
+        self.atom_update_net = atom_update_net
+        self.separate_onsite = separate_onsite
+
+        if if_lcmp == True:
+            mp_output_edge_fea_len = in_edge_fea_len - num_l ** 2
+        else:
+            assert if_MultipleLinear == False
+            mp_output_edge_fea_len = in_edge_fea_len
+
+        if if_edge_update == True:
+            self.mp1 = MPLayer(in_atom_fea_len, in_edge_fea_len, in_edge_fea_len, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+            self.mp2 = MPLayer(in_atom_fea_len, in_edge_fea_len, in_edge_fea_len, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+            self.mp3 = MPLayer(in_atom_fea_len, in_edge_fea_len, in_edge_fea_len, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+            self.mp4 = MPLayer(in_atom_fea_len, in_edge_fea_len, in_edge_fea_len, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+            self.mp5 = MPLayer(in_atom_fea_len, in_edge_fea_len, mp_output_edge_fea_len, if_exp, if_edge_update,
+                               normalization, atom_update_net, gauss_stop)
+        else:
+            self.mp1 = MPLayer(in_atom_fea_len, distance_expansion_len, None, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+            self.mp2 = MPLayer(in_atom_fea_len, distance_expansion_len, None, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+            self.mp3 = MPLayer(in_atom_fea_len, distance_expansion_len, None, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+            self.mp4 = MPLayer(in_atom_fea_len, distance_expansion_len, None, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+            self.mp5 = MPLayer(in_atom_fea_len, distance_expansion_len, None, if_exp, if_edge_update, normalization,
+                               atom_update_net, gauss_stop)
+
+        if if_lcmp == True:
+            if self.if_MultipleLinear == True:
+                self.lcmp = LCMPLayer(in_atom_fea_len, in_edge_fea_len, 32, num_l, if_exp=if_exp)
+                self.multiple_linear1 = MultipleLinear(num_orbital, 32, 16)
+                self.multiple_linear2 = MultipleLinear(num_orbital, 16, 1)
+            else:
+                self.lcmp = LCMPLayer(in_atom_fea_len, in_edge_fea_len, num_orbital, num_l, if_exp=if_exp)
+        else:
+            self.mp_output = MPLayer(in_atom_fea_len, in_edge_fea_len, num_orbital, if_exp, if_edge_update=True,
+                                     normalization=normalization, atom_update_net=atom_update_net,
+                                     gauss_stop=gauss_stop, output_layer=True)
+
+
+    def forward(self, atom_attr, edge_idx, edge_attr, batch,
+                sub_atom_idx=None, sub_edge_idx=None, sub_edge_ang=None, sub_index=None,
+                huge_structure=False, output_final_layer_neuron=''):
+        batch_edge = batch[edge_idx[0]]
+        atom_fea0 = self.embed(atom_attr)
+        distance = edge_attr[:, 0]
+        edge_vec = edge_attr[:, 1:4] - edge_attr[:, 4:7]
+        if self.type_affine is None:
+            edge_fea0 = self.distance_expansion(distance)
+        else:
+            affine_coeff = self.type_affine(self.num_species * atom_attr[edge_idx[0]] + atom_attr[edge_idx[1]])
+            edge_fea0 = self.distance_expansion(distance * affine_coeff[:, 0] + affine_coeff[:, 1])
+        if self.atom_update_net == "PAINN":
+            atom_fea0 = PaninnNodeFea(atom_fea0)
+
+        if self.if_edge_update == True:
+            atom_fea, edge_fea = self.mp1(atom_fea0, edge_idx, edge_fea0, batch, distance, edge_vec)
+            atom_fea, edge_fea = self.mp2(atom_fea, edge_idx, edge_fea, batch, distance, edge_vec)
+            atom_fea0, edge_fea0 = atom_fea0 + atom_fea, edge_fea0 + edge_fea
+            atom_fea, edge_fea = self.mp3(atom_fea0, edge_idx, edge_fea0, batch, distance, edge_vec)
+            atom_fea, edge_fea = self.mp4(atom_fea, edge_idx, edge_fea, batch, distance, edge_vec)
+            atom_fea0, edge_fea0 = atom_fea0 + atom_fea, edge_fea0 + edge_fea
+            atom_fea, edge_fea = self.mp5(atom_fea0, edge_idx, edge_fea0, batch, distance, edge_vec)
+
+            if self.if_lcmp == True:
+                if self.atom_update_net == 'PAINN':
+                    atom_fea_s = atom_fea.node_fea_s
+                else:
+                    atom_fea_s = atom_fea
+                out = self.lcmp(atom_fea_s, edge_fea, sub_atom_idx, sub_edge_idx, sub_edge_ang, sub_index, distance,
+                                huge_structure, output_final_layer_neuron)
+            else:
+                atom_fea, edge_fea = self.mp_output(atom_fea, edge_idx, edge_fea, batch, distance, edge_vec)
+                out = edge_fea
+        else:
+            atom_fea = self.mp1(atom_fea0, edge_idx, edge_fea0, batch, distance, edge_vec)
+            atom_fea = self.mp2(atom_fea, edge_idx, edge_fea0, batch, distance, edge_vec)
+            atom_fea0 = atom_fea0 + atom_fea
+            atom_fea = self.mp3(atom_fea0, edge_idx, edge_fea0, batch, distance, edge_vec)
+            atom_fea = self.mp4(atom_fea, edge_idx, edge_fea0, batch, distance, edge_vec)
+            atom_fea0 = atom_fea0 + atom_fea
+            atom_fea = self.mp5(atom_fea0, edge_idx, edge_fea0, batch, distance, edge_vec)
+
+            if self.atom_update_net == 'PAINN':
+                atom_fea_s = atom_fea.node_fea_s
+            else:
+                atom_fea_s = atom_fea
+            if self.if_lcmp == True:
+                out = self.lcmp(atom_fea_s, edge_fea0, sub_atom_idx, sub_edge_idx, sub_edge_ang, sub_index, distance,
+                                huge_structure, output_final_layer_neuron)
+            else:
+                atom_fea, edge_fea = self.mp_output(atom_fea, edge_idx, edge_fea0, batch, distance, edge_vec)
+                out = edge_fea
+
+        if self.if_MultipleLinear == True:
+            out = self.multiple_linear1(F.silu(out), batch_edge)
+            out = self.multiple_linear2(F.silu(out), batch_edge)
+            out = out.T
+
+        return out

example/diamond/1_data_prepare/data/bands/sc/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

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/preprocess/abacus_get_data.py

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

example/diamond/1_data_prepare/data/bands/sc/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

example/diamond/1_data_prepare/data/bands/sc/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()

example/diamond/1_data_prepare/data/bands/sc/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

example/diamond/1_data_prepare/data/bands/sc/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')

example/diamond/1_data_prepare/data/bands/sc/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"]

example/diamond/1_data_prepare/data/bands/sc/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()

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/rotate.py

@@ -0,0 +1,277 @@
+import json
+import os.path
+import warnings
+
+import numpy as np
+import h5py
+import torch
+from e3nn.o3 import Irrep, Irreps, matrix_to_angles
+
+from deeph import load_orbital_types
+
+dtype_dict = {
+    np.float32: (torch.float32, torch.float32, torch.complex64),
+    np.float64: (torch.float64, torch.float64, torch.complex128),
+    np.complex64: (torch.complex64, torch.float32, torch.complex64),
+    np.complex128: (torch.complex128, torch.float64, torch.complex128),
+    torch.float32: (torch.float32, torch.float32, torch.complex64),
+    torch.float64: (torch.float64, torch.float64, torch.complex128),
+    torch.complex64: (torch.complex64, torch.float32, torch.complex64),
+    torch.complex128: (torch.complex128, torch.float64, torch.complex128),
+}
+
+
+class Rotate:
+    def __init__(self, torch_dtype, torch_dtype_real=torch.float64, torch_dtype_complex=torch.cdouble,
+                 device=torch.device('cpu'), spinful=False):
+        self.dtype = torch_dtype
+        self.torch_dtype_real = torch_dtype_real
+        self.device = device
+        self.spinful = spinful
+        sqrt_2 = 1.4142135623730951
+        self.Us_openmx = {
+            0: torch.tensor([1], dtype=torch_dtype_complex, device=device),
+            1: torch.tensor([[-1 / sqrt_2, 1j / sqrt_2, 0], [0, 0, 1], [1 / sqrt_2, 1j / sqrt_2, 0]],
+                            dtype=torch_dtype_complex, device=device),
+            2: torch.tensor([[0, 1 / sqrt_2, -1j / sqrt_2, 0, 0],
+                             [0, 0, 0, -1 / sqrt_2, 1j / sqrt_2],
+                             [1, 0, 0, 0, 0],
+                             [0, 0, 0, 1 / sqrt_2, 1j / sqrt_2],
+                             [0, 1 / sqrt_2, 1j / sqrt_2, 0, 0]], dtype=torch_dtype_complex, device=device),
+            3: torch.tensor([[0, 0, 0, 0, 0, -1 / sqrt_2, 1j / sqrt_2],
+                             [0, 0, 0, 1 / sqrt_2, -1j / sqrt_2, 0, 0],
+                             [0, -1 / sqrt_2, 1j / sqrt_2, 0, 0, 0, 0],
+                             [1, 0, 0, 0, 0, 0, 0],
+                             [0, 1 / sqrt_2, 1j / sqrt_2, 0, 0, 0, 0],
+                             [0, 0, 0, 1 / sqrt_2, 1j / sqrt_2, 0, 0],
+                             [0, 0, 0, 0, 0, 1 / sqrt_2, 1j / sqrt_2]], dtype=torch_dtype_complex, device=device),
+        }
+        self.Us_openmx2wiki = {
+            0: torch.eye(1, dtype=torch_dtype).to(device=device),
+            1: torch.eye(3, dtype=torch_dtype)[[1, 2, 0]].to(device=device),
+            2: torch.eye(5, dtype=torch_dtype)[[2, 4, 0, 3, 1]].to(device=device),
+            3: torch.eye(7, dtype=torch_dtype)[[6, 4, 2, 0, 1, 3, 5]].to(device=device)
+        }
+        self.Us_wiki2openmx = {k: v.T for k, v in self.Us_openmx2wiki.items()}
+
+    def rotate_e3nn_v(self, v, R, l, order_xyz=True):
+        if self.spinful:
+            raise NotImplementedError
+        assert len(R.shape) == 2
+        if order_xyz:
+            R_e3nn = self.rotate_matrix_convert(R)
+        else:
+            R_e3nn = R
+        return v @ Irrep(l, 1).D_from_matrix(R_e3nn)
+
+    def rotate_openmx_H_old(self, H, R, l_lefts, l_rights, order_xyz=True):
+        assert len(R.shape) == 2
+        if order_xyz:
+            R_e3nn = self.rotate_matrix_convert(R)
+        else:
+            R_e3nn = R
+
+        block_lefts = []
+        for l_left in l_lefts:
+            block_lefts.append(
+                self.Us_openmx2wiki[l_left].T @ Irrep(l_left, 1).D_from_matrix(R_e3nn) @ self.Us_openmx2wiki[l_left])
+        rotation_left = torch.block_diag(*block_lefts)
+
+        block_rights = []
+        for l_right in l_rights:
+            block_rights.append(
+                self.Us_openmx2wiki[l_right].T @ Irrep(l_right, 1).D_from_matrix(R_e3nn) @ self.Us_openmx2wiki[l_right])
+        rotation_right = torch.block_diag(*block_rights)
+
+        return torch.einsum("cd,ca,db->ab", H, rotation_left, rotation_right)
+
+    def rotate_openmx_H(self, H, R, l_lefts, l_rights, order_xyz=True):
+        # spin-1/2 is writed by gongxx
+        assert len(R.shape) == 2
+        if order_xyz:
+            R_e3nn = self.rotate_matrix_convert(R)
+        else:
+            R_e3nn = R
+        irreps_left = Irreps([(1, (l, 1)) for l in l_lefts])
+        irreps_right = Irreps([(1, (l, 1)) for l in l_rights])
+        U_left = irreps_left.D_from_matrix(R_e3nn)
+        U_right = irreps_right.D_from_matrix(R_e3nn)
+        openmx2wiki_left = torch.block_diag(*[self.Us_openmx2wiki[l] for l in l_lefts])
+        openmx2wiki_right = torch.block_diag(*[self.Us_openmx2wiki[l] for l in l_rights])
+        if self.spinful:
+            U_left = torch.kron(self.D_one_half(R_e3nn), U_left)
+            U_right = torch.kron(self.D_one_half(R_e3nn), U_right)
+            openmx2wiki_left = torch.block_diag(openmx2wiki_left, openmx2wiki_left)
+            openmx2wiki_right = torch.block_diag(openmx2wiki_right, openmx2wiki_right)
+        return openmx2wiki_left.T @ U_left.transpose(-1, -2).conj() @ openmx2wiki_left @ H \
+               @ openmx2wiki_right.T @ U_right @ openmx2wiki_right
+
+    def rotate_openmx_phiVdphi(self, phiVdphi, R, l_lefts, l_rights, order_xyz=True):
+        if self.spinful:
+            raise NotImplementedError
+        assert phiVdphi.shape[-1] == 3
+        assert len(R.shape) == 2
+        if order_xyz:
+            R_e3nn = self.rotate_matrix_convert(R)
+        else:
+            R_e3nn = R
+        block_lefts = []
+        for l_left in l_lefts:
+            block_lefts.append(
+                self.Us_openmx2wiki[l_left].T @ Irrep(l_left, 1).D_from_matrix(R_e3nn) @ self.Us_openmx2wiki[l_left])
+        rotation_left = torch.block_diag(*block_lefts)
+
+        block_rights = []
+        for l_right in l_rights:
+            block_rights.append(
+                self.Us_openmx2wiki[l_right].T @ Irrep(l_right, 1).D_from_matrix(R_e3nn) @ self.Us_openmx2wiki[l_right])
+        rotation_right = torch.block_diag(*block_rights)
+
+        rotation_x = self.Us_openmx2wiki[1].T @ Irrep(1, 1).D_from_matrix(R_e3nn) @ self.Us_openmx2wiki[1]
+
+        return torch.einsum("def,da,eb,fc->abc", phiVdphi, rotation_left, rotation_right, rotation_x)
+
+    def wiki2openmx_H(self, H, l_left, l_right):
+        if self.spinful:
+            raise NotImplementedError
+        return self.Us_openmx2wiki[l_left].T @ H @ self.Us_openmx2wiki[l_right]
+
+    def openmx2wiki_H(self, H, l_left, l_right):
+        if self.spinful:
+            raise NotImplementedError
+        return self.Us_openmx2wiki[l_left] @ H @ self.Us_openmx2wiki[l_right].T
+
+    def rotate_matrix_convert(self, R):
+        return R.index_select(0, R.new_tensor([1, 2, 0]).int()).index_select(1, R.new_tensor([1, 2, 0]).int())
+
+    def D_one_half(self, R):
+        # writed by gongxx
+        assert self.spinful
+        d = torch.det(R).sign()
+        R = d[..., None, None] * R
+        k = (1 - d) / 2  # parity index
+        alpha, beta, gamma = matrix_to_angles(R)
+        J = torch.tensor([[1, 1], [1j, -1j]], dtype=self.dtype) / 1.4142135623730951  # <1/2 mz|1/2 my>
+        Uz1 = self._sp_z_rot(alpha)
+        Uy = J @ self._sp_z_rot(beta) @ J.T.conj()
+        Uz2 = self._sp_z_rot(gamma)
+        return Uz1 @ Uy @ Uz2
+
+    def _sp_z_rot(self, angle):
+        # writed by gongxx
+        assert self.spinful
+        M = torch.zeros([*angle.shape, 2, 2], dtype=self.dtype)
+        inds = torch.tensor([0, 1])
+        freqs = torch.tensor([0.5, -0.5], dtype=self.dtype)
+        M[..., inds, inds] = torch.exp(- freqs * (1j) * angle[..., None])
+        return M
+
+
+def get_rh(input_dir, output_dir, target='hamiltonian'):
+    torch_device = torch.device('cpu')
+    assert target in ['hamiltonian', 'phiVdphi']
+    file_name = {
+        'hamiltonian': 'hamiltonians.h5',
+        'phiVdphi': 'phiVdphi.h5',
+    }[target]
+    prime_file_name = {
+        'hamiltonian': 'rh.h5',
+        'phiVdphi': 'rphiVdphi.h5',
+    }[target]
+    assert os.path.exists(os.path.join(input_dir, file_name))
+    assert os.path.exists(os.path.join(input_dir, 'rc.h5'))
+    assert os.path.exists(os.path.join(input_dir, 'orbital_types.dat'))
+    assert os.path.exists(os.path.join(input_dir, 'info.json'))
+
+    atom_num_orbital, orbital_types = load_orbital_types(os.path.join(input_dir, 'orbital_types.dat'),
+                                                         return_orbital_types=True)
+    nsite = len(atom_num_orbital)
+    with open(os.path.join(input_dir, 'info.json'), 'r') as info_f:
+        info_dict = json.load(info_f)
+        spinful = info_dict["isspinful"]
+    fid_H = h5py.File(os.path.join(input_dir, file_name), 'r')
+    fid_rc = h5py.File(os.path.join(input_dir, 'rc.h5'), 'r')
+    fid_rh = h5py.File(os.path.join(output_dir, prime_file_name), 'w')
+    assert '[0, 0, 0, 1, 1]' in fid_H.keys()
+    h5_dtype = fid_H['[0, 0, 0, 1, 1]'].dtype
+    torch_dtype, torch_dtype_real, torch_dtype_complex = dtype_dict[h5_dtype.type]
+    rotate_kernel = Rotate(torch_dtype, torch_dtype_real=torch_dtype_real, torch_dtype_complex=torch_dtype_complex,
+                           device=torch_device, spinful=spinful)
+
+    for key_str, hamiltonian in fid_H.items():
+        if key_str not in fid_rc:
+            warnings.warn(f'Hamiltonian matrix block ({key_str}) do not have local coordinate')
+            continue
+        rotation_matrix = torch.tensor(fid_rc[key_str], dtype=torch_dtype_real, device=torch_device)
+        key = json.loads(key_str)
+        atom_i = key[3] - 1
+        atom_j = key[4] - 1
+        assert atom_i >= 0
+        assert atom_i < nsite
+        assert atom_j >= 0
+        assert atom_j < nsite
+        if target == 'hamiltonian':
+            rotated_hamiltonian = rotate_kernel.rotate_openmx_H(torch.tensor(hamiltonian), rotation_matrix,
+                                                                orbital_types[atom_i], orbital_types[atom_j])
+        elif target == 'phiVdphi':
+            rotated_hamiltonian = rotate_kernel.rotate_openmx_phiVdphi(torch.tensor(hamiltonian), rotation_matrix,
+                                                                       orbital_types[atom_i], orbital_types[atom_j])
+        fid_rh[key_str] = rotated_hamiltonian.numpy()
+
+    fid_H.close()
+    fid_rc.close()
+    fid_rh.close()
+
+
+def rotate_back(input_dir, output_dir, target='hamiltonian'):
+    torch_device = torch.device('cpu')
+    assert target in ['hamiltonian', 'phiVdphi']
+    file_name = {
+        'hamiltonian': 'hamiltonians_pred.h5',
+        'phiVdphi': 'phiVdphi_pred.h5',
+    }[target]
+    prime_file_name = {
+        'hamiltonian': 'rh_pred.h5',
+        'phiVdphi': 'rphiVdphi_pred.h5',
+    }[target]
+    assert os.path.exists(os.path.join(input_dir, prime_file_name))
+    assert os.path.exists(os.path.join(input_dir, 'rc.h5'))
+    assert os.path.exists(os.path.join(input_dir, 'orbital_types.dat'))
+    assert os.path.exists(os.path.join(input_dir, 'info.json'))
+
+    atom_num_orbital, orbital_types = load_orbital_types(os.path.join(input_dir, 'orbital_types.dat'),
+                                                         return_orbital_types=True)
+    nsite = len(atom_num_orbital)
+    with open(os.path.join(input_dir, 'info.json'), 'r') as info_f:
+        info_dict = json.load(info_f)
+        spinful = info_dict["isspinful"]
+    fid_rc = h5py.File(os.path.join(input_dir, 'rc.h5'), 'r')
+    fid_rh = h5py.File(os.path.join(input_dir, prime_file_name), 'r')
+    fid_H = h5py.File(os.path.join(output_dir, file_name), 'w')
+    assert '[0, 0, 0, 1, 1]' in fid_rh.keys()
+    h5_dtype = fid_rh['[0, 0, 0, 1, 1]'].dtype
+    torch_dtype, torch_dtype_real, torch_dtype_complex = dtype_dict[h5_dtype.type]
+    rotate_kernel = Rotate(torch_dtype, torch_dtype_real=torch_dtype_real, torch_dtype_complex=torch_dtype_complex,
+                           device=torch_device, spinful=spinful)
+
+    for key_str, rotated_hamiltonian in fid_rh.items():
+        assert key_str in fid_rc
+        rotation_matrix = torch.tensor(fid_rc[key_str], dtype=torch_dtype_real, device=torch_device).T
+        key = json.loads(key_str)
+        atom_i = key[3] - 1
+        atom_j = key[4] - 1
+        assert atom_i >= 0
+        assert atom_i < nsite
+        assert atom_j >= 0
+        assert atom_j < nsite
+        if target == 'hamiltonian':
+            hamiltonian = rotate_kernel.rotate_openmx_H(torch.tensor(rotated_hamiltonian), rotation_matrix,
+                                                        orbital_types[atom_i], orbital_types[atom_j])
+        elif target == 'phiVdphi':
+            hamiltonian = rotate_kernel.rotate_openmx_phiVdphi(torch.tensor(rotated_hamiltonian), rotation_matrix,
+                                                               orbital_types[atom_i], orbital_types[atom_j])
+        fid_H[key_str] = hamiltonian.numpy()
+
+    fid_H.close()
+    fid_rc.close()
+    fid_rh.close()

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/scripts/evaluate.py

@@ -0,0 +1,173 @@
+import csv
+import os
+import argparse
+import time
+import warnings
+from configparser import ConfigParser
+
+import numpy as np
+import torch
+from pymatgen.core.structure import Structure
+
+from deeph import get_graph, DeepHKernel, collate_fn
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Predict Hamiltonian')
+    parser.add_argument('--trained_model_dir', type=str,
+                        help='path of trained model')
+    parser.add_argument('--input_dir', type=str,
+                        help='')
+    parser.add_argument('--output_dir', type=str,
+                        help='')
+    parser.add_argument('--disable_cuda', action='store_true', help='Disable CUDA')
+    parser.add_argument('--save_csv', action='store_true', help='Save the result for each edge in csv format')
+    parser.add_argument(
+        '--interface',
+        type=str,
+        default='h5',
+        choices=['h5', 'npz'])
+    parser.add_argument('--huge_structure', type=bool, default=False, help='')
+    args = parser.parse_args()
+
+    old_version = False
+    assert os.path.exists(os.path.join(args.trained_model_dir, 'config.ini'))
+    if os.path.exists(os.path.join(args.trained_model_dir, 'best_model.pt')) is False:
+        old_version = True
+        assert os.path.exists(os.path.join(args.trained_model_dir, 'best_model.pkl'))
+        assert os.path.exists(os.path.join(args.trained_model_dir, 'src'))
+
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    config = ConfigParser()
+    config.read(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'default.ini'))
+    config.read(os.path.join(args.trained_model_dir, 'config.ini'))
+    config.set('basic', 'save_dir', os.path.join(args.output_dir))
+    config.set('basic', 'disable_cuda', str(args.disable_cuda))
+    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(args.trained_model_dir, old_version)
+    else:
+        warnings.warn('You are using the trained model with an old version')
+        checkpoint = torch.load(
+            os.path.join(args.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(args.trained_model_dir, old_version)
+        kernel.model.load_state_dict(checkpoint['state_dict'])
+
+    with torch.no_grad():
+        input_dir = args.input_dir
+        structure = Structure(np.loadtxt(os.path.join(args.input_dir, 'lat.dat')).T,
+                              np.loadtxt(os.path.join(args.input_dir, 'element.dat')),
+                              np.loadtxt(os.path.join(args.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=args.input_dir, interface=args.interface,
+                             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=args.huge_structure)
+            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")
+
+        dataset_mask = kernel.make_mask([data])
+        batch, subgraph = collate_fn(dataset_mask)
+        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=args.huge_structure)
+
+        label = batch.label
+        mask = batch.mask
+        output = output.cpu().reshape(label.shape)
+
+        assert label.shape == output.shape == mask.shape
+        mse = torch.pow(label - output, 2)
+        mae = torch.abs(label - output)
+
+        print()
+        for index_orb, orbital_single in enumerate(kernel.orbital):
+            if index_orb != 0:
+                print('================================================================')
+            print('orbital:', orbital_single)
+            if kernel.spinful == False:
+                print(f'mse: {torch.masked_select(mse[:, index_orb], mask[:, index_orb]).mean().item()}, '
+                      f'mae: {torch.masked_select(mae[:, index_orb], mask[:, index_orb]).mean().item()}')
+            else:
+                for index_soc, str_soc in enumerate([
+                    'left_up_real', 'left_up_imag', 'right_down_real', 'right_down_imag',
+                    'right_up_real', 'right_up_imag', 'left_down_real', 'left_down_imag',
+                ]):
+                    if index_soc != 0:
+                        print('----------------------------------------------------------------')
+                    print(str_soc, ':')
+                    index_out = index_orb * 8 + index_soc
+                    print(f'mse: {torch.masked_select(mse[:, index_out], mask[:, index_out]).mean().item()}, '
+                          f'mae: {torch.masked_select(mae[:, index_out], mask[:, index_out]).mean().item()}')
+
+        if args.save_csv:
+            edge_stru_index = torch.squeeze(batch.batch[batch.edge_index[0]]).numpy()
+            edge_slices = torch.tensor(batch.__slices__['x'])[edge_stru_index].view(-1, 1)
+            atom_ids = torch.squeeze(batch.edge_index.T - edge_slices).tolist()
+            atomic_numbers = torch.squeeze(kernel.index_to_Z[batch.x[batch.edge_index.T]]).tolist()
+            edge_infos = torch.squeeze(batch.edge_attr[:, :7].detach().cpu()).tolist()
+
+            with open(os.path.join(kernel.config.get('basic', 'save_dir'), 'error_distance.csv'), 'w', newline='') as f:
+                writer = csv.writer(f)
+                writer.writerow(['index', 'atom_id', 'atomic_number', 'dist', 'atom1_x', 'atom1_y', 'atom1_z',
+                                 'atom2_x', 'atom2_y', 'atom2_z']
+                                + ['target'] * kernel.out_fea_len + ['pred'] * kernel.out_fea_len + [
+                                    'mask'] * kernel.out_fea_len)
+                for index_edge in range(batch.edge_attr.shape[0]):
+                    writer.writerow([
+                        index_edge,
+                        atom_ids[index_edge],
+                        atomic_numbers[index_edge],
+                        *(edge_infos[index_edge]),
+                        *(label[index_edge].tolist()),
+                        *(output[index_edge].tolist()),
+                        *(mask[index_edge].tolist()),
+                    ])
+
+
+if __name__ == '__main__':
+    main()

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/scripts/inference.py

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

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/scripts/preprocess.py

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

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/scripts/train.py

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

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/pred_ham_std/src/deeph/utils.py

@@ -0,0 +1,213 @@
+import os
+import shutil
+import sys
+from configparser import ConfigParser
+from inspect import signature
+
+import numpy as np
+import scipy
+import torch
+from torch import nn, package
+import h5py
+
+
+def print_args(args):
+    for k, v in args._get_kwargs():
+        print('{} = {}'.format(k, v))
+    print('')
+
+
+class Logger(object):
+    def __init__(self, filename):
+        self.terminal = sys.stdout
+        self.log = open(filename, "a", buffering=1)
+
+    def write(self, message):
+        self.terminal.write(message)
+        self.log.write(message)
+
+    def flush(self):
+        pass
+
+
+class MaskMSELoss(nn.Module):
+    def __init__(self) -> None:
+        super(MaskMSELoss, self).__init__()
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+        assert input.shape == target.shape == mask.shape
+        mse = torch.pow(input - target, 2)
+        mse = torch.masked_select(mse, mask).mean()
+
+        return mse
+
+
+class MaskMAELoss(nn.Module):
+    def __init__(self) -> None:
+        super(MaskMAELoss, self).__init__()
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+        assert input.shape == target.shape == mask.shape
+        mae = torch.abs(input - target)
+        mae = torch.masked_select(mae, mask).mean()
+
+        return mae
+
+
+class LossRecord:
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.last_val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, num=1):
+        self.last_val = val
+        self.sum += val * num
+        self.count += num
+        self.avg = self.sum / self.count
+
+
+def if_integer(string):
+    try:
+        int(string)
+        return True
+    except ValueError:
+        return False
+
+
+class Transform:
+    def __init__(self, tensor=None, mask=None, normalizer=False, boxcox=False):
+        self.normalizer = normalizer
+        self.boxcox = boxcox
+        if normalizer:
+            raise NotImplementedError
+            self.mean = abs(tensor).sum(dim=0) / mask.sum(dim=0)
+            self.std = None
+            print(f'[normalizer] mean: {self.mean}, std: {self.std}')
+        if boxcox:
+            raise NotImplementedError
+            _, self.opt_lambda = scipy.stats.boxcox(tensor.double())
+            print('[boxcox] optimal lambda value:', self.opt_lambda)
+
+    def tran(self, tensor):
+        if self.boxcox:
+            tensor = scipy.special.boxcox(tensor, self.opt_lambda)
+        if self.normalizer:
+            tensor = (tensor - self.mean) / self.std
+        return tensor
+
+    def inv_tran(self, tensor):
+        if self.normalizer:
+            tensor = tensor * self.std + self.mean
+        if self.boxcox:
+            tensor = scipy.special.inv_boxcox(tensor, self.opt_lambda)
+        return tensor
+
+    def state_dict(self):
+        result = {'normalizer': self.normalizer,
+                  'boxcox': self.boxcox}
+        if self.normalizer:
+            result['mean'] = self.mean
+            result['std'] = self.std
+        if self.boxcox:
+            result['opt_lambda'] = self.opt_lambda
+        return result
+
+    def load_state_dict(self, state_dict):
+        self.normalizer = state_dict['normalizer']
+        self.boxcox = state_dict['boxcox']
+        if self.normalizer:
+            self.mean = state_dict['mean']
+            self.std = state_dict['std']
+            print(f'Load state dict, mean: {self.mean}, std: {self.std}')
+        if self.boxcox:
+            self.opt_lambda = state_dict['opt_lambda']
+            print('Load state dict, optimal lambda value:', self.opt_lambda)
+
+
+def save_model(state, model_dict, model_state_dict, path, is_best):
+    model_dir = os.path.join(path, 'model.pt')
+    package_dict = {}
+    if 'verbose' in list(signature(package.PackageExporter.__init__).parameters.keys()):
+        package_dict['verbose'] = False
+    with package.PackageExporter(model_dir, **package_dict) as exp:
+        exp.intern('deeph.**')
+        exp.extern([
+            'scipy.**', 'numpy.**', 'torch_geometric.**', 'sklearn.**',
+            'torch_scatter.**', 'torch_sparse.**', 'torch_sparse.**', 'torch_cluster.**', 'torch_spline_conv.**',
+            'pyparsing', 'jinja2', 'sys', 'mkl', 'io', 'setuptools.**', 'rdkit.Chem', 'tqdm',
+            '__future__', '_operator', '_ctypes', 'six.moves.urllib', 'ase', 'matplotlib.pyplot', 'sympy', 'networkx',
+        ])
+        exp.save_pickle('checkpoint', 'model.pkl', state | model_dict)
+    torch.save(state | model_state_dict, os.path.join(path, 'state_dict.pkl'))
+    if is_best:
+        shutil.copyfile(os.path.join(path, 'model.pt'), os.path.join(path, 'best_model.pt'))
+        shutil.copyfile(os.path.join(path, 'state_dict.pkl'), os.path.join(path, 'best_state_dict.pkl'))
+
+
+def write_ham_h5(hoppings_dict, path):
+    fid = h5py.File(path, "w")
+    for k, v in hoppings_dict.items():
+        fid[k] = v
+    fid.close()
+
+
+def write_ham_npz(hoppings_dict, path):
+    np.savez(path, **hoppings_dict)
+
+
+def write_ham(hoppings_dict, path):
+    os.makedirs(path, exist_ok=True)
+    for key_term, matrix in hoppings_dict.items():
+        np.savetxt(os.path.join(path, f'{key_term}_real.dat'), matrix)
+
+
+def get_config(args):
+    config = ConfigParser()
+    config.read(os.path.join(os.path.dirname(__file__), 'default.ini'))
+    for config_file in args:
+        assert os.path.exists(config_file)
+        config.read(config_file)
+    if config['basic']['target'] == 'O_ij':
+        assert config['basic']['O_component'] in ['H_minimum', 'H_minimum_withNA', 'H', 'Rho']
+    if config['basic']['target'] == 'E_ij':
+        assert config['basic']['energy_component'] in ['xc', 'delta_ee', 'both', 'summation', 'E_ij']
+    else:
+        assert config['hyperparameter']['criterion'] in ['MaskMSELoss']
+    assert config['basic']['target'] in ['hamiltonian']
+    assert config['basic']['interface'] in ['h5', 'h5_rc_only', 'h5_Eij', 'npz', 'npz_rc_only']
+    assert config['network']['aggr'] in ['add', 'mean', 'max']
+    assert config['network']['distance_expansion'] in ['GaussianBasis', 'BesselBasis', 'ExpBernsteinBasis']
+    assert config['network']['normalization'] in ['BatchNorm', 'LayerNorm', 'PairNorm', 'InstanceNorm', 'GraphNorm',
+                                                  'DiffGroupNorm', 'None']
+    assert config['network']['atom_update_net'] in ['CGConv', 'GAT', 'PAINN']
+    assert config['hyperparameter']['optimizer'] in ['sgd', 'sgdm', 'adam', 'adamW', 'adagrad', 'RMSprop', 'lbfgs']
+    assert config['hyperparameter']['lr_scheduler'] in ['', 'MultiStepLR', 'ReduceLROnPlateau', 'CyclicLR']
+
+    return config
+
+
+def get_inference_config(*args):
+    config = ConfigParser()
+    config.read(os.path.join(os.path.dirname(__file__), 'inference', 'inference_default.ini'))
+    for config_file in args:
+        config.read(config_file)
+    assert config['basic']['interface'] in ['openmx', 'abacus']
+
+    return config
+
+
+def get_preprocess_config(*args):
+    config = ConfigParser()
+    config.read(os.path.join(os.path.dirname(__file__), 'preprocess', 'preprocess_default.ini'))
+    for config_file in args:
+        config.read(config_file)
+    assert config['basic']['target'] in ['hamiltonian', 'density_matrix', 'phiVdphi']
+    assert config['basic']['interface'] in ['openmx', 'abacus', 'aims', 'siesta']
+    assert if_integer(config['basic']['multiprocessing']), "value of multiprocessing must be an integer"
+
+    return config

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/rc.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02874eaa094e453bc3638de0efea7186ca0c1a9d9e212c1aaac2999d5343704c
+size 1065104

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/rh.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5289fc9b19cad0a621bf3a85dd0af86c9541e23ae88b6536451a5e5831d0bef
+size 4141696

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/rh_pred.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5ac5bd0de9f166e752756e87e1cb2924dcfd14758109b8096209173718860ab
+size 4133504

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/rlat.dat

@@ -0,0 +1,3 @@
+-8.807380587617869017e-01 8.807380587617869017e-01 8.807380587617869017e-01
+8.807380587617869017e-01 -8.807380587617869017e-01 8.807380587617869017e-01
+8.807380587617869017e-01 8.807380587617869017e-01 -8.807380587617869017e-01

example/diamond/1_data_prepare/data/bands/sc/reconstruction/aohamiltonian/site_positions.dat

@@ -0,0 +1,3 @@
+0.000000000000000000e+00 8.917499994284623366e-01 1.783499998856923785e+00 2.675249998285386344e+00 1.783499998856923785e+00 2.675249998285386344e+00 3.566999997713848014e+00 4.458749997142310129e+00 0.000000000000000000e+00 8.917499994284623366e-01 1.783499998856923785e+00 2.675249998285386344e+00 1.783499998856923785e+00 2.675249998285386344e+00 3.566999997713848014e+00 4.458749997142310129e+00
+0.000000000000000000e+00 8.917499994284623366e-01 1.783499998856923785e+00 2.675249998285386344e+00 0.000000000000000000e+00 8.917499994284623366e-01 1.783499998856923785e+00 2.675249998285386344e+00 1.783499998856923785e+00 2.675249998285386344e+00 3.566999997713848014e+00 4.458749997142310129e+00 1.783499998856923785e+00 2.675249998285386344e+00 3.566999997713848014e+00 4.458749997142310129e+00
+0.000000000000000000e+00 8.917499994284623366e-01 0.000000000000000000e+00 8.917499994284623366e-01 1.783499998856923785e+00 2.675249998285386344e+00 1.783499998856923785e+00 2.675249998285386344e+00 1.783499998856923785e+00 2.675249998285386344e+00 1.783499998856923785e+00 2.675249998285386344e+00 3.566999997713848014e+00 4.458749997142310129e+00 3.566999997713848014e+00 4.458749997142310129e+00

example/diamond/1_data_prepare/data/bands/sc/reconstruction/calc.py

@@ -0,0 +1,11 @@
+from HPRO import PW2AOkernel
+
+kernel = PW2AOkernel(
+    lcao_interface='siesta',
+    lcaodata_root='../../../../../aobasis',
+    hrdata_interface='qe-bgw',
+    vscdir='../scf/VSC',
+    upfdir='../../../../../pseudos',
+    ecutwfn=30
+)
+kernel.run_pw2ao_rs('./aohamiltonian')

example/diamond/1_data_prepare/data/bands/sc/reconstruction/hpro.log

@@ -0,0 +1,59 @@
+
+==============================================================================
+Program HPRO
+Author: Xiaoxun Gong (xiaoxun.gong@gmail.com)
+==============================================================================
+
+Structure information:
+Primitive lattice vectors (angstrom):
+a = (   0.0000000    3.5670000    3.5670000)
+b = (   3.5670000    0.0000000    3.5670000)
+c = (   3.5670000    3.5670000    0.0000000)
+Atomic species and numbers in unit cell: C: 16.
+
+Atomic orbital basis:
+Format: siesta
+Element C:
+Orbital 1: l = 0, cutoff =  4.493 a.u., norm =  1.000
+Orbital 2: l = 0, cutoff =  4.502 a.u., norm =  1.000
+Orbital 3: l = 1, cutoff =  5.468 a.u., norm =  1.000
+Orbital 4: l = 1, cutoff =  5.479 a.u., norm =  1.000
+Orbital 5: l = 2, cutoff =  5.446 a.u., norm =  1.000
+
+Real space grid dimensions: (   48    48    48)
+
+Pseudopotential projectors:
+Format: qe
+Element C:
+Orbital 1: l = 0, cutoff =  1.310 a.u., norm =  1.000
+Orbital 2: l = 0, cutoff =  1.310 a.u., norm =  1.000
+Orbital 3: l = 1, cutoff =  1.310 a.u., norm =  1.000
+Orbital 4: l = 1, cutoff =  1.310 a.u., norm =  1.000
+
+IO done, total wall time = 0:00:00
+
+===============================================
+Reconstructing PW Hamiltonian to AOs in real space
+===============================================
+
+Calculating overlap
+
+Writing overlap matrices to disk
+
+Constructing Hamiltonian operator with 1184 blocks
+ 10%|████                                    | 119/1184 [00:18<02:49,  6.26it/s]
+ 20%|████████                                | 238/1184 [00:33<02:07,  7.40it/s]
+ 30%|████████████                            | 357/1184 [00:48<01:49,  7.55it/s]
+ 40%|████████████████                        | 476/1184 [01:03<01:33,  7.60it/s]
+ 50%|████████████████████                    | 595/1184 [01:20<01:19,  7.40it/s]
+ 60%|████████████████████████                | 714/1184 [01:35<01:02,  7.56it/s]
+ 70%|████████████████████████████▏           | 833/1184 [01:54<00:49,  7.09it/s]
+ 80%|████████████████████████████████▏       | 952/1184 [02:12<00:33,  6.93it/s]
+ 90%|████████████████████████████████████▏   | 1071/1184 [02:27<00:15,  7.25it/s]
+100%|████████████████████████████████████████| 1184/1184 [02:42<00:00,  7.27it/s]
+Done, elapsed time: 162.8s.
+
+Writing Hamiltonian matrices to disk
+
+Job done, total wall time = 0:02:46
+