def load_data_local(self):
info = self.info
if info.load_jastrow:
self.load_jastrow_data()
elif 'filepath' in info:
qxml = QmcpackInput(info.filepath)
wavefunction = qxml.get('wavefunction')
wavefunction = wavefunction.get_single('psi0')
self.info.wfn_xml = wavefunction
#end if
if not info.load_jastrow:
self.info.wfn_xml.pluralize()
def load_data_local(self):
info = self.info
if info.load_jastrow:
self.load_jastrow_data()
elif 'filepath' in info:
try:
qxml = QmcpackInput(info.filepath)
wavefunction = qxml.get('wavefunction')
wavefunction = wavefunction.get_single('psi0')
info.wfn_xml = wavefunction
except:
info.wfn_xml = None
info.fail = True
#end try
#end if
if not info.load_jastrow and not info.fail:
info.wfn_xml.pluralize()
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 init_sub_analyzers(self, request=None):
own_request = request == None
if request == None:
request = self.info.request
#end if
group_num = request.group_num
#determine if the run was bundled
if request.source.endswith('.xml'):
self.info.type = 'single'
else:
self.info.type = 'bundled'
self.bundle(request.source)
return
#end if
self.vlog('reading input file: ' + request.source, n=1)
input = QmcpackInput(request.source)
input.pluralize()
input.unroll_calculations()
calculations = input.simulation.calculations
self.info.set(input=input,
ordered_input=input.read_xml(request.source))
project, wavefunction = input.get('project', 'wavefunction')
wavefunction = wavefunction.get_single('psi0')
subindent = self.subindent()
self.wavefunction = WavefunctionAnalyzer(wavefunction,
nindent=subindent)
self.vlog('project id: ' + project.id, n=1)
file_prefix = project.id
if group_num != None:
group_ext = '.g' + str(group_num).zfill(3)
if not file_prefix.endswith(group_ext):
file_prefix += group_ext
#end if
elif self.info.type == 'single':
resdir, infile = os.path.split(request.source)
#ifprefix = infile.replace('.xml','')
ifprefix = infile.replace('.xml', '.')
ls = os.listdir(resdir)
for filename in ls:
if filename.startswith(ifprefix) and filename.endswith('.qmc'):
group_tag = filename.split('.')[-2]
#file_prefix = 'qmc.'+group_tag
file_prefix = project.id + '.' + group_tag
break
#end if
#end for
#end if
if 'series' in project:
series_start = int(project.series)
else:
series_start = 0
#end if
self.vlog('data file prefix: ' + file_prefix, n=1)
run_info = obj(file_prefix=file_prefix,
series_start=series_start,
source_path=os.path.split(request.source)[0],
group_num=group_num,
system=input.return_system())
self.info.transfer_from(run_info)
self.set_global_info()
if len(request.calculations) == 0:
request.calculations = set(series_start +
arange(len(calculations)))
#end if
method_aliases = dict()
for method in self.opt_methods:
method_aliases[method] = 'opt'
#end for
for method in self.vmc_methods:
method_aliases[method] = 'vmc'
#end for
for method in self.dmc_methods:
method_aliases[method] = 'dmc'
#end for
method_objs = ['qmc', 'opt', 'vmc', 'dmc']
for method in method_objs:
self[method] = QAanalyzerCollection()
#end for
for index, calc in calculations.iteritems():
method = calc.method
if method in method_aliases:
method_type = method_aliases[method]
else:
self.error('method ' + method + ' is unrecognized')
#end if
if method_type in request.methods:
series = series_start + index
if series in request.calculations:
if method in self.opt_methods:
qma = OptAnalyzer(series,
calc,
input,
nindent=subindent)
primary = self.opt
elif method in self.vmc_methods:
qma = VmcAnalyzer(series,
calc,
input,
nindent=subindent)
primary = self.vmc
elif method in self.dmc_methods:
qma = DmcAnalyzer(series,
calc,
input,
nindent=subindent)
primary = self.dmc
#end if
primary[series] = qma
self.qmc[series] = qma
#end if
#end if
#end for
for method in method_objs:
if len(self[method]) == 0:
del self[method]
#end if
#end for
#Check for multi-qmc results such as
# optimization or timestep studies
results = QAanalyzerCollection()
if 'opt' in self and len(self.opt) > 0:
optres = OptimizationAnalyzer(input, self.opt, nindent=subindent)
results.optimization = optres
#end if
if 'dmc' in self and len(self.dmc) > 1:
maxtime = 0
times = dict()
for series, dmc in self.dmc.iteritems():
blocks, steps, timestep = dmc.info.method_input.list(
'blocks', 'steps', 'timestep')
times[series] = blocks * steps * timestep
maxtime = max(times[series], maxtime)
#end for
dmc = QAanalyzerCollection()
for series, time in times.iteritems():
if abs(time - maxtime) / maxtime < .5:
dmc[series] = self.dmc[series]
#end if
#end for
if len(dmc) > 1:
results.timestep_study = TimestepStudyAnalyzer(
dmc, nindent=subindent)
#end if
#end if
if len(results) > 0:
self.results = results
#end if
self.unset_global_info()
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 test_incorporate_result():
import os
import shutil
from subprocess import Popen, PIPE
from numpy import array
from generic import NexusError, obj
from nexus_base import nexus_core
from test_vasp_simulation import setup_vasp_sim as get_vasp_sim
from test_vasp_simulation import pseudo_inputs as vasp_pseudo_inputs
from test_qmcpack_converter_simulations import get_pw2qmcpack_sim
from test_qmcpack_converter_simulations import get_convert4qmc_sim
from test_qmcpack_converter_simulations import get_pyscf_to_afqmc_sim
pseudo_inputs = obj(vasp_pseudo_inputs)
tpath = testing.setup_unit_test_output_directory(
'qmcpack_simulation', 'test_incorporate_result', **pseudo_inputs)
nexus_core.runs = ''
nexus_core.results = ''
# incorporate vasp structure
sim = get_qmcpack_sim(identifier='qmc_vasp_structure', tiling=(2, 2, 2))
vasp_struct = get_vasp_sim(tpath, identifier='vasp_structure', files=True)
assert (sim.locdir.strip('/') == tpath.strip('/'))
pc_file = 'diamond_POSCAR'
cc_file = vasp_struct.identifier + '.CONTCAR'
shutil.copy2(os.path.join(tpath, pc_file), os.path.join(tpath, cc_file))
result = vasp_struct.get_result('structure', None)
ion0 = sim.input.get('ion0')
c = ion0.groups.C
cp0 = c.position[0].copy()
s = result.structure.copy()
s.change_units('B')
rp0 = s.pos[0]
zero = array([0, 0, 0], dtype=float)
assert (value_eq(c.position[0], cp0, atol=1e-8))
c.position[0] += 0.1
assert (not value_eq(c.position[0], cp0, atol=1e-8))
assert (not value_eq(c.position[0], rp0, atol=1e-8))
sim.incorporate_result('structure', result, vasp_struct)
ion0 = sim.input.get('ion0')
c = ion0.groups.C
assert (value_eq(c.position[0], rp0, atol=1e-8))
# incorporate pw2qmcpack orbitals
sim = get_qmcpack_sim(identifier='qmc_p2q_orbitals')
p2q_orb = get_pw2qmcpack_sim(identifier='p2q_orbitals')
result = p2q_orb.get_result('orbitals', None)
p2q_output_path = os.path.join(tpath, 'pwscf_output')
if not os.path.exists(p2q_output_path):
os.makedirs(p2q_output_path)
#end if
p2q_h5file = os.path.join(p2q_output_path, 'pwscf.pwscf.h5')
f = open(p2q_h5file, 'w')
f.write('')
f.close()
assert (os.path.exists(p2q_h5file))
spo = sim.input.get('bspline')
assert (spo.href == 'MISSING.h5')
sim.incorporate_result('orbitals', result, p2q_orb)
assert (spo.href == 'pwscf_output/pwscf.pwscf.h5')
# incorporate convert4qmc orbitals
sim = get_qmcpack_sim(identifier='qmc_c4q_orbitals')
c4q_orb = get_convert4qmc_sim(identifier='c4q_orbitals')
result = c4q_orb.get_result('orbitals', None)
wfn_file = os.path.join(tpath, 'c4q_orbitals.wfj.xml')
wfn_file2 = os.path.join(tpath, 'c4q_orbitals.orbs.h5')
input = sim.input.copy()
dset = input.get('determinantset')
dset.href = 'orbs.h5'
qs = input.simulation.qmcsystem
del input.simulation
input.qmcsystem = qs
input.write(wfn_file)
assert (os.path.exists(wfn_file))
open(wfn_file2, 'w').write('fake')
assert (os.path.exists(wfn_file2))
from qmcpack_input import QmcpackInput
inp = QmcpackInput(wfn_file)
dset = sim.input.get('determinantset')
assert ('href' not in dset)
sim.incorporate_result('orbitals', result, c4q_orb)
dset = sim.input.get('determinantset')
assert (dset.href == 'c4q_orbitals.orbs.h5')
# incorporate qmcpack jastrow
sim = get_qmcpack_sim(identifier='qmc_jastrow')
qa_files_path = testing.unit_test_file_path('qmcpack_analyzer',
'diamond_gamma/opt')
command = 'rsync -a {} {}'.format(qa_files_path, tpath)
process = Popen(command,
shell=True,
stdout=PIPE,
stderr=PIPE,
close_fds=True)
out, err = process.communicate()
opt_path = os.path.join(tpath, 'opt')
opt_infile = os.path.join(opt_path, 'opt.in.xml')
assert (os.path.exists(opt_infile))
opt_file = os.path.join(opt_path, 'opt.s004.opt.xml')
assert (os.path.exists(opt_file))
result = obj(opt_file=opt_file)
sim.incorporate_result('jastrow', result, sim)
j = sim.input.get('jastrow')
j_text = j.write().replace('"', ' " ')
j_text_ref = '''
<jastrow type="Two-Body" name="J2" function="bspline" print="yes">
<correlation speciesA="u" speciesB="u" size="8" rcut="2.3851851232">
<coefficients id="uu" type="Array">
0.2576630369 0.1796686015 0.1326653657 0.09407180823 0.06267013118 0.03899100023
0.02070235604 0.009229775746
</coefficients>
</correlation>
<correlation speciesA="u" speciesB="d" size="8" rcut="2.3851851232">
<coefficients id="ud" type="Array">
0.4385891515 0.3212399072 0.2275448261 0.1558506324 0.1009589176 0.06108433554
0.03154274436 0.01389485975
</coefficients>
</correlation>
</jastrow>
'''.replace('"', ' " ')
assert (text_eq(j_text, j_text_ref))
# incorporate qmcpack wavefunction
sim = get_qmcpack_sim(identifier='qmc_wavefunction')
sim.incorporate_result('wavefunction', result, sim)
j = sim.input.get('jastrow')
j_text = j.write().replace('"', ' " ')
assert (text_eq(j_text, j_text_ref))
# incorporate qmcpack wavefunction afqmc
sim = get_qmcpack_sim(type='afqmc', identifier='qmc_wf_afqmc')
p2a_wf = get_pyscf_to_afqmc_sim(identifier='p2a_wavefunction')
result = p2a_wf.get_result('wavefunction', None)
del result.xml
wfn = sim.input.get('wavefunction')
ham = sim.input.get('hamiltonian')
assert (wfn.filename == 'MISSING.h5')
assert (ham.filename == 'MISSING.h5')
sim.incorporate_result('wavefunction', result, p2a_wf)
assert (wfn.filename == 'p2a_wavefunction.afqmc.h5')
assert (ham.filename == 'p2a_wavefunction.afqmc.h5')
clear_all_sims()
restore_nexus()
