2020-07-29 19:14:14 +02:00
|
|
|
#!/usr/bin/env python3
|
|
|
|
|
"""
|
|
|
|
|
convert hdf5 output (e.g. from PySCF) to ezfio
|
|
|
|
|
|
|
|
|
|
Usage:
|
2022-06-29 20:20:22 +02:00
|
|
|
qp_convert_h5_to_ezfio [--noqmc] [--rmg] [-o EZFIO_DIR] FILE
|
2020-07-29 19:14:14 +02:00
|
|
|
|
|
|
|
|
Options:
|
|
|
|
|
-o --output=EZFIO_DIR Produced directory
|
|
|
|
|
by default is FILE.ezfio
|
2020-09-01 18:19:09 +02:00
|
|
|
--noqmc don't include basis, cell, etc. for QMCPACK
|
2022-06-29 20:20:22 +02:00
|
|
|
--rmg h5 contains cholesky decomposition informatin, these h5 result from RMG and the pyscf AFQMC converter of QMCPACK.
|
2020-07-29 19:14:14 +02:00
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
from ezfio import ezfio
|
|
|
|
|
import h5py
|
|
|
|
|
import sys
|
|
|
|
|
import numpy as np
|
|
|
|
|
import os
|
|
|
|
|
from docopt import docopt
|
2022-04-15 23:48:32 +02:00
|
|
|
import gzip
|
2020-07-29 19:14:14 +02:00
|
|
|
#fname = sys.argv[1]
|
|
|
|
|
#qph5name = sys.argv[2]
|
2022-09-21 22:47:51 +02:00
|
|
|
def idx2_tri(i,j):
|
|
|
|
|
"""
|
|
|
|
|
for 0-indexed counting
|
|
|
|
|
"""
|
|
|
|
|
p = max(i,j)
|
|
|
|
|
q = min(i,j)
|
|
|
|
|
return q + (p*(p+1))//2
|
|
|
|
|
def idx2_tri_1(i,j):
|
|
|
|
|
"""
|
|
|
|
|
for 1-indexed counting
|
|
|
|
|
"""
|
|
|
|
|
p = max(i,j)
|
|
|
|
|
q = min(i,j)
|
|
|
|
|
return q + (p*(p-1))//2
|
|
|
|
|
|
|
|
|
|
def idx4_cplx_1(i,j,k,l):
|
|
|
|
|
"""
|
|
|
|
|
original function from qp2 (fortran counting)
|
|
|
|
|
"""
|
|
|
|
|
p = idx2_tri_1(i,k)
|
|
|
|
|
q = idx2_tri_1(j,l)
|
|
|
|
|
i1 = idx2_tri_1(p,q)
|
|
|
|
|
return (i1,p,q)
|
2020-07-29 19:14:14 +02:00
|
|
|
|
2022-09-21 22:47:51 +02:00
|
|
|
def ao_idx_map_sign(i,j,k,l):
|
|
|
|
|
"""
|
|
|
|
|
qp2 indexing
|
|
|
|
|
"""
|
|
|
|
|
idx,ik,jl = idx4_cplx_1(i,j,k,l)
|
|
|
|
|
ij = idx2_tri_1(i,j)
|
|
|
|
|
kl = idx2_tri_1(k,l)
|
|
|
|
|
idx = 2*idx - 1
|
|
|
|
|
|
|
|
|
|
if (ij==kl):
|
|
|
|
|
sign = 0.0
|
|
|
|
|
use_map1 = False
|
|
|
|
|
else:
|
|
|
|
|
if ik==jl:
|
|
|
|
|
if i<k:
|
|
|
|
|
sign = 1.0
|
|
|
|
|
use_map1 = True
|
|
|
|
|
else:
|
|
|
|
|
sign = -1.0
|
|
|
|
|
use_map1 = True
|
|
|
|
|
elif i==k:
|
|
|
|
|
if j<l:
|
|
|
|
|
sign = 1.0
|
|
|
|
|
use_map1 = True
|
|
|
|
|
else:
|
|
|
|
|
sign = -1.0
|
|
|
|
|
use_map1 = True
|
|
|
|
|
elif j==l:
|
|
|
|
|
if i<k:
|
|
|
|
|
sign = 1.0
|
|
|
|
|
use_map1 = True
|
|
|
|
|
else:
|
|
|
|
|
sign = -1.0
|
|
|
|
|
use_map1 = True
|
|
|
|
|
elif ((i<k) == (j<l)):
|
|
|
|
|
if i<k:
|
|
|
|
|
sign = 1.0
|
|
|
|
|
use_map1 = True
|
|
|
|
|
else:
|
|
|
|
|
sign = -1.0
|
|
|
|
|
use_map1 = True
|
|
|
|
|
else:
|
|
|
|
|
if ((j<l) == (ik<jl)):
|
|
|
|
|
sign = 1.0
|
|
|
|
|
use_map1 = False
|
|
|
|
|
else:
|
|
|
|
|
sign = -1.0
|
|
|
|
|
use_map1 = False
|
|
|
|
|
return (idx, use_map1, sign)
|
|
|
|
|
def get_ao_int_cplx(i,j,k,l,map1,map2):
|
|
|
|
|
idx,use_m1,sgn = ao_idx_map_sign(i,j,k,l)
|
|
|
|
|
if use_m1:
|
|
|
|
|
tmp_re = map1[idx]
|
|
|
|
|
tmp_im = map1[idx+1]
|
|
|
|
|
tmp_im *= sgn
|
|
|
|
|
else:
|
|
|
|
|
tmp_re = map2[idx]
|
|
|
|
|
if sgn != 0.0:
|
|
|
|
|
tmp_im = map2[idx+1]
|
|
|
|
|
tmp_im *= sgn
|
|
|
|
|
else:
|
|
|
|
|
tmp_im = 0.0
|
|
|
|
|
return tmp_re + 1j*tmp_im
|
2022-08-24 21:19:55 +02:00
|
|
|
def kconserv_p_from_qkk2_mk(qkk2,mk):
|
|
|
|
|
nk, nk2 = qkk2.shape
|
|
|
|
|
assert(nk == nk2)
|
|
|
|
|
kcon_p = np.zeros((nk,nk,nk),dtype=int)
|
|
|
|
|
for i in range(nk):
|
|
|
|
|
for j in range(nk):
|
|
|
|
|
for k in range(nk):
|
|
|
|
|
kcon_p[i,j,k] = qkk2[mk[j],qkk2[k,i]]
|
2022-09-21 22:47:51 +02:00
|
|
|
assert(qkk2[mk[j],qkk2[k,i]] == qkk2[qkk2[j,k],i])
|
2022-08-24 21:19:55 +02:00
|
|
|
return kcon_p
|
|
|
|
|
|
|
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
def get_full_path(file_path):
|
|
|
|
|
file_path = os.path.expanduser(file_path)
|
|
|
|
|
file_path = os.path.expandvars(file_path)
|
|
|
|
|
# file_path = os.path.abspath(file_path)
|
|
|
|
|
return file_path
|
|
|
|
|
|
2022-08-24 21:19:55 +02:00
|
|
|
def make_reim_identity_kblocks(nk,nm,na=None):
|
|
|
|
|
if na is None:
|
|
|
|
|
na = nm
|
|
|
|
|
single_block = np.eye(nm, na, dtype=np.complex128).view(dtype=np.float64).reshape((nm, na, 2))
|
|
|
|
|
kblocks = np.tile(single_block,[nk, 1, 1, 1])
|
|
|
|
|
return kblocks
|
2022-04-15 23:48:32 +02:00
|
|
|
|
2022-08-24 23:39:42 +02:00
|
|
|
def make_reim_identity_block_diag(nk,nm,na=None):
|
|
|
|
|
from scipy.linalg import block_diag
|
|
|
|
|
kblocks = make_reim_identity_kblocks(nk,nm,na).view(dtype=np.complex128).squeeze()
|
|
|
|
|
kblockdiag = block_diag(*kblocks).view(dtype=np.float64).reshape((nk*nm,nk*na,2))
|
|
|
|
|
print(f'kblockdiag.shape = {kblockdiag.shape}')
|
|
|
|
|
return kblockdiag
|
|
|
|
|
|
2022-04-15 23:48:32 +02:00
|
|
|
def flatten(l):
|
|
|
|
|
res = []
|
|
|
|
|
for i in l:
|
|
|
|
|
if hasattr(i, "__iter__") and not isinstance(i, str):
|
|
|
|
|
res.extend(flatten(i))
|
|
|
|
|
else:
|
|
|
|
|
res.append(i)
|
|
|
|
|
return res
|
|
|
|
|
|
|
|
|
|
def save_array_do(ezfioname,subdir,data,chunksize=16384):
|
|
|
|
|
dims = list(reversed(data.shape))
|
|
|
|
|
rank = len(dims)
|
|
|
|
|
flatdata = data.reshape(-1)
|
|
|
|
|
dim_max = 1
|
|
|
|
|
for i in dims:
|
|
|
|
|
dim_max *= i
|
|
|
|
|
with gzip.open(os.path.join(ezfioname,subdir)+'.gz','wb') as f:
|
|
|
|
|
f.write(f'{rank:3d}\n'.encode())
|
|
|
|
|
for d in dims:
|
|
|
|
|
f.write(f'{d:20d} '.encode())
|
|
|
|
|
f.write("\n".encode())
|
|
|
|
|
fmtstring = chunksize*'{:24.15E}\n'
|
|
|
|
|
for i in range(dim_max//chunksize):
|
|
|
|
|
#f.write((chunksize*'{:24.15E}\n').format(*flatdata[i*chunksize:(i+1)*chunksize]).encode())
|
|
|
|
|
#f.write(fmtstring.format(*flatdata[i*chunksize:(i+1)*chunksize]).encode())
|
|
|
|
|
f.write((''.join("%24.15E\n" % xi for xi in flatdata[i*chunksize:(i+1)*chunksize])).encode())
|
2022-04-16 00:06:09 +02:00
|
|
|
print(f'{100.*i/(dim_max//chunksize):7.3f}% complete')
|
2022-04-15 23:48:32 +02:00
|
|
|
rem = dim_max%chunksize
|
|
|
|
|
if rem:
|
|
|
|
|
f.write((rem*'{:24.15E}\n').format(*flatdata[-rem:]).encode())
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
def convert_mol(filename,qph5path):
|
|
|
|
|
ezfio.set_file(filename)
|
|
|
|
|
ezfio.set_nuclei_is_complex(False)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
nucl_num = qph5['nuclei'].attrs['nucl_num']
|
|
|
|
|
ao_num = qph5['ao_basis'].attrs['ao_num']
|
|
|
|
|
mo_num = qph5['mo_basis'].attrs['mo_num']
|
|
|
|
|
elec_alpha_num = qph5['electrons'].attrs['elec_alpha_num']
|
|
|
|
|
elec_beta_num = qph5['electrons'].attrs['elec_beta_num']
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
ezfio.set_nuclei_nucl_num(nucl_num)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
ezfio.set_ao_basis_ao_num(ao_num)
|
|
|
|
|
ezfio.set_mo_basis_mo_num(mo_num)
|
|
|
|
|
ezfio.electrons_elec_alpha_num = elec_alpha_num
|
|
|
|
|
ezfio.electrons_elec_beta_num = elec_beta_num
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
##ao_num = mo_num
|
|
|
|
|
##Important !
|
|
|
|
|
#import math
|
|
|
|
|
#nelec_per_kpt = num_elec // n_kpts
|
|
|
|
|
#nelec_alpha_per_kpt = int(math.ceil(nelec_per_kpt / 2.))
|
|
|
|
|
#nelec_beta_per_kpt = int(math.floor(nelec_per_kpt / 2.))
|
|
|
|
|
#
|
|
|
|
|
#ezfio.electrons_elec_alpha_num = int(nelec_alpha_per_kpt * n_kpts)
|
|
|
|
|
#ezfio.electrons_elec_beta_num = int(nelec_beta_per_kpt * n_kpts)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
#ezfio.electrons_elec_alpha_num = int(math.ceil(num_elec / 2.))
|
|
|
|
|
#ezfio.electrons_elec_beta_num = int(math.floor(num_elec / 2.))
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
#ezfio.set_utils_num_kpts(n_kpts)
|
|
|
|
|
#ezfio.set_integrals_bielec_df_num(n_aux)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
#(old)Important
|
|
|
|
|
#ezfio.set_nuclei_nucl_num(nucl_num)
|
|
|
|
|
#ezfio.set_nuclei_nucl_charge([0.]*nucl_num)
|
|
|
|
|
#ezfio.set_nuclei_nucl_coord( [ [0.], [0.], [0.] ]*nucl_num )
|
|
|
|
|
#ezfio.set_nuclei_nucl_label( ['He'] * nucl_num )
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
nucl_charge=qph5['nuclei/nucl_charge'][()].tolist()
|
|
|
|
|
nucl_coord=qph5['nuclei/nucl_coord'][()].T.tolist()
|
|
|
|
|
nucl_label=qph5['nuclei/nucl_label'][()].tolist()
|
|
|
|
|
nuclear_repulsion = qph5['nuclei'].attrs['nuclear_repulsion']
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
ezfio.set_nuclei_nucl_charge(nucl_charge)
|
|
|
|
|
ezfio.set_nuclei_nucl_coord(nucl_coord)
|
2020-07-30 00:36:28 +02:00
|
|
|
if isinstance(nucl_label[0],bytes):
|
|
|
|
|
nucl_label = list(map(lambda x:x.decode(),nucl_label))
|
2020-07-29 19:14:14 +02:00
|
|
|
ezfio.set_nuclei_nucl_label(nucl_label)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
ezfio.set_nuclei_io_nuclear_repulsion('Read')
|
|
|
|
|
ezfio.set_nuclei_nuclear_repulsion(nuclear_repulsion)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Basis #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
do_pseudo = qph5['pseudo'].attrs['do_pseudo']
|
|
|
|
|
ezfio.set_pseudo_do_pseudo(do_pseudo)
|
|
|
|
|
if (do_pseudo):
|
|
|
|
|
ezfio.set_pseudo_pseudo_lmax(qph5['pseudo'].attrs['pseudo_lmax'])
|
|
|
|
|
ezfio.set_pseudo_pseudo_klocmax(qph5['pseudo'].attrs['pseudo_klocmax'])
|
|
|
|
|
ezfio.set_pseudo_pseudo_kmax(qph5['pseudo'].attrs['pseudo_kmax'])
|
|
|
|
|
ezfio.set_pseudo_nucl_charge_remove(qph5['pseudo/nucl_charge_remove'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_n_k(qph5['pseudo/pseudo_n_k'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_n_kl(qph5['pseudo/pseudo_n_kl'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_v_k(qph5['pseudo/pseudo_v_k'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_v_kl(qph5['pseudo/pseudo_v_kl'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_dz_k(qph5['pseudo/pseudo_dz_k'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_dz_kl(qph5['pseudo/pseudo_dz_kl'][()].tolist())
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Basis #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
#coeftmp = qph5['ao_basis/ao_coef'][()]
|
|
|
|
|
#expotmp = qph5['ao_basis/ao_expo'][()]
|
|
|
|
|
ezfio.set_ao_basis_ao_basis(qph5['ao_basis'].attrs['ao_basis'])
|
|
|
|
|
ezfio.set_ao_basis_ao_nucl(qph5['ao_basis/ao_nucl'][()].tolist())
|
|
|
|
|
ezfio.set_ao_basis_ao_prim_num(qph5['ao_basis/ao_prim_num'][()].tolist())
|
|
|
|
|
ezfio.set_ao_basis_ao_power(qph5['ao_basis/ao_power'][()].tolist())
|
|
|
|
|
ezfio.set_ao_basis_ao_coef(qph5['ao_basis/ao_coef'][()].tolist())
|
|
|
|
|
ezfio.set_ao_basis_ao_expo(qph5['ao_basis/ao_expo'][()].tolist())
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# MO Coef #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
mo_coef = qph5['mo_basis/mo_coef'][()].tolist()
|
|
|
|
|
ezfio.set_mo_basis_mo_coef(mo_coef)
|
|
|
|
|
#maybe fix qp so we don't need this?
|
|
|
|
|
#ezfio.set_mo_basis_mo_coef([[i for i in range(mo_num)] * ao_num])
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
return
|
|
|
|
|
|
2022-08-24 21:19:55 +02:00
|
|
|
def convert_kpts_cd(filename,qph5path,qmcpack=True,is_ao=True):
|
2022-06-29 20:20:22 +02:00
|
|
|
import json
|
2022-08-24 23:39:42 +02:00
|
|
|
from scipy.linalg import block_diag
|
2022-09-21 22:47:51 +02:00
|
|
|
dump_fci, dump_cd = (False, False)
|
|
|
|
|
#dump_fci, dump_cd = (True, False)
|
|
|
|
|
#dump_fci, dump_cd = (False, True)
|
|
|
|
|
#dump_fci2 = True
|
|
|
|
|
dump_fci2 = False
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2022-05-03 18:23:51 +02:00
|
|
|
ezfio.set_file(filename)
|
|
|
|
|
ezfio.set_nuclei_is_complex(True)
|
|
|
|
|
# Dummy atom since AFQMC h5 has no atom information
|
2022-08-24 23:39:42 +02:00
|
|
|
#nucl_num = 1
|
|
|
|
|
#ezfio.set_nuclei_nucl_num(nucl_num)
|
|
|
|
|
#ezfio.set_nuclei_nucl_charge([0.]*nucl_num)
|
|
|
|
|
#ezfio.set_nuclei_nucl_coord( [ [0.], [0.], [0.] ]*nucl_num )
|
|
|
|
|
#ezfio.set_nuclei_nucl_label( ['He'] * nucl_num )
|
2022-05-04 21:14:04 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
2022-08-24 21:19:55 +02:00
|
|
|
kpt_num = qph5['Hamiltonian/KPoints'][()].shape[0]
|
|
|
|
|
ham_dims = qph5['Hamiltonian/dims'][()]
|
|
|
|
|
NMOPerKP = qph5['Hamiltonian/NMOPerKP'][()]
|
|
|
|
|
_, _, kpt_num, orb_num, elec_alpha_num_tot, elec_beta_num_tot, _, nchol_maybe = ham_dims
|
|
|
|
|
|
|
|
|
|
#for now, all kpts must have same number of MOs
|
|
|
|
|
for nmoi in NMOPerKP:
|
|
|
|
|
if nmoi != NMOPerKP[0]:
|
|
|
|
|
print("ERROR: all KPs must have same number of MOs")
|
|
|
|
|
raise ValueError
|
|
|
|
|
|
|
|
|
|
#TODO: fix na, nb in rmg
|
|
|
|
|
assert(elec_alpha_num_tot % kpt_num == 0)
|
|
|
|
|
assert(elec_beta_num_tot % kpt_num == 0)
|
|
|
|
|
elec_alpha_num_per_kpt = elec_alpha_num_tot // kpt_num
|
|
|
|
|
elec_beta_num_per_kpt = elec_beta_num_tot // kpt_num
|
|
|
|
|
#elec_alpha_num_per_kpt = qph5['Hamiltonian']['dims'][4]
|
|
|
|
|
#elec_beta_num_per_kpt = qph5['Hamiltonian']['dims'][5]
|
|
|
|
|
#orb_num = qph5['Hamiltonian']['dims'][3]
|
|
|
|
|
#try:
|
|
|
|
|
# is_ao = json.loads(qph5['metadata'][()].decode("utf-8").replace("'",'"'))['ortho_ao']
|
|
|
|
|
# if is_ao:
|
|
|
|
|
# ao_num = orb_num
|
|
|
|
|
# elif is_ao ==False:
|
|
|
|
|
# mo_num = orb_num
|
|
|
|
|
# else:
|
|
|
|
|
# raise ValueError('Problem with ortho_ao key in metadata')
|
|
|
|
|
#except:
|
|
|
|
|
# raise UnicodeDecodeError('metadata not correctly parsed from HDF5 file')
|
|
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
|
|
|
|
|
ezfio.set_nuclei_kpt_num(kpt_num)
|
|
|
|
|
kpt_pair_num = (kpt_num*kpt_num + kpt_num)//2
|
|
|
|
|
ezfio.set_nuclei_kpt_pair_num(kpt_pair_num)
|
|
|
|
|
# don't multiply nuclei by kpt_num
|
|
|
|
|
# work in k-space, not in equivalent supercell
|
2022-08-24 23:39:42 +02:00
|
|
|
#nucl_num_per_kpt = nucl_num
|
|
|
|
|
#ezfio.set_nuclei_nucl_num(nucl_num_per_kpt)
|
2022-05-04 21:14:04 +02:00
|
|
|
# these are totals (kpt_num * num_per_kpt)
|
|
|
|
|
# need to change if we want to truncate orbital space within pyscf
|
2022-08-24 21:19:55 +02:00
|
|
|
#if is_ao:
|
|
|
|
|
# ao_num = orb_num*kpt_num
|
|
|
|
|
#TODO: fix this?
|
|
|
|
|
ao_num_tot = orb_num
|
|
|
|
|
ao_num_per_kpt = NMOPerKP[0]
|
|
|
|
|
mo_num_tot = orb_num
|
|
|
|
|
mo_num_per_kpt = NMOPerKP[0]
|
|
|
|
|
#mo_num_per_kpt = ao_num_per_kpt
|
|
|
|
|
ezfio.set_ao_basis_ao_num(ao_num_per_kpt * kpt_num)
|
|
|
|
|
ezfio.set_mo_basis_mo_num(mo_num_per_kpt * kpt_num)
|
|
|
|
|
ezfio.set_ao_basis_ao_num_per_kpt(ao_num_per_kpt)
|
|
|
|
|
ezfio.set_mo_basis_mo_num_per_kpt(mo_num_per_kpt)
|
|
|
|
|
ezfio.electrons_elec_alpha_num = elec_alpha_num_per_kpt * kpt_num
|
|
|
|
|
ezfio.electrons_elec_beta_num = elec_beta_num_per_kpt * kpt_num
|
2022-05-04 21:14:04 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Basis #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
|
|
|
|
#TODO
|
2022-08-24 23:39:42 +02:00
|
|
|
nucl_num = 1
|
|
|
|
|
ezfio.set_nuclei_nucl_num(nucl_num)
|
|
|
|
|
ezfio.set_nuclei_nucl_charge([0.]*nucl_num)
|
|
|
|
|
ezfio.set_nuclei_nucl_coord( [ [0.], [0.], [0.] ]*nucl_num )
|
|
|
|
|
ezfio.set_nuclei_nucl_label( ['He'] * nucl_num )
|
|
|
|
|
nucl_num_per_kpt = nucl_num
|
|
|
|
|
ezfio.set_nuclei_nucl_num(nucl_num_per_kpt)
|
|
|
|
|
ezfio.set_nuclei_io_kpt_symm('Read')
|
|
|
|
|
ezfio.set_ao_basis_ao_basis("dummy basis")
|
|
|
|
|
|
|
|
|
|
#nucleus on which each AO is centered
|
|
|
|
|
ao_nucl = [1 for i in range(ao_num_per_kpt)]*kpt_num
|
|
|
|
|
ezfio.set_ao_basis_ao_nucl(ao_nucl)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#Just need one (can clean this up later)
|
|
|
|
|
ao_prim_num_max = 5
|
|
|
|
|
|
|
|
|
|
d = [ [0] *ao_prim_num_max]*ao_num_tot
|
|
|
|
|
ezfio.set_ao_basis_ao_prim_num([ao_prim_num_max]*ao_num_tot)
|
|
|
|
|
ezfio.set_ao_basis_ao_power(d)
|
|
|
|
|
ezfio.set_ao_basis_ao_coef(d)
|
|
|
|
|
ezfio.set_ao_basis_ao_expo(d)
|
2022-05-04 21:14:04 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# MOCoeff #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
|
|
|
|
#TODO
|
2022-08-24 21:19:55 +02:00
|
|
|
#coef_per_kpt = np.eye(mo_num_per_kpt, ao_num_per_kpt, dtype=np.complex128).view(dtype=np.float64).reshape((mo_num_per_kpt, ao_num_per_kpt, 2))
|
|
|
|
|
|
|
|
|
|
#mo_coef_kpts = np.tile(coef_per_kpt,[kpt_num, 1, 1, 1])
|
|
|
|
|
#qph5.create_dataset('mo_basis/mo_coef_kpts',data=make_reim_identity_kblocks(kpt_num, mo_num_per_kpt, ao_num_per_kpt))
|
|
|
|
|
ezfio.set_mo_basis_mo_coef_kpts(make_reim_identity_kblocks(kpt_num, mo_num_per_kpt, ao_num_per_kpt))
|
2022-08-24 23:39:42 +02:00
|
|
|
ezfio.set_mo_basis_mo_coef_complex(make_reim_identity_block_diag(kpt_num, mo_num_per_kpt, ao_num_per_kpt))
|
2022-08-24 21:19:55 +02:00
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Integrals Mono #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-08-24 21:19:55 +02:00
|
|
|
|
|
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
# we don't have separate kinetic, nuc-elec, pseudo 1e ints, so just combine in nuc-elec and set rest to zero
|
|
|
|
|
mono_ints_tot = np.zeros((kpt_num,ao_num_per_kpt,ao_num_per_kpt,2),dtype=np.float64)
|
|
|
|
|
for i in range(kpt_num):
|
|
|
|
|
mono_ints_tot[i] = qph5[f'Hamiltonian/H1_kp{i}'][()]
|
|
|
|
|
ovlp_ao_reim = make_reim_identity_kblocks(kpt_num,ao_num_per_kpt,ao_num_per_kpt)
|
|
|
|
|
kin_ao_reim = np.zeros((kpt_num,ao_num_per_kpt,ao_num_per_kpt,2),dtype=np.float64)
|
|
|
|
|
ne_ao_reim = mono_ints_tot
|
|
|
|
|
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_kinetic_kpts(kin_ao_reim)
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_overlap_kpts(ovlp_ao_reim)
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_n_e_kpts(ne_ao_reim)
|
|
|
|
|
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_kinetic('Read')
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_overlap('Read')
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_n_e('Read')
|
|
|
|
|
|
|
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
"""
|
2022-08-24 21:19:55 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
2022-05-04 21:14:04 +02:00
|
|
|
if is_ao:
|
|
|
|
|
kin_ao_reim=
|
|
|
|
|
ovlp_ao_reim=
|
|
|
|
|
ne_ao_reim=
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_kinetic_kpts(kin_ao_reim)
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_overlap_kpts(ovlp_ao_reim)
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_n_e_kpts(ne_ao_reim)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_kinetic('Read')
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_overlap('Read')
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_n_e('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
else:
|
2022-05-04 21:14:04 +02:00
|
|
|
kin_mo_reim=
|
|
|
|
|
ovlp_mo_reim=
|
|
|
|
|
ne_mo_reim=
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
ezfio.set_mo_one_e_ints_mo_integrals_kinetic_kpts(kin_mo_reim)
|
|
|
|
|
ezfio.set_mo_one_e_ints_mo_integrals_overlap_kpts(ovlp_mo_reim)
|
|
|
|
|
ezfio.set_mo_one_e_ints_mo_integrals_n_e_kpts(ne_mo_reim)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
ezfio.set_mo_one_e_ints_io_mo_integrals_kinetic('Read')
|
|
|
|
|
ezfio.set_mo_one_e_ints_io_mo_integrals_overlap('Read')
|
|
|
|
|
ezfio.set_mo_one_e_ints_io_mo_integrals_n_e('Read')
|
|
|
|
|
"""
|
|
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# k-points #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
#TODO
|
2022-05-04 21:14:04 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
2022-08-24 21:19:55 +02:00
|
|
|
#kconserv = qph5['nuclei/kconserv'][()].tolist()
|
2022-08-24 23:39:42 +02:00
|
|
|
minusk = qph5['Hamiltonian']['MinusK'][:]+1
|
2022-08-24 21:19:55 +02:00
|
|
|
QKTok2 = qph5['Hamiltonian']['QKTok2'][:]+1
|
2022-08-24 23:39:42 +02:00
|
|
|
#TODO: change this after rmg is fixed
|
|
|
|
|
#minusk = QKTok2[:,0]
|
2022-08-24 21:19:55 +02:00
|
|
|
kconserv = kconserv_p_from_qkk2_mk(QKTok2-1,minusk-1)+1
|
2022-05-18 21:17:50 +02:00
|
|
|
unique_kpt_num = len(qph5['Hamiltonian']['KPFactorized'])
|
2022-05-18 22:28:45 +02:00
|
|
|
unique_k_idx = []
|
|
|
|
|
for i in qph5['Hamiltonian']['KPFactorized'].keys():
|
|
|
|
|
unique_k_idx.append(int(i[1:])+1)
|
2022-08-24 23:39:42 +02:00
|
|
|
unique_k_idx.sort()
|
|
|
|
|
kpt_sparse_map = np.zeros(kpt_num,dtype=int)
|
|
|
|
|
isparse=0
|
|
|
|
|
#TODO: make robust: this assumes that for each pair, the one with data has a lower index
|
2022-05-18 22:28:45 +02:00
|
|
|
for i in range(kpt_num):
|
2022-08-24 21:19:55 +02:00
|
|
|
if i+1 in unique_k_idx:
|
2022-08-24 23:39:42 +02:00
|
|
|
kpt_sparse_map[i] = isparse+1
|
|
|
|
|
isparse += 1
|
2022-05-18 22:28:45 +02:00
|
|
|
else:
|
2022-08-24 23:39:42 +02:00
|
|
|
kpt_sparse_map[i] = -kpt_sparse_map[minusk[i]-1]
|
2022-09-21 22:47:51 +02:00
|
|
|
ezfio.set_nuclei_kconserv(kconserv.transpose(2,1,0))
|
2022-05-04 21:14:04 +02:00
|
|
|
ezfio.set_nuclei_io_kconserv('Read')
|
2022-05-18 20:50:03 +02:00
|
|
|
ezfio.set_nuclei_minusk(minusk)
|
2022-09-21 22:47:51 +02:00
|
|
|
ezfio.set_nuclei_qktok2(np.transpose(QKTok2)) #transposed for correct col-major ordering
|
2022-05-18 22:28:45 +02:00
|
|
|
ezfio.set_nuclei_kpt_sparse_map(kpt_sparse_map)
|
2022-05-18 21:11:12 +02:00
|
|
|
ezfio.set_nuclei_unique_kpt_num(unique_kpt_num)
|
2022-05-04 21:14:04 +02:00
|
|
|
# kpt_sparse_map
|
|
|
|
|
# unique_kpt_num
|
2022-05-11 21:35:44 +02:00
|
|
|
# io_kpt_symm
|
2022-05-04 21:14:04 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Integrals Bi #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
# should this be in ao_basis? ao_two_e_ints?
|
2022-06-29 20:20:22 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
2022-08-24 23:39:42 +02:00
|
|
|
nchol_per_kpt_all = qph5['Hamiltonian']['NCholPerKP'][:]
|
|
|
|
|
print(nchol_per_kpt_all)
|
|
|
|
|
#nchol_per_kpt = nchol_per_kpt_all[nchol_per_kpt_all != 0]
|
|
|
|
|
nchol_per_kpt = nchol_per_kpt_all[np.array(unique_k_idx,dtype=int)-1]
|
2022-08-24 21:19:55 +02:00
|
|
|
print(nchol_per_kpt)
|
2022-08-24 23:39:42 +02:00
|
|
|
print(unique_k_idx)
|
|
|
|
|
#for i in range(kpt_num):
|
|
|
|
|
# if i+1 in unique_k_idx:
|
|
|
|
|
# print('* ',i,nchol_per_kpt_all[i])
|
|
|
|
|
# else:
|
|
|
|
|
# print(' ',i,nchol_per_kpt_all[i])
|
|
|
|
|
|
2022-05-04 22:03:11 +02:00
|
|
|
nchol_per_kpt_max = max(nchol_per_kpt)
|
2022-08-24 21:19:55 +02:00
|
|
|
ezfio.set_ao_two_e_ints_chol_num(nchol_per_kpt)
|
|
|
|
|
ezfio.set_ao_two_e_ints_chol_num_max(nchol_per_kpt_max)
|
2022-05-04 21:14:04 +02:00
|
|
|
if is_ao:
|
2022-08-24 21:19:55 +02:00
|
|
|
#ao_num_per_kpt = ao_num//kpt_num
|
|
|
|
|
ezfio.set_ao_two_e_ints_io_chol_ao_integrals('Read')
|
2022-05-04 22:49:05 +02:00
|
|
|
#ao_chol_two_e_ints = np.zeros((2, ao_num_per_kpt, ao_num_per_kpt, nchol_per_kpt_max, kpt_num, len(nchol_per_kpt)))
|
|
|
|
|
L_list = []
|
2022-08-24 23:39:42 +02:00
|
|
|
L_all = np.zeros((unique_kpt_num, kpt_num, ao_num_per_kpt, ao_num_per_kpt, nchol_per_kpt_max,2),dtype=np.float64)
|
|
|
|
|
print(kpt_sparse_map)
|
|
|
|
|
print(np.array(unique_k_idx)-1)
|
|
|
|
|
for i in range(unique_kpt_num):
|
|
|
|
|
ki = unique_k_idx[i]-1
|
|
|
|
|
print(i, ki)
|
|
|
|
|
L_i = qph5[f'Hamiltonian/KPFactorized/L{ki}'][()].reshape((kpt_num, ao_num_per_kpt, ao_num_per_kpt, nchol_per_kpt[kpt_sparse_map[ki]-1], 2))
|
|
|
|
|
#L.reshape(kpt_num, ao_num_per_kpt, ao_num_per_kpt, nchol_per_kpt[i], 2)
|
|
|
|
|
#L = np.einsum("ijklm->ilkjm", A, B)
|
|
|
|
|
L_all[i,:,:,:,:nchol_per_kpt[kpt_sparse_map[ki]-1],:] = L_i
|
2022-05-04 22:49:05 +02:00
|
|
|
|
2022-05-04 22:03:11 +02:00
|
|
|
#(6, 5184, 2)
|
2022-05-04 22:49:05 +02:00
|
|
|
"""
|
2022-05-04 22:03:11 +02:00
|
|
|
for cmplx in range(2):
|
|
|
|
|
for ao_idx_i in range(ao_num_per_kpt):
|
|
|
|
|
for ao_idx_j in range(ao_num_per_kpt):
|
|
|
|
|
for chol_idx in range(nchol_per_kpt[i]):
|
|
|
|
|
for kpt_idx in range(kpt_num):
|
2022-05-04 22:49:05 +02:00
|
|
|
ao_chol_two_e_ints[cmplx][ao_idx_i][ao_idx_j][chol_idx][kpt_idx][i] = L[kpt_idx][ao_idx_i][ao_idx_j][chol_idx][cmplx]
|
|
|
|
|
"""
|
2022-08-24 23:39:42 +02:00
|
|
|
#ao_chol_two_e_ints = np.vstack(L_list)
|
|
|
|
|
#ao_chol_two_e_ints = ao_chol_two_e_ints.transpose()
|
|
|
|
|
#TODO: check dims/reshape/transpose
|
2022-09-21 22:47:51 +02:00
|
|
|
#ezfio.set_ao_two_e_ints_chol_ao_integrals_complex(L_all.transpose((5,2,3,4,1,0)))
|
|
|
|
|
ezfio.set_ao_two_e_ints_chol_ao_integrals_complex(L_all.transpose((0,1,4,3,2,5)))
|
|
|
|
|
|
|
|
|
|
def fortformat(x0):
|
|
|
|
|
x = f'{abs(x0):25.14E}'.strip()
|
|
|
|
|
xsign = '-' if (x0<0) else ''
|
|
|
|
|
e = x.find('E')
|
|
|
|
|
return xsign + f'0.{x[0]}{x[2:e]}{x[e:e+2]}{abs(int(x[e+1:])*1+1):02d}'
|
|
|
|
|
if dump_cd:
|
|
|
|
|
#for qi in range(unique_kpt_num):
|
|
|
|
|
# for ki in range(kpt_num):
|
|
|
|
|
# for i in range(ao_num_per_kpt):
|
|
|
|
|
# for j in range(ao_num_per_kpt):
|
|
|
|
|
# for ci in range(nchol_per_kpt_max):
|
|
|
|
|
# vr = L_all[qi,ki,i,j,ci,0]
|
|
|
|
|
# vi = L_all[qi,ki,i,j,ci,1]
|
|
|
|
|
# print(f'{qi:6d} {ki:6d} {i:6d} {j:6d} {ci:6d} {vr:25.15E} {vi:25.15E}')
|
|
|
|
|
Lnew = L_all.transpose((5,2,3,4,1,0))
|
|
|
|
|
#for qi in range(unique_kpt_num):
|
|
|
|
|
# for ki in range(kpt_num):
|
|
|
|
|
# for ci in range(nchol_per_kpt_max):
|
|
|
|
|
# for j in range(ao_num_per_kpt):
|
|
|
|
|
# for i in range(ao_num_per_kpt):
|
|
|
|
|
# vr = Lnew[0,i,j,ci,ki,qi]
|
|
|
|
|
# vi = Lnew[1,i,j,ci,ki,qi]
|
|
|
|
|
# print(f'{qi:6d} {ki:6d} {ci:6d} {j:6d} {i:6d} {vr:25.15E} {vi:25.15E}')
|
|
|
|
|
for qi in range(unique_kpt_num):
|
|
|
|
|
for ki in range(kpt_num):
|
|
|
|
|
for ci in range(nchol_per_kpt_max):
|
|
|
|
|
for i in range(ao_num_per_kpt):
|
|
|
|
|
for j in range(ao_num_per_kpt):
|
|
|
|
|
#vr = Lnew[0,i,j,ci,ki,qi]
|
|
|
|
|
#vi = Lnew[1,i,j,ci,ki,qi]
|
|
|
|
|
vr = L_all[qi,ki,i,j,ci,0]
|
|
|
|
|
vi = L_all[qi,ki,i,j,ci,1]
|
|
|
|
|
print(f'{qi+1:6d} {ki+1:6d} {ci+1:6d} {i+1:6d} {j+1:6d} {fortformat(vr):>25s} {fortformat(vi):>25s}')
|
|
|
|
|
|
|
|
|
|
if dump_fci:
|
|
|
|
|
Wfull = np.zeros((ao_num_tot, ao_num_tot, ao_num_tot, ao_num_tot), dtype=np.complex128)
|
|
|
|
|
for Qi in range(kpt_num):
|
|
|
|
|
Qloc = abs(kpt_sparse_map[Qi])-1
|
|
|
|
|
Qneg = (kpt_sparse_map[Qi] < 0)
|
|
|
|
|
LQ00 = L_all[Qloc]
|
|
|
|
|
#LQ0a = LQ00.view(dtype=np.complex128)
|
|
|
|
|
#print(f'LQ0a.shape {LQ0a.shape}')
|
|
|
|
|
#LQ0a1 = LQ0a.reshape((kpt_num,ao_num_per_kpt,ao_num_per_kpt,-1))
|
|
|
|
|
#print(f'LQ0a1.shape {LQ0a1.shape}')
|
|
|
|
|
LQ0 = LQ00[:,:,:,:,0] + 1j*LQ00[:,:,:,:,1]
|
|
|
|
|
#print(f'LQ0.shape {LQ0.shape}')
|
|
|
|
|
#print(f'abdiff {np.abs(LQ0a1 - LQ0).max()}')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for kp in range(kpt_num):
|
|
|
|
|
kr = QKTok2[Qi,kp]-1
|
|
|
|
|
for ks in range(kpt_num):
|
|
|
|
|
kq = QKTok2[Qi,ks]-1
|
|
|
|
|
if Qneg:
|
|
|
|
|
A = LQ0[kr].transpose((1,0,2)).conj()
|
|
|
|
|
B = LQ0[kq]
|
|
|
|
|
W = np.einsum('prn,sqn->pqrs',A,B)
|
|
|
|
|
else:
|
|
|
|
|
A = LQ0[kp]
|
|
|
|
|
B = LQ0[ks].transpose((1,0,2)).conj()
|
|
|
|
|
W = np.einsum('rpn,qsn->pqrs',A,B)
|
|
|
|
|
p0 = kp*ao_num_per_kpt
|
|
|
|
|
r0 = kr*ao_num_per_kpt
|
|
|
|
|
q0 = kq*ao_num_per_kpt
|
|
|
|
|
s0 = ks*ao_num_per_kpt
|
|
|
|
|
for ip in range(ao_num_per_kpt):
|
|
|
|
|
for iq in range(ao_num_per_kpt):
|
|
|
|
|
for ir in range(ao_num_per_kpt):
|
|
|
|
|
for i_s in range(ao_num_per_kpt):
|
|
|
|
|
v = W[ip,iq,ir,i_s]
|
|
|
|
|
print(f'{p0+ip:5d} {q0+iq:5d} {r0+ir:5d} {s0+i_s:5d} {v.real:25.15E} {v.imag:25.15E}')
|
|
|
|
|
Wfull[p0:p0+ao_num_per_kpt,q0:q0+ao_num_per_kpt,r0:r0+ao_num_per_kpt,s0:s0+ao_num_per_kpt] = W.copy()
|
|
|
|
|
H1 = np.zeros((ao_num_tot, ao_num_tot), dtype=np.complex128)
|
|
|
|
|
for Qi in range(kpt_num):
|
|
|
|
|
hi0 = qph5[f'Hamiltonian/H1_kp{Qi}'][()]
|
|
|
|
|
hi = hi0[:,:,0] + 1j*hi0[:,:,1]
|
|
|
|
|
H1[Qi*ao_num_per_kpt:(Qi+1)*ao_num_per_kpt,Qi*ao_num_per_kpt:(Qi+1)*ao_num_per_kpt] = hi.copy()
|
|
|
|
|
mo_occ = ([1,]* elec_alpha_num_per_kpt + [0,] * (ao_num_per_kpt - elec_alpha_num_per_kpt)) * kpt_num
|
|
|
|
|
E1=0
|
|
|
|
|
E2j=0
|
|
|
|
|
E2k=0
|
|
|
|
|
for imo, iocc in enumerate(mo_occ):
|
|
|
|
|
if iocc:
|
|
|
|
|
E1 += 2*H1[imo,imo]
|
|
|
|
|
for jmo, jocc in enumerate(mo_occ):
|
|
|
|
|
if jocc:
|
|
|
|
|
E2j += 2* Wfull[imo,jmo,imo,jmo]
|
|
|
|
|
E2k -= Wfull[imo,jmo,jmo,imo]
|
|
|
|
|
print(f'E1 = {E1:25.15E}')
|
|
|
|
|
print(f'E2j = {E2j:25.15E}')
|
|
|
|
|
print(f'E2k = {E2k:25.15E}')
|
|
|
|
|
print(f'E2 = {E2j+E2k:25.15E}')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if dump_fci2:
|
|
|
|
|
ao_map1 = {}
|
|
|
|
|
ao_map2 = {}
|
|
|
|
|
ao_map1_idx = {}
|
|
|
|
|
ao_map2_idx = {}
|
|
|
|
|
Wdict = {}
|
|
|
|
|
for kQ in range(kpt_num):
|
|
|
|
|
for kl in range(kpt_num):
|
|
|
|
|
kj = QKTok2[kQ,kl]-1
|
|
|
|
|
if (kj>kl):
|
|
|
|
|
continue
|
|
|
|
|
kjkl2 = idx2_tri(kj,kl)
|
|
|
|
|
Qneg = (kpt_sparse_map[kQ] < 0)
|
|
|
|
|
Qloc = abs(kpt_sparse_map[kQ]) - 1
|
|
|
|
|
if not Qneg:
|
|
|
|
|
ints_jl0 = L_all[Qloc,kl,:,:,:,:]
|
|
|
|
|
ints_jl = ints_jl0[:,:,:,0]+1j*ints_jl0[:,:,:,1]
|
|
|
|
|
else:
|
|
|
|
|
ints_jl0 = L_all[Qloc,kj,:,:,:,:]
|
|
|
|
|
ints_jl1 = ints_jl0[:,:,:,0]+1j*ints_jl0[:,:,:,1]
|
|
|
|
|
ints_jl = ints_jl1.transpose((1,0,2)).conj()
|
|
|
|
|
for kk in range(kl+1):
|
|
|
|
|
ki = QKTok2[minusk[kk]-1,kQ]-1 #TODO: check
|
|
|
|
|
if ki != kconserv[kl,kk,kj]-1:
|
|
|
|
|
print(ki,kconserv[kl,kk,kj],kl,kk,kj)
|
|
|
|
|
assert( ki == kconserv[kl,kk,kj]-1) #TODO: check
|
|
|
|
|
if (ki > kl):
|
|
|
|
|
continue
|
|
|
|
|
kikk2 = idx2_tri(ki,kk)
|
|
|
|
|
if not Qneg:
|
|
|
|
|
ints_ik0 = L_all[Qloc,ki,:,:,:]
|
|
|
|
|
ints_ik = ints_ik0[:,:,:,0] + 1j*ints_ik0[:,:,:,1]
|
|
|
|
|
else:
|
|
|
|
|
ints_ik0 = L_all[Qloc,kk,:,:,:]
|
|
|
|
|
ints_ik1 = ints_ik0[:,:,:,0]+1j*ints_ik0[:,:,:,1]
|
|
|
|
|
ints_ik = ints_ik1.transpose((1,0,2)).conj()
|
|
|
|
|
ints_jl_flat = ints_jl.reshape((ao_num_per_kpt**2, -1))
|
|
|
|
|
ints_ik_flat = ints_ik.reshape((ao_num_per_kpt**2, -1))
|
|
|
|
|
|
|
|
|
|
ints_ikjl = np.einsum('an,bn->ab',ints_ik_flat,ints_jl_flat).reshape((ao_num_per_kpt,)*4)
|
|
|
|
|
|
|
|
|
|
for il in range(ao_num_per_kpt):
|
|
|
|
|
l = il + kl*ao_num_per_kpt
|
|
|
|
|
for ij in range(ao_num_per_kpt):
|
|
|
|
|
j = ij + kj*ao_num_per_kpt
|
|
|
|
|
if (j>l):
|
|
|
|
|
break
|
|
|
|
|
jl2 = idx2_tri(j,l)
|
|
|
|
|
for ik in range(ao_num_per_kpt):
|
|
|
|
|
k = ik + kk*ao_num_per_kpt
|
|
|
|
|
if (k>l):
|
|
|
|
|
break
|
|
|
|
|
for ii in range(ao_num_per_kpt):
|
|
|
|
|
i = ii + ki*ao_num_per_kpt
|
|
|
|
|
if ((j==l) and (i>k)):
|
|
|
|
|
break
|
|
|
|
|
ik2 = idx2_tri(i,k)
|
|
|
|
|
if (ik2 > jl2):
|
|
|
|
|
break
|
|
|
|
|
integral = ints_ikjl[ii,ik,ij,il]
|
|
|
|
|
if abs(integral) < 1E-15:
|
|
|
|
|
continue
|
|
|
|
|
idx_tmp,use_map1,sign = ao_idx_map_sign(i+1,j+1,k+1,l+1)
|
|
|
|
|
tmp_re = integral.real
|
|
|
|
|
tmp_im = integral.imag
|
|
|
|
|
Wdict[i,j,k,l] = tmp_re + 1j*tmp_im
|
|
|
|
|
if use_map1:
|
|
|
|
|
if idx_tmp in ao_map1:
|
|
|
|
|
print(idx_tmp,1)
|
|
|
|
|
raise
|
|
|
|
|
ao_map1[idx_tmp] = tmp_re
|
|
|
|
|
ao_map1_idx[idx_tmp] = (i,j,k,l,'re')
|
|
|
|
|
if sign != 0.0:
|
|
|
|
|
ao_map1[idx_tmp+1] = tmp_im*sign
|
|
|
|
|
ao_map1_idx[idx_tmp+1] = (i,j,k,l,'im')
|
|
|
|
|
else:
|
|
|
|
|
if idx_tmp in ao_map2:
|
|
|
|
|
print(idx_tmp,2)
|
|
|
|
|
raise
|
|
|
|
|
ao_map2[idx_tmp] = tmp_re
|
|
|
|
|
ao_map2_idx[idx_tmp] = (i,j,k,l,'re')
|
|
|
|
|
if sign != 0.0:
|
|
|
|
|
ao_map2[idx_tmp+1] = tmp_im*sign
|
|
|
|
|
ao_map2_idx[idx_tmp+1] = (i,j,k,l,'im')
|
|
|
|
|
# for idx in ao_map1:
|
|
|
|
|
# i,j,k,l,ax = ao_map1_idx[idx]
|
|
|
|
|
# print(f'1,{idx},{i},{j},{k},{l},{ax},{ao_map1[idx]}')
|
|
|
|
|
# for idx in ao_map2:
|
|
|
|
|
# i,j,k,l,ax = ao_map2_idx[idx]
|
|
|
|
|
# print(f'2,{idx},{i},{j},{k},{l},{ax},{ao_map2[idx]}')
|
|
|
|
|
for idx in Wdict:
|
|
|
|
|
i,j,k,l = idx
|
|
|
|
|
v = Wdict[idx]
|
|
|
|
|
print(f'{i+1:6d} {j+1:6d} {k+1:6d} {l+1:6d} {fortformat(v.real):>25s} {fortformat(v.imag):>25s}')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#for Qi in range(kpt_num):
|
|
|
|
|
# Qloc = abs(kpt_sparse_map[Qi])-1
|
|
|
|
|
# Qneg = (kpt_sparse_map[Qi] < 0)
|
|
|
|
|
# LQ00 = L_all[Qloc]
|
|
|
|
|
# #LQ0a = LQ00.view(dtype=np.complex128)
|
|
|
|
|
# #print(f'LQ0a.shape {LQ0a.shape}')
|
|
|
|
|
# #LQ0a1 = LQ0a.reshape((kpt_num,ao_num_per_kpt,ao_num_per_kpt,-1))
|
|
|
|
|
# #print(f'LQ0a1.shape {LQ0a1.shape}')
|
|
|
|
|
# LQ0 = LQ00[:,:,:,:,0] + 1j*LQ00[:,:,:,:,1]
|
|
|
|
|
# #print(f'LQ0.shape {LQ0.shape}')
|
|
|
|
|
# #print(f'abdiff {np.abs(LQ0a1 - LQ0).max()}')
|
|
|
|
|
|
|
|
|
|
#
|
|
|
|
|
|
|
|
|
|
# for kp in range(kpt_num):
|
|
|
|
|
# kr = QKTok2[Qi,kp]-1
|
|
|
|
|
# for ks in range(kpt_num):
|
|
|
|
|
# kq = QKTok2[Qi,ks]-1
|
|
|
|
|
# if Qneg:
|
|
|
|
|
# A = LQ0[kr].transpose((1,0,2)).conj()
|
|
|
|
|
# B = LQ0[kq]
|
|
|
|
|
# W = np.einsum('prn,sqn->pqrs',A,B)
|
|
|
|
|
# else:
|
|
|
|
|
# A = LQ0[kp]
|
|
|
|
|
# B = LQ0[ks].transpose((1,0,2)).conj()
|
|
|
|
|
# W = np.einsum('rpn,qsn->pqrs',A,B)
|
|
|
|
|
# p0 = kp*ao_num_per_kpt
|
|
|
|
|
# r0 = kr*ao_num_per_kpt
|
|
|
|
|
# q0 = kq*ao_num_per_kpt
|
|
|
|
|
# s0 = ks*ao_num_per_kpt
|
|
|
|
|
# for ip in range(ao_num_per_kpt):
|
|
|
|
|
# for iq in range(ao_num_per_kpt):
|
|
|
|
|
# for ir in range(ao_num_per_kpt):
|
|
|
|
|
# for i_s in range(ao_num_per_kpt):
|
|
|
|
|
# v = W[ip,iq,ir,i_s]
|
|
|
|
|
# print(f'{p0+ip:5d} {q0+iq:5d} {r0+ir:5d} {s0+i_s:5d} {v.real:25.15E} {v.imag:25.15E}')
|
|
|
|
|
# Wfull[p0:p0+ao_num_per_kpt,q0:q0+ao_num_per_kpt,r0:r0+ao_num_per_kpt,s0:s0+ao_num_per_kpt] = W.copy()
|
|
|
|
|
#H1 = np.zeros((ao_num_tot, ao_num_tot), dtype=np.complex128)
|
|
|
|
|
#for Qi in range(kpt_num):
|
|
|
|
|
# hi0 = qph5[f'Hamiltonian/H1_kp{Qi}'][()]
|
|
|
|
|
# hi = hi0[:,:,0] + 1j*hi0[:,:,1]
|
|
|
|
|
# H1[Qi*ao_num_per_kpt:(Qi+1)*ao_num_per_kpt,Qi*ao_num_per_kpt:(Qi+1)*ao_num_per_kpt] = hi.copy()
|
|
|
|
|
#mo_occ = ([1,]* elec_alpha_num_per_kpt + [0,] * (ao_num_per_kpt - elec_alpha_num_per_kpt)) * kpt_num
|
|
|
|
|
#E1=0
|
|
|
|
|
#E2j=0
|
|
|
|
|
#E2k=0
|
|
|
|
|
#for imo, iocc in enumerate(mo_occ):
|
|
|
|
|
# if iocc:
|
|
|
|
|
# E1 += 2*H1[imo,imo]
|
|
|
|
|
# for jmo, jocc in enumerate(mo_occ):
|
|
|
|
|
# if jocc:
|
|
|
|
|
# E2j += 2* Wfull[imo,jmo,imo,jmo]
|
|
|
|
|
# E2k -= Wfull[imo,jmo,jmo,imo]
|
|
|
|
|
#print(f'E1 = {E1:25.15E}')
|
|
|
|
|
#print(f'E2j = {E2j:25.15E}')
|
|
|
|
|
#print(f'E2k = {E2k:25.15E}')
|
|
|
|
|
#print(f'E2 = {E2j+E2k:25.15E}')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-05-04 22:03:11 +02:00
|
|
|
|
|
|
|
|
#(2,ao_basis.ao_num_per_kpt,ao_basis.ao_num_per_kpt,ao_two_e_ints.chol_num_max,nuclei.kpt_num,nuclei.unique_kpt_num#)
|
2022-05-04 21:14:04 +02:00
|
|
|
"""
|
|
|
|
|
df_num = qph5['ao_two_e_ints'].attrs['df_num']
|
|
|
|
|
ezfio.set_ao_two_e_ints_df_num(df_num)
|
|
|
|
|
if 'df_ao_integrals' in qph5['ao_two_e_ints'].keys():
|
|
|
|
|
dfao_reim=qph5['ao_two_e_ints/df_ao_integrals'][()].tolist()
|
|
|
|
|
ezfio.set_ao_two_e_ints_df_ao_integrals_complex(dfao_reim)
|
|
|
|
|
ezfio.set_ao_two_e_ints_io_df_ao_integrals('Read')
|
|
|
|
|
"""
|
|
|
|
|
else:
|
|
|
|
|
"""
|
|
|
|
|
ezfio.set_io_chol_mo_integrals('Read')
|
|
|
|
|
df_num = qph5['ao_two_e_ints'].attrs['df_num']
|
|
|
|
|
ezfio.set_ao_two_e_ints_df_num(df_num)
|
|
|
|
|
dfmo_reim=qph5['mo_two_e_ints/df_mo_integrals'][()].tolist()
|
|
|
|
|
ezfio.set_mo_two_e_ints_df_mo_integrals_complex(dfmo_reim)
|
|
|
|
|
ezfio.set_mo_two_e_ints_io_df_mo_integrals('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
"""
|
2022-08-24 21:19:55 +02:00
|
|
|
#mo_num_per_kpt = ao_num//kpt_num
|
2022-05-11 21:35:44 +02:00
|
|
|
ezfio.set_io_chol_mo_integrals('Read')
|
|
|
|
|
#ao_chol_two_e_ints = np.zeros((2, ao_num_per_kpt, ao_num_per_kpt, nchol_per_kpt_max, kpt_num, len(nchol_per_kpt)))
|
|
|
|
|
L_list = []
|
|
|
|
|
for i in len(nchol_per_kpt):
|
|
|
|
|
L = qph5['Hamiltonian']['KPFactorized'][f'L{i}'][:]
|
|
|
|
|
L.reshape(kpt_num, mo_num_per_kpt, mo_num_per_kpt, nchol_per_kpt[i], 2)
|
|
|
|
|
L = np.einsum("ijklm->ilkjm", A, B)
|
|
|
|
|
L_list.append(L)
|
|
|
|
|
|
|
|
|
|
#(6, 5184, 2)
|
|
|
|
|
"""
|
|
|
|
|
for cmplx in range(2):
|
|
|
|
|
for ao_idx_i in range(ao_num_per_kpt):
|
|
|
|
|
for ao_idx_j in range(ao_num_per_kpt):
|
|
|
|
|
for chol_idx in range(nchol_per_kpt[i]):
|
|
|
|
|
for kpt_idx in range(kpt_num):
|
|
|
|
|
ao_chol_two_e_ints[cmplx][ao_idx_i][ao_idx_j][chol_idx][kpt_idx][i] = L[kpt_idx][ao_idx_i][ao_idx_j][chol_idx][cmplx]
|
|
|
|
|
"""
|
|
|
|
|
mo_chol_two_e_ints = np.vstack(L_list)
|
|
|
|
|
mo_chol_two_e_ints = mo_chol_two_e_ints.transpose()
|
|
|
|
|
ezfio.set_chol_mo_integrals_complex(mo_chol_two_e_ints)
|
|
|
|
|
return
|
|
|
|
|
|
2022-05-04 21:14:04 +02:00
|
|
|
|
|
|
|
|
|
2022-05-03 18:23:51 +02:00
|
|
|
|
2020-09-01 18:19:09 +02:00
|
|
|
def convert_kpts(filename,qph5path,qmcpack=True):
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_file(filename)
|
|
|
|
|
ezfio.set_nuclei_is_complex(True)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
kpt_num = qph5['nuclei'].attrs['kpt_num']
|
|
|
|
|
nucl_num = qph5['nuclei'].attrs['nucl_num']
|
|
|
|
|
ao_num = qph5['ao_basis'].attrs['ao_num']
|
|
|
|
|
mo_num = qph5['mo_basis'].attrs['mo_num']
|
|
|
|
|
elec_alpha_num = qph5['electrons'].attrs['elec_alpha_num']
|
|
|
|
|
elec_beta_num = qph5['electrons'].attrs['elec_beta_num']
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_kpt_num(kpt_num)
|
|
|
|
|
kpt_pair_num = (kpt_num*kpt_num + kpt_num)//2
|
|
|
|
|
ezfio.set_nuclei_kpt_pair_num(kpt_pair_num)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
# don't multiply nuclei by kpt_num
|
|
|
|
|
# work in k-space, not in equivalent supercell
|
2022-05-11 21:35:44 +02:00
|
|
|
nucl_num_per_kpt = nucl_num
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_nucl_num(nucl_num_per_kpt)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
# these are totals (kpt_num * num_per_kpt)
|
|
|
|
|
# need to change if we want to truncate orbital space within pyscf
|
|
|
|
|
ezfio.set_ao_basis_ao_num(ao_num)
|
|
|
|
|
ezfio.set_mo_basis_mo_num(mo_num)
|
|
|
|
|
ezfio.set_ao_basis_ao_num_per_kpt(ao_num//kpt_num)
|
|
|
|
|
ezfio.set_mo_basis_mo_num_per_kpt(mo_num//kpt_num)
|
|
|
|
|
ezfio.electrons_elec_alpha_num = elec_alpha_num
|
|
|
|
|
ezfio.electrons_elec_beta_num = elec_beta_num
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##ao_num = mo_num
|
|
|
|
|
##Important !
|
|
|
|
|
#import math
|
|
|
|
|
#nelec_per_kpt = num_elec // n_kpts
|
|
|
|
|
#nelec_alpha_per_kpt = int(math.ceil(nelec_per_kpt / 2.))
|
|
|
|
|
#nelec_beta_per_kpt = int(math.floor(nelec_per_kpt / 2.))
|
|
|
|
|
#
|
|
|
|
|
#ezfio.electrons_elec_alpha_num = int(nelec_alpha_per_kpt * n_kpts)
|
|
|
|
|
#ezfio.electrons_elec_beta_num = int(nelec_beta_per_kpt * n_kpts)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
#ezfio.electrons_elec_alpha_num = int(math.ceil(num_elec / 2.))
|
|
|
|
|
#ezfio.electrons_elec_beta_num = int(math.floor(num_elec / 2.))
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
#ezfio.set_utils_num_kpts(n_kpts)
|
|
|
|
|
#ezfio.set_integrals_bielec_df_num(n_aux)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
#(old)Important
|
|
|
|
|
#ezfio.set_nuclei_nucl_num(nucl_num)
|
|
|
|
|
#ezfio.set_nuclei_nucl_charge([0.]*nucl_num)
|
|
|
|
|
#ezfio.set_nuclei_nucl_coord( [ [0.], [0.], [0.] ]*nucl_num )
|
|
|
|
|
#ezfio.set_nuclei_nucl_label( ['He'] * nucl_num )
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
nucl_charge=qph5['nuclei/nucl_charge'][()].tolist()
|
|
|
|
|
nucl_coord=qph5['nuclei/nucl_coord'][()].T.tolist()
|
|
|
|
|
nucl_label=qph5['nuclei/nucl_label'][()].tolist()
|
|
|
|
|
nuclear_repulsion = qph5['nuclei'].attrs['nuclear_repulsion']
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_nucl_charge(nucl_charge)
|
|
|
|
|
ezfio.set_nuclei_nucl_coord(nucl_coord)
|
|
|
|
|
if isinstance(nucl_label[0],bytes):
|
|
|
|
|
nucl_label = list(map(lambda x:x.decode(),nucl_label))
|
|
|
|
|
ezfio.set_nuclei_nucl_label(nucl_label)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_io_nuclear_repulsion('Read')
|
|
|
|
|
ezfio.set_nuclei_nuclear_repulsion(nuclear_repulsion)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
2020-09-01 17:13:04 +02:00
|
|
|
# Basis(Dummy) #
|
2020-07-29 21:07:03 +02:00
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-09-01 17:13:04 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
ezfio.set_ao_basis_ao_basis(qph5['ao_basis'].attrs['ao_basis'])
|
|
|
|
|
ezfio.set_ao_basis_ao_nucl(qph5['ao_basis/ao_nucl'][()].tolist())
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
#Just need one (can clean this up later)
|
2020-09-01 17:13:04 +02:00
|
|
|
ao_prim_num_max = 5
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-09-01 17:13:04 +02:00
|
|
|
d = [ [0] *ao_prim_num_max]*ao_num
|
|
|
|
|
ezfio.set_ao_basis_ao_prim_num([ao_prim_num_max]*ao_num)
|
|
|
|
|
ezfio.set_ao_basis_ao_power(d)
|
|
|
|
|
ezfio.set_ao_basis_ao_coef(d)
|
|
|
|
|
ezfio.set_ao_basis_ao_expo(d)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-09-01 17:13:04 +02:00
|
|
|
###########################################
|
|
|
|
|
## #
|
|
|
|
|
## Pseudo #
|
|
|
|
|
## #
|
|
|
|
|
###########################################
|
|
|
|
|
|
|
|
|
|
#with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
# do_pseudo = qph5['pseudo'].attrs['do_pseudo']
|
|
|
|
|
# ezfio.set_pseudo_do_pseudo(do_pseudo)
|
|
|
|
|
# if (do_pseudo):
|
|
|
|
|
# ezfio.set_pseudo_pseudo_lmax(qph5['pseudo'].attrs['pseudo_lmax'])
|
|
|
|
|
# ezfio.set_pseudo_pseudo_klocmax(qph5['pseudo'].attrs['pseudo_klocmax'])
|
|
|
|
|
# ezfio.set_pseudo_pseudo_kmax(qph5['pseudo'].attrs['pseudo_kmax'])
|
|
|
|
|
# ezfio.set_pseudo_nucl_charge_remove(qph5['pseudo/nucl_charge_remove'][()].tolist())
|
|
|
|
|
# ezfio.set_pseudo_pseudo_n_k(qph5['pseudo/pseudo_n_k'][()].tolist())
|
|
|
|
|
# ezfio.set_pseudo_pseudo_n_kl(qph5['pseudo/pseudo_n_kl'][()].tolist())
|
|
|
|
|
# ezfio.set_pseudo_pseudo_v_k(qph5['pseudo/pseudo_v_k'][()].tolist())
|
|
|
|
|
# ezfio.set_pseudo_pseudo_v_kl(qph5['pseudo/pseudo_v_kl'][()].tolist())
|
|
|
|
|
# ezfio.set_pseudo_pseudo_dz_k(qph5['pseudo/pseudo_dz_k'][()].tolist())
|
|
|
|
|
# ezfio.set_pseudo_pseudo_dz_kl(qph5['pseudo/pseudo_dz_kl'][()].tolist())
|
|
|
|
|
|
2020-08-28 21:13:09 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
2020-09-01 17:13:04 +02:00
|
|
|
# Basis(Dummy) #
|
2020-08-28 21:13:09 +02:00
|
|
|
# #
|
|
|
|
|
##########################################
|
|
|
|
|
|
2020-09-01 17:13:04 +02:00
|
|
|
#with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
# coeftmp = qph5['ao_basis/ao_coef'][()]
|
|
|
|
|
# expotmp = qph5['ao_basis/ao_expo'][()]
|
|
|
|
|
# ezfio.set_ao_basis_ao_basis(qph5['ao_basis'].attrs['ao_basis'])
|
|
|
|
|
# ezfio.set_ao_basis_ao_nucl(qph5['ao_basis/ao_nucl'][()].tolist())
|
|
|
|
|
# ezfio.set_ao_basis_ao_prim_num(qph5['ao_basis/ao_prim_num'][()].tolist())
|
|
|
|
|
# ezfio.set_ao_basis_ao_power(qph5['ao_basis/ao_power'][()].tolist())
|
|
|
|
|
# ezfio.set_ao_basis_ao_coef(qph5['ao_basis/ao_coef'][()].tolist())
|
|
|
|
|
# ezfio.set_ao_basis_ao_expo(qph5['ao_basis/ao_expo'][()].tolist())
|
2020-08-28 21:13:09 +02:00
|
|
|
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-09-01 17:13:04 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Basis(QMC) #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2020-08-28 21:13:09 +02:00
|
|
|
|
2020-09-01 17:13:04 +02:00
|
|
|
if qmcpack:
|
2020-09-01 18:19:09 +02:00
|
|
|
try:
|
|
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
ezfio.set_qmcpack_qmc_nshell(qph5['qmcpack'].attrs['qmc_nshell'])
|
|
|
|
|
ezfio.set_qmcpack_qmc_prim_num_max(qph5['qmcpack'].attrs['qmc_prim_num_max'])
|
|
|
|
|
ezfio.set_qmcpack_qmc_nucl(qph5['qmcpack/qmc_nucl'][()].tolist())
|
|
|
|
|
ezfio.set_qmcpack_qmc_prim_num(qph5['qmcpack/qmc_prim_num'][()].tolist())
|
|
|
|
|
ezfio.set_qmcpack_qmc_lbas(qph5['qmcpack/qmc_lbas'][()].tolist())
|
|
|
|
|
ezfio.set_qmcpack_qmc_coef(qph5['qmcpack/qmc_coef'][()].tolist())
|
|
|
|
|
ezfio.set_qmcpack_qmc_expo(qph5['qmcpack/qmc_expo'][()].tolist())
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-09-01 18:19:09 +02:00
|
|
|
ezfio.set_qmcpack_qmc_pbc(qph5['qmcpack'].attrs['PBC'])
|
2020-09-15 22:45:45 +02:00
|
|
|
ezfio.set_qmcpack_qmc_cart(qph5['qmcpack'].attrs['cart'])
|
2020-10-19 20:26:16 +02:00
|
|
|
ezfio.set_qmcpack_qmc_pseudo(qph5['qmcpack'].attrs['Pseudo'])
|
2020-09-01 18:19:09 +02:00
|
|
|
ezfio.set_qmcpack_supertwist(qph5['qmcpack/Super_Twist'][()].tolist())
|
|
|
|
|
ezfio.set_qmcpack_latticevectors(qph5['qmcpack/LatticeVectors'][()].tolist())
|
2020-10-19 20:26:16 +02:00
|
|
|
ezfio.set_qmcpack_qmc_phase(qph5['qmcpack/qmc_phase'][()].tolist())
|
2020-09-01 18:19:09 +02:00
|
|
|
ezfio.set_qmcpack_qmc_mo_energy(qph5['qmcpack/eigenval'][()].tolist())
|
2020-10-19 20:26:16 +02:00
|
|
|
|
2020-09-01 18:19:09 +02:00
|
|
|
except AttributeError as err:
|
|
|
|
|
print("################################################")
|
|
|
|
|
print("# ERROR: problem copying QMCPACK data to ezfio #")
|
|
|
|
|
print("# make sure qmcpack plugin is built #")
|
|
|
|
|
print("################################################")
|
|
|
|
|
#print(f"AttributeError: {err}")
|
|
|
|
|
print("to create ezfio without qmcpack data, use 'qp_convert_h5_to_ezfio --noqmc'")
|
|
|
|
|
raise
|
2020-08-28 21:13:09 +02:00
|
|
|
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# MO Coef #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
mo_coef_kpts = qph5['mo_basis/mo_coef_kpts'][()].tolist()
|
|
|
|
|
mo_coef_cplx = qph5['mo_basis/mo_coef_complex'][()].tolist()
|
|
|
|
|
ezfio.set_mo_basis_mo_coef_kpts(mo_coef_kpts)
|
|
|
|
|
ezfio.set_mo_basis_mo_coef_complex(mo_coef_cplx)
|
|
|
|
|
#maybe fix qp so we don't need this?
|
|
|
|
|
#ezfio.set_mo_basis_mo_coef([[i for i in range(mo_num)] * ao_num])
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Integrals Mono #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
if 'ao_one_e_ints' in qph5.keys():
|
|
|
|
|
kin_ao_reim=qph5['ao_one_e_ints/ao_integrals_kinetic_kpts'][()].tolist()
|
|
|
|
|
ovlp_ao_reim=qph5['ao_one_e_ints/ao_integrals_overlap_kpts'][()].tolist()
|
|
|
|
|
ne_ao_reim=qph5['ao_one_e_ints/ao_integrals_n_e_kpts'][()].tolist()
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_kinetic_kpts(kin_ao_reim)
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_overlap_kpts(ovlp_ao_reim)
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_n_e_kpts(ne_ao_reim)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_kinetic('Read')
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_overlap('Read')
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_n_e('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
if 'mo_one_e_ints' in qph5.keys():
|
|
|
|
|
kin_mo_reim=qph5['mo_one_e_ints/mo_integrals_kinetic_kpts'][()].tolist()
|
|
|
|
|
ovlp_mo_reim=qph5['mo_one_e_ints/mo_integrals_overlap_kpts'][()].tolist()
|
|
|
|
|
ne_mo_reim=qph5['mo_one_e_ints/mo_integrals_n_e_kpts'][()].tolist()
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_mo_one_e_ints_mo_integrals_kinetic_kpts(kin_mo_reim)
|
|
|
|
|
ezfio.set_mo_one_e_ints_mo_integrals_overlap_kpts(ovlp_mo_reim)
|
|
|
|
|
#ezfio.set_mo_one_e_ints_mo_integrals_n_e_complex(ne_mo_reim)
|
|
|
|
|
ezfio.set_mo_one_e_ints_mo_integrals_n_e_kpts(ne_mo_reim)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_mo_one_e_ints_io_mo_integrals_kinetic('Read')
|
|
|
|
|
ezfio.set_mo_one_e_ints_io_mo_integrals_overlap('Read')
|
|
|
|
|
#ezfio.set_mo_one_e_ints_io_mo_integrals_n_e('Read')
|
|
|
|
|
ezfio.set_mo_one_e_ints_io_mo_integrals_n_e('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# k-points #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
kconserv = qph5['nuclei/kconserv'][()].tolist()
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_kconserv(kconserv)
|
|
|
|
|
ezfio.set_nuclei_io_kconserv('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Integrals Bi #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
# should this be in ao_basis? ao_two_e_ints?
|
|
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
if 'ao_two_e_ints' in qph5.keys():
|
|
|
|
|
df_num = qph5['ao_two_e_ints'].attrs['df_num']
|
|
|
|
|
ezfio.set_ao_two_e_ints_df_num(df_num)
|
|
|
|
|
if 'df_ao_integrals' in qph5['ao_two_e_ints'].keys():
|
|
|
|
|
# dfao_re0=qph5['ao_two_e_ints/df_ao_integrals_real'][()].transpose((3,2,1,0))
|
|
|
|
|
# dfao_im0=qph5['ao_two_e_ints/df_ao_integrals_imag'][()].transpose((3,2,1,0))
|
|
|
|
|
# dfao_cmplx0 = np.stack((dfao_re0,dfao_im0),axis=-1).tolist()
|
|
|
|
|
# ezfio.set_ao_two_e_ints_df_ao_integrals_complex(dfao_cmplx0)
|
2022-04-15 02:02:48 +02:00
|
|
|
#dfao_reim=qph5['ao_two_e_ints/df_ao_integrals'][()].tolist()
|
|
|
|
|
dfao_reim=qph5['ao_two_e_ints/df_ao_integrals'][()]
|
2022-04-15 23:48:32 +02:00
|
|
|
save_array_do(filename,'ao_two_e_ints/df_ao_integrals_complex',dfao_reim)
|
|
|
|
|
#ezfio.set_ao_two_e_ints_df_ao_integrals_complex(dfao_reim)
|
|
|
|
|
#dfao_dims = list(reversed(dfao_reim.shape))
|
|
|
|
|
#test_write_df_ao(,5,dfao_dims,dfao_reim.size,dfao_reim.ravel())
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_ao_two_e_ints_io_df_ao_integrals('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
if 'mo_two_e_ints' in qph5.keys():
|
|
|
|
|
df_num = qph5['ao_two_e_ints'].attrs['df_num']
|
|
|
|
|
ezfio.set_ao_two_e_ints_df_num(df_num)
|
|
|
|
|
# dfmo_re0=qph5['mo_two_e_ints/df_mo_integrals_real'][()].transpose((3,2,1,0))
|
|
|
|
|
# dfmo_im0=qph5['mo_two_e_ints/df_mo_integrals_imag'][()].transpose((3,2,1,0))
|
|
|
|
|
# dfmo_cmplx0 = np.stack((dfmo_re0,dfmo_im0),axis=-1).tolist()
|
|
|
|
|
# ezfio.set_mo_two_e_ints_df_mo_integrals_complex(dfmo_cmplx0)
|
|
|
|
|
dfmo_reim=qph5['mo_two_e_ints/df_mo_integrals'][()].tolist()
|
|
|
|
|
ezfio.set_mo_two_e_ints_df_mo_integrals_complex(dfmo_reim)
|
|
|
|
|
ezfio.set_mo_two_e_ints_io_df_mo_integrals('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
return
|
|
|
|
|
|
|
|
|
|
def convert_cplx(filename,qph5path):
|
|
|
|
|
ezfio.set_file(filename)
|
|
|
|
|
ezfio.set_nuclei_is_complex(True)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
kpt_num = qph5['nuclei'].attrs['kpt_num']
|
|
|
|
|
nucl_num = qph5['nuclei'].attrs['nucl_num']
|
|
|
|
|
ao_num = qph5['ao_basis'].attrs['ao_num']
|
|
|
|
|
mo_num = qph5['mo_basis'].attrs['mo_num']
|
|
|
|
|
elec_alpha_num = qph5['electrons'].attrs['elec_alpha_num']
|
|
|
|
|
elec_beta_num = qph5['electrons'].attrs['elec_beta_num']
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_kpt_num(kpt_num)
|
|
|
|
|
kpt_pair_num = (kpt_num*kpt_num + kpt_num)//2
|
|
|
|
|
ezfio.set_nuclei_kpt_pair_num(kpt_pair_num)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
# don't multiply nuclei by kpt_num
|
|
|
|
|
# work in k-space, not in equivalent supercell
|
2022-05-11 21:35:44 +02:00
|
|
|
nucl_num_per_kpt = nucl_num
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_nucl_num(nucl_num_per_kpt)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
# these are totals (kpt_num * num_per_kpt)
|
|
|
|
|
# need to change if we want to truncate orbital space within pyscf
|
|
|
|
|
ezfio.set_ao_basis_ao_num(ao_num)
|
|
|
|
|
ezfio.set_mo_basis_mo_num(mo_num)
|
|
|
|
|
ezfio.electrons_elec_alpha_num = elec_alpha_num
|
|
|
|
|
ezfio.electrons_elec_beta_num = elec_beta_num
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##ao_num = mo_num
|
|
|
|
|
##Important !
|
|
|
|
|
#import math
|
|
|
|
|
#nelec_per_kpt = num_elec // n_kpts
|
|
|
|
|
#nelec_alpha_per_kpt = int(math.ceil(nelec_per_kpt / 2.))
|
|
|
|
|
#nelec_beta_per_kpt = int(math.floor(nelec_per_kpt / 2.))
|
|
|
|
|
#
|
|
|
|
|
#ezfio.electrons_elec_alpha_num = int(nelec_alpha_per_kpt * n_kpts)
|
|
|
|
|
#ezfio.electrons_elec_beta_num = int(nelec_beta_per_kpt * n_kpts)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
#ezfio.electrons_elec_alpha_num = int(math.ceil(num_elec / 2.))
|
|
|
|
|
#ezfio.electrons_elec_beta_num = int(math.floor(num_elec / 2.))
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
#ezfio.set_utils_num_kpts(n_kpts)
|
|
|
|
|
#ezfio.set_integrals_bielec_df_num(n_aux)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
#(old)Important
|
|
|
|
|
#ezfio.set_nuclei_nucl_num(nucl_num)
|
|
|
|
|
#ezfio.set_nuclei_nucl_charge([0.]*nucl_num)
|
|
|
|
|
#ezfio.set_nuclei_nucl_coord( [ [0.], [0.], [0.] ]*nucl_num )
|
|
|
|
|
#ezfio.set_nuclei_nucl_label( ['He'] * nucl_num )
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
nucl_charge=qph5['nuclei/nucl_charge'][()].tolist()
|
|
|
|
|
nucl_coord=qph5['nuclei/nucl_coord'][()].T.tolist()
|
|
|
|
|
nucl_label=qph5['nuclei/nucl_label'][()].tolist()
|
|
|
|
|
nuclear_repulsion = qph5['nuclei'].attrs['nuclear_repulsion']
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_nucl_charge(nucl_charge)
|
|
|
|
|
ezfio.set_nuclei_nucl_coord(nucl_coord)
|
|
|
|
|
if isinstance(nucl_label[0],bytes):
|
|
|
|
|
nucl_label = list(map(lambda x:x.decode(),nucl_label))
|
|
|
|
|
ezfio.set_nuclei_nucl_label(nucl_label)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_io_nuclear_repulsion('Read')
|
|
|
|
|
ezfio.set_nuclei_nuclear_repulsion(nuclear_repulsion)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Basis #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-08-28 21:13:09 +02:00
|
|
|
# with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
# ezfio.set_ao_basis_ao_basis(qph5['ao_basis'].attrs['ao_basis'])
|
|
|
|
|
# ezfio.set_ao_basis_ao_nucl(qph5['ao_basis/ao_nucl'][()].tolist())
|
2022-05-11 21:35:44 +02:00
|
|
|
#
|
|
|
|
|
#
|
2020-08-28 21:13:09 +02:00
|
|
|
# #Just need one (can clean this up later)
|
|
|
|
|
# ao_prim_num_max = 5
|
2022-05-11 21:35:44 +02:00
|
|
|
#
|
2020-08-28 21:13:09 +02:00
|
|
|
# d = [ [0] *ao_prim_num_max]*ao_num
|
|
|
|
|
# ezfio.set_ao_basis_ao_prim_num([ao_prim_num_max]*ao_num)
|
|
|
|
|
# ezfio.set_ao_basis_ao_power(d)
|
|
|
|
|
# ezfio.set_ao_basis_ao_coef(d)
|
|
|
|
|
# ezfio.set_ao_basis_ao_expo(d)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-08-28 21:13:09 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Basis #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
2020-08-28 21:13:09 +02:00
|
|
|
do_pseudo = qph5['pseudo'].attrs['do_pseudo']
|
|
|
|
|
ezfio.set_pseudo_do_pseudo(do_pseudo)
|
|
|
|
|
if (do_pseudo):
|
|
|
|
|
ezfio.set_pseudo_pseudo_lmax(qph5['pseudo'].attrs['pseudo_lmax'])
|
|
|
|
|
ezfio.set_pseudo_pseudo_klocmax(qph5['pseudo'].attrs['pseudo_klocmax'])
|
|
|
|
|
ezfio.set_pseudo_pseudo_kmax(qph5['pseudo'].attrs['pseudo_kmax'])
|
|
|
|
|
ezfio.set_pseudo_nucl_charge_remove(qph5['pseudo/nucl_charge_remove'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_n_k(qph5['pseudo/pseudo_n_k'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_n_kl(qph5['pseudo/pseudo_n_kl'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_v_k(qph5['pseudo/pseudo_v_k'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_v_kl(qph5['pseudo/pseudo_v_kl'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_dz_k(qph5['pseudo/pseudo_dz_k'][()].tolist())
|
|
|
|
|
ezfio.set_pseudo_pseudo_dz_kl(qph5['pseudo/pseudo_dz_kl'][()].tolist())
|
|
|
|
|
|
|
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Basis #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
|
|
|
|
|
|
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
coeftmp = qph5['ao_basis/ao_coef'][()]
|
|
|
|
|
expotmp = qph5['ao_basis/ao_expo'][()]
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_ao_basis_ao_basis(qph5['ao_basis'].attrs['ao_basis'])
|
|
|
|
|
ezfio.set_ao_basis_ao_nucl(qph5['ao_basis/ao_nucl'][()].tolist())
|
2020-08-28 21:13:09 +02:00
|
|
|
ezfio.set_ao_basis_ao_prim_num(qph5['ao_basis/ao_prim_num'][()].tolist())
|
|
|
|
|
ezfio.set_ao_basis_ao_power(qph5['ao_basis/ao_power'][()].tolist())
|
|
|
|
|
ezfio.set_ao_basis_ao_coef(qph5['ao_basis/ao_coef'][()].tolist())
|
|
|
|
|
ezfio.set_ao_basis_ao_expo(qph5['ao_basis/ao_expo'][()].tolist())
|
|
|
|
|
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# MO Coef #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
mo_coef_reim = qph5['mo_basis/mo_coef_complex'][()].tolist()
|
|
|
|
|
ezfio.set_mo_basis_mo_coef_complex(mo_coef_reim)
|
|
|
|
|
#maybe fix qp so we don't need this?
|
|
|
|
|
#ezfio.set_mo_basis_mo_coef([[i for i in range(mo_num)] * ao_num])
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Integrals Mono #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
if 'ao_one_e_ints' in qph5.keys():
|
|
|
|
|
kin_ao_reim=qph5['ao_one_e_ints/ao_integrals_kinetic'][()].tolist()
|
|
|
|
|
ovlp_ao_reim=qph5['ao_one_e_ints/ao_integrals_overlap'][()].tolist()
|
|
|
|
|
ne_ao_reim=qph5['ao_one_e_ints/ao_integrals_n_e'][()].tolist()
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_kinetic_complex(kin_ao_reim)
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_overlap_complex(ovlp_ao_reim)
|
|
|
|
|
ezfio.set_ao_one_e_ints_ao_integrals_n_e_complex(ne_ao_reim)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_kinetic('Read')
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_overlap('Read')
|
|
|
|
|
ezfio.set_ao_one_e_ints_io_ao_integrals_n_e('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
|
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
if 'mo_one_e_ints' in qph5.keys():
|
|
|
|
|
kin_mo_reim=qph5['mo_one_e_ints/mo_integrals_kinetic'][()].tolist()
|
|
|
|
|
#ovlp_mo_reim=qph5['mo_one_e_ints/mo_integrals_overlap'][()].tolist()
|
|
|
|
|
ne_mo_reim=qph5['mo_one_e_ints/mo_integrals_n_e'][()].tolist()
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_mo_one_e_ints_mo_integrals_kinetic_complex(kin_mo_reim)
|
|
|
|
|
#ezfio.set_mo_one_e_ints_mo_integrals_overlap_complex(ovlp_mo_reim)
|
|
|
|
|
#ezfio.set_mo_one_e_ints_mo_integrals_n_e_complex(ne_mo_reim)
|
|
|
|
|
ezfio.set_mo_one_e_ints_mo_integrals_n_e_complex(ne_mo_reim)
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_mo_one_e_ints_io_mo_integrals_kinetic('Read')
|
|
|
|
|
#ezfio.set_mo_one_e_ints_io_mo_integrals_overlap('Read')
|
|
|
|
|
#ezfio.set_mo_one_e_ints_io_mo_integrals_n_e('Read')
|
|
|
|
|
ezfio.set_mo_one_e_ints_io_mo_integrals_n_e('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# k-points #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
kconserv = qph5['nuclei/kconserv'][()].tolist()
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
ezfio.set_nuclei_kconserv(kconserv)
|
|
|
|
|
ezfio.set_nuclei_io_kconserv('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2022-05-18 20:50:03 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
##########################################
|
|
|
|
|
# #
|
|
|
|
|
# Integrals Bi #
|
|
|
|
|
# #
|
|
|
|
|
##########################################
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
# should this be in ao_basis? ao_two_e_ints?
|
|
|
|
|
with h5py.File(qph5path,'r') as qph5:
|
|
|
|
|
if 'ao_two_e_ints' in qph5.keys():
|
|
|
|
|
df_num = qph5['ao_two_e_ints'].attrs['df_num']
|
|
|
|
|
ezfio.set_ao_two_e_ints_df_num(df_num)
|
|
|
|
|
if 'df_ao_integrals' in qph5['ao_two_e_ints'].keys():
|
|
|
|
|
# dfao_re0=qph5['ao_two_e_ints/df_ao_integrals_real'][()].transpose((3,2,1,0))
|
|
|
|
|
# dfao_im0=qph5['ao_two_e_ints/df_ao_integrals_imag'][()].transpose((3,2,1,0))
|
|
|
|
|
# dfao_cmplx0 = np.stack((dfao_re0,dfao_im0),axis=-1).tolist()
|
|
|
|
|
# ezfio.set_ao_two_e_ints_df_ao_integrals_complex(dfao_cmplx0)
|
|
|
|
|
dfao_reim=qph5['ao_two_e_ints/df_ao_integrals'][()].tolist()
|
|
|
|
|
ezfio.set_ao_two_e_ints_df_ao_integrals_complex(dfao_reim)
|
|
|
|
|
ezfio.set_ao_two_e_ints_io_df_ao_integrals('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
if 'mo_two_e_ints' in qph5.keys():
|
|
|
|
|
df_num = qph5['ao_two_e_ints'].attrs['df_num']
|
|
|
|
|
ezfio.set_ao_two_e_ints_df_num(df_num)
|
|
|
|
|
# dfmo_re0=qph5['mo_two_e_ints/df_mo_integrals_real'][()].transpose((3,2,1,0))
|
|
|
|
|
# dfmo_im0=qph5['mo_two_e_ints/df_mo_integrals_imag'][()].transpose((3,2,1,0))
|
|
|
|
|
# dfmo_cmplx0 = np.stack((dfmo_re0,dfmo_im0),axis=-1).tolist()
|
|
|
|
|
# ezfio.set_mo_two_e_ints_df_mo_integrals_complex(dfmo_cmplx0)
|
|
|
|
|
dfmo_reim=qph5['mo_two_e_ints/df_mo_integrals'][()].tolist()
|
|
|
|
|
ezfio.set_mo_two_e_ints_df_mo_integrals_complex(dfmo_reim)
|
|
|
|
|
ezfio.set_mo_two_e_ints_io_df_mo_integrals('Read')
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
return
|
2022-05-11 21:35:44 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
|
2020-07-29 19:14:14 +02:00
|
|
|
if __name__ == '__main__':
|
|
|
|
|
ARGUMENTS = docopt(__doc__)
|
|
|
|
|
|
2022-09-21 22:47:51 +02:00
|
|
|
#for i in range(1,6):
|
|
|
|
|
# for j in range(1,6):
|
|
|
|
|
# for k in range(1,6):
|
|
|
|
|
# for l in range(1,6):
|
|
|
|
|
# idx,usem1,sgn = ao_idx_map_sign(i,j,k,l)
|
|
|
|
|
# print(f'{i:4d} {j:4d} {k:4d} {l:4d} {str(usem1)[0]:s} {idx:6d} {sgn:5.1f}')
|
2020-07-29 19:14:14 +02:00
|
|
|
FILE = get_full_path(ARGUMENTS['FILE'])
|
2020-09-01 18:19:09 +02:00
|
|
|
qmcpack = True
|
2022-06-29 20:20:22 +02:00
|
|
|
rmg = False
|
2020-07-29 19:14:14 +02:00
|
|
|
if ARGUMENTS["--output"]:
|
|
|
|
|
EZFIO_FILE = get_full_path(ARGUMENTS["--output"])
|
|
|
|
|
else:
|
|
|
|
|
EZFIO_FILE = "{0}.ezfio".format(FILE)
|
|
|
|
|
|
2020-09-01 18:19:09 +02:00
|
|
|
if ARGUMENTS["--noqmc"]:
|
|
|
|
|
qmcpack = False
|
2022-05-03 18:23:51 +02:00
|
|
|
if ARGUMENTS["--rmg"]:
|
|
|
|
|
rmg = True
|
2020-07-29 21:07:03 +02:00
|
|
|
with h5py.File(FILE,'r') as qph5:
|
2022-06-29 20:20:22 +02:00
|
|
|
try:
|
|
|
|
|
do_kpts = ('kconserv' in qph5['nuclei'].keys())
|
|
|
|
|
except:
|
|
|
|
|
do_kpts = False
|
|
|
|
|
if (do_kpts or rmg):
|
2020-07-29 21:07:03 +02:00
|
|
|
print("converting HDF5 to EZFIO for periodic system")
|
2022-06-29 20:20:22 +02:00
|
|
|
if rmg:
|
2022-05-03 18:23:51 +02:00
|
|
|
print("Using RMG and AFQMC h5")
|
|
|
|
|
convert_kpts_cd(EZFIO_FILE,FILE,qmcpack)
|
|
|
|
|
else:
|
2022-05-04 21:14:04 +02:00
|
|
|
convert_kpts(EZFIO_FILE,FILE,qmcpack)
|
2020-07-29 21:07:03 +02:00
|
|
|
else:
|
|
|
|
|
print("converting HDF5 to EZFIO for molecular system")
|
|
|
|
|
convert_mol(EZFIO_FILE,FILE)
|
2020-07-29 19:14:14 +02:00
|
|
|
|
2020-07-29 21:07:03 +02:00
|
|
|
# sys.stdout.flush()
|
|
|
|
|
# if os.system("qp_run save_ortho_mos "+EZFIO_FILE) != 0:
|
|
|
|
|
# print("""Warning: You need to run
|
|
|
|
|
#
|
|
|
|
|
# qp run save_ortho_mos
|
|
|
|
|
#
|
|
|
|
|
#to be sure your MOs will be orthogonal, which is not the case when
|
|
|
|
|
#the MOs are read from output files (not enough precision in output).""")
|
