def get_zero_backflow(rcut):
from qmcpack_input import generate_transformation1, generate_transformation2
tr1 = generate_transformation1(['H'], rcut)
tr2 = generate_transformation2([('u', 'u'), ('u', 'd')], rcut)
from qmcpack_input import backflow, collection
bf = backflow(transformations=collection([tr1, tr2]))
return bf
def incorporate_result(self,result_name,result,sim):
input = self.input
system = self.system
if result_name=='orbitals':
if isinstance(sim,Pw2qmcpack) or isinstance(sim,Wfconvert):
h5file = result.h5file
wavefunction = input.get('wavefunction')
if isinstance(wavefunction,collection):
wavefunction = wavefunction.get_single('psi0')
#end if
wf = wavefunction
if 'sposet_builder' in wf and wf.sposet_builder.type=='bspline':
orb_elem = wf.sposet_builder
elif 'sposet_builders' in wf and 'bspline' in wf.sposet_builders:
orb_elem = wf.sposet_builders.bspline
elif 'sposet_builders' in wf and 'einspline' in wf.sposet_builders:
orb_elem = wf.sposet_builders.einspline
elif 'determinantset' in wf and wf.determinantset.type in ('bspline','einspline'):
orb_elem = wf.determinantset
else:
self.error('could not incorporate pw2qmcpack/wfconvert orbitals\nbspline sposet_builder and determinantset are both missing')
#end if
if 'href' in orb_elem and isinstance(orb_elem.href,str) and os.path.exists(orb_elem.href):
# user specified h5 file for orbitals, bypass orbital dependency
orb_elem.href = os.path.relpath(orb_elem.href,self.locdir)
else:
orb_elem.href = os.path.relpath(h5file,self.locdir)
if system.structure.folded_structure!=None:
orb_elem.tilematrix = array(system.structure.tmatrix)
#end if
#end if
defs = obj(
#twistnum = 0,
meshfactor = 1.0
)
for var,val in defs.iteritems():
if not var in orb_elem:
orb_elem[var] = val
#end if
#end for
has_twist = 'twist' in orb_elem
has_twistnum = 'twistnum' in orb_elem
if not has_twist and not has_twistnum:
orb_elem.twistnum = 0
#end if
system = self.system
structure = system.structure
nkpoints = len(structure.kpoints)
if nkpoints==0:
self.error('system must have kpoints to assign twistnums')
#end if
if not os.path.exists(h5file):
self.error('wavefunction file not found: \n'+h5file)
#end if
twistnums = range(len(structure.kpoints))
if self.should_twist_average:
self.twist_average(twistnums)
elif not has_twist and orb_elem.twistnum is None:
orb_elem.twistnum = twistnums[0]
#end if
elif isinstance(sim,Sqd):
h5file = os.path.join(result.dir,result.h5file)
h5file = os.path.relpath(h5file,self.locdir)
sqdxml_loc = os.path.join(result.dir,result.qmcfile)
sqdxml = QmcpackInput(sqdxml_loc)
#sqd sometimes puts the wrong ionic charge
# rather than setting Z to the number of electrons
# set it to the actual atomic number
g = sqdxml.qmcsystem.particlesets.atom.group
elem = g.name
if not elem in periodic_table.elements:
self.error(elem+' is not an element in the periodic table')
#end if
g.charge = periodic_table.elements[elem].atomic_number
input = self.input
s = input.simulation
qsys_old = s.qmcsystem
del s.qmcsystem
s.qmcsystem = sqdxml.qmcsystem
if 'jastrows' in qsys_old.wavefunction:
s.qmcsystem.wavefunction.jastrows = qsys_old.wavefunction.jastrows
for jastrow in s.qmcsystem.wavefunction.jastrows:
if 'type' in jastrow:
jtype = jastrow.type.lower().replace('-','_')
if jtype=='one_body':
jastrow.source = 'atom'
#end if
#end if
#end for
#end if
s.qmcsystem.hamiltonian = hamiltonian(
name='h0',type='generic',target='e',
pairpots = [
pairpot(name='ElecElec',type='coulomb',source='e',target='e'),
pairpot(name='Coulomb' ,type='coulomb',source='atom',target='e'),
]
)
s.init = init(source='atom',target='e')
abset = input.get('atomicbasisset')
abset.href = h5file
elif isinstance(sim,Convert4qmc):
res = QmcpackInput(result.location)
qs = input.simulation.qmcsystem
oldwfn = qs.wavefunction
newwfn = res.qmcsystem.wavefunction
dset = newwfn.determinantset
if 'jastrows' in newwfn:
del newwfn.jastrows
#end if
if 'jastrows' in oldwfn:
newwfn.jastrows = oldwfn.jastrows
#end if
if input.cusp_correction():
dset.cuspcorrection = True
#end if
if 'orbfile' in result:
orb_h5file = result.orbfile
if not os.path.exists(orb_h5file) and 'href' in dset:
orb_h5file = os.path.join(sim.locdir,dset.href)
#end if
if not os.path.exists(orb_h5file):
self.error('orbital h5 file from convert4qmc does not exist\nlocation checked: {}'.format(orb_h5file))
#end if
orb_path = os.path.relpath(orb_h5file,self.locdir)
dset.href = orb_path
detlist = dset.get('detlist')
if detlist is not None and 'href' in detlist:
detlist.href = orb_path
#end if
#end if
qs.wavefunction = newwfn
else:
self.error('incorporating orbitals from '+sim.__class__.__name__+' has not been implemented')
#end if
elif result_name=='jastrow':
if isinstance(sim,Qmcpack):
opt_file = result.opt_file
opt = QmcpackInput(opt_file)
wavefunction = input.get('wavefunction')
optwf = opt.qmcsystem.wavefunction
def process_jastrow(wf):
if 'jastrow' in wf:
js = [wf.jastrow]
elif 'jastrows' in wf:
js = wf.jastrows.values()
else:
js = []
#end if
jd = dict()
for j in js:
jtype = j.type.lower().replace('-','_').replace(' ','_')
jd[jtype] = j
#end for
return jd
#end def process_jastrow
if wavefunction==None:
qs = input.get('qmcsystem')
qs.wavefunction = optwf.copy()
else:
jold = process_jastrow(wavefunction)
jopt = process_jastrow(optwf)
jnew = list(jopt.values())
for jtype in jold.keys():
if not jtype in jopt:
jnew.append(jold[jtype])
#end if
#end for
if len(jnew)==1:
wavefunction.jastrow = jnew[0].copy()
else:
wavefunction.jastrows = collection(jnew)
#end if
#end if
del optwf
elif isinstance(sim,Sqd):
wavefunction = input.get('wavefunction')
jastrows = []
if 'jastrows' in wavefunction:
for jastrow in wavefunction.jastrows:
jname = jastrow.name
if jname!='J1' and jname!='J2':
jastrows.append(jastrow)
#end if
#end for
del wavefunction.jastrows
#end if
ionps = input.get_ion_particlesets()
if ionps is None or len(ionps)==0:
self.error('ion particleset does not seem to exist')
elif len(ionps)==1:
ionps_name = list(ionps.keys())[0]
else:
self.error('multiple ion species not supported for atomic calculations')
#end if
jastrows.extend([
generate_jastrow('J1','bspline',8,result.rcut,iname=ionps_name,system=self.system),
generate_jastrow('J2','pade',result.B)
])
wavefunction.jastrows = collection(jastrows)
else:
self.error('incorporating jastrow from '+sim.__class__.__name__+' has not been implemented')
#end if
elif result_name=='particles':
if isinstance(sim,Convert4qmc):
ptcl_file = result.location
qi = QmcpackInput(ptcl_file)
self.input.simulation.qmcsystem.particlesets = qi.qmcsystem.particlesets
else:
self.error('incorporating particles from '+sim.__class__.__name__+' has not been implemented')
# end if
elif result_name=='structure':
relstruct = result.structure.copy()
relstruct.change_units('B')
self.system.structure = relstruct
self.system.remove_folded()
self.input.incorporate_system(self.system)
elif result_name=='cuspcorr':
ds = self.input.get('determinantset')
ds.cuspcorrection = True
try: # multideterminant
ds.sposets['spo-up'].cuspinfo = os.path.relpath(result.spo_up_cusps,self.locdir)
ds.sposets['spo-dn'].cuspinfo = os.path.relpath(result.spo_dn_cusps,self.locdir)
except: # single determinant
sd = ds.slaterdeterminant
sd.determinants['updet'].cuspinfo = os.path.relpath(result.updet_cusps,self.locdir)
sd.determinants['downdet'].cuspinfo = os.path.relpath(result.dndet_cusps,self.locdir)
# end try
elif result_name=='wavefunction':
if not isinstance(sim,Qmcpack):
self.error('incorporating wavefunction from '+sim.__class__.__name__+' has not been implemented')
#end if
print ' getting optimal wavefunction from: '+result.opt_file
opt = QmcpackInput(result.opt_file)
qs = input.get('qmcsystem')
qs.wavefunction = opt.qmcsystem.wavefunction.copy()
else:
self.error('ability to incorporate result '+result_name+' has not been implemented')
def incorporate_result(self, result_name, result, sim):
input = self.input
system = self.system
if result_name == 'orbitals':
if isinstance(sim, Pw2qmcpack):
h5file = result.h5file
wavefunction = input.get('wavefunction')
if isinstance(wavefunction, collection):
wavefunction = wavefunction.get_single('psi0')
#end if
wf = wavefunction
if 'sposet_builder' in wf and wf.sposet_builder.type == 'bspline':
orb_elem = wf.sposet_builder
elif 'sposet_builders' in wf and 'bspline' in wf.sposet_builders:
orb_elem = wf.sposet_builders.bspline
elif 'sposet_builders' in wf and 'einspline' in wf.sposet_builders:
orb_elem = wf.sposet_builders.einspline
elif 'determinantset' in wf and wf.determinantset.type in (
'bspline', 'einspline'):
orb_elem = wf.determinantset
else:
self.error(
'could not incorporate pw2qmcpack orbitals\nbspline sposet_builder and determinantset are both missing'
)
#end if
if 'href' in orb_elem and isinstance(
orb_elem.href, str) and os.path.exists(orb_elem.href):
# user specified h5 file for orbitals, bypass orbital dependency
orb_elem.href = os.path.relpath(orb_elem.href, self.locdir)
else:
orb_elem.href = os.path.relpath(h5file, self.locdir)
if system.structure.folded_structure != None:
orb_elem.tilematrix = array(system.structure.tmatrix)
#end if
#end if
defs = obj(
#twistnum = 0,
meshfactor=1.0)
for var, val in defs.items():
if not var in orb_elem:
orb_elem[var] = val
#end if
#end for
has_twist = 'twist' in orb_elem
has_twistnum = 'twistnum' in orb_elem
if not has_twist and not has_twistnum:
orb_elem.twistnum = 0
#end if
system = self.system
structure = system.structure
nkpoints = len(structure.kpoints)
if nkpoints == 0:
self.error('system must have kpoints to assign twistnums')
#end if
if not os.path.exists(h5file):
self.error('wavefunction file not found:\n' + h5file)
#end if
twistnums = list(range(len(structure.kpoints)))
if self.should_twist_average:
self.twist_average(twistnums)
elif not has_twist and orb_elem.twistnum is None:
orb_elem.twistnum = twistnums[0]
#end if
elif isinstance(sim, Convert4qmc):
res = QmcpackInput(result.location)
qs = input.simulation.qmcsystem
oldwfn = qs.wavefunction
newwfn = res.qmcsystem.wavefunction
dset = newwfn.determinantset
if 'jastrows' in newwfn:
del newwfn.jastrows
#end if
if 'jastrows' in oldwfn:
newwfn.jastrows = oldwfn.jastrows
#end if
if input.cusp_correction():
dset.cuspcorrection = True
#end if
if 'orbfile' in result:
orb_h5file = result.orbfile
if not os.path.exists(orb_h5file) and 'href' in dset:
orb_h5file = os.path.join(sim.locdir, dset.href)
#end if
if not os.path.exists(orb_h5file):
self.error(
'orbital h5 file from convert4qmc does not exist\nlocation checked: {}'
.format(orb_h5file))
#end if
orb_path = os.path.relpath(orb_h5file, self.locdir)
dset.href = orb_path
detlist = dset.get('detlist')
if detlist is not None and 'href' in detlist:
detlist.href = orb_path
#end if
#end if
qs.wavefunction = newwfn
else:
self.error('incorporating orbitals from ' +
sim.__class__.__name__ +
' has not been implemented')
#end if
elif result_name == 'jastrow':
if isinstance(sim, Qmcpack):
opt_file = result.opt_file
opt = QmcpackInput(opt_file)
wavefunction = input.get('wavefunction')
optwf = opt.qmcsystem.wavefunction
def process_jastrow(wf):
if 'jastrow' in wf:
js = [wf.jastrow]
elif 'jastrows' in wf:
js = list(wf.jastrows.values())
else:
js = []
#end if
jd = dict()
for j in js:
jtype = j.type.lower().replace('-',
'_').replace(' ', '_')
key = jtype
# take care of multiple jastrows of the same type
if key in jd: # use name to distinguish
key += j.name
if key in jd: # if still duplicate then error out
msg = 'duplicate jastrow in ' + self.__class__.__name__
self.error(msg)
#end if
#end if
jd[key] = j
#end for
return jd
#end def process_jastrow
if wavefunction == None:
qs = input.get('qmcsystem')
qs.wavefunction = optwf.copy()
else:
jold = process_jastrow(wavefunction)
jopt = process_jastrow(optwf)
jnew = list(jopt.values())
for jtype in jold.keys():
if not jtype in jopt:
jnew.append(jold[jtype])
#end if
#end for
if len(jnew) == 1:
wavefunction.jastrow = jnew[0].copy()
else:
wavefunction.jastrows = collection(jnew)
#end if
#end if
del optwf
elif result_name == 'particles':
if isinstance(sim, Convert4qmc):
ptcl_file = result.location
qi = QmcpackInput(ptcl_file)
self.input.simulation.qmcsystem.particlesets = qi.qmcsystem.particlesets
else:
self.error('incorporating particles from ' +
sim.__class__.__name__ +
' has not been implemented')
# end if
elif result_name == 'structure':
relstruct = result.structure.copy()
relstruct.change_units('B')
self.system.structure = relstruct
self.system.remove_folded()
self.input.incorporate_system(self.system)
elif result_name == 'cuspcorr':
ds = self.input.get('determinantset')
ds.cuspcorrection = True
try: # multideterminant
ds.sposets['spo-up'].cuspinfo = os.path.relpath(
result.spo_up_cusps, self.locdir)
ds.sposets['spo-dn'].cuspinfo = os.path.relpath(
result.spo_dn_cusps, self.locdir)
except: # single determinant
sd = ds.slaterdeterminant
sd.determinants['updet'].cuspinfo = os.path.relpath(
result.updet_cusps, self.locdir)
sd.determinants['downdet'].cuspinfo = os.path.relpath(
result.dndet_cusps, self.locdir)
#end try
elif result_name == 'wavefunction':
if isinstance(sim, Qmcpack):
opt = QmcpackInput(result.opt_file)
qs = input.get('qmcsystem')
qs.wavefunction = opt.qmcsystem.wavefunction.copy()
elif isinstance(sim, PyscfToAfqmc):
if not self.input.is_afqmc_input():
self.error(
'incorporating wavefunction from {} is only supported for AFQMC calculations'
.format(sim.__class__.__name__))
#end if
h5_file = os.path.relpath(result.h5_file, self.locdir)
wfn = self.input.simulation.wavefunction
ham = self.input.simulation.hamiltonian
wfn.filename = h5_file
wfn.filetype = 'hdf5'
if 'filename' not in ham or ham.filename == 'MISSING.h5':
ham.filename = h5_file
ham.filetype = 'hdf5'
#end if
if 'xml' in result:
xml = QmcpackInput(result.xml)
info_new = xml.simulation.afqmcinfo.copy()
info = self.input.simulation.afqmcinfo
info.set_optional(**info_new)
# override particular inputs set by default
if 'generation_info' in input._metadata:
g = input._metadata.generation_info
if 'walker_type' not in g:
walker_type = xml.get('walker_type')
walkerset = input.get('walkerset')
if walker_type is not None and walkerset is not None:
walkerset.walker_type = walker_type
#end if
#end if
#end if
#end if
else:
self.error('incorporating wavefunction from ' +
sim.__class__.__name__ +
' has not been implemented')
#end if
elif result_name == 'gc_occupation':
from pwscf import Pwscf
from qmcpack_converters import gcta_occupation
if not isinstance(sim, Pw2qmcpack):
msg = 'grand-canonical occupation require Pw2qmcpack'
self.error(msg)
#endif
# step 1: extract Fermi energy for each spin from nscf
nscf = None
npwdep = 0
for dep in sim.dependencies:
if isinstance(dep.sim, Pwscf):
nscf = dep.sim
npwdep += 1
if npwdep != 1:
msg = 'need exactly 1 scf/nscf calculation for Fermi energy'
msg += '\n found %d' % npwdep
self.error(msg)
#end if
na = nscf.load_analyzer_image()
Ef_list = na.fermi_energies
# step 2: analyze ESH5 file for states below Fermi energy
pa = sim.load_analyzer_image()
if 'wfh5' not in pa:
pa.analyze(Ef_list=Ef_list)
sim.save_analyzer_image(pa)
#end if
# step 3: count the number of up/dn electrons at each supertwist
s1 = self.system.structure
ntwist = len(s1.kpoints)
nelecs_at_twist = gcta_occupation(pa.wfh5, ntwist)
self.nelecs_at_twist = nelecs_at_twist
else:
self.error('ability to incorporate result ' + result_name +
' has not been implemented')
def incorporate_result(self,result_name,result,sim):
input = self.input
system = self.system
if result_name=='orbitals':
if isinstance(sim,Pw2qmcpack) or isinstance(sim,Wfconvert):
h5file = result.h5file
wavefunction = input.get('wavefunction')
if isinstance(wavefunction,collection):
wavefunction = wavefunction.get_single('psi0')
#end if
wf = wavefunction
if 'sposet_builder' in wf and wf.sposet_builder.type=='bspline':
orb_elem = wf.sposet_builder
elif 'sposet_builders' in wf and 'bspline' in wf.sposet_builders:
orb_elem = wf.sposet_builders.bspline
elif 'determinantset' in wf and wf.determinantset.type in ('bspline','einspline'):
orb_elem = wf.determinantset
else:
self.error('could not incorporate pw2qmcpack/wfconvert orbitals\n bspline sposet_builder and determinantset are both missing')
#end if
orb_elem.href = os.path.relpath(h5file,self.locdir)
if system.structure.folded_structure!=None:
orb_elem.tilematrix = array(system.structure.tmatrix)
#end if
defs = obj(
twistnum = 0,
meshfactor = 1.0
)
for var,val in defs.iteritems():
if not var in orb_elem:
orb_elem[var] = val
#end if
#end for
system = self.system
structure = system.structure
nkpoints = len(structure.kpoints)
if nkpoints==0:
self.error('system must have kpoints to assign twistnums')
#end if
if not os.path.exists(h5file):
self.error('wavefunction file not found: \n'+h5file)
#end if
twistnums = range(len(structure.kpoints))
if self.should_twist_average:
self.twist_average(twistnums)
elif orb_elem.twistnum is None:
orb_elem.twistnum = twistnums[0]
#end if
elif isinstance(sim,Sqd):
h5file = os.path.join(result.dir,result.h5file)
h5file = os.path.relpath(h5file,self.locdir)
sqdxml_loc = os.path.join(result.dir,result.qmcfile)
sqdxml = QmcpackInput(sqdxml_loc)
#sqd sometimes puts the wrong ionic charge
# rather than setting Z to the number of electrons
# set it to the actual atomic number
g = sqdxml.qmcsystem.particlesets.atom.group
elem = g.name
if not elem in periodic_table.elements:
self.error(elem+' is not an element in the periodic table')
#end if
g.charge = periodic_table.elements[elem].atomic_number
input = self.input
s = input.simulation
qsys_old = s.qmcsystem
del s.qmcsystem
s.qmcsystem = sqdxml.qmcsystem
if 'jastrows' in qsys_old.wavefunction:
s.qmcsystem.wavefunction.jastrows = qsys_old.wavefunction.jastrows
for jastrow in s.qmcsystem.wavefunction.jastrows:
if 'type' in jastrow:
jtype = jastrow.type.lower().replace('-','_')
if jtype=='one_body':
jastrow.source = 'atom'
#end if
#end if
#end for
#end if
s.qmcsystem.hamiltonian = hamiltonian(
name='h0',type='generic',target='e',
pairpots = [
pairpot(name='ElecElec',type='coulomb',source='e',target='e'),
pairpot(name='Coulomb' ,type='coulomb',source='atom',target='e'),
]
)
s.init = init(source='atom',target='e')
abset = input.get('atomicbasisset')
abset.href = h5file
else:
self.error('incorporating orbitals from '+sim.__class__.__name__+' has not been implemented')
#end if
elif result_name=='jastrow':
if isinstance(sim,Qmcpack):
opt_file = result.opt_file
opt = QmcpackInput(opt_file)
wavefunction = input.get('wavefunction')
optwf = opt.qmcsystem.wavefunction
def process_jastrow(wf):
if 'jastrow' in wf:
js = [wf.jastrow]
elif 'jastrows' in wf:
js = wf.jastrows.values()
else:
js = []
#end if
jd = dict()
for j in js:
jtype = j.type.lower().replace('-','_').replace(' ','_')
jd[jtype] = j
#end for
return jd
#end def process_jastrow
if wavefunction==None:
qs = input.get('qmcsystem')
qs.wavefunction = optwf.copy()
else:
jold = process_jastrow(wavefunction)
jopt = process_jastrow(optwf)
jnew = list(jopt.values())
for jtype in jold.keys():
if not jtype in jopt:
jnew.append(jold[jtype])
#end if
#end for
if len(jnew)==1:
wavefunction.jastrow = jnew[0].copy()
else:
wavefunction.jastrows = collection(jnew)
#end if
#end if
del optwf
elif isinstance(sim,Sqd):
wavefunction = input.get('wavefunction')
jastrows = []
if 'jastrows' in wavefunction:
for jastrow in wavefunction.jastrows:
jname = jastrow.name
if jname!='J1' and jname!='J2':
jastrows.append(jastrow)
#end if
#end for
del wavefunction.jastrows
#end if
ionps = input.get_ion_particlesets()
if ionps is None or len(ionps)==0:
self.error('ion particleset does not seem to exist')
elif len(ionps)==1:
ionps_name = list(ionps.keys())[0]
else:
self.error('multiple ion species not supported for atomic calculations')
#end if
jastrows.extend([
generate_jastrow('J1','bspline',8,result.rcut,iname=ionps_name,system=self.system),
generate_jastrow('J2','pade',result.B)
])
wavefunction.jastrows = collection(jastrows)
else:
self.error('incorporating jastrow from '+sim.__class__.__name__+' has not been implemented')
#end if
elif result_name=='structure':
structure = self.system.structure
relstruct = result.structure
structure.set(
pos = relstruct.positions,
atoms = relstruct.atoms
)
self.input.incorporate_system(self.system)
else:
self.error('ability to incorporate result '+result_name+' has not been implemented')
def incorporate_result(self, result_name, result, sim):
input = self.input
system = self.system
if result_name == "orbitals":
if isinstance(sim, Pw2qmcpack) or isinstance(sim, Wfconvert):
h5file = result.h5file
dsold, wavefunction = input.get("determinantset", "wavefunction")
if isinstance(wavefunction, collection):
if "psi0" in wavefunction:
wavefunction = wavefunction.psi0
else:
wavefunction = wavefunction.list()[0]
# end if
# end if
dsnew = dsold
dsnew.set(type="einspline", href=os.path.relpath(h5file, self.locdir))
if system.structure.folded_structure != None:
dsnew.tilematrix = array(system.structure.tmatrix)
# end if
defs = obj(twistnum=0, meshfactor=1.0, gpu=False)
for var, val in defs.iteritems():
if not var in dsnew:
dsnew[var] = val
# end if
# end for
input.remove("determinantset")
wavefunction.determinantset = dsnew
system = self.system
structure = system.structure
nkpoints = len(structure.kpoints)
if nkpoints == 0:
self.error("system must have kpoints to assign twistnums")
# end if
if not os.path.exists(h5file):
self.error("wavefunction file not found: \n" + h5file)
# end if
if "tilematrix" in system:
dsnew.tilematrix = array(system.tilematrix)
# end if
twistnums = range(len(structure.kpoints))
if len(twistnums) > 1:
self.twist_average(twistnums)
else:
dsnew.twistnum = twistnums[0]
# end if
elif isinstance(sim, Sqd):
h5file = os.path.join(result.dir, result.h5file)
h5file = os.path.relpath(h5file, self.locdir)
sqdxml_loc = os.path.join(result.dir, result.qmcfile)
sqdxml = QmcpackInput(sqdxml_loc)
# sqd sometimes puts the wrong ionic charge
# rather than setting Z to the number of electrons
# set it to the actual atomic number
g = sqdxml.qmcsystem.particlesets.atom.group
elem = g.name
if not elem in periodic_table.elements:
self.error(elem + " is not an element in the periodic table")
# end if
g.charge = periodic_table.elements[elem].atomic_number
input = self.input
s = input.simulation
qsys_old = s.qmcsystem
del s.qmcsystem
s.qmcsystem = sqdxml.qmcsystem
if "jastrows" in qsys_old.wavefunction:
s.qmcsystem.wavefunction.jastrows = qsys_old.wavefunction.jastrows
for jastrow in s.qmcsystem.wavefunction.jastrows:
if "type" in jastrow:
jtype = jastrow.type.lower().replace("-", "_")
if jtype == "one_body":
jastrow.source = "atom"
# end if
# end if
# end for
# end if
s.qmcsystem.hamiltonian = hamiltonian(
name="h0",
type="generic",
target="e",
pairpots=[
pairpot(name="ElecElec", type="coulomb", source="e", target="e"),
pairpot(name="Coulomb", type="coulomb", source="atom", target="e"),
],
)
s.init = init(source="atom", target="e")
abset = input.get("atomicbasisset")
abset.href = h5file
else:
self.error("incorporating orbitals from " + sim.__class__.__name__ + " has not been implemented")
# end if
elif result_name == "jastrow":
if isinstance(sim, Qmcpack):
opt_file = result.opt_file
opt = QmcpackInput(opt_file)
wavefunction = input.get("wavefunction")
optwf = opt.qmcsystem.wavefunction
def process_jastrow(wf):
if "jastrow" in wf:
js = [wf.jastrow]
elif "jastrows" in wf:
js = wf.jastrows.values()
else:
js = []
# end if
jd = dict()
for j in js:
jtype = j.type.lower().replace("-", "_").replace(" ", "_")
jd[jtype] = j
# end for
return jd
# end def process_jastrow
if wavefunction == None:
qs = input.get("qmcsystem")
qs.wavefunction = optwf.copy()
else:
jold = process_jastrow(wavefunction)
jopt = process_jastrow(optwf)
jnew = list(jopt.values())
for jtype in jold.keys():
if not jtype in jopt:
jnew.append(jold[jtype])
# end if
# end for
if len(jnew) == 1:
wavefunction.jastrow = jnew[0].copy()
else:
wavefunction.jastrows = collection(jnew)
# end if
# end if
del optwf
elif isinstance(sim, Sqd):
wavefunction = input.get("wavefunction")
jastrows = []
if "jastrows" in wavefunction:
for jastrow in wavefunction.jastrows:
jname = jastrow.name
if jname != "J1" and jname != "J2":
jastrows.append(jastrow)
# end if
# end for
del wavefunction.jastrows
# end if
ionps = input.get_ion_particlesets()
if ionps is None or len(ionps) == 0:
self.error("ion particleset does not seem to exist")
elif len(ionps) == 1:
ionps_name = list(ionps.keys())[0]
else:
self.error("multiple ion species not supported for atomic calculations")
# end if
jastrows.extend(
[
generate_jastrow("J1", "bspline", 8, result.rcut, iname=ionps_name, system=self.system),
generate_jastrow("J2", "pade", result.B),
]
)
wavefunction.jastrows = collection(jastrows)
else:
self.error("incorporating jastrow from " + sim.__class__.__name__ + " has not been implemented")
# end if
elif result_name == "structure":
structure = self.system.structure
relstruct = result.structure
structure.set(pos=relstruct.positions, atoms=relstruct.atoms)
self.input.incorporate_system(self.system)
else:
self.error("ability to incorporate result " + result_name + " has not been implemented")