def __init__(self, args, vasp_db):
self.plotonly = args.plotonly
if args.qhamode is not None:
self.qhamode = args.qhamode
else:
self.qhamode = 'phonon'
if args.qhamode == 'debye': self.qhamode = 'qha'
if not self.plotonly:
try:
self.vasp_db = vasp_db
self.items = (self.vasp_db).db[self.qhamode].find({})
if self.qhamode == 'phonon':
self.items = list((self.vasp_db).db['phonon'].find({"S_vib": { "$exists": True } },\
{'metadata':1, 'unitcell':1, 'volume':1, 'supercell_matrix':1}))
else:
self.items = list((self.vasp_db).db['qha'].find({"debye": { "$exists": True } },\
{'metadata':1, 'structure':1}))
except:
self.vasp_db = None
warnings.warn(
"\n*********WARNING: CANNOT get MongoDB service, so I will proceed using local data"
)
self.check = args.check
self.remove = args.remove
self.tags = []
self._Yphon = []
self.within = []
self.containall = []
self.containany = []
self.excludeall = []
self.excludeany = []
self.nV = args.nV
self.metatag = args.metatag
self.get = args.get
self.supercellN = args.supercellN
self.t0 = args.t0
self.t1 = args.t1
self.td = args.td
self.jobpath = args.jobpath
self.findbandgap = args.findbandgap
if args.within is not None:
self.within, tmp = formula2composition(args.within)
if args.containall is not None:
self.containall, tmp = formula2composition(args.containall)
if args.containany is not None:
self.containany, tmp = formula2composition(args.containany)
if args.excludeall is not None:
self.excludeall, tmp = formula2composition(args.excludeall)
def debye_find(self):
hit = []
phases = []
count = []
for i in self.items:
mm = i['metadata']
if mm in hit:
count[hit.index(mm)] += 1
else:
hit.append(mm)
count.append(1)
structure = Structure.from_dict(i['structure'])
formula_pretty = structure.composition.reduced_formula
try:
formula2composition(formula_pretty)
except:
formula_pretty = reduced_formula(
structure.composition.alphabetical_formula)
sa = SpacegroupAnalyzer(structure)
phasename = formula_pretty+'_'\
+ sa.get_space_group_symbol().replace('/','.')+'_'+str(sa.get_space_group_number())
if phasename in phases:
for jj in range(10000):
nphasename = phasename + "#" + str(jj)
if nphasename in phases: continue
phasename = nphasename
break
phases.append(phasename)
print("\nfound complete calculations in the collection:", self.qhamode,
"\n")
all_static_calculations = list((self.vasp_db).db['tasks'].\
find({'$and':[{'metadata': { "$exists": True }}, {'adopted': True} ]},\
{'metadata':1, 'output':1, 'input':1, 'orig_inputs':1}))
for i, m in enumerate(hit):
if self.skipby(phases[i], m['tag']): continue
static_calculations = [
f for f in all_static_calculations
if f['metadata']['tag'] == m['tag']
]
for ii, calc in enumerate(static_calculations):
potsoc = get_used_pot(calc)
if self.qhamode == 'qha': potsoc += "_debye"
pname = phases[i].split('#')
if len(pname) > 1:
phases[i] = pname[0] + potsoc + '#' + pname[1]
else:
phases[i] = pname[0] + potsoc
break
print(m, ":", phases[i])
self.tags.append({'tag': m['tag'], 'phasename': phases[i]})
def skipby(self, phase, metatag):
if self.metatag != None:
if self.metatag != metatag: return True
try:
els, tmp = formula2composition(phase.split('_')[0])
except:
return True
if len(self.within) != 0:
for e in els:
if e not in self.within: return True
if len(self.excludeall) != 0:
for e in self.excludeall:
rx = e not in els
if rx: break
if not rx: return True
if len(self.excludeany) != 0:
for e in self.excludeany:
return True
if len(self.containall) != 0:
for e in self.containall:
if e not in els: return True
return False
if len(self.containany) != 0:
for e in self.containany:
if e in els: return False
return True
return False
def __init__(self, args):
db_file = loadfn(config_to_dict()["FWORKER_LOC"])["env"]["db_file"]
self.vasp_db = VaspCalcDb.from_db_file(db_file, admin=True)
self.items = (self.vasp_db).collection.find({'adopted': True})
self.within = []
self.containall = []
self.containany = []
self.excludeall = []
self.excludeany = []
self.nV = args.nV
self.print = args.print
self.plot = args.plot
self.findbandgap = args.findbandgap
if args.within is not None: self.within, tmp = formula2composition(args.within)
if args.containall is not None: self.containall, tmp = formula2composition(args.containall)
if args.containany is not None: self.containany, tmp = formula2composition(args.containany)
if args.excludeall is not None: self.excludeall, tmp = formula2composition(args.excludeall)
def debye_find(self):
hit = []
phases = []
count = []
for i in self.items:
"""
try:
ii = len(i['debye'])
mm = i['metadata']
except:
continue
if ii < 6: continue
"""
mm = i['metadata']
if mm in hit:
count[hit.index(mm)] += 1
else:
hit.append(mm)
count.append(1)
structure = Structure.from_dict(i['structure'])
formula_pretty = structure.composition.reduced_formula
try:
formula2composition(formula_pretty)
except:
formula_pretty = reduced_formula(
structure.composition.alphabetical_formula)
sa = SpacegroupAnalyzer(structure)
phasename = formula_pretty+'_'\
+ sa.get_space_group_symbol().replace('/','.')+'_'+str(sa.get_space_group_number())
if phasename in phases:
for jj in range(10000):
nphasename = phasename + "#" + str(jj)
if nphasename in phases: continue
phasename = nphasename
break
phases.append(phasename)
print("\nfound complete calculations in the collection:", self.qhamode,
"\n")
for i, m in enumerate(hit):
if self.skipby(phases[i], m['tag']): continue
print(m, ":", phases[i])
self.tags.append({'tag': m['tag'], 'phasename': phases[i]})
def __init__(self, args, vasp_db):
self.vasp_db = vasp_db
self.items = (self.vasp_db).collection.find({'adopted': True})
self.within = []
self.containall = []
self.containany = []
self.excludeall = []
self.excludeany = []
self.nV = args.nV
self.print = args.print
self.plot = args.plot
self.findbandgap = args.findbandgap
if args.within is not None:
self.within, tmp = formula2composition(args.within)
if args.containall is not None:
self.containall, tmp = formula2composition(args.containall)
if args.containany is not None:
self.containany, tmp = formula2composition(args.containany)
if args.excludeall is not None:
self.excludeall, tmp = formula2composition(args.excludeall)
def skipby(self, phase):
els, tmp = formula2composition(phase.split('_')[0])
if len(self.within) != 0:
for e in els:
if e not in self.within: return True
if len(self.excludeall) != 0:
for e in self.excludeall:
rx = e not in els
if rx: break
if not rx: return True
if len(self.excludeany) != 0:
for e in self.excludeany:
return True
if len(self.containall) != 0:
for e in self.containall:
if e not in els: return True
return False
if len(self.containany) != 0:
for e in self.containany:
if e in els: return False
return True
return False
def __init__(self, args):
self.plotonly = args.plotonly
if args.qhamode is not None:
self.qhamode = args.qhamode
else:
self.qhamode = 'phonon'
if args.qhamode == 'debye': self.qhamode = 'qha'
from fireworks.fw_config import config_to_dict
from monty.serialization import loadfn
db_file = loadfn(config_to_dict()["FWORKER_LOC"])["env"]["db_file"]
if not self.plotonly:
try:
self.vasp_db = VaspCalcDb.from_db_file(db_file, admin=True)
self.items = (self.vasp_db).db[self.qhamode].find({})
if self.qhamode == 'phonon':
self.items = list((self.vasp_db).db['phonon'].find({"S_vib": { "$exists": True } },\
{'metadata':1, 'unitcell':1, 'volume':1, 'supercell_matrix':1}))
else:
self.items = list((self.vasp_db).db['qha'].find({"debye": { "$exists": True } },\
{'metadata':1, 'structure':1}))
except:
self.vasp_db = None
print(
"\n*********WARNING: CANNOT get MongoDB service, so I will proceed using local data"
)
print(
"*********WARNING: CANNOT get MongoDB service, so I will proceed using local data"
)
print(
"*********WARNING: CANNOT get MongoDB service, so I will proceed using local data\n"
)
#items = vasp_db.db['phonon'].find(properties=['metadata.tag','F_vib', 'CV_vib', 'S_vib'])
#items = vasp_db.db['phonon'].find({F_vib: {$gt: 0}})
#items = vasp_db.db['phonon'].find({'metadata.tag': "djdjd"})
#items = vasp_db.db['phonon'].find({})
self.check = args.check
self.remove = args.remove
self.tags = []
self._Yphon = []
self.within = []
self.containall = []
self.containany = []
self.excludeall = []
self.excludeany = []
self.nV = args.nV
self.metatag = args.metatag
self.get = args.get
self.supercellN = args.supercellN
self.t0 = args.t0
self.t1 = args.t1
self.td = args.td
self.jobpath = args.jobpath
self.findbandgap = args.findbandgap
if args.within is not None:
self.within, tmp = formula2composition(args.within)
if args.containall is not None:
self.containall, tmp = formula2composition(args.containall)
if args.containany is not None:
self.containany, tmp = formula2composition(args.containany)
if args.excludeall is not None:
self.excludeall, tmp = formula2composition(args.excludeall)
def check_find(self):
"""
hit = []
relaxations_collection = (self.vasp_db).db['relaxations'].find({})
for i in relaxations_collection:
try:
mm = i['metadata']['tag']
hit.append(mm)
except:
continue
lastupdated = [None] * len(hit)
for i,mm in enumerate(hit):
static_calc = (self.vasp_db).collection.\
find({'$and':[ {'metadata.tag': mm} ]})
for calc in static_calc:
lnew = calc['last_updated']
if lastupdated[i]!=None:
lold = lastupdated[i]
if lnew > lold: lastupdated[i] = lnew
else:
lastupdated[i] = lnew
"""
print(
"\nfinding tags for complete calculations in the static collection\n"
)
hit = []
lastupdated = []
static_collection = (self.vasp_db).collection.find({})
for i in static_collection:
try:
mm = i['metadata']['tag']
except:
continue
if mm in hit:
idx = hit.index(mm)
lold = lastupdated[idx]
lnew = i['last_updated']
if lnew > lold: lastupdated[idx] = lnew
else:
lastupdated.append(i['last_updated'])
hit.append(mm)
print("\nfinding complete calculations in the phonon collection\n")
phases = [""] * len(hit)
supercellsize = [0] * len(hit)
phonon_count = [0] * len(hit)
#phonon_calc = (self.vasp_db).db['phonon'].find({},{'metadata':1})
phonon_calc = list((self.vasp_db).db['phonon'].find({"S_vib": { "$exists": True } },\
{'metadata':1, 'unitcell':1, 'supercell_matrix':1}))
for i, mm in enumerate(hit):
#print ('eeeeeeeeee', mm)
#phonon_calc = (self.vasp_db).db['phonon'].\
# find({'$and':[ {'metadata.tag': mm} ]})
for calc in phonon_calc:
if calc['metadata']['tag'] != mm: continue
#print (calc['metadata']['tag'])
phonon_count[i] += 1
if phonon_count[i] == 1:
structure = Structure.from_dict(calc['unitcell'])
natoms = len(structure.sites)
supercell_matrix = calc['supercell_matrix']
supercellsize[i] = (
natoms *
int(np.linalg.det(np.array(supercell_matrix)) + .5))
formula_pretty = structure.composition.reduced_formula
try:
formula2composition(formula_pretty)
except:
formula_pretty = reduced_formula(
structure.composition.alphabetical_formula)
sa = SpacegroupAnalyzer(structure)
phasename = formula_pretty+'_'\
+ sa.get_space_group_symbol().replace('/','.')+'_'+str(sa.get_space_group_number())
if phasename in phases:
for jj in range(10000):
nphasename = phasename + "#" + str(jj)
if nphasename in phases: continue
phasename = nphasename
break
phases[i] = phasename
print("\nfinding complete calculations in the static collection\n")
static_count = [0] * len(hit)
for i, mm in enumerate(hit):
if self.skipby(phases[i], mm): continue
static_calc = (self.vasp_db).collection.\
find({'$and':[ {'metadata.tag': mm} ]})
for calc in static_calc:
static_count[i] += 1
print("\nfinding complete calculations in the qha collection\n")
qha_count = [0] * len(hit)
for i, mm in enumerate(hit):
qha_calc = (self.vasp_db).db['qha'].\
find({'$and':[ {'metadata.tag': mm} ]})
for calc in qha_calc:
qha_count[i] += 1
print("\nfinding complete calculations in the qha_phonon collection\n")
qha_phonon_count = [0] * len(hit)
for i, mm in enumerate(hit):
try:
qha_phonon_calculations = self.vasp_db.db['qha_phonon'].find(
{'metadata.tag': mm})
T = qha_phonon_calculations[0]['phonon']['temperatures']
qha_phonon_count[i] += 1
except:
try:
qha_phonon_calculations = self.vasp_db.db['qha'].find(
{'metadata.tag': mm})
T = qha_phonon_calculations[0]['phonon']['temperatures']
qha_phonon_count[i] += 1
except:
pass
print(
"\nfinding complete calculations in the relaxations collection\n")
relaxations_count = [0] * len(hit)
for i, mm in enumerate(hit):
relaxations_calc = (self.vasp_db).db['relaxations'].\
find({'$and':[ {'metadata.tag': mm} ]})
for calc in relaxations_calc:
relaxations_count[i] += 1
nTBD = 0
for i, mm in enumerate(hit):
#dd = datetime.datetime.strptime(lastupdated[i], '%Y-%m-%d %H:%M:%S.%f').date()
dd = lastupdated[i].date()
now = datetime.datetime.now().date()
#if supercellsize[i]>=16 and phonon_count[i]>=5: continue
if supercellsize[i] >= self.supercellN and phonon_count[
i] >= self.nV:
continue
if dd > now - datetime.timedelta(days=7): continue
nTBD += 1
sys.stdout.write(
'[{:>04}] relax: {:>2}, static: {:>2}, qha: {:>2}, qha_phonon: {:>2}, phonon: {:>2}, SN: {:>3}, phases: {}, {}\n'
.format(i, relaxations_count[i], static_count[i], qha_count[i],
qha_phonon_count[i], phonon_count[i], supercellsize[i],
phases[i], dd))
#sys.stdout.write('{}, static: {:>2}, qha: {:>2}, qha_phonon: {:>2}, phonon: {:>2}, SN: {:>3}, phases: {}, date: {}\n'.format(mm['tag'], static_count[i], qha_count[i], qha_phonon_count[i], phonon_count[i], supercellsize[i], phases[i], lastupdated[i]))
self.tags.append({'tag': mm, 'phasename': phases[i]})
print("\n", nTBD, "/", len(hit), "recs to be removed\n")
for t in self.tags:
print(t)
def phonon_find(self):
hit = []
count = []
phases = []
volumes = []
ITEMS = []
self.supercellsize = []
for i in self.items:
"""
try:
ii = len(i['S_vib'])
mm = i['metadata']
except:
continue
if ii <= 0: continue
"""
mm = i['metadata']
if mm in hit:
if i['volume'] not in volumes[hit.index(mm)]:
volumes[hit.index(mm)].append(i['volume'])
count[hit.index(mm)] += 1
else:
ITEMS.append(i)
hit.append(mm)
count.append(1)
volumes.append([i['volume']])
structure = Structure.from_dict(i['unitcell'])
natoms = len(structure.sites)
supercell_matrix = i['supercell_matrix']
self.supercellsize.append(
natoms *
int(np.linalg.det(np.array(supercell_matrix)) + .5))
formula_pretty = structure.composition.reduced_formula
try:
formula2composition(formula_pretty)
except:
formula_pretty = reduced_formula(
structure.composition.alphabetical_formula)
sa = SpacegroupAnalyzer(structure)
phasename = formula_pretty+'_'\
+ sa.get_space_group_symbol().replace('/','.')+'_'+str(sa.get_space_group_number())
if phasename in phases:
for jj in range(10000):
nphasename = phasename + "#" + str(jj)
if nphasename in phases: continue
phasename = nphasename
break
phases.append(phasename)
print("\nfound complete calculations in the collection:", self.qhamode,
"\n")
total = 0
total_qha_phonon = 0
all_static_calculations = list((self.vasp_db).db['tasks'].\
find({'$and':[{'metadata': { "$exists": True }}, {'adopted': True} ]},\
{'metadata':1, 'output':1, 'input':1, 'orig_inputs':1}))
all_qha_calculations = list((self.vasp_db).db['qha'].\
find({'$and':[{'metadata': { "$exists": True }},{'has_phonon':True}]}, {'metadata':1, 'temperatures':1}))
all_qha_phonon_calculations = list((self.vasp_db).db['qha_phonon'].\
find({'$and':[{'metadata': { "$exists": True }},{'has_phonon':True}]}, {'metadata':1, 'temperatures':1}))
for i, m in enumerate(hit):
if self.skipby(phases[i], m['tag']): continue
total += 1
static_calculations = [
f for f in all_static_calculations
if f['metadata']['tag'] == m['tag']
]
qha_calculations = [
f for f in all_qha_calculations
if f['metadata']['tag'] == m['tag']
]
qha_phonon_calculations = [
f for f in all_qha_phonon_calculations
if f['metadata']['tag'] == m['tag']
]
qha_phonon_success = True
if len(qha_calculations) > 0:
total_qha_phonon += 1
elif len(qha_phonon_calculations) > 0:
total_qha_phonon += 1
else:
qha_phonon_success = False
nS = 0
gapfound = False
potsoc = ""
for calc in static_calculations:
vol = calc['output']['structure']['lattice']['volume']
if potsoc == "":
pot = calc['input']['pseudo_potential'][
'functional'].upper()
if pot == "":
pot = calc['orig_inputs']['potcar'][
'functional'].upper()
if pot == 'Perdew-Zunger81'.upper(): pot = "LDA"
try:
pot += "+" + calc['input']['incar']['GGA']
except:
pass
if calc['input']['is_hubbard']: pot += '+U'
try:
if calc['input']['incar']['LSORBIT']:
potsoc = pot + "+SOC"
except:
potsoc = pot
pname = phases[i].split('#')
if len(pname) > 1:
phases[i] = pname[0] + potsoc + '#' + pname[1]
else:
phases[i] = pname[0] + potsoc
nS += 1
bandgap = calc['output']['bandgap']
if not gapfound: gapfound = float(bandgap) > 0.0
#print("eeeeeeee", self.findbandgap)
if self.findbandgap:
#if gapfound: print ("eeeeee", gapfound, bandgap, phases[i])
if gapfound:
sys.stdout.write(
'{}, phonon: {:>2}, static: {:>2}, supercellsize: {:>3}, {}\n'
.format(m, count[i], nS, self.supercellsize[i],
phases[i]))
else:
if count[i] < self.nV: continue
if self.supercellsize[i] < self.supercellN: continue
jobpath = findjobdir(self.jobpath, m['tag'])
if jobpath == None:
sys.stdout.write('{}, phonon: {:>2}, static: {:>2}, SN: {:>3}, qha_phonon: {:<1.1s}, {}\n'\
.format(m, count[i], nS, self.supercellsize[i], str(qha_phonon_success), phases[i]))
else:
sys.stdout.write('{}, phonon: {:>2}, static: {:>2}, SN: {:>3}, qha_phonon: {:<1.1s}, {},{}\n'\
.format(m, count[i], nS, self.supercellsize[i], str(qha_phonon_success), phases[i],jobpath))
#if count[i]>=5: self.tags.append({'tag':m['tag'],'phasename':phases[i]})
if count[i] >= self.nV:
self.tags.append({'tag': m['tag'], 'phasename': phases[i]})
sys.stdout.write ('\n{}/{} qha_phonon successful under the given searching conditions.\n'\
.format(total_qha_phonon, total))
def __init__(self, args, vasp_db):
self.vasp_db = vasp_db
self.qhamode = args.qhamode
#self.items = (self.vasp_db).collection.find({'adopted': True})
#print(self.hit_condition)
self.within = []
self.containall = []
self.containany = []
self.excludeall = []
self.excludeany = []
self.nV = args.nV
self.print = args.print
self.plot = args.plot
self.natoms = args.natoms
self.findbandgap = args.findbandgap
self.metatag = args.metatag
if args.within is not None:
self.within, tmp = formula2composition(args.within)
if args.containall is not None:
self.containall, tmp = formula2composition(args.containall)
if args.containany is not None:
self.containany, tmp = formula2composition(args.containany)
if args.excludeall is not None:
self.excludeall, tmp = formula2composition(args.excludeall)
if args.excludeany is not None:
self.excludeany, tmp = formula2composition(args.excludeany)
search_condition = [{
'output.structure.lattice.volume': {
'$exists': True
}
}, {
'metadata': {
'$exists': True
}
}]
if len(self.containall) != 0:
search_condition.append({"elements": {"$all": self.containall}})
if len(self.containany) != 0:
search_condition.append({"elements": {"$in": self.containany}})
if len(self.excludeany) != 0:
search_condition.append({"elements": {"$nin": self.excludeany}})
#print (search_condition)
self.items = (self.vasp_db).collection.find({'$and':search_condition},\
{'metadata':1, 'output':1, 'input':1, 'orig_inputs':1, 'elements':1})
scondition = []
if len(search_condition) > 1:
metadata_list = (self.vasp_db).collection.find(
{'$and': search_condition}, {'metadata': 1})
metadata_list = list(
set([i['metadata']['tag'] for i in metadata_list]))
metadata_list = [{'tag': i} for i in metadata_list]
scondition.append({"metadata": {"$in": metadata_list}})
if self.qhamode == 'phonon':
scondition.extend([{
'adopted': True
}, {
"S_vib": {
"$exists": True
}
}])
hit_condition = list(
(self.vasp_db).db['phonon'].find({'$and': scondition},
{'metadata': 1}))
elif self.qhamode == 'debye':
scondition.append({"debye": {"$exists": True}})
hit_condition = list(
(self.vasp_db).db['qha'].find({'$and': scondition},
{'metadata': 1}))
else:
hit_condition = None
if hit_condition is not None:
metadata = [i['metadata']['tag'] for i in hit_condition]
self.hit_condition = list(set(metadata))
self.hit_count = {i: metadata.count(i) for i in metadata}
else:
self.hit_condition = None
def EV_find(self):
evdirhome = 'E-V'
if not os.path.exists(evdirhome): os.mkdir(evdirhome)
hit = []
count = []
phases = []
volumes = []
ITEMS = []
potname = []
fp_ev = open(os.path.join(evdirhome, "E-V.dat"), "w")
for i in self.items:
mm = i['metadata']['tag']
els = i['elements']
if self.skipby("", mm, els=els): continue
if self.hit_condition is not None:
if mm not in self.hit_condition: continue
if mm in hit:
volume = i['output']['structure']['lattice']['volume']
if volume not in volumes[hit.index(mm)]:
volumes[hit.index(mm)].append(volume)
count[hit.index(mm)] += 1
else:
ITEMS.append(i)
hit.append(mm)
count.append(1)
volumes.append([i['output']['structure']['lattice']['volume']])
potsoc = get_used_pot(i)
structure = Structure.from_dict(i['output']['structure'])
formula_pretty = structure.composition.reduced_formula
try:
formula2composition(formula_pretty)
except:
formula_pretty = reduced_formula(
structure.composition.alphabetical_formula)
sa = SpacegroupAnalyzer(structure)
phasename = formula_pretty+'_'\
+ sa.get_space_group_symbol().replace('/','.')+'_'+str(sa.get_space_group_number())
potname.append(potsoc)
if phasename in phases:
for jj in range(10000):
nphasename = phasename + "#" + str(jj)
if nphasename in phases: continue
phasename = nphasename
break
phases.append(phasename)
blank_lines = False
for i, mm in enumerate(hit):
if self.hit_condition is not None:
if mm not in self.hit_condition: continue
if self.qhamode == 'phonon':
if self.hit_count[mm] < self.nV: continue
if count[i] < self.nV: continue
if self.skipby(phases[i], mm): continue
EV, POSCAR, INCAR = get_rec_from_metatag(self.vasp_db, mm)
metadata = {'tag': mm}
pname = phases[i].split('#')
if len(pname) > 1:
phases[i] = pname[0] + potname[i] + EV[
'MagState'] + '#' + pname[1]
else:
phases[i] = pname[0] + potname[i] + EV['MagState']
if EV['natoms'] < self.natoms: continue
sys.stdout.write('{}, static: {:>2}, natoms: {:>3}, {}\n'.format(
metadata, count[i], EV['natoms'], phases[i]))
folder = os.path.join(evdirhome, phases[i])
if not os.path.exists(folder): os.mkdir(folder)
with open(os.path.join(folder, 'POSCAR'), 'w') as fp:
fp.write(POSCAR)
readme = {}
readme['E-V'] = EV
readme['INCAR'] = INCAR
readme['POSCAR'] = POSCAR
natoms = readme['E-V']['natoms']
with open(os.path.join(folder, 'readme'), 'w') as fp:
myjsonout(readme, fp, indent="", comma="")
i_energies = np.array(EV['energies']) / natoms
i_volumes = np.array(EV['volumes']) / natoms
val, idx = min((val, idx) for (idx, val) in enumerate(i_energies))
if blank_lines: print("\n", file=fp_ev)
blank_lines = True
print("#phase:", phases[i], file=fp_ev)
print("#metadata:", mm, file=fp_ev)
print("#natoms:", natoms, file=fp_ev)
elist = ['Fe', 'Cu', 'Se', 'Al', 'Ni', 'Co', 'Pt', 'Ta', 'O']
el = []
nel = []
if len(EV['magmoms']) > 0:
fp_ev.write("#magmoms:")
magmoms = EV['magmoms'][idx]
m0 = magmoms[0]
n0 = 1
for j in range(1, len(magmoms)):
if magmoms[j] == m0:
n0 += 1
else:
if n0 == 1: fp_ev.write('{},'.format(m0))
else: fp_ev.write('{}*{},'.format(n0, m0))
idx = len(el) % len(elist)
el.append(elist[idx])
nel.append(n0)
n0 = 1
m0 = magmoms[j]
if n0 == 1: fp_ev.write('{}\n'.format(m0))
else: fp_ev.write('{}*{}\n'.format(n0, m0))
idx = len(el) % len(elist)
el.append(elist[idx])
nel.append(n0)
lines = [l for l in POSCAR.split('\n') if l != ""]
with open(os.path.join(folder, phases[i] + '.VASP'),
'w') as fp:
for j in range(0, 5):
print(lines[j], file=fp)
for j in range(len(el)):
fp.write(' {}'.format(el[j]))
fp.write('\n')
for j in range(len(nel)):
fp.write(' {}'.format(nel[j]))
fp.write('\n')
print(lines[7], file=fp)
for j in range(8, len(lines)):
print(lines[j],
float(list(magmoms[j - 8].values())[0]),
file=fp)
for j in range(len(i_volumes)):
print(i_volumes[j], i_energies[j], file=fp_ev)
thermoplot(folder, "0 K total energies (eV/atom)", i_volumes,
i_energies)
def EV_find(self):
hit = []
count = []
phases = []
volumes = []
ITEMS = []
for i in self.items:
try:
mm = i['metadata']['tag']
except:
continue
if mm in hit:
volume = i['output']['structure']['lattice']['volume']
if volume not in volumes[hit.index(mm)]:
volumes[hit.index(mm)].append(volume)
count[hit.index(mm)] += 1
#if mm=='5252ccc3-e8da-499f-bb9e-9cf7eb1c5370': print("eeeeeeeee",mm, pot)
else:
ITEMS.append(i)
hit.append(mm)
count.append(1)
volumes.append([i['output']['structure']['lattice']['volume']])
pot = i['input']['pseudo_potential']['functional'].upper()
#if mm=='5252ccc3-e8da-499f-bb9e-9cf7eb1c5370': print("eeeeeeeee",mm, pot)
if pot == "":
pot = i['orig_inputs']['potcar']['functional'].upper()
if pot == 'Perdew-Zunger81'.upper(): pot = "LDA"
try:
pot += "+" + i['input']['GGA']
except:
pass
if i['input']['is_hubbard']: pot += '+U'
try:
if i['input']['incar']['LSORBIT']: potsoc = pot + "SOC"
except:
potsoc = pot
structure = Structure.from_dict(i['output']['structure'])
natoms = len(structure.sites)
formula_pretty = structure.composition.reduced_formula
try:
formula2composition(formula_pretty)
except:
formula_pretty = reduced_formula(
structure.composition.alphabetical_formula)
sa = SpacegroupAnalyzer(structure)
phasename = formula_pretty+'_'\
+ sa.get_space_group_symbol().replace('/','.')+'_'+str(sa.get_space_group_number())+potsoc
if phasename in phases:
for jj in range(10000):
nphasename = phasename + "#" + str(jj)
if nphasename in phases: continue
phasename = nphasename
break
phases.append(phasename)
for i, m in enumerate(hit):
if count[i] < self.nV: continue
if self.skipby(phases[i]): continue
sys.stdout.write('{}, static: {:>2}, {}\n'.format(
m, count[i], phases[i]))
EV, POSCAR, INCAR = get_rec_from_metatag(self.vasp_db, m)
evdir = './E-V/'
if not os.path.exists(evdir): os.mkdir(evdir)
folder = evdir + phases[i]
if not os.path.exists(folder): os.mkdir(folder)
with open(folder + '/POSCAR', 'w') as fp:
fp.write(POSCAR)
readme = {}
readme['E-V'] = EV
readme['INCAR'] = INCAR
readme['POSCAR'] = POSCAR
with open(folder + '/readme', 'w') as fp:
myjsonout(readme, fp, indent="", comma="")
thermoplot(folder, "0 K total energies (eV/atom)", EV['volumes'],
EV['energies'])
def __init__(self, args, vasp_db):
self.check = args.check
self.remove = args.remove
self.tags = []
self._Yphon = []
self.within = []
self.containall = []
self.containany = []
self.excludeall = []
self.excludeany = []
self.nV = args.nV
self.metatag = args.metatag
self.get = args.get
self.supercellN = args.supercellN
self.t0 = args.t0
self.t1 = args.t1
self.td = args.td
self.jobpath = args.jobpath
self.findbandgap = args.findbandgap
self.db_repair = args.db_repair
self.db_renew = args.db_renew
if args.within is not None:
self.within, tmp = formula2composition(args.within)
if args.containall is not None:
self.containall, tmp = formula2composition(args.containall)
if args.containany is not None:
self.containany, tmp = formula2composition(args.containany)
if args.excludeall is not None:
self.excludeall, tmp = formula2composition(args.excludeall)
if args.excludeany is not None:
self.excludeany, tmp = formula2composition(args.excludeany)
self.plotonly = args.plotonly
if args.qhamode is not None:
self.qhamode = args.qhamode
else:
self.qhamode = 'phonon'
if args.qhamode == 'debye': self.qhamode = 'qha'
search_condition = [{
'output.structure.lattice.volume': {
'$exists': True
}
}]
if len(self.containall) != 0:
search_condition.append({"elements": {"$all": self.containall}})
if len(self.containany) != 0:
search_condition.append({"elements": {"$in": self.containany}})
if len(self.excludeany) != 0:
search_condition.append({"elements": {"$nin": self.excludeany}})
scondition = []
if len(search_condition) > 1:
try:
metadata_list = vasp_db.collection.find(
{'$and': search_condition}, {'metadata': 1})
metadata_list = list(
set([i['metadata']['tag'] for i in metadata_list]))
metadata_list = [{'tag': i} for i in metadata_list]
scondition.append({"metadata": {"$in": metadata_list}})
except:
pass
if not self.plotonly:
try:
self.vasp_db = vasp_db
if self.qhamode == 'phonon':
scondition.append({"S_vib": {"$exists": True}})
self.items = list((self.vasp_db).db['phonon'].find({'$and':scondition},\
{'metadata':1, 'unitcell':1, 'volume':1, 'supercell_matrix':1}))
else:
scondition.append({"debye": {"$exists": True}})
self.items = list((self.vasp_db).db['qha'].find({'$and':scondition},\
{'metadata':1, 'structure':1}))
except:
self.vasp_db = None
warnings.warn(
"\n*********WARNING: CANNOT get MongoDB service, so I will proceed using local data"
)
def qha_renew(self):
hit = []
phases = []
static_collection = (self.vasp_db).collection.find({'$and':[{'metadata': { "$exists": True }}, \
{'adopted': True} ]})
for i in static_collection:
mm = i['metadata']
if mm in hit: continue
if len(mm) > 1: continue
else:
hit.append(mm)
structure = Structure.from_dict(i['output']['structure'])
formula_pretty = structure.composition.reduced_formula
try:
formula2composition(formula_pretty)
except:
formula_pretty = reduced_formula(
structure.composition.alphabetical_formula)
sa = SpacegroupAnalyzer(structure)
phasename = formula_pretty+'_'\
+ sa.get_space_group_symbol().replace('/','.')+'_'+str(sa.get_space_group_number())
if phasename in phases:
for jj in range(10000):
nphasename = phasename + "#" + str(jj)
if nphasename in phases: continue
phasename = nphasename
break
phases.append(phasename)
print("\nfound complete calculations in the task collection:\n")
total = 0
total_qha = 0
total_qha_phonon = 0
all_static_calculations = list((self.vasp_db).db['tasks'].\
find({'$and':[{'metadata': { "$exists": True }}, {'adopted': True} ]},\
{'metadata':1, 'output':1, 'input':1, 'orig_inputs':1}))
all_qha_calculations = list((self.vasp_db).db['qha'].\
find({'$and':[{'metadata': { "$exists": True }},{'has_phonon':True}]}, {'metadata':1, 'temperatures':1}))
all_qha_phonon_calculations = list((self.vasp_db).db['qha_phonon'].\
find({'$and':[{'metadata': { "$exists": True }},{'has_phonon':True}]}, {'metadata':1, 'temperatures':1}))
for i, m in enumerate(hit):
if self.skipby(phases[i], m['tag']): continue
total += 1
static_calculations = [
f for f in all_static_calculations
if f['metadata']['tag'] == m['tag']
]
qha_calculations = [
f for f in all_qha_calculations
if f['metadata']['tag'] == m['tag']
]
qha_phonon_calculations = [
f for f in all_qha_phonon_calculations
if f['metadata']['tag'] == m['tag']
]
qha_phonon_success = len(qha_phonon_calculations) > 0
if qha_phonon_success: total_qha_phonon += 1
if len(qha_calculations) > 0 or qha_phonon_success: total_qha += 1
potsoc = None
volumes = []
energies = []
for ii, calc in enumerate(static_calculations):
vol = calc['output']['structure']['lattice']['volume']
if vol in volumes:
if len(calc['metadata']) > 1: continue
else:
ix = volumes.index(vol)
volumes.pop(ix)
energies.pop(ix)
volumes.append(
calc['output']['structure']['lattice']['volume'])
energies.append(calc['output']['energy'])
if potsoc is None:
potsoc = get_used_pot(calc)
pname = phases[i].split('#')
if len(pname) > 1:
phases[i] = pname[0] + potsoc + '#' + pname[1]
else:
phases[i] = pname[0] + potsoc
nS = len(volumes)
if nS < 6: continue
if qha_phonon_success and not self.db_renew: continue
energies = sort_x_by_y(energies, volumes)
volumes = sorted(volumes)
volumes = np.array(volumes)
energies = np.array(energies)
val, idx = min((val, idx) for (idx, val) in enumerate(energies))
if idx < 2 or idx > nS - 2: continue
jobpath = findjobdir(self.jobpath, m['tag'])
if jobpath == None:
sys.stdout.write('{}, static: {:>2}, qha_phonon: {:<1.1s}, {}\n'\
.format(m, nS, str(qha_phonon_success), phases[i]))
else:
sys.stdout.write('{}, static: {:>2}, qha_phonon: {:<1.1s}, {},{}\n'\
.format(m, nS, str(qha_phonon_success), phases[i],jobpath))
self.tags.append({'tag': m['tag'], 'phasename': phases[i]})
sys.stdout.write ('\n({},{})/{} (qha, qha_phonon) entries returned under the given searching conditions.\n'\
.format(total_qha, total_qha_phonon, total))
def phonon_find(self):
hit = []
count = []
phases = []
volumes = []
ITEMS = []
self.supercellsize = []
for i in self.items:
mm = i['metadata']
if mm in hit:
if i['volume'] not in volumes[hit.index(mm)]:
volumes[hit.index(mm)].append(i['volume'])
count[hit.index(mm)] += 1
else:
ITEMS.append(i)
hit.append(mm)
count.append(1)
volumes.append([i['volume']])
structure = Structure.from_dict(i['unitcell'])
natoms = len(structure.sites)
supercell_matrix = i['supercell_matrix']
self.supercellsize.append(
natoms *
int(np.linalg.det(np.array(supercell_matrix)) + .5))
formula_pretty = structure.composition.reduced_formula
try:
formula2composition(formula_pretty)
except:
formula_pretty = reduced_formula(
structure.composition.alphabetical_formula)
sa = SpacegroupAnalyzer(structure)
phasename = formula_pretty+'_'\
+ sa.get_space_group_symbol().replace('/','.')+'_'+str(sa.get_space_group_number())
if phasename in phases:
for jj in range(10000):
nphasename = phasename + "#" + str(jj)
if nphasename in phases: continue
phasename = nphasename
break
phases.append(phasename)
print("\nfound complete calculations in the collection:", self.qhamode,
"\n")
total = 0
total_qha_phonon = 0
all_static_calculations = list((self.vasp_db).db['tasks'].\
find({'$and':[{'metadata': { "$exists": True }}, {'adopted': True} ]},\
{'metadata':1, 'output':1, 'input':1, 'orig_inputs':1}))
all_qha_calculations = list((self.vasp_db).db['qha'].\
find({'$and':[{'metadata': { "$exists": True }},{'has_phonon':True}]}, {'metadata':1, 'temperatures':1}))
all_qha_phonon_calculations = list((self.vasp_db).db['qha_phonon'].\
find({'$and':[{'metadata': { "$exists": True }},{'has_phonon':True}]}, {'metadata':1, 'temperatures':1}))
for i, m in enumerate(hit):
if self.skipby(phases[i], m['tag']): continue
total += 1
static_calculations = [
f for f in all_static_calculations
if f['metadata']['tag'] == m['tag']
]
qha_calculations = [
f for f in all_qha_calculations
if f['metadata']['tag'] == m['tag']
]
qha_phonon_calculations = [
f for f in all_qha_phonon_calculations
if f['metadata']['tag'] == m['tag']
]
"""
static_calculations = [f for f in all_static_calculations if f['metadata']==m]
qha_calculations = [f for f in all_qha_calculations if f['metadata']==m]
qha_phonon_calculations = [f for f in all_qha_phonon_calculations if f['metadata']==m]
"""
qha_phonon_success = True
if len(qha_calculations) > 0:
total_qha_phonon += 1
elif len(qha_phonon_calculations) > 0:
total_qha_phonon += 1
else:
qha_phonon_success = False
gapfound = False
potsoc = None
_volumes = []
emin = 1.e36
for ii, calc in enumerate(static_calculations):
vol = calc['output']['structure']['lattice']['volume']
ene = calc['output']['energy']
if ene < emin: _calc = calc
if vol not in _volumes: _volumes.append(vol)
bandgap = calc['output']['bandgap']
if not gapfound: gapfound = float(bandgap) > 0.0
potsoc = get_used_pot(_calc)
Mag_State = get_Magnetic_State(_calc)
pname = phases[i].split('#')
if len(pname) > 1:
phases[i] = pname[0] + potsoc + Mag_State + '#' + pname[1]
else:
phases[i] = pname[0] + potsoc + Mag_State
nS = len(_volumes)
if self.findbandgap:
if gapfound:
sys.stdout.write(
'{}, phonon: {:>2}, static: {:>2}, supercellsize: {:>3}, {}\n'
.format(m, count[i], nS, self.supercellsize[i],
phases[i]))
else:
if count[i] < self.nV: continue
if self.db_repair:
if qha_phonon_success and not self.db_renew: continue
if self.supercellsize[i] < self.supercellN: continue
jobpath = findjobdir(self.jobpath, m['tag'])
if self.remove:
sys.stdout.write('dfttk db_remove --force -m all -tag {} phonon: {:>2}, static: {:>2}, SN: {:>3}, qha_phonon: {:<1.1s}, {}\n'\
.format(m['tag'], count[i], nS, self.supercellsize[i], str(qha_phonon_success), phases[i]))
elif jobpath == None:
sys.stdout.write('{}, phonon: {:>2}, static: {:>2}, SN: {:>3}, qha_phonon: {:<1.1s}, {}\n'\
.format(m, count[i], nS, self.supercellsize[i], str(qha_phonon_success), phases[i]))
else:
sys.stdout.write('{}, phonon: {:>2}, static: {:>2}, SN: {:>3}, qha_phonon: {:<1.1s}, {},{}\n'\
.format(m, count[i], nS, self.supercellsize[i], str(qha_phonon_success), phases[i],jobpath))
#if count[i]>=5: self.tags.append({'tag':m['tag'],'phasename':phases[i]})
self.tags.append({'tag': m['tag'], 'phasename': phases[i]})
#print(sorted(volumes[i]))
sys.stdout.write ('\n{}/{} qha_phonon successful under the given searching conditions.\n'\
.format(total_qha_phonon, total))
