def addAdsorbate(constraint="1"):
constrnts = AND(COMPLETED, RELAX, SURFACE, SYMMETRIC(False), constraint)
ads = {'H': ['O1']}
output = db.query(['fwid', 'params_json', 'finaltraj_pckl'], constrnts)
question = 'Are you sure you want to add adsorbates to %d slabs?' % len(
output)
if ask(question):
for fw, paramStr, ftraj in output:
params = json.loads(paramStr)
newsurf = surfFuncs.adsorbedSurface(
ftraj, json.loads(params['facet_json']), ads)
if jobs.Job(params).spinpol():
newsurf.set_initial_magnetic_moments([
3 if e in misc.magElems else 0
for e in newsurf.get_chemical_symbols()
])
ase.visualize.view(newsurf)
params['name'] += '_' + printAds(ads)
params['surfparent'] = fw
params['inittraj_pckl'] = pickle.dumps(newsurf)
params['adsorbates_json'] = json.dumps(ads)
job = jobs.Job(params)
if job.new():
viz.view(newsurf)
question = 'Does this structure look right?\n' + abbreviateDict(
params)
if ask(question):
job.check()
job.submit()
misc.launch()
def vary(constraint, param, rang, check=True):
# verify that constraint uniquely picks out a job
readJobs.readJobs()
defaults = RELAXORLAT
output = dbase.queryCol('params_json', AND([defaults, constraint]))
assert len(
output
) == 1, 'Constraint %s is not specific enough, the following sets of params are returned: %s' % (
constraint, '\n\n'.join([abbreviateDict(z) for z in output]))
params = json.loads(output[0])
assert param in params.keys(), 'param %s not in keys: %s' % (
abbreviateDict(param), params.keys())
print 'Param dict with %s being varied over the range %s: %s' % (
param, str(rang), abbreviateDict(params))
jbs = []
for v in rang:
ps = copy.deepcopy(params)
assert not (jobs.assignJob(ps).new()
), 'varying a job that isn\'t complete or doesn\'t exist'
ps[param] = v
job = jobs.assignJob(ps)
if job.new(): jbs.append(job)
if not check or ask('Do you want to launch %d new jobs?' % len(jbs)):
for j in jbs:
j.check()
j.submit()
if check: misc.launch()
def varies(constraint, param, rang):
"""
varies("xc='BEEF' and name like '%Pd%'",'pw',range(500,1000,100))
--> create jobs varying planewave_cutoff (500,600,...,1000) for all BEEF jobs with Pd
"""
jbs = []
defaults = RELAXORLAT
cnst = AND(defaults, constraint)
output = db.queryCol('storage_directory', cnst)
existing = manage.listOfIncompleteJobStrs()
if ask('Do you want to vary %s over range %s for %d jobs?' %
(param, str(rang), len(output))):
for stordir in output:
params = json.loads(misc.readOnSherOrSlac(stordir + 'params.json'))
for v in rang:
ps = copy.deepcopy(params)
assert not (jobs.Job(ps).new(
)), 'varying a job that isn\'t complete or doesn\'t exist'
ps[param] = v
job = jobs.Job(ps)
if job.new(existing): jbs.append(job)
if ask('Do you want to launch %d new jobs?' % len(jbs)):
for j in jbs:
j.submit()
misc.launch()
def getVibs(constraint="1"):
cons = AND([QE, COMPLETED, RELAXORLAT, NONMETAL, constraint])
details.load('finaltraj_pckl', cons)
output = dbase.query(
['fwid', 'params_json', 'finaltraj_pckl', 'natoms', 'numbers_pckl'],
cons)
question = 'Are you sure you want to calculate vibrations for %d structures?' % len(
output)
if ask(question):
newjbs = []
for fwid, paramStr, ftraj, n, ns in output:
param = json.loads(paramStr)
nums = zip(range(n), pickle.loads(ns))
nonmetal = [x for x, y in nums if y in misc.nonmetals
] #default do vibrations only on nonmetal atoms
if len(nonmetal) > 0:
param['jobkind'] = 'vib'
param['relax'] = fwid
param['inittraj_pckl'] = misc.restoreMagmom(ftraj)
param['vibids_json'] = json.dumps(nonmetal)
param['delta'] = 0.04
job = jobs.assignJob(param)
print abbreviateDict(param)
if job.new(): newjbs.append(job)
if ask("launch %d new jobs?" % len(newjbs)):
for j in newjbs:
j.check()
j.submit()
misc.launch()
def calculateBulkModulus(constraint="1"):
details.load(['finaltraj_pckl'], incomplete=False)
cons = AND([COMPLETED, LATTICEOPT,
constraint]) # necessary for bulkmodulus calc to be valid
output = dbase.query(['fwid', 'params_json', 'finaltraj_pckl'], cons)
question = 'Are you sure you want to calculate bulk modulus for %d structures?' % len(
output)
if ask(question):
newjbs = []
for fwid, paramStr, ftraj in output:
param = json.loads(paramStr)
del param['xtol']
param['jobkind'] = 'bulkmod'
param['strain'] = 0.03
param['relax'] = fwid
param['inittraj_pckl'] = misc.restoreMagmom(ftraj)
job = jobs.assignJob(param)
if job.new(): newjbs.append(job)
if ask("launch %d new jobs?" % len(newjbs)):
for j in newjbs:
j.check()
j.submit()
misc.launch()
def relaunch(predicate=lambda x: True):
"""Relaunch timed out jobs and unconverged GPAW jobs"""
fizzleLostRuns()
lpad.detect_unreserved(expiration_secs=3600 * 24 * 7, rerun=True)
timeouts, unconvergeds = filter(predicate, errFWIDS('timeout')), filter(
predicate, errFWIDS('kohnsham'))
tQuestion = "Do you want to relaunch %d timed out runs?" % len(timeouts)
uQuestion = "Do you want to relaunch %d unconverged jobs?" % len(
unconvergeds)
if misc.ask(tQuestion):
for fwid in timeouts:
q = lpad.get_fw_dict_by_id(fwid)['spec']['_queueadapter']
q['walltime'] = misc.doubleTime(q['walltime'])
lpad.update_spec([fwid], {'_queueadapter': q})
lpad.rerun_fw(fwid)
if q['walltime'][:2] == '40':
print 'warning, 40h job with fwid ', fwid
if misc.ask(uQuestion):
inc = listOfIncompleteJobStrs()
for fwid in unconvergeds:
p = fwid2params(fwid)
p['sigma'] += 0.05
p['mixing'] *= 0.5
job = jobs.Job(p)
lpad.archive_wf(fwid)
if job.new(inc): job.submit()
misc.launch()
def setWalltimeUnder40():
""" If too much time was requested accidentally (such that job is stuck in READY), use this to modify the job"""
details.load(['walltime'])
output = db.query(['fwid','queueadapter'],QOVER40)
print "Resetting walltime for %d jobs"%len(output)
for fw,fwpckl in output:
q=pickle.loads(fwpckl)['spec']['_queueadapter']
q['walltime'] = '39:59' + ':00' if q['walltime'].count(':')>1 else ''
lpad.update_spec([fw],{'_queueadapter':q})
misc.launch()
def calculateBulkModulus(constraint="1"):
cons = AND(LATTICEOPT,
constraint) # necessary for bulkmodulus calc to be valid
output = db.query([
'fwid', 'storage_directory', 'job_name', 'structure_ksb',
'bulkvacancy_ksb', 'bulkscale_ksb', 'system_type_ksb',
'planewave_cutoff', 'xc', 'kptden_ksb', 'psp_ksb', 'dwrat_ksb',
'econv_ksb', 'mixing_ksb', 'nmix_ksb', 'maxstep_ksb', 'nbands_ksb',
'sigma_ksb', 'fmax_ksb', 'dftcode'
], cons)
existing = manage.listOfIncompleteJobStrs()
question = 'Are you sure you want to calculate bulk modulus for %d structures?' % len(
output)
if ask(question):
newjbs = []
for fwid, stor_dir, name, structure, bvj, bsj, kind, pw, xc, kptden, psp, dwrat, econv, mixing, nmix, maxstep, nbands, sigma, fmax, dftcode in output:
params = {
'jobkind': 'bulkmod',
'strain': 0.03,
'inittraj_pckl':
misc.restoreMagmom(misc.storageDir2pckl(stor_dir)),
'name': name + '_bulkmod',
'structure': structure,
'bulkvacancy_json': bvj,
'bulkscale_json': bsj,
'kind': kind,
'dftcode': dftcode,
'pw': pw,
'xc': xc,
'kptden': kptden,
'psp': psp,
'dwrat': dwrat,
'econv': econv,
'mixing': mixing,
'nmix': nmix,
'maxstep': maxstep,
'nbands': nbands,
'sigma': sigma,
'fmax': fmax,
'parent': fwid
}
job = jobs.Job(params)
if job.new(existing): newjbs.append(job)
if ask("launch %d new jobs?" % len(newjbs)):
for j in newjbs:
j.submit()
misc.launch()
def getBareSlab(constraint="1",
facet=[1, 1, 1],
xy=[1, 1],
layers=4,
constrained=2,
symmetric=0,
vacuum=10,
vacancies=[]):
cons = AND([COMPLETED, LATTICEOPT, constraint])
details.load('finaltraj_pckl', cons)
output = dbase.query(['fwid', 'params_json', 'finaltraj_pckl'], cons)
question = 'Are you sure you want to create bare slabs for %d structures?' % len(
output)
if ask(question):
newjbs = []
for fwid, paramStr, ftraj in output:
param = json.loads(paramStr)
surf, img = surfFuncs.bulk2surf(ftraj, facet, xy, layers,
constrained, symmetric, vacuum,
vacancies)
param['jobkind'] = 'relax'
param['kind'] = 'surface'
param['name'] += '_' + ','.join(map(str, facet)) + '_' + 'x'.join(
map(str, (xy + [layers])))
param['relax'] = 0
param['bulkparent'] = fwid
param['inittraj_pckl'] = pickle.dumps(surf)
param['sites_base64'] = img
param['facet_json'] = json.dumps(facet)
param['xy_json'] = json.dumps(xy)
param['layers'] = layers
param['constrained'] = constrained
param['symmetric'] = symmetric
param['vacuum'] = vacuum
param['vacancies_json'] = json.dumps(vacancies)
param['adsorbates_json'] = json.dumps({})
job = jobs.assignJob(param)
if job.new():
viz.view(surf)
question = 'Does this structure look right?\n' + abbreviateDict(
param)
if ask(question):
job.check()
job.submit()
misc.launch()
def app_launch(fn, prefix=config.root_dir, additional_args=None):
"""
Launch the application `fn` (with optional additional command line
arguments), in the prefix (which defaults to the root environment).
Returned is the process object (the one returned by subprocess.Popen),
or None if the application `fn` is not installed in the prefix.
"""
from misc import launch
return launch(fn, prefix, additional_args)
def relaunch(cnst = '1',expiration_secs=80000,skip_load=False):
"""Relaunch timed out jobs and unconverged GPAW jobs"""
lpad.detect_lostruns(expiration_secs=expiration_secs, fizzle=True)
lpad.detect_unreserved(expiration_secs=3600*24*7, rerun=True)
if not skip_load: details.load('status fwpckl status trace',NOTCOMPLETED)
unconverged = AND([NOTCOMPLETED,KOHNSHAM,cnst])
timedout = AND([TIMEOUT,NOTKOHN,cnst])
launchflag = False
tOutput = db.query(['fwid','fwpckl'],timedout)
uOutput = db.query(['fwid','params_json'],unconverged)
tQuestion = "Do you want to relaunch %d timed out runs?"%len(tOutput)
uQuestion = "Do you want to relaunch %d unconverged jobs?"%len(uOutput)
if ask(tQuestion):
launchflag = True
for fid,fwpckl in tOutput:
if lpad.get_fw_dict_by_id(fid)['state']=='FIZZLED':
q = pickle.loads(fwpckl)['spec']['_queueadapter']
wallT = q['walltime']
q['walltime'] = doubleTime(wallT)
lpad.update_spec([fid],{'_queueadapter':q})
lpad.rerun_fw(fid)
else: print ("Wait up to 24 hours to relaunch fwid %d, or change default expiration time for detect_lostruns"%(fid))
if ask(uQuestion):
launchflag = True
for fw,paramstr in uOutput:
p = json.loads(paramstr)
p['sigma'] += 0.1
p['mixing'] = p['mixing']*0.5
job= jobs.assignJob(p)
if job.new():
job.check();job.submit()
delete(FWID(fw),check=False)
readJobs.readJobs()
if launchflag:
misc.launch()
duplicates()
def molecule(molname=None):
readJobs.readJobs()
for name, m in gas.aseMolDict.items():
if molname is None or name == molname:
mol = pickle.dumps(m)
variableParams = {
'pw': 500,
'xc': 'RPBE',
'psp': 'gbrv15pbe',
'fmax': 0.05,
'dftcode': 'quantumespresso'
}
defaultParams = {
'jobkind': 'relax',
'inittraj_pckl': mol,
'comments': 'created by gendata.molecule()',
'trajcomments': '',
'name': name,
'relaxed': 0,
'kind': 'molecule',
'kptden':
1 #doesn't matter, will be ignored. Use 1 to be safe.
,
'dwrat': 10,
'econv': 5e-4,
'mixing': 0.1,
'nmix': 10,
'maxstep': 500,
'nbands': -12,
'sigma': 0.1
}
p = misc.mergeDicts([variableParams, defaultParams])
if molname is None or ask(
'Do you want to run a gas phase calculation with these params?\n%s'
% (abbreviateDict(p))):
j = jobs.assignJob(p)
if j.new():
j.check()
j.submit()
misc.launch()
def getXCcontribs(constraint="1"):
"""NOT YET DEBUGGED"""
cons = AND(GPAW, RELAXORLAT, constraint)
output = db.query([
'fwid', 'storage_directory', 'job_name', 'system_type_ksb',
'planewave_cutoff', 'xc', 'kptden_ksb', 'psp_ksb', 'dwrat_ksb',
'econv_ksb', 'mixing_ksb', 'nmix_ksb', 'maxstep_ksb', 'nbands_ksb',
'sigma_ksb', 'fmax_ksb', 'dftcode'
], cons)
question = 'Are you sure you want to calculate XC contributions for %d structures?' % len(
output)
if ask(question):
newjbs = []
for fwid, stor_dir, name, kind, pw, xc, kptden, psp, dwrat, econv, mixing, nmix, maxstep, nbands, sigma, fmax, dftcode in output:
params = {
'jobkind': 'xc',
'inittraj_pckl': storageDir2pckl(stor_dir),
'name': name + '_xc',
'kind': kind,
'dftcode': dftcode,
'pw': pw,
'xc': xc,
'kptden': kptden,
'psp': psp,
'dwrat': dwrat,
'econv': econv,
'mixing': mixing,
'nmix': nmix,
'maxstep': maxstep,
'nbands': nbands,
'sigma': sigma,
'fmax': fmax,
'parent': fwid
}
job = jobs.Job(params)
if job.new() and ask('does this look right %s' % str(params)):
newjbs.append(job)
if ask("launch %d new jobs?" % len(newjbs)):
for j in newjbs:
j.submit()
misc.launch()
def getXCcontribs(constraint="1"):
details.load(['finaltraj_pckl'], incomplete=False)
cons = AND([COMPLETED, GPAW, RELAXORLAT, constraint])
output = dbase.query(['fwid', 'params_json', 'finaltraj_pckl'], cons)
question = 'Are you sure you want to calculate XC contributions for %d structures?' % len(
output)
if ask(question):
newjbs = []
for fwid, paramStr, ftraj in output:
param = json.loads(paramStr)
param['jobkind'] = 'xc'
param['inittraj_pckl'] = misc.restoreMagmom(ftraj)
param['relax'] = fwid
job = jobs.assignJob(param)
if job.new(): newjbs.append(job)
if ask("launch %d new jobs?" % len(newjbs)):
for j in newjbs:
j.check()
j.submit()
misc.launch()
def molecule(molname=None):
"""
Give molecule name to choose initial structure, modify dictionary parameters for relaxation job
"""
existing = manage.listOfIncompleteJobStrs()
for name, m in gas.aseMolDict.items():
if molname is None or name == molname:
mol = pickle.dumps(m)
params = {
'pw': 500,
'xc': 'BEEF',
'psp': 'gbrv15pbe',
'fmax': 0.05,
'dftcode': 'quantumespresso',
'jobkind': 'relax',
'inittraj_pckl': mol,
'name': name,
'relaxed': 0,
'kind': 'molecule',
'kptden':
1 #doesn't matter, will be ignored. Use 1 to be safe.
,
'dwrat': 10,
'econv': 5e-4,
'mixing': 0.1,
'nmix': 10,
'maxstep': 500,
'nbands': -12,
'sigma': 0.1
}
if molname is None or ask(
'Do you want to run a gas phase calculation with these params?\n%s'
% (misc.abbreviateDict(params))):
jobs.Job(params).submit(existing)
misc.launch()
def varies(constraint, param, rang):
readJobs.readJobs()
jbs = []
defaults = RELAXORLAT
cnst = AND([defaults, constraint])
output = dbase.queryCol('params_json', cnst)
if ask('Do you want to vary %s over range %s for %d jobs?' %
(param, str(rang), len(output))):
for params in map(json.loads, output):
for v in rang:
ps = copy.deepcopy(params)
assert not (jobs.assignJob(ps).new(
)), 'varying a job that isn\'t complete or doesn\'t exist'
ps[param] = v
job = jobs.assignJob(ps)
if job.new(): jbs.append(job)
if ask('Do you want to launch %d new jobs?' % len(jbs)):
for j in jbs:
j.check()
j.submit()
misc.launch()
def toDo():
params = db.queryCol('params_json',VIB,deleted=True)
for p in params:
j = jobs.assignJob(json.loads(p))
if j.new(): j.check();j.submit()
misc.launch()
def addInterstitial(constraint="1", emttol=0.2, vischeck=True, limit=1):
"""
Specify an interstitial and the number (up to which) you want to add them to the cell
Filter duplicates via EMT-calculated energy (stipulate a tolerance)
Assume final structure is triclinic
"""
inter, num = 'H', 2
cons = AND(LATTICEOPT, QE, PW(500), KPTDEN(2), constraint)
output = db.query(
[
'fwid',
'storage_directory',
'job_name',
'system_type_ksb' # generic parameters
,
'planewave_cutoff',
'xc',
'kptden_ksb',
'psp_ksb',
'dwrat_ksb',
'econv_ksb',
'mixing_ksb',
'nmix_ksb',
'maxstep_ksb',
'nbands_ksb',
'sigma_ksb',
'fmax_ksb',
'dftcode' # calc parameters
,
'bulkvacancy_ksb',
'bulkscale_ksb'
],
cons,
limit=limit) # bulk parameters
existing = manage.listOfIncompleteJobStrs(
) # check currently running/fizzled jobs to avoid duplicates
if ask('Are you sure you want to create interstitials for %d structures?' %
len(output)):
newjbs, totJbs, totStruct = [], 0, 0 #initialize variables
for fwid, stor_dir, name, kind, pw, xc, kptden, psp, dwrat, econv, mixing, nmix, maxstep, nbands, sigma, fmax, dftcode, bv, bs in output:
params = {
'jobkind': 'vcrelax',
'kind': 'bulk',
'dftcode': dftcode,
'name': name,
'pw': pw,
'xc': xc,
'kptden': kptden,
'psp': psp,
'bulkparent': fwid,
'dwrat': dwrat,
'econv': econv,
'mixing': mixing,
'nmix': nmix,
'maxstep': maxstep,
'nbands': nbands,
'sigma': sigma,
'fmax': fmax,
'structure': 'triclinic',
'bulkvacancy_json': bv,
'bulkscale_json': bs
} #bulk
ftraj = misc.storageDir2pckl(stor_dir)
spnpl = any([
x > 0
for x in pickle.loads(ftraj).get_initial_magnetic_moments()
])
trajs = [[(pickle.loads(ftraj), '')]] # initial state
for i in range(num):
lastround = trajs[
-1] # for all structures with n - 1 interstitials (note: initially there is only one, with 0 interstitials)
trajs.append(
[]
) # initialize container for all new structures with n interstitials
for inputtraj, strname in lastround:
for newtraj, newname in interstitialFuncs.getInterstitials(
inputtraj, inter, spnpl):
trajs[-1].append(
(newtraj, strname + newname)
) # add all new trajs found for all previous structures (append suffix to name)
def modParams(
par, trj, nam
): # For a given new traj and name, create input parameters
p = copy.deepcopy(
par) # All parameters common to all of these jobs
p['name'] += nam # Unique job name
p['inittraj_pckl'] = pickle.dumps(trj) # Initial structure
return p
def getEMT(x):
a = pickle.loads(x['inittraj_pckl'])
a.set_calculator(emt.EMT())
return a.get_potential_energy()
onelevel = [
modParams(params, item[0], item[1]) for sublist in trajs[1:]
for item in sublist
] #collapse list of lists to a single list of input parameters
emtPairs = sorted(
zip(map(getEMT, onelevel),
onelevel)) # pairs of (Energy,Params) ordered by energy
emtCounter, jbs = 0, []
for e, p in emtPairs:
if e - emtCounter > emttol:
jbs.append(jobs.Job(p))
emtCounter = e
newjbs.extend([x for x in jbs if x.new(existing)])
totJbs += len(jbs)
totStruct += len(onelevel)
check = ask(
'Do you want to check %d/%d new jobs? (%d filtered by emt)' %
(len(newjbs), totStruct, totStruct - totJbs))
if not check and ask('Do you want to exit?'): return 0
for jb in newjbs:
question = 'Does this structure look right?\n' + misc.abbreviateDict(
jb.params)
if vischeck: viz.view(pickle.loads(jb.params['inittraj_pckl']))
if not vischeck or ask(question): jb.submit()
misc.launch()
def getBareSlab(constraint="1", check=True):
"""Create a bare slab for some set of relaxed bulk structures. Alter parameters below as necessary"""
cons = AND(RELAXORLAT, BULK, MBEEF, PAWPSP, BCC, PW(1500), KPTDEN(2),
constraint)
facet = [1, 0, 0]
xy = [1, 1]
layers = 6
constrained = 2
symmetric = 1
vacuum = 10
vacancies = []
output = db.query([
'fwid', 'storage_directory', 'job_name', 'structure_ksb',
'planewave_cutoff', 'xc', 'kptden_ksb', 'psp_ksb', 'dwrat_ksb',
'econv_ksb', 'mixing_ksb', 'nmix_ksb', 'maxstep_ksb', 'nbands_ksb',
'sigma_ksb', 'fmax_ksb', 'dftcode'
], cons)
question = 'Are you sure you want to create bare slabs for %d structures?' % len(
output)
if ask(question):
existing = manage.listOfIncompleteJobStrs()
newjbs = []
for fwid, stor_dir, name, structure, pw, xc, kptden, psp, dwrat, econv, mixing, nmix, maxstep, nbands, sigma, fmax, dftcode in output:
ftraj = misc.readOnSherOrSlac(stor_dir + 'raw.pckl')
surf, img = surfFuncs.bulk2surf(ftraj, facet, xy, layers,
constrained, symmetric, vacuum,
vacancies)
name += '_' + ','.join(map(str, facet)) + '_' + 'x'.join(
map(str, (xy + [layers])))
params = {
'jobkind': 'relax',
'inittraj_pckl': pickle.dumps(surf),
'name': name,
'kind': 'surface',
'dftcode': dftcode,
'structure': structure # don't need bulk vacancies/scale?
,
'pw': pw,
'xc': xc,
'kptden': kptden,
'psp': psp,
'bulkparent': fwid,
'dwrat': dwrat,
'econv': econv,
'mixing': mixing,
'nmix': nmix,
'maxstep': maxstep,
'nbands': nbands,
'sigma': sigma,
'fmax': fmax,
'sites_base64': img,
'facet_json': json.dumps(facet),
'xy_json': json.dumps(xy),
'layers': layers,
'constrained': constrained,
'symmetric': symmetric,
'vacuum': vacuum,
'vacancies_json': json.dumps(vacancies),
'adsorbates_json': json.dumps({})
}
job = jobs.Job(params)
if job.new(existing):
if check: viz.view(surf)
question = 'Does this structure look right?\n' + misc.abbreviateDict(
params)
if not check or ask(question): job.submit()
misc.launch()
def getVibs(constraint="1"):
"""
Launch vibration calculation for all latticeopt or (vc-)relax jobs that meet some (SQL) constraint in the shared database
Only (and all) nonmetal atoms will be vibrated (defined in misc.py)
"""
existing = manage.listOfIncompleteJobStrs()
cons = AND(
QE, RELAXORLAT, constraint
) #could we add a column to quickly filter things with nonmetals?
output = db.query(
[
'fwid',
'storage_directory',
'job_name',
'system_type_ksb' # generic parameters
,
'planewave_cutoff',
'xc',
'kptden_ksb',
'psp_ksb',
'dwrat_ksb',
'econv_ksb',
'mixing_ksb',
'nmix_ksb',
'maxstep_ksb',
'nbands_ksb',
'sigma_ksb',
'fmax_ksb',
'dftcode' # calc parameters
,
'structure_ksb',
'bulkvacancy_ksb',
'bulkscale_ksb' # possible bulk parameters
,
'facet_ksb',
'xy_ksb',
'layers_ksb',
'constrained_ksb',
'symmetric_ksb',
'vacuum_ksb',
'vacancies_ksb',
'adsorbates_ksb',
'sites_ksb'
],
cons) # possible surf parameters
question = 'Are you sure you want to calculate vibrations for %d structures?' % len(
output)
if ask(question):
newjbs = []
for fwid, stor_dir, name, kind, pw, xc, kptden, psp, dwrat, econv, mixing, nmix, maxstep, nbands, sigma, fmax, dftcode, structure, bv, bs, facet, xy, lay, const, sym, vac, vacan, ads, sites in output:
inittraj_pckl = storageDir2pckl(stor_dir)
atoms = pickle.loads(inittraj_pckl)
nonmetal_inds = [
i for i, x in enumerate(atoms.get_chemical_symbols())
if x in misc.nonmetalSymbs
]
if len(nonmetal_inds) > 0:
params = {
'jobkind': 'vib',
'inittraj_pckl': inittraj_pckl,
'name': name + '_vib',
'kind': kind,
'dftcode': dftcode,
'structure': structure,
'pw': pw,
'xc': xc,
'kptden': kptden,
'psp': psp,
'dwrat': dwrat,
'econv': econv,
'mixing': mixing,
'nmix': nmix,
'maxstep': maxstep,
'nbands': nbands,
'sigma': sigma,
'fmax': fmax,
'structure': structure,
'bulkvacancy_json': bv,
'bulkscale_json': bs,
'facet_json': facet,
'xy_json': xy,
'layers': lay,
'constrained': const,
'symmetric': sym,
'vacuum': vac,
'vacancies_json': vacan,
'adsorbates_json': ads,
'sites_base64': sites,
'parent': fwid,
'vibids_json': json.dumps(nonmetal_inds),
'delta': 0.04
}
job = jobs.Job(params)
if job.new() and ask('does this look right %s' % str(params)):
newjbs.append(job)
if ask("launch %d new jobs?" % len(newjbs)):
for j in newjbs:
j.submit(existing)
misc.launch()
def addInterstitial(constraint="1", load=True, emttol=0.2):
inter, num = 'H', 2
cons = AND([COMPLETED, LATTICEOPT, QE, constraint])
if load: details.load(['finaltraj_pckl'], cons)
else: readJobs.readJobs()
output = dbase.query(['fwid', 'params_json', 'finaltraj_pckl'], cons)
question = 'Are you sure you want to add interstitials to %d structures?' % len(
output)
if ask(question):
jbs = []
for fwid, paramStr, ftraj in output:
param = json.loads(paramStr)
spnpl = jobs.assignJob(param).spinpol()
param['structure'] = 'triclinic'
param['jobkind'] = 'vcrelax'
param['relaxed'] = fwid
if 'xtol' in param.keys(): del param['xtol']
trajs = [[(pickle.loads(ftraj), '')]]
for i in range(num):
lastround = trajs[-1]
trajs.append([])
for inputtraj, strname in lastround:
for newtraj, newname in interstitialFuncs.getInterstitials(
inputtraj, inter, spnpl):
trajs[-1].append((newtraj, strname + newname))
def modParams(par, trj, nam):
p = copy.deepcopy(par)
p['name'] += nam
p['inittraj_pckl'] = pickle.dumps(trj)
return p
onelevel = [item for sublist in trajs[1:] for item in sublist]
tentativejoblist = [
jobs.assignJob(modParams(param, t, n)) for t, n in onelevel
]
addJobs, efilt = [], 0
for j in tentativejoblist:
if any([abs(j.emt() - x.emt()) < emttol for x in addJobs]):
efilt += 1
else:
addJobs.append(j)
jbs.extend(addJobs)
newjbs = [j for j in jbs if j.new()]
for j in newjbs:
print j.symbols(), j.emt()
check = ask(
'Do you want to check %d/%d new jobs? (%d filtered by emt)' %
(len(newjbs), len(jbs) + efilt, efilt))
if not check and ask('Do you want to exit?'): return 0
for jb in newjbs:
question = 'Does this structure look right?\n' + abbreviateDict(
j.params)
if check: viz.view(newtraj)
if not check or ask(question):
jb.check()
jb.submit()
misc.launch()
def rerun(cnstrt='1'):
fwids = db.queryCol('fwid',AND([FIZZLED,cnstrt]))
question='Do you want to rerun %d fizzled jobs selected by %s?'%(len(fwids),cnstrt)
if ask(question):
for f in fwids: lpad.rerun_fw(f)
misc.launch()