def vmc_pbyp_input_from_p2q(p2q, system, suffix='-p2q'):
from nexus import vmc
# determine ID and path from p2q simulation
myid = p2q.identifier.replace(suffix, '-vmc')
p2q_dir = os.path.basename(p2q.path)
mypath = p2q.path.replace(p2q_dir, 'vmc')
# write default inputs
vmc_block = obj(move='pbyp',
warmupsteps=16,
blocks=64,
steps=4,
substeps=4,
timestep=0.4,
walkers=16,
checkpoint=0)
calcs = [vmc(**vmc_block)]
vmc_inputs = obj(identifier=myid,
path=mypath,
system=system,
input_type='basic',
bconds='ppp',
calculations=calcs,
dependencies=[(p2q, 'orbitals')])
return vmc_inputs
def check_empty_settings():
settings(command_line=False, )
settings.command_line = True
nexus_core.command_line = True
check_settings_core_noncore()
# nexus core sets basic run stages and Pseudopotentials object
assert (nexus_core.stages_set == set(
nexus_core_defaults.primary_modes))
assert (isinstance(nexus_core.pseudopotentials, Pseudopotentials))
assert (len(nexus_core.pseudopotentials) == 0)
nexus_core.stages_set = set()
nexus_core.stages = []
nexus_core.pseudopotentials = None
assert (object_eq(nexus_core, nexus_core_defaults))
# nexus noncore sets Pseudopotentials and BasisSets objects
assert (isinstance(nexus_noncore.pseudopotentials, Pseudopotentials))
assert (len(nexus_noncore.pseudopotentials) == 0)
assert (isinstance(nexus_noncore.basissets, BasisSets))
assert (len(nexus_noncore.basissets) == 0)
nnc_defaults = obj(nexus_noncore_defaults, nexus_core_noncore_defaults)
nexus_noncore.pseudopotentials = None
nexus_noncore.basissets = None
assert (object_eq(nexus_noncore, nnc_defaults))
# other settings objects should be at default also
aux_defaults()
def dmc_wbyw_input_from_p2q(p2q,
system,
nwalker=512,
tss=[0.006, 0.002],
corr=0.4,
suffix='-p2q'):
from nexus import dmc
# get a quick start from VMC defaults
dmc_inputs = vmc_wbyw_input_from_p2q(p2q, system)
# change ID and path
myid = p2q.identifier.replace(suffix, '-dmc')
p2q_dir = os.path.basename(p2q.path)
mypath = p2q.path.replace(p2q_dir, 'dmc')
dmc_inputs.identifier = myid
dmc_inputs.path = mypath
# ask VMC for samples
calcs = dmc_inputs.calculations
assert len(calcs) == 1 # expect 1 VMC calculation
vcalc = calcs[0]
vcalc['samples'] = nwalker
# add DMC calculations
for ts in tss:
steps = int(round(corr / ts))
dmc_block = obj(move='not_pbyp_or_whatever',
blocks=64,
steps=steps,
timestep=ts,
targetwalkers=nwalker)
calcs += [dmc(**dmc_block)]
# end for ts
return dmc_inputs
def vmc_wbyw_input_from_p2q(p2q, system, suffix='-p2q'):
""" construct vmc (walker-by-walker) inputs as nexus.obj
assume orbitals come from a mean-field calculation "p2q"
The returned nexus.obj can be edited at will even after return
thus, the "system" input is not actually mandatory. I put it
there simply as a reminder.
The "job" attribute still needs to be filled in after return.
"job" is not assigned in this function to improve tranferability
among machines.
Args:
p2q (nexus.Pw2qmcpack): may also be any other Simulation object
having 'orbitals' in 'application_results'.
system (nexus.PhysicalSystem): system to simulate.
suffix (str,optional): suffix to the p2q simulation identifier and path.
"""
from nexus import vmc
# determine ID and path from p2q simulation
myid = p2q.identifier.replace(suffix, '-vmc')
p2q_dir = os.path.basename(p2q.path)
mypath = p2q.path.replace(p2q_dir, 'vmc')
# write default inputs
vmc_block = obj(
warmuptimestep=0.01,
move='not_pbyp_or_whatever',
warmupsteps=128,
blocks=64,
steps=4,
substeps=4,
timestep=0.03,
walkers=16,
)
calcs = [vmc(**vmc_block)]
vmc_inputs = obj(identifier=myid,
path=mypath,
system=system,
input_type='basic',
bconds='ppp',
calculations=calcs,
dependencies=[(p2q, 'orbitals')])
return vmc_inputs
def gamma_opt_input(p2q, system, init_jas=None):
from nexus import loop, linear
myid = p2q.identifier.replace('-p2q', '-opt')
nscf_dir = os.path.basename(p2q.path)
mypath = p2q.path.replace(nscf_dir, 'opt')
linopt = obj(
minmethod='OneShiftOnly',
energy=0.95,
reweightedvariance=0.05,
unreweightedvariance=0.0,
warmupsteps=40,
blocks=128,
substeps=3,
timestep=0.8,
samples=8192,
)
calcs = [loop(max=5, qmc=linear(**linopt))]
myjas = init_jas
if init_jas is None:
myjas = [('J1', 'size', 8, 'cusp', 1), ('J2', 'size', 8)]
# end if
opt_inputs = obj(
identifier=myid,
path=mypath,
input_type='basic',
system=system,
bconds='ppp', # periodic in xyz directions
calculations=calcs,
twistnum=0,
estimators=[],
jastrows=myjas,
pseudos=[],
dependencies=[(p2q, 'orbitals')])
return opt_inputs
def p2q_input_from_nscf(nscf, suffix='-nscf', cusp_corr=False):
""" take an nscf simulation object and create a p2q run to generate wavefunction.
Args:
nscf (nexus.Pwscf): nscf simulation object. An scf simulation object can also be used here.
suffix (str,optional): suffix in the identifier and path of the nscf simulation. Default is '-nscf'.
cusp_corr (bool,optional): apply cusp correction, namely divide DFT orbitals by RPA Jastrows. This option requires a custom version of quantum espresso. Default=False.
Returns:
nexus.obj: inputs necessary for the p2q run.
"""
p2q_input = obj(identifier=nscf.identifier.replace(suffix, '-p2q'),
path=nscf.path,
outdir=nscf.input.control.outdir,
write_psir=False,
dependencies=(nscf, 'orbitals'))
if cusp_corr:
p2q_input['cusp_corr'] = True
return p2q_input
vo2 = generate_physical_system(
structure=s,
V1=13,
V2=13,
O=6,
)
# generate pwscf input
pw = generate_pwscf_input(
selector='generic',
calculation='scf',
disk_io='low',
verbosity='high',
wf_collect=True,
input_dft='lda',
hubbard_u=obj(V1=3.5, V2=3.5),
ecutwfc=350,
bandfac=1.3,
nosym=True,
occupations='smearing',
smearing='fermi-dirac',
degauss=0.0001,
nspin=2,
start_mag=obj(V1=1.0, V2=-1.0),
diagonalization='david',
conv_thr=1e-8,
mixing_beta=0.2,
electron_maxstep=1000,
system=vo2,
pseudos=['V.opt.upf', 'O.opt.upf'],
kgrid=(6, 6, 6),
# vasp inputs used by all runs
shared_inputs = obj(
encut=550,
ediff=1e-8,
algo='Normal',
nelm=400,
nwrite=2,
prec='Accurate',
ismear=-5,
lwave=False,
lcharg=False,
lreal='.FALSE.',
nbands=200,
ispin=2,
magmom=24 * [0] + [-6, 6, 6, -6, 6, -6, -6, 6] + 8 * [0],
ldau=True,
ldautype=2,
ldaul=[-1, 2, -1],
ldauu=[0, 2, 0],
ldauj=[0, 0, 0],
lmaxmix=4,
lorbit=11,
kpar=8,
ncore=4,
pseudos=[
'Bi.d.lda.POTCAR', # TITEL= PAW Bi_d 09Feb1998
'Fe.pv.lda.POTCAR', # TITEL= PAW Fe_pv 03Mar1998
'O.lda.POTCAR'
] # TITEL= PAW O 31May2000
)
C 0.8925 0.8925 0.8925
''',
kgrid = (1,1,1),
kshift = (0,0,0),
C = 4,
)
scf = generate_pyscf(
identifier = 'scf', # log output goes to scf.out
path = 'diamond_pp_dft_gamma', # directory to run in
job = job(serial=True,threads=16),# pyscf must run w/o mpi
template = './dft_template.py', # pyscf template file
system = system,
cell = obj( # used to make Cell() inputs
basis = 'bfd-vdz',
ecp = 'bfd',
drop_exponent = 0.1,
verbose = 5,
),
save_qmc = True, # save wfn data for qmcpack
)
c4q = generate_convert4qmc(
identifier = 'c4q',
path = 'diamond_pp_dft_gamma',
job = job(cores=1),
no_jastrow = True,
dependencies = (scf,'orbitals'),
)
qmc = generate_qmcpack(
identifier = 'vmc',
results='',
sleep=3,
machine='ws16',
)
system = generate_physical_system(structure='H2O.xyz', )
scf = generate_pyscf(
identifier='scf', # log output goes to scf.out
path='h2o_ae_hf', # directory to run in
job=job(serial=True), # pyscf must run serially
template='./scf_template.py', # pyscf template file
system=system,
mole=obj( # used to make Mole() inputs
verbose=5,
basis='ccpvtz',
symmetry=True,
),
save_qmc=True, # save wfn data for qmcpack
)
c4q = generate_convert4qmc(
identifier='c4q',
path='h2o_ae_hf',
job=job(cores=1),
no_jastrow=True,
dependencies=(scf, 'orbitals'),
)
qmc = generate_qmcpack(
identifier='vmc',
def apply_machine_settings(machine, run_dir, account='', nk=1, **kwargs):
""" apply default machines settings for hydrogen simulations
return a dictionary of jobs for ['dft','p2q','opt','dmc']
Args:
machine (str): one of ['golub','titan','ws4','ws8',...]. 'ws' stands for workstation.
run_dir (str): directory to run the jobs in.
account (str,optional): default is to depend on the machine's default in nexus.
nk (int,optional): the npool option in pw.x, default is 1 because it always runs. For large number of kpoints, set nk to be as large as possible for speed.
kwargs (dict): extra keyword arguments to be passed to nexus.settings.
Returns:
dict: jobs, a dictionary of nexus.obj objects for ['dft','p2q','opt','dmc'], each can be passed to create nexus.Job objects using Job(**jobs['dft']), for example.
"""
if (machine not in ['golub', 'titan', 'eos', 'bluewaters_xe'
]) and (not machine.startswith('ws')):
raise NotImplementedError('cannot handle machine=%s yet' % machine)
# end if
from nexus import settings, obj
if machine == 'titan':
account = 'mat158'
pseudo_dir = '/ccs/home/yyang173/scratch/hsolid/pseudo'
vdw_table = '/ccs/home/yyang173/scratch/hsolid/vdw/vdW_kernel_table'
qedir = '~/soft/espresso-5.3.0/bin'
ccdir = '~/soft/qmcpack-espresso-5.3.0/bin'
qmcdir = '~/soft/kylin_qmcpack'
elif machine == 'eos':
account = 'mat158'
pseudo_dir = '/ccs/home/yyang173/scratch/hsolid/pseudo'
vdw_table = '/ccs/home/yyang173/scratch/hsolid/vdw/vdW_kernel_table'
qedir = '~/soft/espresso-5.3.0/bin'
ccdir = '~/soft/qmcpack-espresso-5.3.0/bin'
qmcdir = '~/soft/intel_kylin_qmcpack'
elif machine == 'bluewaters_xe':
pseudo_dir = '/u/sciteam/yang5/scratch/hsolid/pseudo'
vdw_table = '/u/sciteam/yang5/scratch/hsolid/vdw/vdW_kernel_table'
qedir = '~/soft/espresso-5.3.0/bin'
ccdir = '~/soft/qmcpack-espresso-5.3.0/bin'
qmcdir = '~/soft/kylin_qmcpack'
elif machine == 'golub':
pseudo_dir = '/home/yyang173/scratch/hsolid/pseudo'
vdw_table = '/home/yyang173/scratch/hsolid/vdw/vdW_kernel_table'
qedir = '/projects/physics/yyang/soft/espresso-5.3.0/bin'
ccdir = '/projects/physics/yyang/soft/qmcpack-espresso-5.3.0/bin'
qmcdir = '~/soft/kylin_qmcpack'
else: # workstation, defaults should do
pseudo_dir = '/home/yyang173/Desktop/hsolid/pseudo'
vdw_table = '/home/yyang173/Desktop/hsolid/vdw/vdW_kernel_table'
qedir = '~/soft/espresso-5.3.0/bin'
ccdir = '~/soft/qmcpack-espresso-5.3.0/bin'
qmcdir = '~/soft/kylin_qmcpack'
# end if
settings(runs=run_dir,
machine=machine,
account=account,
pseudo_dir=pseudo_dir,
vdw_table=vdw_table,
**kwargs)
pw_bin = os.path.join(qedir, 'pw.x')
cc_bin = os.path.join(ccdir, 'pw2qmcpack.x')
qmc_bin = os.path.join(qmcdir, "qmcpack_cpu_real")
tabc_bin = os.path.join(qmcdir, "qmcpack_cpu_comp")
# assign jobs
if machine == 'titan':
dft_job = obj(nodes=1,
minutes=10,
app_options="-nk %d" % nk,
app=pw_bin)
p2q_job = obj(nodes=1, serial=True, minutes=30, app=cc_bin)
opt_job = obj(nodes=4, threads=8, hours=2, app=qmc_bin)
dmc_job = obj(nodes=8, threads=8, hours=2, app=qmc_bin)
elif machine == 'eos':
dft_job = obj(nodes=1,
minutes=10,
app_options="-nk %d" % nk,
app=pw_bin)
p2q_job = obj(nodes=1, serial=True, minutes=30, app=cc_bin)
opt_job = obj(nodes=4, threads=8, hours=2, app=qmc_bin)
dmc_job = obj(nodes=8, threads=8, hours=2, app=qmc_bin)
elif machine == 'bluewaters_xe':
dft_job = obj(nodes=1,
minutes=10,
app_options="-nk %d" % nk,
app=pw_bin)
p2q_job = obj(nodes=1, serial=True, minutes=30, app=cc_bin)
opt_job = obj(nodes=4, threads=8, hours=2, app=qmc_bin)
dmc_job = obj(nodes=8, threads=8, hours=2, app=qmc_bin)
for job in [dft_job, p2q_job, opt_job, dmc_job]:
job['user_env'] = False # the -V option is deprecated
# end for
elif machine == 'golub':
dft_job = obj(nodes=1, hours=4, app=pw_bin, app_options='-nk %d' % nk)
p2q_job = obj(nodes=1, serial=True, minutes=30, app=cc_bin)
opt_job = obj(nodes=1, threads=8, hours=4, app=qmc_bin)
dmc_job = obj(nodes=1, threads=8, hours=4, app=qmc_bin)
else:
dft_job = obj(app_options='-nk %d' % nk, app=pw_bin)
p2q_job = obj(serial=True, app=cc_bin)
opt_job = obj(app=qmc_bin, threads=8)
dmc_job = obj(app=qmc_bin, threads=8)
# end if
tabc_job = dmc_job.copy()
tabc_job.app = tabc_bin
jobs = {
'dft': dft_job,
'p2q': p2q_job,
'opt': opt_job,
'dmc': dmc_job,
'tabc': tabc_job
}
return jobs
params_defaults = obj(
electron_maxstep=200,
system=None,
j=11,
dft_pps=None,
qmc_pps=None,
dft_grid=(6, 6, 6),
tilings=[[[1, 0, 0], [0, 1, 0], [0, 0, 1]]],
qmc_grids=[(3, 3, 3)],
uatoms=None,
ulist=None,
charge=0,
tot_mag=None,
machine='titan',
j3=True,
j2=False,
code='cpu',
qp=False,
big=False,
density=None,
nopre=False,
tmoves=False,
meshfactor=1.0,
hybrid_rcut=None,
hybrid_lmax=None,
rcut=None,
two_u=False,
natoms=None,
vmc=False,
vmc_opt=True,
twistnum=1,
excitation=None,
bundle=False,
qmc_skip_submit=False,
timesteps=None,
qmc=True,
seed=None,
kshift=(0, 0, 0),
print_ke_corr=False,
relax=False,
relax_functional='PBESOL',
relax_u=4,
relax_pps=None,
relax_pp_dir=None,
nscf_only=False,
nscf_skip=False,
)
hubbard_u={1: 3.1},
starting_magnetization={1: 0.9},
starting_ns_eigenvalue={
(1, 2, 1): 0.0,
(2, 2, 1): 0.0476060,
(3, 2, 1): 0.0476060,
(4, 2, 1): 0.9654373,
(5, 2, 1): 0.9954307
},
# electrons inputs
conv_thr=1.0e-9,
mixing_beta=0.7,
diagonalization='david',
mixing_fixed_ns=500,
# atomic_species inputs
mass=obj(Fe=58.69000),
pseudos=['Fe.pbe-nd-rrkjus.UPF'],
# atomic_positions inputs
elem=['Fe', 'Fe'],
pos=[[2.070000000, 0.000000000, 0.000000000],
[0.000000000, 0.000000000, 0.000000000]],
pos_specifier='angstrom',
# k_points inputs
kgrid=(1, 1, 1),
kshift=(1, 1, 1),
)
# manipulate and write
for ecut in [100, 120, 140, 160]:
pw.system.ecutwfc = ecut
pw.write('scf_05_ecut_{0}.in'.format(ecut))
#! /usr/bin/env python
import numpy as np
# ======= setup machine and jobs =======
from nexus import settings, Job, obj
machine_settings = obj(
runs='grid', # default to 'runs'
generate_only=0,
status_only=0,
sleep=1,
machine='ws1',
ericfmt='/opt/intel14/gamess-2014R1/auxdata/ericfmt.dat')
settings(**machine_settings)
gms_job = Job(serial=True, app="rungms", cores=1)
# ======= structure =======
from nexus import generate_physical_system, Structure
from nexus import generate_gamess
CH = 1.0655 # ang
CN = 1.1538 # ang
basis = 'ccd'
# ======= simulations =======
'''
MODERN BASIS SET FAMILIES (CCN, PCN, MCP_NZP, IMCP) ARE INTENDED
FOR USE ONLY AS SPHERICAL HARMONIC BASIS SETS. PLEASE SET ISPHER=1
IN THE $CONTRL GROUP IN ORDER TO USE GBASIS=ACCT
'''
rhf_runs = []
#! /usr/bin/env python
import numpy as np
# ======= setup machine and jobs =======
from nexus import settings,Job,obj
machine_settings = obj(
runs = 'grid', # default to 'runs'
generate_only = 0,
status_only = 0,
sleep = 1,
machine = 'ws1',
ericfmt = '/opt/intel14/gamess-2014R1/auxdata/ericfmt.dat'
)
settings(**machine_settings)
gms_job = Job(serial=True,app="rungms",cores=1)
# ======= structure =======
from nexus import generate_physical_system, Structure
from nexus import generate_gamess
CH = 1.0655 # ang
CN = 1.1538 # ang
basis = 'ccd'
# ======= simulations =======
'''
MODERN BASIS SET FAMILIES (CCN, PCN, MCP_NZP, IMCP) ARE INTENDED
FOR USE ONLY AS SPHERICAL HARMONIC BASIS SETS. PLEASE SET ISPHER=1
IN THE $CONTRL GROUP IN ORDER TO USE GBASIS=ACCT
'''
shared_inputs = obj(
# nexus inputs
identifier='scf',
job=job(cores=8, app='rmg-cpu'),
pseudos=['C.BFD.xml'],
input_type='generic',
# control options
calculation_mode='Quench Electrons',
compressed_infile=False,
compressed_outfile=False,
description='diamond',
energy_convergence_criterion=1.0e-09,
max_scf_steps=100,
#start_mode = 'Restart From File',
write_data_period=10,
# cell parameter options
atomic_coordinate_type='Cell Relative',
kpoint_is_shift=(0, 0, 0),
kpoint_mesh=(4, 4, 4),
potential_grid_refinement=2,
# pseudopotential related options
localize_localpp=False,
localize_projectors=False,
# kohn sham solver options
kohn_sham_mucycles=3,
kohn_sham_solver='davidson',
# orbital occupation options
occupations_type='Fixed',
# charge density mixing options
charge_density_mixing=0.5,
charge_mixing_type='Broyden',
potential_acceleration_constant_step=1.0,
# diagonalization options
subdiag_driver='lapack',
## testing options
#test_energy = -11.39547539 # reference energy for validation
# miscellaneous options
kpoint_distribution=8,
)
net_spin=1)
mag = [0.7]
tot_mag = 1
#######################################################################
########################## Change here only ##########################
shared_scf = obj(
input_type='generic',
occupations='smearing',
smearing='gaussian',
degauss=0.005,
tot_magnetization=tot_mag,
####################
#plus-u is here
input_DFT='PBE',
lda_plus_u=True,
####################
ecutwfc=320,
start_mag=obj(Ni=mag[0]),
conv_thr=1.0e-7,
mixing_beta=0.2,
# no_sym is deleted! jtk added
use_folded=True,
)
params = obj(electron_maxstep=100,
system=ph,
j=11,
dft_pps=['Li.BFD.upf', 'Ni.opt.upf', 'O.opt.upf'],
qmc_pps=['Li.BFD.xml', 'Ni.opt.xml', 'O.opt.xml'],
dft_grid=(5, 5, 5),
tilings=[[[1, 0, 0], [0, 1, 0], [0, 0, 1]]],
H = 1,
net_spin = 0, # 2S
net_charge = 0,
)
sims = []
# perform Hartree-Fock
scf = generate_pyscf(
identifier = 'scf', # log output goes to scf.out
path = 'scf', # directory to run in
job = job(serial=True, nodes=4, queue='debug', hours=0.5, constraint='knl', presub=scf_presub),
#job = job(serial=True, nodes=1, threads=4, presub=scf_presub),
template = 'scf_guess/scf_template.py', # pyscf template file
system = system,
mole = obj( # used to make Mole() inputs
verbose = 4,
#symmetry = 'D2h',
),
save_qmc = True, # save wfn data for qmcpack
)
sims.append(scf)
#### convert orbitals to QMCPACK format
c4q = generate_convert4qmc(
identifier = 'c4q',
path = 'scf',
job = job(nodes=4, queue='debug', hours=0.50, constraint='knl', presub=scf_presub),
#job = job(serial=True, nodes=1, threads=4),
no_jastrow = True,
hdf5 = True, # use hdf5 format
dependencies = (scf,'orbitals'),
)
def mworkflow(shared_qe, params, sims):
for i in params_defaults.keys():
if i not in params:
setattr(params, i, params_defaults[i])
#end if
#end if
if params.j3:
if params.code == 'gpu':
print "GPU code and j3 not possible yet"
exit()
#end if
#end if
if params.excitation is not None:
params.twistnum = 0
########################
#DMC and VMC parameters#
########################
samples = 25600 #25600
vmcblocks = 100
dmcblocks = 300
dmceqblocks = 200
dmcwalkers = 1024 # For cades it is multiplied by 2
vmcdt = 0.3
if params.vmc:
vmcblocks = 9000
vmcdt = 0.3
dmcblocks = 1
dmceqblocks = 1
#end if
#############################
# Machine specific variables#
#############################
if params.machine == 'cades':
minnodes = 1
scf_nodes = 2
scf_hours = 48
p2q_nodes = scf_nodes
p2q_hours = 1
qeapp = 'pw.x -npool 4 '
if params.dft_grid == (1, 1, 1):
scf_nodes = 1
qeapp = 'pw.x'
#end if
qe_presub = 'module purge; module load PE-intel/3.0; module load hdf5_parallel/1.10.3'
opt_nodes = 4
opt_hours = 12
dmcnodespertwist = 0.5
dmc_hours = 24
qmc_threads = 18
walkers = qmc_threads
blocks = samples / (walkers * opt_nodes)
params.code = 'cpu'
qmcapp = ' qmcpack_cades_cpu_comp_SoA'
qmc_presub = 'module purge; module load PE-intel'
opt_job = Job(nodes=opt_nodes,
hours=opt_hours,
threads=qmc_threads,
app=qmcapp,
presub=qmc_presub)
elif params.machine == 'titan' or params.machine == 'eos':
minnodes = 1
dmcwalkers *= 2
scf_nodes = 8
scf_hours = 2
p2q_nodes = scf_nodes
p2q_hours = 1
qeapp = 'pw.x -npool 4 '
qe_presub = ''
if params.machine == 'eos':
opt_nodes = 16
opt_hours = 2
qmc_threads = 16
walkers = qmc_threads
blocks = samples / (walkers * opt_nodes)
params.code = 'cpu'
qmcapp = '/ccs/home/kayahan/SOFTWARE/qmcpack/eos/qmcpack/qmcpack_eos_cpu_comp_SoA'
qmc_presub = ''
params.rundmc = False
elif params.machine == 'titan':
if params.code == 'cpu':
dmcwalkers *= 2
vmcblocks = 50
opt_nodes = 16
opt_hours = 2
dmcnodespertwist = 32
dmc_hours = 6
qmc_threads = 16
walkers = qmc_threads
blocks = samples / (walkers * opt_nodes)
qmcapp = '/ccs/home/kayahan/SOFTWARE/qmcpack/titan/qmcpack/qmcpack_titan_cpu_comp_SoA'
qmc_presub = ''
params.rundmc = True
elif params.code == 'gpu':
dmcwalkers *= 8
opt_nodes = 4
opt_hours = 4
dmcnodespertwist = 8
dmc_hours = 1.5
qmc_threads = 16
walkers = qmc_threads
blocks = samples / (walkers * opt_nodes)
qmcapp = '/ccs/home/kayahan/SOFTWARE/qmcpack/titan/qmcpack/qmcpack_titan_gpu_comp_SoA'
qmc_presub = 'module load cudatoolkit'
#end if
#end if
opt_job = Job(nodes=opt_nodes,
hours=opt_hours,
threads=qmc_threads,
app=qmcapp,
presub=qmc_presub)
elif params.machine == 'cetus' or params.machine == 'mira':
if params.machine == 'cetus':
minnodes = 128
opt_hours = 1
dmc_hours = 1
elif params.machine == 'mira':
minnodes = 128
dmc_hours = 1
dmc_hours = 1
#end if
scf_nodes = 128
scf_hours = 1
p2q_nodes = 128
p2q_hours = 1
qeapp = 'pw.x'
qe_presub = ''
opt_nodes = 128.0
opt_nodes = np.round(opt_nodes / minnodes) * minnodes
dmcnodespertwist = 18
qmc_threads = 16
walkers = qmc_threads
qmc_processes_per_node = 16
blocks = samples / (walkers * opt_nodes)
params.code = 'cpu'
qmcapp = 'qmcpack'
qmc_presub = ''
opt_job = Job(nodes=opt_nodes,
hours=opt_hours,
threads=qmc_threads,
processes_per_node=qmc_processes_per_node,
app=qmcapp,
presub=qmc_presub)
elif params.machine == 'summit':
dmcwalkers *= 8
minnodes = 1
scf_nodes = 2
scf_hours = 24
p2q_nodes = 2
p2q_hours = 1
qeapp = 'pw.x -npool 4 '
if params.dft_grid == (1, 1, 1):
scf_nodes = 1
qeapp = 'pw.x'
#end if
qe_presub = 'module purge; module load PE-intel/3.0'
opt_nodes = 4
opt_hours = 4
dmcnodespertwist = 8
dmc_hours = 6
qmc_threads = 42
walkers = qmc_threads
blocks = samples / (walkers * opt_nodes)
qmcapp = '/ccs/home/kayahan/SOFTWARE/qmcpack/summit/qmcpack/build_summit_comp/bin/qmcpack'
else:
print "Machine is not defined!"
exit()
#end if
scf_job = Job(nodes=scf_nodes,
hours=scf_hours,
app=qeapp,
presub=qe_presub)
p2q_job = Job(nodes=p2q_nodes,
hours=p2q_hours,
app='pw2qmcpack.x -npool 4 ',
presub=qe_presub)
if params.big or params.qp:
dmcblocks *= 4
dmcnodespertwist *= 1
dmc_hours *= 2
dmcwalkers *= 2
#end if
shared_qe.wf_collect = False
shared_qe.nosym = True
shared_qe.job = scf_job
shared_qe.pseudos = params.dft_pps
if params.tot_mag is not None:
shared_qe.tot_magnetization = params.tot_mag
#end if
if params.two_u:
ulist = [params.ulist[0]]
else:
ulist = params.ulist
#end if
shared_relax = shared_qe.copy()
# qmcs list to possibly bundle all DMC calculations
qmcs = []
scf_ks_energy = 0
for u in ulist:
if u != 0.:
shared_qe.hubbard_u = obj()
shared_relax.hubbard_u = obj()
for inum, i in enumerate(params.uatoms):
if params.two_u:
setattr(shared_qe.hubbard_u, i, params.ulist[inum])
else:
setattr(shared_qe.hubbard_u, i, u)
setattr(shared_relax.hubbard_u, i, params.relax_u)
#end if
#end for
#end if
scf_inf = None
scf_path = './scf-u-' + str(u) + '-inf'
if params.relax:
shared_relax = shared_qe.copy()
shared_relax['ion_dynamics'] = 'bfgs'
shared_relax['cell_dynamics'] = 'bfgs'
shared_relax['calculation'] = 'vc-relax'
shared_relax['conv_thr'] = 10e-6
shared_relax['forc_conv_thr'] = 0.001
shared_relax['input_DFT'] = params.relax_functional
shared_relax.nosym = True
coarse_relax = generate_pwscf(
identifier='scf',
path='./coarse_relax-u-' + str(params.relax_u) + '-inf',
electron_maxstep=params.electron_maxstep,
nogamma=True,
system=params.system,
kgrid=params.dft_grid,
**shared_relax)
sims.append(coarse_relax)
shared_relax['conv_thr'] = 10e-8
shared_relax['forc_conv_thr'] = 0.001
fine_relax = generate_pwscf(
identifier='scf',
path='./fine_relax-u-' + str(params.relax_u) + '-inf',
electron_maxstep=params.electron_maxstep,
nogamma=True,
system=params.system,
kgrid=params.dft_grid,
dependencies=(coarse_relax, 'structure'),
**shared_relax)
sims.append(fine_relax)
scf_inf = generate_pwscf(
identifier='scf',
path=scf_path,
electron_maxstep=params.electron_maxstep,
nogamma=True,
system=params.system,
#nosym = True,
kgrid=params.dft_grid,
calculation='scf',
dependencies=(fine_relax, 'structure'),
**shared_qe)
#pdb.set_trace()
else:
scf_inf = generate_pwscf(
identifier='scf',
path=scf_path,
electron_maxstep=params.electron_maxstep,
nogamma=True,
system=params.system,
#nosym = True,
kgrid=params.dft_grid,
calculation='scf',
**shared_qe)
sims.append(scf_inf)
if params.nscf_only is True:
params.tilings = []
params.vmc_opt = False
params.qmc = False
if params.print_ke_corr:
scf_dir = scf_inf.remdir
pwscf_output = scf_inf.input.control.outdir
datafile_xml = scf_dir + '/' + pwscf_output + '/pwscf.save/data-file-schema.xml'
if os.path.isfile(datafile_xml):
xmltree = minidom.parse(datafile_xml)
ks_energies = xmltree.getElementsByTagName("ks_energies")
eig_tot = 0
for kpt in ks_energies:
w = float(
kpt.getElementsByTagName('k_point')[0].getAttribute(
'weight'))
eigs = np.array(kpt.getElementsByTagName('eigenvalues')
[0].firstChild.nodeValue.split(' '),
dtype='f')
occs = np.array(
kpt.getElementsByTagName(
'occupations')[0].firstChild.nodeValue.split(' '),
dtype='f') #Non-integer occupations from DFT
eig_tot += w * sum(
eigs * occs) / 2 #Divide by two for both spins
#end for
print scf_dir, "e_tot eigenvalues in Ha ", eig_tot / 2
if scf_ks_energy == 0:
scf_ks_energy = eig_tot / 2
#end if
#end if
for tl_num, tl in enumerate(params.tilings):
for k in params.qmc_grids:
knum = k[1] * k[2] * k[0]
if params.relax:
relax = fine_relax #prim = scf_inf.load_analyzer_image().input_structure.copy()
print 'Make sure the previous run is loaded to results!'
#scf_inf.system.structure
else:
relax = scf_inf
prim = params.system.structure.copy()
#system = params.system
prim.clear_kpoints()
super = prim.tile(tl)
tl_np = np.array(tl)
tl_det = int(np.abs(np.linalg.det(tl_np)) + 0.001)
if params.natoms is not None:
natoms = tl_det * params.natoms
else:
natoms = len(super.elem)
#end if
if params.rcut:
rcut = params.rcut[tl_num]
else:
rcut = super.rwigner() - 0.00001
#end if
if params.tot_mag is not None and params.qp is False:
system = generate_physical_system(
structure=prim,
tiling=tl,
kgrid=k,
kshift=params.kshift, #(0, 0, 0),
net_charge=params.charge,
net_spin=params.tot_mag,
use_prim=False,
**params.system.valency)
elif params.qp is False:
system = generate_physical_system(
structure=prim,
tiling=tl,
kgrid=k,
shift=params.kshift, #(0, 0, 0),
net_charge=params.charge,
**params.system.valency)
else:
system = generate_physical_system(
structure=prim,
tiling=tl,
kgrid=k,
kshift=params.kshift, #(0, 0, 0),
use_prim=False,
**params.system.valency)
#end if
# DFT NSCF To Generate Wave Function At Specified K-points
if params.dft_grid == params.qmc_grids[0] and len(
params.qmc_grids) == 1:
params.nscf_skip = True
if not params.nscf_skip:
if params.relax:
nscf_dep = [(scf_inf, 'charge_density'),
(relax, 'structure')]
else:
nscf_dep = [(scf_inf, 'charge_density')]
#end if
nscf_path = './nscf-u-' + str(u) + '-' + str(
knum) + '-' + str(natoms)
p2q_path = nscf_path
nscf = generate_pwscf(
identifier='nscf',
path=nscf_path,
system=system,
#nosym = True,
nogamma=True,
dependencies=nscf_dep,
calculation='nscf',
**shared_qe)
sims.append(nscf)
if params.relax:
p2q_dep = [(nscf, 'orbitals'), (relax, 'structure')]
else:
p2q_dep = [(nscf, 'orbitals')]
#end if
else:
p2q_path = scf_path
if params.relax:
p2q_dep = [(scf_inf, 'orbitals'), (relax, 'structure')]
else:
p2q_dep = [(scf_inf, 'orbitals')]
#end if
#end if
# Convert DFT Wavefunction Into HDF5 File For QMCPACK
p2q = generate_pw2qmcpack(
identifier='p2q',
path=p2q_path,
job=p2q_job,
write_psir=False,
dependencies=p2q_dep,
)
sims.append(p2q)
if params.print_ke_corr and not params.nscf_skip:
import h5py
nscf_dir = nscf.remdir
pwscf_output = nscf.input.control.outdir
h5_file = nscf_dir + '/' + pwscf_output + '/pwscf.pwscf.h5'
#Assume equal weight for all k-points
eig_tot = 0
nkpts = 0
if os.path.isfile(h5_file):
f = h5py.File(h5_file, 'r+')
nelect = f['electrons']['number_of_electrons'][:]
for group_e in f['electrons'].keys():
if group_e.startswith('kpoint'):
nkpts += 1
f_temp = f['electrons'][group_e]
for group_k in f_temp.keys():
k_s_eig = [0]
w = 0
if group_k.startswith('spin_0'):
k_s_eig = f_temp[group_k][
'eigenvalues'][:]
k_s_eig = k_s_eig[0:nelect[
0]] #fixed occupations from the number of electrons
w = f_temp['weight'][0]
elif group_k.startswith('spin_1'):
k_s_eig = f_temp[group_k][
'eigenvalues'][:]
k_s_eig = k_s_eig[0:nelect[1]]
w = f_temp['weight'][0]
#pdb.set_trace()
#end if
eig_tot += sum(k_s_eig) * w / 2
#end for
#end if
#end fof
print nscf_dir, "e_tot eigenvalues in Ha", eig_tot / 2 - scf_ks_energy, "wigner " + str(
system['structure'].rwigner())
#end if
#end if
# DFT is complete, rest is QMC
# change here for other AFM atoms
system.rename(Co1='Co', Co2='Co', Co3='Co', folded=False)
system.rename(Ni1='Ni', Ni2='Ni', Ni3='Ni', folded=False)
# VMC Optimization
linopt1 = linear(
energy=0.0, # 0.95
unreweightedvariance=1.0,
reweightedvariance=0.0, # 0.05
timestep=0.3,
samples=samples,
walkers=walkers,
warmupsteps=10,
blocks=blocks,
steps=1,
substeps=10,
maxweight=1e9,
gpu=True,
minmethod='OneShiftOnly',
minwalkers=0.01,
usebuffer=True,
exp0=-6,
bigchange=10.0,
alloweddifference=1e-04,
stepsize=0.15,
nstabilizers=1,
)
# Quasiparticle calculation
if params.qp:
etot = system.particles.down_electron.count + system.particles.up_electron.count
upe = (etot + params.tot_mag * tl_det) / 2 - params.charge
downe = etot - params.charge - upe
system.particles.down_electron.count = downe
system.particles.up_electron.count = upe
#end if
# 1. VMC optimization is requested
# 2. VMC optimization is done on the first element uf ulist
# 3. VMC optimization is done on the first element of qmc_grids
if params.vmc_opt and u == params.ulist[
0] and k == params.qmc_grids[0]:
# VMC Variance minimization
opt_varmin = generate_qmcpack(
identifier='opt-varmin',
path='./opt-u-' + str(u) + '-' + str(natoms) +
'-varmin-' + str(params.j),
job=opt_job,
input_type='basic',
system=system,
spin_polarized=True, # jtk: needs this
meshfactor=1.0,
hybrid_rcut=params.hybrid_rcut,
hybrid_lmax=params.hybrid_lmax,
#spline_radius = params.spline_radius,
twistnum=params.twistnum,
#bconds = 'ppp',
pseudos=params.qmc_pps,
jastrows=[('J1', 'bspline', params.j, rcut),
('J2', 'bspline', params.j, rcut, 'init',
'zero')],
calculations=[
loop(max=6, qmc=linopt1),
loop(max=6, qmc=linopt1)
],
dependencies=(p2q, 'orbitals'))
sims.append(opt_varmin)
# QMC Optimization Parameters - Finer Sampling Set -- Energy Minimization
linopt2 = linopt1.copy()
linopt2.minwalkers = 0.5
linopt2.energy = 0.95
linopt2.unreweightedvariance = 0.0
linopt2.reweightedvariance = 0.05
linopt3 = linopt2.copy()
linopt3.minwalkers = 0.5
##
emin_dep = []
# Use preliminary optimization step made of two steps
if not params.nopre:
preopt_emin = generate_qmcpack(
identifier='opt-emin',
path='./preopt-u-' + str(u) + '-' + str(natoms) +
'-emin-' + str(params.j),
job=opt_job,
input_type='basic',
system=system,
spin_polarized=True, # jtk: needs this
meshfactor=params.meshfactor,
hybrid_rcut=params.hybrid_rcut,
hybrid_lmax=params.hybrid_lmax,
#spline_radius = params.spline_radius,
twistnum=params.twistnum,
#bconds = 'ppp',
pseudos=params.qmc_pps,
jastrows=[],
calculations=[loop(max=2, qmc=linopt2)],
dependencies=[(p2q, 'orbitals'),
(opt_varmin, 'jastrow')])
sims.append(preopt_emin)
emin_dep = preopt_emin
else:
emin_dep = opt_varmin
#end if
opt_emin = generate_qmcpack(
identifier='opt-emin',
path='./opt-u-' + str(u) + '-' + str(natoms) +
'-emin-' + str(params.j),
job=opt_job,
input_type='basic',
system=system,
spin_polarized=True, # jtk: needs this
meshfactor=params.meshfactor,
hybrid_rcut=params.hybrid_rcut,
hybrid_lmax=params.hybrid_lmax,
#spline_radius = params.spline_radius,
twistnum=params.twistnum,
#bconds = 'ppp',
pseudos=params.qmc_pps,
jastrows=[],
calculations=[
loop(max=4, qmc=linopt2),
loop(max=4, qmc=linopt3)
],
dependencies=[(p2q, 'orbitals'),
(emin_dep, 'jastrow')])
sims.append(opt_emin)
# 3-body jastrows
if params.j3:
j3_dep = []
linopt2.walkers = 16
linopt2.blocks = linopt2.blocks * 2
linopt2.samples = linopt1.samples * 2
j3_rcut = min(system['structure'].rwigner() - 0.0001,
4.0)
if not params.nopre:
preopt_emin_J3 = generate_qmcpack(
identifier='opt-emin-J3',
path='./preopt-u-' + str(u) + '-' +
str(natoms) + '-emin-J3-' + str(params.j),
job=opt_job,
input_type='basic',
system=system,
spin_polarized=True, # jtk: needs this
meshfactor=params.meshfactor,
hybrid_rcut=params.hybrid_rcut,
hybrid_lmax=params.hybrid_lmax,
#spline_radius = params.spline_radius,
twistnum=params.twistnum,
#bconds = 'ppp',
pseudos=params.qmc_pps,
jastrows=[('J3', 'polynomial', 3, 3, j3_rcut)],
calculations=[loop(max=2, qmc=linopt2)],
dependencies=[(p2q, 'orbitals'),
(opt_emin, 'jastrow')])
sims.append(preopt_emin_J3)
j3_dep = preopt_emin_J3
else:
j3_dep = opt_emin
#end if
opt_emin_J3 = generate_qmcpack(
identifier='opt-emin-J3',
path='./opt-u-' + str(u) + '-' + str(natoms) +
'-emin-J3-' + str(params.j),
job=opt_job,
input_type='basic',
system=system,
spin_polarized=True, # jtk: needs this
meshfactor=params.meshfactor,
hybrid_rcut=params.hybrid_rcut,
hybrid_lmax=params.hybrid_lmax,
#spline_radius = params.spline_radius,
twistnum=params.twistnum,
#bconds = 'ppp',
pseudos=params.qmc_pps,
jastrows=[('J3', 'polynomial', 3, 3, j3_rcut)],
calculations=[
loop(max=4, qmc=linopt2),
loop(max=4, qmc=linopt2)
],
dependencies=[(p2q, 'orbitals'),
(j3_dep, 'jastrow')])
sims.append(opt_emin_J3)
#end if
#end if
# VMC is complete, run DMC
dmc_nodes = np.round(
np.ceil(knum * dmcnodespertwist) / minnodes) * minnodes
dmc_job = Job(nodes=int(dmc_nodes),
hours=dmc_hours,
threads=qmc_threads,
app=qmcapp,
presub=qmc_presub)
# Add any future estimators here
from qmcpack_input import spindensity, skall, density
if params.density is not None:
est = [spindensity(grid=params.density)]
else:
est = None
#end if
#Initial VMC calculation to generate walkers for DMC
calculations = [
vmc(
warmupsteps=25,
blocks=vmcblocks,
steps=1,
stepsbetweensamples=1,
walkers=walkers,
timestep=vmcdt,
substeps=4,
samplesperthread=int(dmcwalkers /
(dmcnodespertwist * walkers)),
),
# dmc(
# warmupsteps =0,
# blocks =dmceqblocks/4,
# steps =5,
# timestep =0.04,
# nonlocalmoves=params.tmoves,
# ),
# dmc(
# warmupsteps =0,
# blocks =dmceqblocks/4,
# steps =5,
# timestep =0.02,
# nonlocalmoves=params.tmoves,
# ),
]
# Scan over timesteps
if params.timesteps is None:
params.timesteps = [0.01]
#end if
for t in params.timesteps:
calculations.append(
dmc(
warmupsteps=dmceqblocks / 2,
blocks=int(dmcblocks / (np.sqrt(t) * 10)),
steps=10,
timestep=t,
nonlocalmoves=params.tmoves,
))
#end for
# Prepanding name for the path
pathpre = 'dmc'
if params.vmc:
pathpre = 'vmc'
#end if
deps = [(p2q, 'orbitals')]
has_jastrow = False
# 3-body jastrow calculation with VMC or DMC
if params.j3:
has_jastrow = True
# add j3 dependenciies
if params.vmc_opt:
deps.append((opt_emin_J3, 'jastrow'))
#end if
if params.tmoves:
path = './' + pathpre + '-j3-tm-u-' + str(
u) + '-' + str(knum) + '-' + str(natoms)
else:
path = './' + pathpre + '-j3-nl-u-' + str(
u) + '-' + str(knum) + '-' + str(natoms)
#end if
#end if
# 2-body jastrow calculation with VMC or DMC
if params.j2:
has_jastrow = True
#add j2 dependencies
if params.vmc_opt:
deps.append((opt_emin, 'jastrow'))
#end if
if params.tmoves:
path = './' + pathpre + '-j2-tm-u-' + str(
u) + '-' + str(knum) + '-' + str(natoms)
else:
path = './' + pathpre + '-j2-nl-u-' + str(
u) + '-' + str(knum) + '-' + str(natoms)
#end if
#end if
# No jastrow calculation with VMC or DMC
if not has_jastrow:
if params.tmoves:
path = './' + pathpre + '-j0-tm-u-' + str(
u) + '-' + str(knum) + '-' + str(natoms)
else:
path = './' + pathpre + '-j0-nl-u-' + str(
u) + '-' + str(knum) + '-' + str(natoms)
#end if
#end if
det_format = 'new'
# Optical excitation
if params.excitation is not None:
path += '_' + params.excitation[
0] + '_' + params.excitation[1].replace(" ", "_")
det_format = 'old'
#end if
# Charged cell
if params.charge != 0:
path += '_' + str(params.charge)
#end if
if params.qmc:
qmc = generate_qmcpack(seed=params.seed,
skip_submit=params.qmc_skip_submit,
det_format=det_format,
identifier=pathpre,
path=path,
job=dmc_job,
input_type='basic',
system=system,
estimators=est,
meshfactor=params.meshfactor,
hybrid_rcut=params.hybrid_rcut,
hybrid_lmax=params.hybrid_lmax,
excitation=params.excitation,
pseudos=params.qmc_pps,
jastrows=[],
spin_polarized=True,
calculations=calculations,
dependencies=deps)
qmcs.append(qmc)
#end if
#end if
#end for
#end for
if params.bundle:
from bundle import bundle
qmcb = bundle(qmcs)
sims.append(qmcb)
else:
sims = sims + qmcs
return sims
from nexus import settings,job,run_project,obj
from nexus import generate_physical_system
from nexus import generate_pyscf
settings(
results = '',
sleep = 3,
machine = 'ws16',
)
system = generate_physical_system(
structure = 'H2O.xyz',
O = 6,
H = 1,
)
scf = generate_pyscf(
identifier = 'scf', # log output goes to scf.out
path = 'h2o_pp_hf', # directory to run in
job = job(serial=True), # pyscf must run serially
template = './scf_template.py', # pyscf template file
system = system,
mole = obj( # used to make Mole() inputs
basis = 'bfd-vtz',
ecp = 'bfd',
symmetry = True,
),
)
run_project()
elem_pos='''
C 0.00000000 0.00000000 0.00000000
H 0.00000000 0.00000000 1.10850000
H 1.04510382 0.00000000 -0.36950000
H -0.52255191 0.90508646 -0.36950000
H -0.52255191 -0.90508646 -0.36950000
''',
)
scf = generate_pyscf(
identifier='scf',
path='rhf',
job=job(serial=True),
template='./scf_template.py',
system=system,
mole=obj(basis='sto-3g', ),
checkpoint=True,
)
p2a = generate_pyscf_to_afqmc(
identifier='p2a',
path='rhf',
job=job(serial=True),
cholesky_threshold=1e-5,
verbose=True,
dependencies=(scf, 'wavefunction'),
)
qmc = generate_qmcpack(
identifier='qmc',
path='afqmc',
machine = 'ws16',
)
system = generate_physical_system(
units = 'A',
elem_pos = 'Ne 0 0 0',
)
scf = generate_pyscf(
identifier = 'scf',
path = 'rhf',
job = job(serial=True),
template = './scf_template.py',
system = system,
mole = obj(
verbose = 4,
basis = 'aug-cc-pvdz',
),
checkpoint = True,
)
p2a = generate_pyscf_to_afqmc(
identifier = 'p2a',
path = 'rhf',
job = job(serial=True),
cholesky_threshold = 1e-5,
dependencies = (scf,'wavefunction'),
)
qmc = generate_qmcpack(
identifier = 'qmc',
path = 'afqmc',
job = gms_job,
system = h2o,
pseudos = ['O.BFD_V5Z.gms','H.BFD_V5Z_ANO.gms'],
scftyp = 'mcscf',
runtyp = 'energy',
exetyp = 'run',
ispher = 1,
maxit = 200,
memory = 150000000,
dirscf = True,
symmetry = 'Cnv 2',
drt = obj(
group = 'C2v',
nmcc = 0,
ndoc = 4,
nalp = 0,
nval = 4,
istsym = 1,
mxnint = 500000,
fors = True,
),
mcscf = obj(
cistep = 'guga',
maxit = 1000,
fullnr = True,
acurcy = 1e-5,
),
dependencies = (rhf,'orbitals')
)
sims.append(cas)
run_project(sims)
elem=('C', 'C'),
pos=[[0, 0, 0], [a / 4, a / 4, a / 4]],
tiling=(2, 2, 2),
kgrid=(1, 1, 1),
kshift=(0, 0, 0),
)
scf = generate_pyscf(
identifier='scf',
path='rhf',
job=job(serial=True),
template='./scf_template.py',
system=system,
cell=obj(
basis='gth-szv',
pseudo='gth-pade',
mesh=[25, 25, 25],
verbose=5,
),
checkpoint=True,
)
p2a = generate_pyscf_to_afqmc(
identifier='p2a',
path='rhf',
job=job(serial=True),
cholesky_threshold=1e-5,
ao=True,
kpoint=True,
verbose=True,
dependencies=(scf, 'wavefunction'),
)
pseudos = ['O.BFD_V5Z.gms','H.BFD_V5Z_ANO.gms'],
scftyp = 'none',
cityp = 'guga',
runtyp = 'energy',
exetyp = 'run',
ispher = 1,
maxit = 200,
memory = 150000000,
dirscf = True,
symmetry = 'Cnv 2',
cidrt = obj(
group = 'C2v',
nfzc = 0,
ndoc = 4,
nalp = 0,
nval = 60,
nprt = 2,
istsym = 1,
iexcit = 2,
mxnint = 500000,
),
gugdia = obj(
prttol = 0.001,
cvgtol = 1.0e-5,
itermx = 1000,
),
dependencies = (rhf,'orbitals')
)
run_project()
)
system = generate_physical_system(
units='A',
elem_pos='C 0 0 0',
net_spin=2,
)
scf = generate_pyscf(
identifier='scf',
path='uhf',
job=job(serial=True),
template='./scf_template.py',
system=system,
mole=obj(
verbose=4,
basis='cc-pvtz',
),
checkpoint=True,
)
p2a = generate_pyscf_to_afqmc(
identifier='p2a',
path='uhf',
job=job(serial=True),
cholesky_threshold=1e-5,
ao=True,
verbose=True,
dependencies=(scf, 'wavefunction'),
)
qmc = generate_qmcpack(
