Add files using upload-large-folder tool

.gitattributes

@@ -231,3 +231,5 @@ aobasis/siesta.DM filter=lfs diff=lfs merge=lfs -text
 1_data_prepare/data/disp-07/scf/VSC filter=lfs diff=lfs merge=lfs -text
 1_data_prepare/data/disp-07/scf/diamond.save/charge-density.dat filter=lfs diff=lfs merge=lfs -text
 2_training/forces/diamond_ase_ref.nequip.pt2 filter=lfs diff=lfs merge=lfs -text
+3_epc/displacements/group_8/tmp/VSC filter=lfs diff=lfs merge=lfs -text
+3_epc/displacements/group_8/tmp/scf.save/charge-density.dat filter=lfs diff=lfs merge=lfs -text

3_epc/displacements/group_8/nscf.in

@@ -0,0 +1,261 @@
+&CONTROL
+   calculation      = 'nscf'
+   verbosity        = 'high'
+   tstress          = .false.
+   tprnfor          = .true.
+   outdir           = './tmp/'
+   prefix           = 'scf'
+   pseudo_dir       = '/home/apolyukhin/scripts/ml/diamond-qe/pseudos/'
+/
+&SYSTEM
+   ibrav            = 0
+   nbnd             = 8
+   ecutwfc          = 60
+   nosym            = .true.
+   noinv            = .true.
+   ntyp             = 1
+   nat              = 2
+/
+&ELECTRONS
+   electron_maxstep = 1000
+   conv_thr         = 1e-13
+   mixing_mode      = 'plain'
+   mixing_beta      = 0.7
+   diagonalization  = 'david'
+/
+&IONS
+/
+&CELL
+/
+
+ATOMIC_SPECIES
+C 12.011 C.upf
+
+K_POINTS crystal
+216
+  0.000000000000  0.000000000000  0.000000000000  4.62962963e-03
+  0.000000000000  0.000000000000  0.166666666667  4.62962963e-03
+  0.000000000000  0.000000000000  0.333333333333  4.62962963e-03
+  0.000000000000  0.000000000000  0.500000000000  4.62962963e-03
+  0.000000000000  0.000000000000  0.666666666667  4.62962963e-03
+  0.000000000000  0.000000000000  0.833333333333  4.62962963e-03
+  0.000000000000  0.166666666667  0.000000000000  4.62962963e-03
+  0.000000000000  0.166666666667  0.166666666667  4.62962963e-03
+  0.000000000000  0.166666666667  0.333333333333  4.62962963e-03
+  0.000000000000  0.166666666667  0.500000000000  4.62962963e-03
+  0.000000000000  0.166666666667  0.666666666667  4.62962963e-03
+  0.000000000000  0.166666666667  0.833333333333  4.62962963e-03
+  0.000000000000  0.333333333333  0.000000000000  4.62962963e-03
+  0.000000000000  0.333333333333  0.166666666667  4.62962963e-03
+  0.000000000000  0.333333333333  0.333333333333  4.62962963e-03
+  0.000000000000  0.333333333333  0.500000000000  4.62962963e-03
+  0.000000000000  0.333333333333  0.666666666667  4.62962963e-03
+  0.000000000000  0.333333333333  0.833333333333  4.62962963e-03
+  0.000000000000  0.500000000000  0.000000000000  4.62962963e-03
+  0.000000000000  0.500000000000  0.166666666667  4.62962963e-03
+  0.000000000000  0.500000000000  0.333333333333  4.62962963e-03
+  0.000000000000  0.500000000000  0.500000000000  4.62962963e-03
+  0.000000000000  0.500000000000  0.666666666667  4.62962963e-03
+  0.000000000000  0.500000000000  0.833333333333  4.62962963e-03
+  0.000000000000  0.666666666667  0.000000000000  4.62962963e-03
+  0.000000000000  0.666666666667  0.166666666667  4.62962963e-03
+  0.000000000000  0.666666666667  0.333333333333  4.62962963e-03
+  0.000000000000  0.666666666667  0.500000000000  4.62962963e-03
+  0.000000000000  0.666666666667  0.666666666667  4.62962963e-03
+  0.000000000000  0.666666666667  0.833333333333  4.62962963e-03
+  0.000000000000  0.833333333333  0.000000000000  4.62962963e-03
+  0.000000000000  0.833333333333  0.166666666667  4.62962963e-03
+  0.000000000000  0.833333333333  0.333333333333  4.62962963e-03
+  0.000000000000  0.833333333333  0.500000000000  4.62962963e-03
+  0.000000000000  0.833333333333  0.666666666667  4.62962963e-03
+  0.000000000000  0.833333333333  0.833333333333  4.62962963e-03
+  0.166666666667  0.000000000000  0.000000000000  4.62962963e-03
+  0.166666666667  0.000000000000  0.166666666667  4.62962963e-03
+  0.166666666667  0.000000000000  0.333333333333  4.62962963e-03
+  0.166666666667  0.000000000000  0.500000000000  4.62962963e-03
+  0.166666666667  0.000000000000  0.666666666667  4.62962963e-03
+  0.166666666667  0.000000000000  0.833333333333  4.62962963e-03
+  0.166666666667  0.166666666667  0.000000000000  4.62962963e-03
+  0.166666666667  0.166666666667  0.166666666667  4.62962963e-03
+  0.166666666667  0.166666666667  0.333333333333  4.62962963e-03
+  0.166666666667  0.166666666667  0.500000000000  4.62962963e-03
+  0.166666666667  0.166666666667  0.666666666667  4.62962963e-03
+  0.166666666667  0.166666666667  0.833333333333  4.62962963e-03
+  0.166666666667  0.333333333333  0.000000000000  4.62962963e-03
+  0.166666666667  0.333333333333  0.166666666667  4.62962963e-03
+  0.166666666667  0.333333333333  0.333333333333  4.62962963e-03
+  0.166666666667  0.333333333333  0.500000000000  4.62962963e-03
+  0.166666666667  0.333333333333  0.666666666667  4.62962963e-03
+  0.166666666667  0.333333333333  0.833333333333  4.62962963e-03
+  0.166666666667  0.500000000000  0.000000000000  4.62962963e-03
+  0.166666666667  0.500000000000  0.166666666667  4.62962963e-03
+  0.166666666667  0.500000000000  0.333333333333  4.62962963e-03
+  0.166666666667  0.500000000000  0.500000000000  4.62962963e-03
+  0.166666666667  0.500000000000  0.666666666667  4.62962963e-03
+  0.166666666667  0.500000000000  0.833333333333  4.62962963e-03
+  0.166666666667  0.666666666667  0.000000000000  4.62962963e-03
+  0.166666666667  0.666666666667  0.166666666667  4.62962963e-03
+  0.166666666667  0.666666666667  0.333333333333  4.62962963e-03
+  0.166666666667  0.666666666667  0.500000000000  4.62962963e-03
+  0.166666666667  0.666666666667  0.666666666667  4.62962963e-03
+  0.166666666667  0.666666666667  0.833333333333  4.62962963e-03
+  0.166666666667  0.833333333333  0.000000000000  4.62962963e-03
+  0.166666666667  0.833333333333  0.166666666667  4.62962963e-03
+  0.166666666667  0.833333333333  0.333333333333  4.62962963e-03
+  0.166666666667  0.833333333333  0.500000000000  4.62962963e-03
+  0.166666666667  0.833333333333  0.666666666667  4.62962963e-03
+  0.166666666667  0.833333333333  0.833333333333  4.62962963e-03
+  0.333333333333  0.000000000000  0.000000000000  4.62962963e-03
+  0.333333333333  0.000000000000  0.166666666667  4.62962963e-03
+  0.333333333333  0.000000000000  0.333333333333  4.62962963e-03
+  0.333333333333  0.000000000000  0.500000000000  4.62962963e-03
+  0.333333333333  0.000000000000  0.666666666667  4.62962963e-03
+  0.333333333333  0.000000000000  0.833333333333  4.62962963e-03
+  0.333333333333  0.166666666667  0.000000000000  4.62962963e-03
+  0.333333333333  0.166666666667  0.166666666667  4.62962963e-03
+  0.333333333333  0.166666666667  0.333333333333  4.62962963e-03
+  0.333333333333  0.166666666667  0.500000000000  4.62962963e-03
+  0.333333333333  0.166666666667  0.666666666667  4.62962963e-03
+  0.333333333333  0.166666666667  0.833333333333  4.62962963e-03
+  0.333333333333  0.333333333333  0.000000000000  4.62962963e-03
+  0.333333333333  0.333333333333  0.166666666667  4.62962963e-03
+  0.333333333333  0.333333333333  0.333333333333  4.62962963e-03
+  0.333333333333  0.333333333333  0.500000000000  4.62962963e-03
+  0.333333333333  0.333333333333  0.666666666667  4.62962963e-03
+  0.333333333333  0.333333333333  0.833333333333  4.62962963e-03
+  0.333333333333  0.500000000000  0.000000000000  4.62962963e-03
+  0.333333333333  0.500000000000  0.166666666667  4.62962963e-03
+  0.333333333333  0.500000000000  0.333333333333  4.62962963e-03
+  0.333333333333  0.500000000000  0.500000000000  4.62962963e-03
+  0.333333333333  0.500000000000  0.666666666667  4.62962963e-03
+  0.333333333333  0.500000000000  0.833333333333  4.62962963e-03
+  0.333333333333  0.666666666667  0.000000000000  4.62962963e-03
+  0.333333333333  0.666666666667  0.166666666667  4.62962963e-03
+  0.333333333333  0.666666666667  0.333333333333  4.62962963e-03
+  0.333333333333  0.666666666667  0.500000000000  4.62962963e-03
+  0.333333333333  0.666666666667  0.666666666667  4.62962963e-03
+  0.333333333333  0.666666666667  0.833333333333  4.62962963e-03
+  0.333333333333  0.833333333333  0.000000000000  4.62962963e-03
+  0.333333333333  0.833333333333  0.166666666667  4.62962963e-03
+  0.333333333333  0.833333333333  0.333333333333  4.62962963e-03
+  0.333333333333  0.833333333333  0.500000000000  4.62962963e-03
+  0.333333333333  0.833333333333  0.666666666667  4.62962963e-03
+  0.333333333333  0.833333333333  0.833333333333  4.62962963e-03
+  0.500000000000  0.000000000000  0.000000000000  4.62962963e-03
+  0.500000000000  0.000000000000  0.166666666667  4.62962963e-03
+  0.500000000000  0.000000000000  0.333333333333  4.62962963e-03
+  0.500000000000  0.000000000000  0.500000000000  4.62962963e-03
+  0.500000000000  0.000000000000  0.666666666667  4.62962963e-03
+  0.500000000000  0.000000000000  0.833333333333  4.62962963e-03
+  0.500000000000  0.166666666667  0.000000000000  4.62962963e-03
+  0.500000000000  0.166666666667  0.166666666667  4.62962963e-03
+  0.500000000000  0.166666666667  0.333333333333  4.62962963e-03
+  0.500000000000  0.166666666667  0.500000000000  4.62962963e-03
+  0.500000000000  0.166666666667  0.666666666667  4.62962963e-03
+  0.500000000000  0.166666666667  0.833333333333  4.62962963e-03
+  0.500000000000  0.333333333333  0.000000000000  4.62962963e-03
+  0.500000000000  0.333333333333  0.166666666667  4.62962963e-03
+  0.500000000000  0.333333333333  0.333333333333  4.62962963e-03
+  0.500000000000  0.333333333333  0.500000000000  4.62962963e-03
+  0.500000000000  0.333333333333  0.666666666667  4.62962963e-03
+  0.500000000000  0.333333333333  0.833333333333  4.62962963e-03
+  0.500000000000  0.500000000000  0.000000000000  4.62962963e-03
+  0.500000000000  0.500000000000  0.166666666667  4.62962963e-03
+  0.500000000000  0.500000000000  0.333333333333  4.62962963e-03
+  0.500000000000  0.500000000000  0.500000000000  4.62962963e-03
+  0.500000000000  0.500000000000  0.666666666667  4.62962963e-03
+  0.500000000000  0.500000000000  0.833333333333  4.62962963e-03
+  0.500000000000  0.666666666667  0.000000000000  4.62962963e-03
+  0.500000000000  0.666666666667  0.166666666667  4.62962963e-03
+  0.500000000000  0.666666666667  0.333333333333  4.62962963e-03
+  0.500000000000  0.666666666667  0.500000000000  4.62962963e-03
+  0.500000000000  0.666666666667  0.666666666667  4.62962963e-03
+  0.500000000000  0.666666666667  0.833333333333  4.62962963e-03
+  0.500000000000  0.833333333333  0.000000000000  4.62962963e-03
+  0.500000000000  0.833333333333  0.166666666667  4.62962963e-03
+  0.500000000000  0.833333333333  0.333333333333  4.62962963e-03
+  0.500000000000  0.833333333333  0.500000000000  4.62962963e-03
+  0.500000000000  0.833333333333  0.666666666667  4.62962963e-03
+  0.500000000000  0.833333333333  0.833333333333  4.62962963e-03
+  0.666666666667  0.000000000000  0.000000000000  4.62962963e-03
+  0.666666666667  0.000000000000  0.166666666667  4.62962963e-03
+  0.666666666667  0.000000000000  0.333333333333  4.62962963e-03
+  0.666666666667  0.000000000000  0.500000000000  4.62962963e-03
+  0.666666666667  0.000000000000  0.666666666667  4.62962963e-03
+  0.666666666667  0.000000000000  0.833333333333  4.62962963e-03
+  0.666666666667  0.166666666667  0.000000000000  4.62962963e-03
+  0.666666666667  0.166666666667  0.166666666667  4.62962963e-03
+  0.666666666667  0.166666666667  0.333333333333  4.62962963e-03
+  0.666666666667  0.166666666667  0.500000000000  4.62962963e-03
+  0.666666666667  0.166666666667  0.666666666667  4.62962963e-03
+  0.666666666667  0.166666666667  0.833333333333  4.62962963e-03
+  0.666666666667  0.333333333333  0.000000000000  4.62962963e-03
+  0.666666666667  0.333333333333  0.166666666667  4.62962963e-03
+  0.666666666667  0.333333333333  0.333333333333  4.62962963e-03
+  0.666666666667  0.333333333333  0.500000000000  4.62962963e-03
+  0.666666666667  0.333333333333  0.666666666667  4.62962963e-03
+  0.666666666667  0.333333333333  0.833333333333  4.62962963e-03
+  0.666666666667  0.500000000000  0.000000000000  4.62962963e-03
+  0.666666666667  0.500000000000  0.166666666667  4.62962963e-03
+  0.666666666667  0.500000000000  0.333333333333  4.62962963e-03
+  0.666666666667  0.500000000000  0.500000000000  4.62962963e-03
+  0.666666666667  0.500000000000  0.666666666667  4.62962963e-03
+  0.666666666667  0.500000000000  0.833333333333  4.62962963e-03
+  0.666666666667  0.666666666667  0.000000000000  4.62962963e-03
+  0.666666666667  0.666666666667  0.166666666667  4.62962963e-03
+  0.666666666667  0.666666666667  0.333333333333  4.62962963e-03
+  0.666666666667  0.666666666667  0.500000000000  4.62962963e-03
+  0.666666666667  0.666666666667  0.666666666667  4.62962963e-03
+  0.666666666667  0.666666666667  0.833333333333  4.62962963e-03
+  0.666666666667  0.833333333333  0.000000000000  4.62962963e-03
+  0.666666666667  0.833333333333  0.166666666667  4.62962963e-03
+  0.666666666667  0.833333333333  0.333333333333  4.62962963e-03
+  0.666666666667  0.833333333333  0.500000000000  4.62962963e-03
+  0.666666666667  0.833333333333  0.666666666667  4.62962963e-03
+  0.666666666667  0.833333333333  0.833333333333  4.62962963e-03
+  0.833333333333  0.000000000000  0.000000000000  4.62962963e-03
+  0.833333333333  0.000000000000  0.166666666667  4.62962963e-03
+  0.833333333333  0.000000000000  0.333333333333  4.62962963e-03
+  0.833333333333  0.000000000000  0.500000000000  4.62962963e-03
+  0.833333333333  0.000000000000  0.666666666667  4.62962963e-03
+  0.833333333333  0.000000000000  0.833333333333  4.62962963e-03
+  0.833333333333  0.166666666667  0.000000000000  4.62962963e-03
+  0.833333333333  0.166666666667  0.166666666667  4.62962963e-03
+  0.833333333333  0.166666666667  0.333333333333  4.62962963e-03
+  0.833333333333  0.166666666667  0.500000000000  4.62962963e-03
+  0.833333333333  0.166666666667  0.666666666667  4.62962963e-03
+  0.833333333333  0.166666666667  0.833333333333  4.62962963e-03
+  0.833333333333  0.333333333333  0.000000000000  4.62962963e-03
+  0.833333333333  0.333333333333  0.166666666667  4.62962963e-03
+  0.833333333333  0.333333333333  0.333333333333  4.62962963e-03
+  0.833333333333  0.333333333333  0.500000000000  4.62962963e-03
+  0.833333333333  0.333333333333  0.666666666667  4.62962963e-03
+  0.833333333333  0.333333333333  0.833333333333  4.62962963e-03
+  0.833333333333  0.500000000000  0.000000000000  4.62962963e-03
+  0.833333333333  0.500000000000  0.166666666667  4.62962963e-03
+  0.833333333333  0.500000000000  0.333333333333  4.62962963e-03
+  0.833333333333  0.500000000000  0.500000000000  4.62962963e-03
+  0.833333333333  0.500000000000  0.666666666667  4.62962963e-03
+  0.833333333333  0.500000000000  0.833333333333  4.62962963e-03
+  0.833333333333  0.666666666667  0.000000000000  4.62962963e-03
+  0.833333333333  0.666666666667  0.166666666667  4.62962963e-03
+  0.833333333333  0.666666666667  0.333333333333  4.62962963e-03
+  0.833333333333  0.666666666667  0.500000000000  4.62962963e-03
+  0.833333333333  0.666666666667  0.666666666667  4.62962963e-03
+  0.833333333333  0.666666666667  0.833333333333  4.62962963e-03
+  0.833333333333  0.833333333333  0.000000000000  4.62962963e-03
+  0.833333333333  0.833333333333  0.166666666667  4.62962963e-03
+  0.833333333333  0.833333333333  0.333333333333  4.62962963e-03
+  0.833333333333  0.833333333333  0.500000000000  4.62962963e-03
+  0.833333333333  0.833333333333  0.666666666667  4.62962963e-03
+  0.833333333333  0.833333333333  0.833333333333  4.62962963e-03
+
+CELL_PARAMETERS angstrom
+0.00000000000000 1.78350000000000 1.78350000000000
+1.78350000000000 0.00000000000000 1.78350000000000
+1.78350000000000 1.78350000000000 0.00000000000000
+
+ATOMIC_POSITIONS crystal
+C 0.0000000000 0.0000000000 -0.0000000000 
+C 0.2497901964 0.2500000000 0.2500000000 
+

3_epc/displacements/group_8/pw2bgw.in

@@ -0,0 +1,19 @@
+&input_pw2bgw
+   prefix = 'scf'
+   outdir = './tmp/'
+   real_or_complex = 2
+   wfng_flag = .false.
+   wfng_file = 'WFN'
+   wfng_kgrid = .true.
+   wfng_nk1 = 6
+   wfng_nk2 = 6
+   wfng_nk3 = 6
+   wfng_dk1 = 0.0
+   wfng_dk2 = 0.0
+   wfng_dk3 = 0.0
+   rhog_flag = .false.
+   vxcg_flag = .false.
+   vscg_flag = .true.
+   vscg_file = 'VSC'
+   vkbg_flag = .false.
+/

3_epc/displacements/group_8/pw2bgw.out

@@ -0,0 +1,57 @@
+
+     Program PW2BGW v.7.2 starts on 19Feb2026 at 20:59:32 
+
+     This program is part of the open-source Quantum ESPRESSO suite
+     for quantum simulation of materials; please cite
+         "P. Giannozzi et al., J. Phys.:Condens. Matter 21 395502 (2009);
+         "P. Giannozzi et al., J. Phys.:Condens. Matter 29 465901 (2017);
+         "P. Giannozzi et al., J. Chem. Phys. 152 154105 (2020);
+          URL http://www.quantum-espresso.org", 
+     in publications or presentations arising from this work. More details at
+     http://www.quantum-espresso.org/quote
+
+     Parallel version (MPI), running on     8 processors
+
+     MPI processes distributed on     1 nodes
+     R & G space division:  proc/nbgrp/npool/nimage =       8
+     1126 MiB available memory on the printing compute node when the environment starts
+ 
+
+     Reading xml data from directory:
+
+     ./tmp/scf.save/
+
+     IMPORTANT: XC functional enforced from input :
+     Exchange-correlation= PBE
+                           (   1   4   3   4   0   0   0)
+     Any further DFT definition will be discarded
+     Please, verify this is what you really want
+
+ 
+     Parallelization info
+     --------------------
+     sticks:   dense  smooth     PW     G-vecs:    dense   smooth      PW
+     Min          47      47     16                  613      613     129
+     Max          48      48     18                  615      615     130
+     Sum         379     379    139                 4909     4909    1037
+ 
+     Using Slab Decomposition
+ 
+     Reading collected, re-writing distributed wavefunctions
+
+     NLCC is present
+
+     call write_vscg
+     done write_vscg
+
+ 
+     write_vscg   :      0.00s CPU      0.00s WALL (       1 calls)
+ 
+     PW2BGW       :      0.09s CPU      0.11s WALL
+
+ 
+   This run was terminated on:  20:59:33  19Feb2026            
+
+=------------------------------------------------------------------------------=
+   JOB DONE.
+=------------------------------------------------------------------------------=

3_epc/displacements/group_8/reconstruction/aohamiltonian/element.dat

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/graph.pkl

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/hamiltonians.h5

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/hamiltonians_pred.h5

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/hamiltonians_pred_e3.h5

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/info.json

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/lat.dat

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/orbital_types.dat

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/overlaps.h5

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

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/config.ini

@@ -0,0 +1,82 @@
+[basic]
+graph_dir = /home/apolyukhin/scripts/ml/diamond-qe/deeph-data/graph
+save_dir = /home/apolyukhin/scripts/ml/diamond-qe/diamond_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std
+raw_dir = /home/apolyukhin/scripts/ml/diamond-qe/deeph-data/preprocess
+dataset_name = diamond_qe
+only_get_graph = False
+interface = h5
+target = hamiltonian
+disable_cuda = True
+device = cpu
+num_threads = -1
+save_to_time_folder = False
+save_csv = True
+tb_writer = False
+seed = 42
+multiprocessing = 0
+orbital = [{"6 6": [0, 0]}, {"6 6": [0, 1]}, {"6 6": [0, 2]}, {"6 6": [0, 3]}, {"6 6": [0, 4]}, {"6 6": [0, 5]}, {"6 6": [0, 6]}, {"6 6": [0, 7]}, {"6 6": [0, 8]}, {"6 6": [0, 9]}, {"6 6": [0, 10]}, {"6 6": [0, 11]}, {"6 6": [0, 12]}, {"6 6": [1, 0]}, {"6 6": [1, 1]}, {"6 6": [1, 2]}, {"6 6": [1, 3]}, {"6 6": [1, 4]}, {"6 6": [1, 5]}, {"6 6": [1, 6]}, {"6 6": [1, 7]}, {"6 6": [1, 8]}, {"6 6": [1, 9]}, {"6 6": [1, 10]}, {"6 6": [1, 11]}, {"6 6": [1, 12]}, {"6 6": [2, 0]}, {"6 6": [2, 1]}, {"6 6": [2, 2]}, {"6 6": [2, 3]}, {"6 6": [2, 4]}, {"6 6": [2, 5]}, {"6 6": [2, 6]}, {"6 6": [2, 7]}, {"6 6": [2, 8]}, {"6 6": [2, 9]}, {"6 6": [2, 10]}, {"6 6": [2, 11]}, {"6 6": [2, 12]}, {"6 6": [3, 0]}, {"6 6": [3, 1]}, {"6 6": [3, 2]}, {"6 6": [3, 3]}, {"6 6": [3, 4]}, {"6 6": [3, 5]}, {"6 6": [3, 6]}, {"6 6": [3, 7]}, {"6 6": [3, 8]}, {"6 6": [3, 9]}, {"6 6": [3, 10]}, {"6 6": [3, 11]}, {"6 6": [3, 12]}, {"6 6": [4, 0]}, {"6 6": [4, 1]}, {"6 6": [4, 2]}, {"6 6": [4, 3]}, {"6 6": [4, 4]}, {"6 6": [4, 5]}, {"6 6": [4, 6]}, {"6 6": [4, 7]}, {"6 6": [4, 8]}, {"6 6": [4, 9]}, {"6 6": [4, 10]}, {"6 6": [4, 11]}, {"6 6": [4, 12]}, {"6 6": [5, 0]}, {"6 6": [5, 1]}, {"6 6": [5, 2]}, {"6 6": [5, 3]}, {"6 6": [5, 4]}, {"6 6": [5, 5]}, {"6 6": [5, 6]}, {"6 6": [5, 7]}, {"6 6": [5, 8]}, {"6 6": [5, 9]}, {"6 6": [5, 10]}, {"6 6": [5, 11]}, {"6 6": [5, 12]}, {"6 6": [6, 0]}, {"6 6": [6, 1]}, {"6 6": [6, 2]}, {"6 6": [6, 3]}, {"6 6": [6, 4]}, {"6 6": [6, 5]}, {"6 6": [6, 6]}, {"6 6": [6, 7]}, {"6 6": [6, 8]}, {"6 6": [6, 9]}, {"6 6": [6, 10]}, {"6 6": [6, 11]}, {"6 6": [6, 12]}, {"6 6": [7, 0]}, {"6 6": [7, 1]}, {"6 6": [7, 2]}, {"6 6": [7, 3]}, {"6 6": [7, 4]}, {"6 6": [7, 5]}, {"6 6": [7, 6]}, {"6 6": [7, 7]}, {"6 6": [7, 8]}, {"6 6": [7, 9]}, {"6 6": [7, 10]}, {"6 6": [7, 11]}, {"6 6": [7, 12]}, {"6 6": [8, 0]}, {"6 6": [8, 1]}, {"6 6": [8, 2]}, {"6 6": [8, 3]}, {"6 6": [8, 4]}, {"6 6": [8, 5]}, {"6 6": [8, 6]}, {"6 6": [8, 7]}, {"6 6": [8, 8]}, {"6 6": [8, 9]}, {"6 6": [8, 10]}, {"6 6": [8, 11]}, {"6 6": [8, 12]}, {"6 6": [9, 0]}, {"6 6": [9, 1]}, {"6 6": [9, 2]}, {"6 6": [9, 3]}, {"6 6": [9, 4]}, {"6 6": [9, 5]}, {"6 6": [9, 6]}, {"6 6": [9, 7]}, {"6 6": [9, 8]}, {"6 6": [9, 9]}, {"6 6": [9, 10]}, {"6 6": [9, 11]}, {"6 6": [9, 12]}, {"6 6": [10, 0]}, {"6 6": [10, 1]}, {"6 6": [10, 2]}, {"6 6": [10, 3]}, {"6 6": [10, 4]}, {"6 6": [10, 5]}, {"6 6": [10, 6]}, {"6 6": [10, 7]}, {"6 6": [10, 8]}, {"6 6": [10, 9]}, {"6 6": [10, 10]}, {"6 6": [10, 11]}, {"6 6": [10, 12]}, {"6 6": [11, 0]}, {"6 6": [11, 1]}, {"6 6": [11, 2]}, {"6 6": [11, 3]}, {"6 6": [11, 4]}, {"6 6": [11, 5]}, {"6 6": [11, 6]}, {"6 6": [11, 7]}, {"6 6": [11, 8]}, {"6 6": [11, 9]}, {"6 6": [11, 10]}, {"6 6": [11, 11]}, {"6 6": [11, 12]}, {"6 6": [12, 0]}, {"6 6": [12, 1]}, {"6 6": [12, 2]}, {"6 6": [12, 3]}, {"6 6": [12, 4]}, {"6 6": [12, 5]}, {"6 6": [12, 6]}, {"6 6": [12, 7]}, {"6 6": [12, 8]}, {"6 6": [12, 9]}, {"6 6": [12, 10]}, {"6 6": [12, 11]}, {"6 6": [12, 12]}]
+o_component = H
+energy_component = summation
+max_element = -1
+statistics = False
+normalizer = False
+boxcox = False
+
+[graph]
+radius = -1.0
+max_num_nbr = 0
+create_from_dft = True
+if_lcmp_graph = True
+separate_onsite = False
+new_sp = False
+
+[train]
+epochs = 5000
+pretrained = 
+resume = 
+train_ratio = 0.6
+val_ratio = 0.2
+test_ratio = 0.2
+early_stopping_loss = 0.0
+early_stopping_loss_epoch = [0.000000, 500]
+revert_then_decay = True
+revert_threshold = 30
+revert_decay_epoch = [800, 2000, 3000, 4000]
+revert_decay_gamma = [0.4, 0.5, 0.5, 0.4]
+clip_grad = True
+clip_grad_value = 4.2
+switch_sgd = False
+switch_sgd_lr = 1e-4
+switch_sgd_epoch = -1
+
+[hyperparameter]
+batch_size = 1
+dtype = float32
+optimizer = adam
+learning_rate = 0.001
+lr_scheduler = 
+lr_milestones = []
+momentum = 0.9
+weight_decay = 0
+criterion = MaskMSELoss
+retain_edge_fea = True
+lambda_eij = 0.0
+lambda_ei = 0.1
+lambda_etot = 0.0
+
+[network]
+atom_fea_len = 64
+edge_fea_len = 128
+gauss_stop = 6.0
+num_l = 4
+aggr = add
+distance_expansion = GaussianBasis
+if_exp = True
+if_multiplelinear = False
+if_edge_update = True
+if_lcmp = True
+normalization = LayerNorm
+atom_update_net = PAINN
+trainable_gaussians = False
+type_affine = False
+

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/result.txt

@@ -0,0 +1,87 @@
+====== CONFIG ======
+[basic]
+graph_dir=/home/apolyukhin/scripts/ml/diamond-qe/deeph-data/graph
+save_dir=/home/apolyukhin/scripts/ml/diamond-qe/diamond_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std
+raw_dir=/home/apolyukhin/scripts/ml/diamond-qe/deeph-data/preprocess
+dataset_name=diamond_qe
+only_get_graph=False
+interface=h5
+target=hamiltonian
+disable_cuda=True
+device=cpu
+num_threads=-1
+save_to_time_folder=False
+save_csv=True
+tb_writer=False
+seed=42
+multiprocessing=0
+orbital=[{"6 6": [0, 0]}, {"6 6": [0, 1]}, {"6 6": [0, 2]}, {"6 6": [0, 3]}, {"6 6": [0, 4]}, {"6 6": [0, 5]}, {"6 6": [0, 6]}, {"6 6": [0, 7]}, {"6 6": [0, 8]}, {"6 6": [0, 9]}, {"6 6": [0, 10]}, {"6 6": [0, 11]}, {"6 6": [0, 12]}, {"6 6": [1, 0]}, {"6 6": [1, 1]}, {"6 6": [1, 2]}, {"6 6": [1, 3]}, {"6 6": [1, 4]}, {"6 6": [1, 5]}, {"6 6": [1, 6]}, {"6 6": [1, 7]}, {"6 6": [1, 8]}, {"6 6": [1, 9]}, {"6 6": [1, 10]}, {"6 6": [1, 11]}, {"6 6": [1, 12]}, {"6 6": [2, 0]}, {"6 6": [2, 1]}, {"6 6": [2, 2]}, {"6 6": [2, 3]}, {"6 6": [2, 4]}, {"6 6": [2, 5]}, {"6 6": [2, 6]}, {"6 6": [2, 7]}, {"6 6": [2, 8]}, {"6 6": [2, 9]}, {"6 6": [2, 10]}, {"6 6": [2, 11]}, {"6 6": [2, 12]}, {"6 6": [3, 0]}, {"6 6": [3, 1]}, {"6 6": [3, 2]}, {"6 6": [3, 3]}, {"6 6": [3, 4]}, {"6 6": [3, 5]}, {"6 6": [3, 6]}, {"6 6": [3, 7]}, {"6 6": [3, 8]}, {"6 6": [3, 9]}, {"6 6": [3, 10]}, {"6 6": [3, 11]}, {"6 6": [3, 12]}, {"6 6": [4, 0]}, {"6 6": [4, 1]}, {"6 6": [4, 2]}, {"6 6": [4, 3]}, {"6 6": [4, 4]}, {"6 6": [4, 5]}, {"6 6": [4, 6]}, {"6 6": [4, 7]}, {"6 6": [4, 8]}, {"6 6": [4, 9]}, {"6 6": [4, 10]}, {"6 6": [4, 11]}, {"6 6": [4, 12]}, {"6 6": [5, 0]}, {"6 6": [5, 1]}, {"6 6": [5, 2]}, {"6 6": [5, 3]}, {"6 6": [5, 4]}, {"6 6": [5, 5]}, {"6 6": [5, 6]}, {"6 6": [5, 7]}, {"6 6": [5, 8]}, {"6 6": [5, 9]}, {"6 6": [5, 10]}, {"6 6": [5, 11]}, {"6 6": [5, 12]}, {"6 6": [6, 0]}, {"6 6": [6, 1]}, {"6 6": [6, 2]}, {"6 6": [6, 3]}, {"6 6": [6, 4]}, {"6 6": [6, 5]}, {"6 6": [6, 6]}, {"6 6": [6, 7]}, {"6 6": [6, 8]}, {"6 6": [6, 9]}, {"6 6": [6, 10]}, {"6 6": [6, 11]}, {"6 6": [6, 12]}, {"6 6": [7, 0]}, {"6 6": [7, 1]}, {"6 6": [7, 2]}, {"6 6": [7, 3]}, {"6 6": [7, 4]}, {"6 6": [7, 5]}, {"6 6": [7, 6]}, {"6 6": [7, 7]}, {"6 6": [7, 8]}, {"6 6": [7, 9]}, {"6 6": [7, 10]}, {"6 6": [7, 11]}, {"6 6": [7, 12]}, {"6 6": [8, 0]}, {"6 6": [8, 1]}, {"6 6": [8, 2]}, {"6 6": [8, 3]}, {"6 6": [8, 4]}, {"6 6": [8, 5]}, {"6 6": [8, 6]}, {"6 6": [8, 7]}, {"6 6": [8, 8]}, {"6 6": [8, 9]}, {"6 6": [8, 10]}, {"6 6": [8, 11]}, {"6 6": [8, 12]}, {"6 6": [9, 0]}, {"6 6": [9, 1]}, {"6 6": [9, 2]}, {"6 6": [9, 3]}, {"6 6": [9, 4]}, {"6 6": [9, 5]}, {"6 6": [9, 6]}, {"6 6": [9, 7]}, {"6 6": [9, 8]}, {"6 6": [9, 9]}, {"6 6": [9, 10]}, {"6 6": [9, 11]}, {"6 6": [9, 12]}, {"6 6": [10, 0]}, {"6 6": [10, 1]}, {"6 6": [10, 2]}, {"6 6": [10, 3]}, {"6 6": [10, 4]}, {"6 6": [10, 5]}, {"6 6": [10, 6]}, {"6 6": [10, 7]}, {"6 6": [10, 8]}, {"6 6": [10, 9]}, {"6 6": [10, 10]}, {"6 6": [10, 11]}, {"6 6": [10, 12]}, {"6 6": [11, 0]}, {"6 6": [11, 1]}, {"6 6": [11, 2]}, {"6 6": [11, 3]}, {"6 6": [11, 4]}, {"6 6": [11, 5]}, {"6 6": [11, 6]}, {"6 6": [11, 7]}, {"6 6": [11, 8]}, {"6 6": [11, 9]}, {"6 6": [11, 10]}, {"6 6": [11, 11]}, {"6 6": [11, 12]}, {"6 6": [12, 0]}, {"6 6": [12, 1]}, {"6 6": [12, 2]}, {"6 6": [12, 3]}, {"6 6": [12, 4]}, {"6 6": [12, 5]}, {"6 6": [12, 6]}, {"6 6": [12, 7]}, {"6 6": [12, 8]}, {"6 6": [12, 9]}, {"6 6": [12, 10]}, {"6 6": [12, 11]}, {"6 6": [12, 12]}]
+o_component=H
+energy_component=summation
+max_element=-1
+statistics=False
+normalizer=False
+boxcox=False
+
+[graph]
+radius=-1.0
+max_num_nbr=0
+create_from_dft=True
+if_lcmp_graph=True
+separate_onsite=False
+new_sp=False
+
+[train]
+epochs=5000
+pretrained=
+resume=
+train_ratio=0.6
+val_ratio=0.2
+test_ratio=0.2
+early_stopping_loss=0.0
+early_stopping_loss_epoch=[0.000000, 500]
+revert_then_decay=True
+revert_threshold=30
+revert_decay_epoch=[800, 2000, 3000, 4000]
+revert_decay_gamma=[0.4, 0.5, 0.5, 0.4]
+clip_grad=True
+clip_grad_value=4.2
+switch_sgd=False
+switch_sgd_lr=1e-4
+switch_sgd_epoch=-1
+
+[hyperparameter]
+batch_size=1
+dtype=float32
+optimizer=adam
+learning_rate=0.001
+lr_scheduler=
+lr_milestones=[]
+momentum=0.9
+weight_decay=0
+criterion=MaskMSELoss
+retain_edge_fea=True
+lambda_eij=0.0
+lambda_ei=0.1
+lambda_etot=0.0
+
+[network]
+atom_fea_len=64
+edge_fea_len=128
+gauss_stop=6.0
+num_l=4
+aggr=add
+distance_expansion=GaussianBasis
+if_exp=True
+if_multiplelinear=False
+if_edge_update=True
+if_lcmp=True
+normalization=LayerNorm
+atom_update_net=PAINN
+trainable_gaussians=False
+type_affine=False
+
+=> load best checkpoint (epoch 3217)
+=> Atomic types: [6], spinful: False, the number of atomic types: 1.
+Save processed graph to /home/apolyukhin/scripts/ml/diamond-qe/diamond_epc/displacements/group_8/reconstruction/aohamiltonian/graph.pkl, cost 0.11131572723388672 seconds
+
  0%|          | 0/1 [00:00<?, ?it/s]

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/__init__.py

@@ -0,0 +1,10 @@
+from .data import HData
+from .model import HGNN, ExpBernsteinBasis
+from .utils import print_args, Logger, MaskMSELoss, MaskMAELoss, write_ham_npz, write_ham, write_ham_h5, get_config, \
+    get_inference_config, get_preprocess_config
+from .graph import Collater, collate_fn, get_graph, load_orbital_types
+from .kernel import DeepHKernel
+from .preprocess import get_rc, OijLoad, GetEEiEij, abacus_parse, siesta_parse
+from .rotate import get_rh, rotate_back, Rotate, dtype_dict
+
+__version__ = "0.2.2"

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/data.py

@@ -0,0 +1,217 @@
+import warnings
+import os
+import time
+import tqdm
+
+from pymatgen.core.structure import Structure
+import numpy as np
+import torch
+from torch_geometric.data import InMemoryDataset
+from pathos.multiprocessing import ProcessingPool as Pool
+
+from .graph import get_graph
+
+
+class HData(InMemoryDataset):
+    def __init__(self, raw_data_dir: str, graph_dir: str, interface: str, target: str,
+                 dataset_name: str, multiprocessing: int, radius, max_num_nbr,
+                 num_l, max_element, create_from_DFT, if_lcmp_graph, separate_onsite, new_sp,
+                 default_dtype_torch, nums: int = None, transform=None, pre_transform=None, pre_filter=None):
+        """
+when interface == 'h5',
+raw_data_dir
+├── 00
+│     ├──rh.h5 / rdm.h5
+│     ├──rc.h5
+│     ├──element.dat
+│     ├──orbital_types.dat
+│     ├──site_positions.dat
+│     ├──lat.dat
+│     └──info.json
+├── 01
+│     ├──rh.h5 / rdm.h5
+│     ├──rc.h5
+│     ├──element.dat
+│     ├──orbital_types.dat
+│     ├──site_positions.dat
+│     ├──lat.dat
+│     └──info.json
+├── 02
+│     ├──rh.h5 / rdm.h5
+│     ├──rc.h5
+│     ├──element.dat
+│     ├──orbital_types.dat
+│     ├──site_positions.dat
+│     ├──lat.dat
+│     └──info.json
+├── ...
+        """
+        self.raw_data_dir = raw_data_dir
+        assert dataset_name.find('-') == -1, '"-" can not be included in the dataset name'
+        if create_from_DFT:
+            way_create_graph = 'FromDFT'
+        else:
+            way_create_graph = f'{radius}r{max_num_nbr}mn'
+        if if_lcmp_graph:
+            lcmp_str = f'{num_l}l'
+        else:
+            lcmp_str = 'WithoutLCMP'
+        if separate_onsite is True:
+            onsite_str = '-SeparateOnsite'
+        else:
+            onsite_str = ''
+        if new_sp:
+            new_sp_str = '-NewSP'
+        else:
+            new_sp_str = ''
+        if target == 'hamiltonian':
+            title = 'HGraph'
+        else:
+            raise ValueError('Unknown prediction target: {}'.format(target))
+        graph_file_name = f'{title}-{interface}-{dataset_name}-{lcmp_str}-{way_create_graph}{onsite_str}{new_sp_str}.pkl'
+        self.data_file = os.path.join(graph_dir, graph_file_name)
+        os.makedirs(graph_dir, exist_ok=True)
+        self.data, self.slices = None, None
+        self.interface = interface
+        self.target = target
+        self.dataset_name = dataset_name
+        self.multiprocessing = multiprocessing
+        self.radius = radius
+        self.max_num_nbr = max_num_nbr
+        self.num_l = num_l
+        self.create_from_DFT = create_from_DFT
+        self.if_lcmp_graph = if_lcmp_graph
+        self.separate_onsite = separate_onsite
+        self.new_sp = new_sp
+        self.default_dtype_torch = default_dtype_torch
+
+        self.nums = nums
+        self.transform = transform
+        self.pre_transform = pre_transform
+        self.pre_filter = pre_filter
+        self.__indices__ = None
+        self.__data_list__ = None
+        self._indices = None
+        self._data_list = None
+
+        print(f'Graph data file: {graph_file_name}')
+        if os.path.exists(self.data_file):
+            print('Use existing graph data file')
+        else:
+            print('Process new data file......')
+            self.process()
+        begin = time.time()
+        try:
+            loaded_data = torch.load(self.data_file)
+        except AttributeError:
+            raise RuntimeError('Error in loading graph data file, try to delete it and generate the graph file with the current version of PyG')
+        if len(loaded_data) == 2:
+            warnings.warn('You are using the graph data file with an old version')
+            self.data, self.slices = loaded_data
+            self.info = {
+                "spinful": False,
+                "index_to_Z": torch.arange(max_element + 1),
+                "Z_to_index": torch.arange(max_element + 1),
+            }
+        elif len(loaded_data) == 3:
+            self.data, self.slices, tmp = loaded_data
+            if isinstance(tmp, dict):
+                self.info = tmp
+                print(f"Atomic types: {self.info['index_to_Z'].tolist()}")
+            else:
+                warnings.warn('You are using an old version of the graph data file')
+                self.info = {
+                    "spinful": tmp,
+                    "index_to_Z": torch.arange(max_element + 1),
+                    "Z_to_index": torch.arange(max_element + 1),
+                }
+        print(f'Finish loading the processed {len(self)} structures (spinful: {self.info["spinful"]}, '
+              f'the number of atomic types: {len(self.info["index_to_Z"])}), cost {time.time() - begin:.0f} seconds')
+
+    def process_worker(self, folder, **kwargs):
+        stru_id = os.path.split(folder)[-1]
+
+        structure = Structure(np.loadtxt(os.path.join(folder, 'lat.dat')).T,
+                              np.loadtxt(os.path.join(folder, 'element.dat')),
+                              np.loadtxt(os.path.join(folder, 'site_positions.dat')).T,
+                              coords_are_cartesian=True,
+                              to_unit_cell=False)
+
+        cart_coords = torch.tensor(structure.cart_coords, dtype=self.default_dtype_torch)
+        frac_coords = torch.tensor(structure.frac_coords, dtype=self.default_dtype_torch)
+        numbers = torch.tensor(structure.atomic_numbers)
+        structure.lattice.matrix.setflags(write=True)
+        lattice = torch.tensor(structure.lattice.matrix, dtype=self.default_dtype_torch)
+        if self.target == 'E_ij':
+            huge_structure = True
+        else:
+            huge_structure = False
+        return get_graph(cart_coords, frac_coords, numbers, stru_id, r=self.radius, max_num_nbr=self.max_num_nbr,
+                         numerical_tol=1e-8, lattice=lattice, default_dtype_torch=self.default_dtype_torch,
+                         tb_folder=folder, interface=self.interface, num_l=self.num_l,
+                         create_from_DFT=self.create_from_DFT, if_lcmp_graph=self.if_lcmp_graph,
+                         separate_onsite=self.separate_onsite,
+                         target=self.target, huge_structure=huge_structure, if_new_sp=self.new_sp, **kwargs)
+
+    def process(self):
+        begin = time.time()
+        folder_list = []
+        for root, dirs, files in os.walk(self.raw_data_dir):
+            if (self.interface == 'h5' and 'rc.h5' in files) or (
+                    self.interface == 'npz' and 'rc.npz' in files):
+                folder_list.append(root)
+        folder_list = sorted(folder_list)
+        folder_list = folder_list[: self.nums]
+        if self.dataset_name == 'graphene_450':
+            folder_list = folder_list[500:5000:10]
+        if self.dataset_name == 'graphene_1500':
+            folder_list = folder_list[500:5000:3]
+        if self.dataset_name == 'bp_bilayer':
+            folder_list = folder_list[:600]
+        assert len(folder_list) != 0, "Can not find any structure"
+        print('Found %d structures, have cost %d seconds' % (len(folder_list), time.time() - begin))
+
+        if self.multiprocessing == 0:
+            print(f'Use multiprocessing (nodes = num_processors x num_threads = 1 x {torch.get_num_threads()})')
+            data_list = [self.process_worker(folder) for folder in tqdm.tqdm(folder_list)]
+        else:
+            pool_dict = {} if self.multiprocessing < 0 else {'nodes': self.multiprocessing}
+            # BS (2023.06.06): 
+            # The keyword "num_threads" in kernel.py can be used to set the torch threads.
+            # The multiprocessing in the "process_worker" is in contradiction with the num_threads utilized in torch.
+            # To avoid this conflict, I limit the number of torch threads to one,
+            # and recover it when finishing the process_worker.
+            torch_num_threads = torch.get_num_threads()
+            torch.set_num_threads(1)
+
+            with Pool(**pool_dict) as pool:
+                nodes = pool.nodes
+                print(f'Use multiprocessing (nodes = num_processors x num_threads = {nodes} x {torch.get_num_threads()})')
+                data_list = list(tqdm.tqdm(pool.imap(self.process_worker, folder_list), total=len(folder_list)))
+            torch.set_num_threads(torch_num_threads)
+        print('Finish processing %d structures, have cost %d seconds' % (len(data_list), time.time() - begin))
+
+        if self.pre_filter is not None:
+            data_list = [d for d in data_list if self.pre_filter(d)]
+        if self.pre_transform is not None:
+            data_list = [self.pre_transform(d) for d in data_list]
+
+        index_to_Z, Z_to_index = self.element_statistics(data_list)
+        spinful = data_list[0].spinful
+        for d in data_list:
+            assert spinful == d.spinful
+
+        data, slices = self.collate(data_list)
+        torch.save((data, slices, dict(spinful=spinful, index_to_Z=index_to_Z, Z_to_index=Z_to_index)), self.data_file)
+        print('Finish saving %d structures to %s, have cost %d seconds' % (
+        len(data_list), self.data_file, time.time() - begin))
+
+    def element_statistics(self, data_list):
+        index_to_Z, inverse_indices = torch.unique(data_list[0].x, sorted=True, return_inverse=True)
+        Z_to_index = torch.full((100,), -1, dtype=torch.int64)
+        Z_to_index[index_to_Z] = torch.arange(len(index_to_Z))
+
+        for data in data_list:
+            data.x = Z_to_index[data.x]
+
+        return index_to_Z, Z_to_index

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/default.ini

@@ -0,0 +1,88 @@
+[basic]
+graph_dir = /your/own/path
+save_dir = /your/own/path
+raw_dir = /your/own/path
+dataset_name = your_own_name
+only_get_graph = False
+;choices = ['h5', 'npz']
+interface = h5
+target = hamiltonian
+disable_cuda = False
+device = cuda:0
+;-1 for cpu_count(logical=False) // torch.cuda.device_count()
+num_threads = -1
+save_to_time_folder = True
+save_csv = False
+tb_writer = True
+seed = 42
+multiprocessing = 0
+orbital = [{"6 6": [0, 0]}, {"6 6": [0, 1]}, {"6 6": [0, 2]}, {"6 6": [0, 3]}, {"6 6": [0, 4]}, {"6 6": [0, 5]}, {"6 6": [0, 6]}, {"6 6": [0, 7]}, {"6 6": [0, 8]}, {"6 6": [0, 9]}, {"6 6": [0, 10]}, {"6 6": [0, 11]}, {"6 6": [0, 12]}, {"6 6": [1, 0]}, {"6 6": [1, 1]}, {"6 6": [1, 2]}, {"6 6": [1, 3]}, {"6 6": [1, 4]}, {"6 6": [1, 5]}, {"6 6": [1, 6]}, {"6 6": [1, 7]}, {"6 6": [1, 8]}, {"6 6": [1, 9]}, {"6 6": [1, 10]}, {"6 6": [1, 11]}, {"6 6": [1, 12]}, {"6 6": [2, 0]}, {"6 6": [2, 1]}, {"6 6": [2, 2]}, {"6 6": [2, 3]}, {"6 6": [2, 4]}, {"6 6": [2, 5]}, {"6 6": [2, 6]}, {"6 6": [2, 7]}, {"6 6": [2, 8]}, {"6 6": [2, 9]}, {"6 6": [2, 10]}, {"6 6": [2, 11]}, {"6 6": [2, 12]}, {"6 6": [3, 0]}, {"6 6": [3, 1]}, {"6 6": [3, 2]}, {"6 6": [3, 3]}, {"6 6": [3, 4]}, {"6 6": [3, 5]}, {"6 6": [3, 6]}, {"6 6": [3, 7]}, {"6 6": [3, 8]}, {"6 6": [3, 9]}, {"6 6": [3, 10]}, {"6 6": [3, 11]}, {"6 6": [3, 12]}, {"6 6": [4, 0]}, {"6 6": [4, 1]}, {"6 6": [4, 2]}, {"6 6": [4, 3]}, {"6 6": [4, 4]}, {"6 6": [4, 5]}, {"6 6": [4, 6]}, {"6 6": [4, 7]}, {"6 6": [4, 8]}, {"6 6": [4, 9]}, {"6 6": [4, 10]}, {"6 6": [4, 11]}, {"6 6": [4, 12]}, {"6 6": [5, 0]}, {"6 6": [5, 1]}, {"6 6": [5, 2]}, {"6 6": [5, 3]}, {"6 6": [5, 4]}, {"6 6": [5, 5]}, {"6 6": [5, 6]}, {"6 6": [5, 7]}, {"6 6": [5, 8]}, {"6 6": [5, 9]}, {"6 6": [5, 10]}, {"6 6": [5, 11]}, {"6 6": [5, 12]}, {"6 6": [6, 0]}, {"6 6": [6, 1]}, {"6 6": [6, 2]}, {"6 6": [6, 3]}, {"6 6": [6, 4]}, {"6 6": [6, 5]}, {"6 6": [6, 6]}, {"6 6": [6, 7]}, {"6 6": [6, 8]}, {"6 6": [6, 9]}, {"6 6": [6, 10]}, {"6 6": [6, 11]}, {"6 6": [6, 12]}, {"6 6": [7, 0]}, {"6 6": [7, 1]}, {"6 6": [7, 2]}, {"6 6": [7, 3]}, {"6 6": [7, 4]}, {"6 6": [7, 5]}, {"6 6": [7, 6]}, {"6 6": [7, 7]}, {"6 6": [7, 8]}, {"6 6": [7, 9]}, {"6 6": [7, 10]}, {"6 6": [7, 11]}, {"6 6": [7, 12]}, {"6 6": [8, 0]}, {"6 6": [8, 1]}, {"6 6": [8, 2]}, {"6 6": [8, 3]}, {"6 6": [8, 4]}, {"6 6": [8, 5]}, {"6 6": [8, 6]}, {"6 6": [8, 7]}, {"6 6": [8, 8]}, {"6 6": [8, 9]}, {"6 6": [8, 10]}, {"6 6": [8, 11]}, {"6 6": [8, 12]}, {"6 6": [9, 0]}, {"6 6": [9, 1]}, {"6 6": [9, 2]}, {"6 6": [9, 3]}, {"6 6": [9, 4]}, {"6 6": [9, 5]}, {"6 6": [9, 6]}, {"6 6": [9, 7]}, {"6 6": [9, 8]}, {"6 6": [9, 9]}, {"6 6": [9, 10]}, {"6 6": [9, 11]}, {"6 6": [9, 12]}, {"6 6": [10, 0]}, {"6 6": [10, 1]}, {"6 6": [10, 2]}, {"6 6": [10, 3]}, {"6 6": [10, 4]}, {"6 6": [10, 5]}, {"6 6": [10, 6]}, {"6 6": [10, 7]}, {"6 6": [10, 8]}, {"6 6": [10, 9]}, {"6 6": [10, 10]}, {"6 6": [10, 11]}, {"6 6": [10, 12]}, {"6 6": [11, 0]}, {"6 6": [11, 1]}, {"6 6": [11, 2]}, {"6 6": [11, 3]}, {"6 6": [11, 4]}, {"6 6": [11, 5]}, {"6 6": [11, 6]}, {"6 6": [11, 7]}, {"6 6": [11, 8]}, {"6 6": [11, 9]}, {"6 6": [11, 10]}, {"6 6": [11, 11]}, {"6 6": [11, 12]}, {"6 6": [12, 0]}, {"6 6": [12, 1]}, {"6 6": [12, 2]}, {"6 6": [12, 3]}, {"6 6": [12, 4]}, {"6 6": [12, 5]}, {"6 6": [12, 6]}, {"6 6": [12, 7]}, {"6 6": [12, 8]}, {"6 6": [12, 9]}, {"6 6": [12, 10]}, {"6 6": [12, 11]}, {"6 6": [12, 12]}]
+O_component = H
+energy_component = summation
+max_element = -1
+statistics = False
+normalizer = False
+boxcox = False
+
+[graph]
+radius = -1.0
+max_num_nbr = 0
+create_from_DFT = True
+if_lcmp_graph = True
+separate_onsite = False
+new_sp = False
+
+[train]
+epochs = 4000
+pretrained =
+resume =
+train_ratio = 0.6
+val_ratio = 0.2
+test_ratio = 0.2
+early_stopping_loss = 0.0
+early_stopping_loss_epoch = [0.000000, 500]
+revert_then_decay = True
+revert_threshold = 30
+revert_decay_epoch = [500, 2000, 3000]
+revert_decay_gamma = [0.4, 0.5, 0.5]
+clip_grad = True
+clip_grad_value = 4.2
+switch_sgd = False
+switch_sgd_lr = 1e-4
+switch_sgd_epoch = -1
+
+[hyperparameter]
+batch_size = 3
+dtype = float32
+;choices = ['sgd', 'sgdm', 'adam', 'lbfgs']
+optimizer = adam
+;initial learning rate
+learning_rate = 0.001
+;choices = ['', 'MultiStepLR', 'ReduceLROnPlateau', 'CyclicLR']
+lr_scheduler =
+lr_milestones = []
+momentum = 0.9
+weight_decay = 0
+criterion = MaskMSELoss
+retain_edge_fea = True
+lambda_Eij = 0.0
+lambda_Ei = 0.1
+lambda_Etot = 0.0
+
+[network]
+atom_fea_len = 64
+edge_fea_len = 128
+gauss_stop = 6
+;The number of angular quantum numbers that spherical harmonic functions have
+num_l = 5
+aggr = add
+distance_expansion = GaussianBasis
+if_exp = True
+if_MultipleLinear = False
+if_edge_update = True
+if_lcmp = True
+normalization = LayerNorm
+;choices = ['CGConv', 'GAT', 'PAINN']
+atom_update_net = CGConv
+trainable_gaussians = False
+type_affine = False

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_HermNet/__init__.py

@@ -0,0 +1 @@
+from .rmnet import RBF, cosine_cutoff, ShiftedSoftplus, _eps

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_HermNet/license.txt

@@ -0,0 +1 @@
+The code in this folder was obtained from "https://github.com/sakuraiiiii/HermNet"

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_HermNet/rmnet.py

@@ -0,0 +1,105 @@
+import math
+
+import torch
+from torch import nn, Tensor
+import numpy as np
+
+
+_eps = 1e-3
+
+r"""Tricks: Introducing the parameter `_eps` is to avoid NaN.
+In HVNet and HTNet, a subgraph will be extracted to calculate angles. 
+And with all the nodes still be included in the subgraph, 
+each hidden state in such a subgraph will contain 0 value.
+In `painn`, the calculation w.r.t $r / \parallel r \parallel$ will be taken.
+If just alternate $r / \parallel r \parallel$ with $r / (\parallel r \parallel + _eps)$, 
+NaN will still occur in during the training.
+Considering the following example,
+$$
+(\frac{x}{r+_eps})^\prime = \frac{r+b-\frac{x^2}{r}}{(r+b)^2}
+$$
+where $r = \sqrt{x^2+y^2+z^2}$. It is obvious that NaN will occur.
+Thus the solution is change the norm $r$ as $r^\prime = \sqrt(x^2+y^2+z^2+_eps)$.
+Since $r$ is rotational invariant, $r^2$ is rotational invariant.
+Obviously, $\sqrt(r^2 + _eps)$ is rotational invariant.
+"""
+class RBF(nn.Module):
+    r"""Radial basis function.
+    A modified version of feature engineering in `DimeNet`,
+    which is used in `PAINN`.
+
+    Parameters
+    ----------
+    rc      : float
+        Cutoff radius
+    l       : int
+        Parameter in feature engineering in DimeNet
+    """
+    def __init__(self, rc: float, l: int):
+        super(RBF, self).__init__()
+        self.rc = rc
+        self.l = l
+
+    def forward(self, x: Tensor):
+        ls = torch.arange(1, self.l + 1).float().to(x.device)
+        norm = torch.sqrt((x ** 2).sum(dim=-1) + _eps).unsqueeze(-1)
+        return torch.sin(math.pi / self.rc * norm@ls.unsqueeze(0)) / norm
+
+
+class cosine_cutoff(nn.Module):
+    r"""Cutoff function in https://aip.scitation.org/doi/pdf/10.1063/1.3553717.
+
+    Parameters
+    ----------
+    rc      : float
+        Cutoff radius
+    """
+    def __init__(self, rc: float):
+        super(cosine_cutoff, self).__init__()
+        self.rc = rc
+
+    def forward(self, x: Tensor):
+        norm = torch.norm(x, dim=-1, keepdim=True) + _eps
+        return 0.5 * (torch.cos(math.pi * norm / self.rc) + 1)
+
+class ShiftedSoftplus(nn.Module):
+    r"""
+
+    Description
+    -----------
+    Applies the element-wise function:
+
+    .. math::
+        \text{SSP}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x)) - \log(\text{shift})
+
+    Attributes
+    ----------
+    beta : int
+        :math:`\beta` value for the mathematical formulation. Default to 1.
+    shift : int
+        :math:`\text{shift}` value for the mathematical formulation. Default to 2.
+    """
+    def __init__(self, beta=1, shift=2, threshold=20):
+        super(ShiftedSoftplus, self).__init__()
+
+        self.shift = shift
+        self.softplus = nn.Softplus(beta=beta, threshold=threshold)
+
+    def forward(self, inputs):
+        """
+
+        Description
+        -----------
+        Applies the activation function.
+
+        Parameters
+        ----------
+        inputs : float32 tensor of shape (N, *)
+            * denotes any number of additional dimensions.
+
+        Returns
+        -------
+        float32 tensor of shape (N, *)
+            Result of applying the activation function to the input.
+        """
+        return self.softplus(inputs) - np.log(float(self.shift))

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_PyG_future/__init__.py

@@ -0,0 +1,2 @@
+from .graph_norm import GraphNorm
+from .diff_group_norm import DiffGroupNorm

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_PyG_future/diff_group_norm.py

@@ -0,0 +1,109 @@
+import torch
+from torch import Tensor
+from torch.nn import Linear, BatchNorm1d
+
+
+class DiffGroupNorm(torch.nn.Module):
+    r"""The differentiable group normalization layer from the `"Towards Deeper
+    Graph Neural Networks with Differentiable Group Normalization"
+    <https://arxiv.org/abs/2006.06972>`_ paper, which normalizes node features
+    group-wise via a learnable soft cluster assignment
+
+    .. math::
+
+        \mathbf{S} = \text{softmax} (\mathbf{X} \mathbf{W})
+
+    where :math:`\mathbf{W} \in \mathbb{R}^{F \times G}` denotes a trainable
+    weight matrix mapping each node into one of :math:`G` clusters.
+    Normalization is then performed group-wise via:
+
+    .. math::
+
+        \mathbf{X}^{\prime} = \mathbf{X} + \lambda \sum_{i = 1}^G
+        \text{BatchNorm}(\mathbf{S}[:, i] \odot \mathbf{X})
+
+    Args:
+        in_channels (int): Size of each input sample :math:`F`.
+        groups (int): The number of groups :math:`G`.
+        lamda (float, optional): The balancing factor :math:`\lambda` between
+            input embeddings and normalized embeddings. (default: :obj:`0.01`)
+        eps (float, optional): A value added to the denominator for numerical
+            stability. (default: :obj:`1e-5`)
+        momentum (float, optional): The value used for the running mean and
+            running variance computation. (default: :obj:`0.1`)
+        affine (bool, optional): If set to :obj:`True`, this module has
+            learnable affine parameters :math:`\gamma` and :math:`\beta`.
+            (default: :obj:`True`)
+        track_running_stats (bool, optional): If set to :obj:`True`, this
+            module tracks the running mean and variance, and when set to
+            :obj:`False`, this module does not track such statistics and always
+            uses batch statistics in both training and eval modes.
+            (default: :obj:`True`)
+    """
+    def __init__(self, in_channels, groups, lamda=0.01, eps=1e-5, momentum=0.1,
+                 affine=True, track_running_stats=True):
+        super(DiffGroupNorm, self).__init__()
+
+        self.in_channels = in_channels
+        self.groups = groups
+        self.lamda = lamda
+
+        self.lin = Linear(in_channels, groups, bias=False)
+        self.norm = BatchNorm1d(groups * in_channels, eps, momentum, affine,
+                                track_running_stats)
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        self.lin.reset_parameters()
+        self.norm.reset_parameters()
+
+    def forward(self, x: Tensor) -> Tensor:
+        """"""
+        F, G = self.in_channels, self.groups
+
+        s = self.lin(x).softmax(dim=-1)  # [N, G]
+        out = s.unsqueeze(-1) * x.unsqueeze(-2)  # [N, G, F]
+        out = self.norm(out.view(-1, G * F)).view(-1, G, F).sum(-2)  # [N, F]
+
+        return x + self.lamda * out
+
+    @staticmethod
+    def group_distance_ratio(x: Tensor, y: Tensor, eps: float = 1e-5) -> float:
+        r"""Measures the ratio of inter-group distance over intra-group
+        distance
+
+        .. math::
+            R_{\text{Group}} = \frac{\frac{1}{(C-1)^2} \sum_{i!=j}
+            \frac{1}{|\mathbf{X}_i||\mathbf{X}_j|} \sum_{\mathbf{x}_{iv}
+            \in \mathbf{X}_i } \sum_{\mathbf{x}_{jv^{\prime}} \in \mathbf{X}_j}
+            {\| \mathbf{x}_{iv} - \mathbf{x}_{jv^{\prime}} \|}_2 }{
+            \frac{1}{C} \sum_{i} \frac{1}{{|\mathbf{X}_i|}^2}
+            \sum_{\mathbf{x}_{iv}, \mathbf{x}_{iv^{\prime}} \in \mathbf{X}_i }
+            {\| \mathbf{x}_{iv} - \mathbf{x}_{iv^{\prime}} \|}_2 }
+
+        where :math:`\mathbf{X}_i` denotes the set of all nodes that belong to
+        class :math:`i`, and :math:`C` denotes the total number of classes in
+        :obj:`y`.
+        """
+        num_classes = int(y.max()) + 1
+
+        numerator = 0.
+        for i in range(num_classes):
+            mask = y == i
+            dist = torch.cdist(x[mask].unsqueeze(0), x[~mask].unsqueeze(0))
+            numerator += (1 / dist.numel()) * float(dist.sum())
+        numerator *= 1 / (num_classes - 1)**2
+
+        denominator = 0.
+        for i in range(num_classes):
+            mask = y == i
+            dist = torch.cdist(x[mask].unsqueeze(0), x[mask].unsqueeze(0))
+            denominator += (1 / dist.numel()) * float(dist.sum())
+        denominator *= 1 / num_classes
+
+        return numerator / (denominator + eps)
+
+    def __repr__(self):
+        return '{}({}, groups={})'.format(self.__class__.__name__,
+                                          self.in_channels, self.groups)

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_PyG_future/graph_norm.py

@@ -0,0 +1,60 @@
+from typing import Optional
+
+import torch
+from torch import Tensor
+from torch_scatter import scatter_mean
+
+from torch_geometric.nn.inits import zeros, ones
+
+
+class GraphNorm(torch.nn.Module):
+    r"""Applies graph normalization over individual graphs as described in the
+    `"GraphNorm: A Principled Approach to Accelerating Graph Neural Network
+    Training" <https://arxiv.org/abs/2009.03294>`_ paper
+
+    .. math::
+        \mathbf{x}^{\prime}_i = \frac{\mathbf{x} - \alpha \odot
+        \textrm{E}[\mathbf{x}]}
+        {\sqrt{\textrm{Var}[\mathbf{x} - \alpha \odot \textrm{E}[\mathbf{x}]]
+        + \epsilon}} \odot \gamma + \beta
+
+    where :math:`\alpha` denotes parameters that learn how much information
+    to keep in the mean.
+
+    Args:
+        in_channels (int): Size of each input sample.
+        eps (float, optional): A value added to the denominator for numerical
+            stability. (default: :obj:`1e-5`)
+    """
+    def __init__(self, in_channels: int, eps: float = 1e-5):
+        super(GraphNorm, self).__init__()
+
+        self.in_channels = in_channels
+        self.eps = eps
+
+        self.weight = torch.nn.Parameter(torch.Tensor(in_channels))
+        self.bias = torch.nn.Parameter(torch.Tensor(in_channels))
+        self.mean_scale = torch.nn.Parameter(torch.Tensor(in_channels))
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        ones(self.weight)
+        zeros(self.bias)
+        ones(self.mean_scale)
+
+    def forward(self, x: Tensor, batch: Optional[Tensor] = None) -> Tensor:
+        """"""
+        if batch is None:
+            batch = x.new_zeros(x.size(0), dtype=torch.long)
+
+        batch_size = int(batch.max()) + 1
+
+        mean = scatter_mean(x, batch, dim=0, dim_size=batch_size)[batch]
+        out = x - mean * self.mean_scale
+        var = scatter_mean(out.pow(2), batch, dim=0, dim_size=batch_size)
+        std = (var + self.eps).sqrt()[batch]
+        return self.weight * out / std + self.bias
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self.in_channels})'

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_PyG_future/license.txt

@@ -0,0 +1,22 @@
+The code in this folder was obtained from "https://github.com/rusty1s/pytorch_geometric", which has the following license:
+
+
+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.

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_pymatgen/__init__.py

@@ -0,0 +1 @@
+from .lattice import find_neighbors, _one_to_three, _compute_cube_index, _three_to_one

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_pymatgen/lattice.py

@@ -0,0 +1,71 @@
+import itertools
+import numpy as np
+
+
+# The following internal methods are used in the get_points_in_sphere method.
+def _compute_cube_index(coords: np.ndarray, global_min: float, radius: float
+                        ) -> np.ndarray:
+    """
+    Compute the cube index from coordinates
+    Args:
+        coords: (nx3 array) atom coordinates
+        global_min: (float) lower boundary of coordinates
+        radius: (float) cutoff radius
+
+    Returns: (nx3 array) int indices
+
+    """
+    return np.array(np.floor((coords - global_min) / radius), dtype=int)
+
+def _three_to_one(label3d: np.ndarray, ny: int, nz: int) -> np.ndarray:
+    """
+    The reverse of _one_to_three
+    """
+    return np.array(label3d[:, 0] * ny * nz +
+                    label3d[:, 1] * nz + label3d[:, 2]).reshape((-1, 1))
+
+def _one_to_three(label1d: np.ndarray, ny: int, nz: int) -> np.ndarray:
+    """
+    Convert a 1D index array to 3D index array
+
+    Args:
+        label1d: (array) 1D index array
+        ny: (int) number of cells in y direction
+        nz: (int) number of cells in z direction
+
+    Returns: (nx3) int array of index
+
+    """
+    last = np.mod(label1d, nz)
+    second = np.mod((label1d - last) / nz, ny)
+    first = (label1d - last - second * nz) / (ny * nz)
+    return np.concatenate([first, second, last], axis=1)
+
+def find_neighbors(label: np.ndarray, nx: int, ny: int, nz: int):
+    """
+    Given a cube index, find the neighbor cube indices
+
+    Args:
+        label: (array) (n,) or (n x 3) indice array
+        nx: (int) number of cells in y direction
+        ny: (int) number of cells in y direction
+        nz: (int) number of cells in z direction
+
+    Returns: neighbor cell indices
+
+    """
+
+    array = [[-1, 0, 1]] * 3
+    neighbor_vectors = np.array(list(itertools.product(*array)),
+                                dtype=int)
+    if np.shape(label)[1] == 1:
+        label3d = _one_to_three(label, ny, nz)
+    else:
+        label3d = label
+    all_labels = label3d[:, None, :] - neighbor_vectors[None, :, :]
+    filtered_labels = []
+    # filter out out-of-bound labels i.e., label < 0
+    for labels in all_labels:
+        ind = (labels[:, 0] < nx) * (labels[:, 1] < ny) * (labels[:, 2] < nz) * np.all(labels > -1e-5, axis=1)
+        filtered_labels.append(labels[ind])
+    return filtered_labels

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_pymatgen/license.txt

@@ -0,0 +1,22 @@
+The code in this folder was obtained from "https://github.com/materialsproject/pymatgen", which has the following license:
+
+
+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.

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_schnetpack/__init__.py

@@ -0,0 +1 @@
+from .acsf import GaussianBasis

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_schnetpack/acsf.py

@@ -0,0 +1,50 @@
+import torch
+from torch import nn
+
+
+def gaussian_smearing(distances, offset, widths, centered=False):
+    if not centered:
+        # compute width of Gaussian functions (using an overlap of 1 STDDEV)
+        coeff = -0.5 / torch.pow(widths, 2)
+        # Use advanced indexing to compute the individual components
+        diff = distances[..., None] - offset
+    else:
+        # if Gaussian functions are centered, use offsets to compute widths
+        coeff = -0.5 / torch.pow(offset, 2)
+        # if Gaussian functions are centered, no offset is subtracted
+        diff = distances[..., None]
+    # compute smear distance values
+    gauss = torch.exp(coeff * torch.pow(diff, 2))
+    return gauss
+
+
+class GaussianBasis(nn.Module):
+    def __init__(
+            self, start=0.0, stop=5.0, n_gaussians=50, centered=False, trainable=False
+    ):
+        super(GaussianBasis, self).__init__()
+        # compute offset and width of Gaussian functions
+        offset = torch.linspace(start, stop, n_gaussians)
+        widths = torch.FloatTensor((offset[1] - offset[0]) * torch.ones_like(offset))
+        if trainable:
+            self.width = nn.Parameter(widths)
+            self.offsets = nn.Parameter(offset)
+        else:
+            self.register_buffer("width", widths)
+            self.register_buffer("offsets", offset)
+        self.centered = centered
+
+    def forward(self, distances):
+        """Compute smeared-gaussian distance values.
+
+        Args:
+            distances (torch.Tensor): interatomic distance values of
+                (N_b x N_at x N_nbh) shape.
+
+        Returns:
+            torch.Tensor: layer output of (N_b x N_at x N_nbh x N_g) shape.
+
+        """
+        return gaussian_smearing(
+            distances, self.offsets, self.width, centered=self.centered
+        )

3_epc/displacements/group_8/reconstruction/aohamiltonian/pred_ham_std/src/deeph/from_schnetpack/license.txt

@@ -0,0 +1,35 @@
+The code in this folder was obtained from "https://github.com/atomistic-machine-learning/schnetpack", which has the following license:
+
+
+COPYRIGHT
+
+Copyright (c) 2018 Kristof Schütt, Michael Gastegger, Pan Kessel, Kim Nicoli
+
+All other contributions:
+Copyright (c) 2018, the respective contributors.
+All rights reserved.
+
+Each contributor holds copyright over their respective contributions.
+The project versioning (Git) records all such contribution source information.
+
+LICENSE
+
+The MIT License
+
+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.

3_epc/displacements/group_8/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

3_epc/displacements/group_8/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

3_epc/displacements/group_8/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

3_epc/displacements/group_8/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

3_epc/displacements/group_8/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)