def add_snl(self, snl, force_new=False, snlgroup_guess=None):
try:
self.lock_db()
snl_id = self._get_next_snl_id()
spstruc = snl.structure.copy()
spstruc.remove_oxidation_states()
sf = SymmetryFinder(spstruc, SPACEGROUP_TOLERANCE)
sf.get_spacegroup()
sgnum = sf.get_spacegroup_number() if sf.get_spacegroup_number() \
else -1
sgsym = sf.get_spacegroup_symbol() if sf.get_spacegroup_symbol() \
else 'unknown'
sghall = sf.get_hall() if sf.get_hall() else 'unknown'
sgxtal = sf.get_crystal_system() if sf.get_crystal_system() \
else 'unknown'
sglatt = sf.get_lattice_type() if sf.get_lattice_type() else 'unknown'
sgpoint = unicode(sf.get_point_group(), errors="ignore")
mpsnl = MPStructureNL.from_snl(snl, snl_id, sgnum, sgsym, sghall,
sgxtal, sglatt, sgpoint)
snlgroup, add_new, spec_group = self.add_mpsnl(mpsnl, force_new, snlgroup_guess)
self.release_lock()
return mpsnl, snlgroup.snlgroup_id, spec_group
except:
self.release_lock()
traceback.print_exc()
raise ValueError("Error while adding SNL!")
def add_snl(self, snl, force_new=False, snlgroup_guess=None):
try:
self.lock_db()
snl_id = self._get_next_snl_id()
spstruc = snl.structure.copy()
spstruc.remove_oxidation_states()
sf = SymmetryFinder(spstruc, SPACEGROUP_TOLERANCE)
sf.get_spacegroup()
sgnum = sf.get_spacegroup_number() if sf.get_spacegroup_number() \
else -1
sgsym = sf.get_spacegroup_symbol() if sf.get_spacegroup_symbol() \
else 'unknown'
sghall = sf.get_hall() if sf.get_hall() else 'unknown'
sgxtal = sf.get_crystal_system() if sf.get_crystal_system() \
else 'unknown'
sglatt = sf.get_lattice_type() if sf.get_lattice_type(
) else 'unknown'
sgpoint = unicode(sf.get_point_group(), errors="ignore")
mpsnl = MPStructureNL.from_snl(snl, snl_id, sgnum, sgsym, sghall,
sgxtal, sglatt, sgpoint)
snlgroup, add_new, spec_group = self.add_mpsnl(
mpsnl, force_new, snlgroup_guess)
self.release_lock()
return mpsnl, snlgroup.snlgroup_id, spec_group
except:
self.release_lock()
traceback.print_exc()
raise ValueError("Error while adding SNL!")
def _generate_entry(structure, params, name, energy, pressure):
comp = structure.composition
entry = {"structure": structure.to_dict, "name": name, "energy": energy, "energy_per_site": energy / comp.num_atoms,
"pressure": pressure, "potential": {"name": "lennard_jones", "params": params.to_dict}}
# Set the composition and formulas for the system
el_amt = comp.get_el_amt_dict()
entry.update({"unit_cell_formula": comp.to_dict,
"reduced_cell_formula": comp.to_reduced_dict,
"elements": list(el_amt.keys()),
"nelements": len(el_amt),
"pretty_formula": comp.reduced_formula,
"anonymous_formula": comp.anonymized_formula,
"nsites": comp.num_atoms,
"chemsys": "-".join(sorted(el_amt.keys()))})
# Figure out the symmetry group
sg = SymmetryFinder(structure, normalised_symmetry_precision(structure), -1)
entry["spacegroup"] = {"symbol": unicode(sg.get_spacegroup_symbol(), errors="ignore"),
"number": sg.get_spacegroup_number(),
"point_group": unicode(sg.get_point_group(), errors="ignore"),
"source": "spglib",
"crystal_system": sg.get_crystal_system(),
"hall": sg.get_hall()}
return entry
def process_res(cls, resfile):
fullpath = os.path.abspath(resfile)
res = Res.from_file(resfile)
d = res.to_dict
d["file_name"] = fullpath
s = res.structure
# Set the composition and formulas for the system
comp = s.composition
el_amt = s.composition.get_el_amt_dict()
d.update({"unit_cell_formula": comp.to_dict,
"reduced_cell_formula": comp.to_reduced_dict,
"elements": list(el_amt.keys()),
"nelements": len(el_amt),
"pretty_formula": comp.reduced_formula,
"anonymous_formula": comp.anonymized_formula,
"nsites": comp.num_atoms,
"chemsys": "-".join(sorted(el_amt.keys()))})
#d["density"] = s.density
# Figure out the symmetry group
sg = SymmetryFinder(s, util.normalised_symmetry_precision(s), -1)
d["spacegroup"] = {"symbol": unicode(sg.get_spacegroup_symbol(),
errors="ignore"),
"number": sg.get_spacegroup_number(),
"point_group": unicode(sg.get_point_group(),
errors="ignore"),
"source": "spglib",
"crystal_system": sg.get_crystal_system(),
"hall": sg.get_hall()}
return d
def add_snl(self, snl):
snl_id = self._get_next_snl_id()
sf = SymmetryFinder(snl.structure, SPACEGROUP_TOLERANCE)
sf.get_spacegroup()
mpsnl = MPStructureNL.from_snl(snl, snl_id, sf.get_spacegroup_number(),
sf.get_spacegroup_symbol(), sf.get_hall(),
sf.get_crystal_system(), sf.get_lattice_type())
snlgroup, add_new = self.add_mpsnl(mpsnl)
return mpsnl, snlgroup.snlgroup_id
def add_snl(self, snl, force_new=False, snlgroup_guess=None):
snl_id = self._get_next_snl_id()
sf = SymmetryFinder(snl.structure, SPACEGROUP_TOLERANCE)
sf.get_spacegroup()
sgnum = sf.get_spacegroup_number() if sf.get_spacegroup_number() \
else -1
sgsym = sf.get_spacegroup_symbol() if sf.get_spacegroup_symbol() \
else 'unknown'
sghall = sf.get_hall() if sf.get_hall() else 'unknown'
sgxtal = sf.get_crystal_system() if sf.get_crystal_system() \
else 'unknown'
sglatt = sf.get_lattice_type() if sf.get_lattice_type() else 'unknown'
sgpoint = unicode(sf.get_point_group(), errors="ignore")
mpsnl = MPStructureNL.from_snl(snl, snl_id, sgnum, sgsym, sghall,
sgxtal, sglatt, sgpoint)
snlgroup, add_new = self.add_mpsnl(mpsnl, force_new, snlgroup_guess)
return mpsnl, snlgroup.snlgroup_id
def add_snl(self, snl, force_new=False, snlgroup_guess=None):
snl_id = self._get_next_snl_id()
sf = SymmetryFinder(snl.structure, SPACEGROUP_TOLERANCE)
sf.get_spacegroup()
sgnum = sf.get_spacegroup_number() if sf.get_spacegroup_number() \
else -1
sgsym = sf.get_spacegroup_symbol() if sf.get_spacegroup_symbol() \
else 'unknown'
sghall = sf.get_hall() if sf.get_hall() else 'unknown'
sgxtal = sf.get_crystal_system() if sf.get_crystal_system() \
else 'unknown'
sglatt = sf.get_lattice_type() if sf.get_lattice_type() else 'unknown'
sgpoint = unicode(sf.get_point_group(), errors="ignore")
mpsnl = MPStructureNL.from_snl(snl, snl_id, sgnum, sgsym, sghall,
sgxtal, sglatt, sgpoint)
snlgroup, add_new = self.add_mpsnl(mpsnl, force_new, snlgroup_guess)
return mpsnl, snlgroup.snlgroup_id
def get_structure_hash(self, structure):
"""
Hash for structure.
Args:
structure: A structure
Returns:
Reduced formula for the structure is used as a hash for the
SpeciesComparator.
"""
if not hasattr(structure, 'spacegroup'):
sg = SymmetryFinder(structure, splpy.util.normalised_symmetry_precision(structure), -1)
structure.spacegroup = {"symbol": unicode(sg.get_spacegroup_symbol(), errors="ignore"),
"number": sg.get_spacegroup_number(),
"point_group": unicode(sg.get_point_group(), errors="ignore"),
"crystal_system": sg.get_crystal_system(),
"hall": sg.get_hall()}
return "{} {}".format(structure.spacegroup['number'], self._parent.get_structure_hash(structure))
def generate_doc(cls, dir_name, vasprun_files, parse_dos, additional_fields):
"""
Process aflow style runs, where each run is actually a combination of
two vasp runs.
"""
try:
fullpath = os.path.abspath(dir_name)
# Defensively copy the additional fields first. This is a MUST.
# Otherwise, parallel updates will see the same object and inserts
# will be overridden!!
d = {k: v for k, v in additional_fields.items()} if additional_fields else {}
d["dir_name"] = fullpath
d["schema_version"] = VaspToDbTaskDrone.__version__
d["calculations"] = [
cls.process_vasprun(dir_name, taskname, filename, parse_dos)
for taskname, filename in vasprun_files.items()
]
d1 = d["calculations"][0]
d2 = d["calculations"][-1]
# Now map some useful info to the root level.
for root_key in [
"completed_at",
"nsites",
"unit_cell_formula",
"reduced_cell_formula",
"pretty_formula",
"elements",
"nelements",
"cif",
"density",
"is_hubbard",
"hubbards",
"run_type",
]:
d[root_key] = d2[root_key]
d["chemsys"] = "-".join(sorted(d2["elements"]))
d["input"] = {"crystal": d1["input"]["crystal"]}
vals = sorted(d2["reduced_cell_formula"].values())
d["anonymous_formula"] = {string.ascii_uppercase[i]: float(vals[i]) for i in xrange(len(vals))}
d["output"] = {
"crystal": d2["output"]["crystal"],
"final_energy": d2["output"]["final_energy"],
"final_energy_per_atom": d2["output"]["final_energy_per_atom"],
}
d["name"] = "aflow"
d["pseudo_potential"] = {"functional": "pbe", "pot_type": "paw", "labels": d2["input"]["potcar"]}
if len(d["calculations"]) == 2 or vasprun_files.keys()[0] != "relax1":
d["state"] = "successful" if d2["has_vasp_completed"] else "unsuccessful"
else:
d["state"] = "stopped"
s = Structure.from_dict(d2["output"]["crystal"])
if not s.is_valid():
d["state"] = "errored_bad_structure"
d["analysis"] = get_basic_analysis_and_error_checks(d)
sg = SymmetryFinder(Structure.from_dict(d["output"]["crystal"]), 0.1)
d["spacegroup"] = {
"symbol": sg.get_spacegroup_symbol(),
"number": sg.get_spacegroup_number(),
"point_group": unicode(sg.get_point_group(), errors="ignore"),
"source": "spglib",
"crystal_system": sg.get_crystal_system(),
"hall": sg.get_hall(),
}
d["last_updated"] = datetime.datetime.today()
return d
except Exception as ex:
logger.error("Error in " + os.path.abspath(dir_name) + ".\nError msg: " + str(ex))
return None
def generate_doc(cls, dir_name, vasprun_files, parse_dos,
additional_fields):
"""Process aflow style and NEB runs."""
print "TTM DEBUG: In generate_doc for NEB task drone."
try:
fullpath = os.path.abspath(dir_name)
#Defensively copy the additional fields first. This is a MUST.
#Otherwise, parallel updates will see the same object and inserts
#will be overridden!!
d = {k: v for k, v in additional_fields.items()} \
if additional_fields else {}
d["dir_name"] = fullpath
print "TTM DEBUG: fullpath: ", fullpath
d["schema_version"] = NEBToDbTaskDrone.__version__
d["calculations"] = [
cls.process_vasprun(dir_name, taskname, filename, parse_dos)
for taskname, filename in vasprun_files.items()]
d1 = d["calculations"][0]
d2 = d["calculations"][-1]
#Now map some useful info to the root level.
for root_key in ["completed_at", "nsites", "unit_cell_formula",
"reduced_cell_formula", "pretty_formula",
"elements", "nelements", "cif", "density",
"is_hubbard", "hubbards", "run_type"]:
d[root_key] = d2[root_key]
d["chemsys"] = "-".join(sorted(d2["elements"]))
d["input"] = {"crystal": d1["input"]["crystal"]}
vals = sorted(d2["reduced_cell_formula"].values())
d["anonymous_formula"] = {string.ascii_uppercase[i]: float(vals[i])
for i in xrange(len(vals))}
d["output"] = {
"crystal": d2["output"]["crystal"],
"final_energy": d2["output"]["final_energy"],
"final_energy_per_atom": d2["output"]["final_energy_per_atom"]}
d["name"] = "aflow"
d["pseudo_potential"] = {"functional": "pbe", "pot_type": "paw",
"labels": d2["input"]["potcar"]}
if len(d["calculations"]) == 2 or \
vasprun_files.keys()[0] != "relax1":
d["state"] = "successful" if d2["has_vasp_completed"] \
else "unsuccessful"
else:
d["state"] = "stopped"
s = Structure.from_dict(d2["output"]["crystal"])
if not s.is_valid():
d["state"] = "errored_bad_structure"
d["analysis"] = get_basic_analysis_and_error_checks(d)
sg = SymmetryFinder(Structure.from_dict(d["output"]["crystal"]),
0.1)
d["spacegroup"] = {"symbol": sg.get_spacegroup_symbol(),
"number": sg.get_spacegroup_number(),
"point_group": unicode(sg.get_point_group(),
errors="ignore"),
"source": "spglib",
"crystal_system": sg.get_crystal_system(),
"hall": sg.get_hall()}
d["last_updated"] = datetime.datetime.today()
# Process NEB runs. The energy and magnetic moments for each image are listed.
# Some useful values are calculated.
# Number of NEB images
print "TTM DEBUG: At NEB processing stage."
image_list = []
for i in xrange(0,9):
append = "0"+str(i)
newpath = os.path.join(fullpath,append)
if os.path.exists(newpath):
image_list.append(newpath)
d["num_images"] = len(image_list)
print "TTM DEBUG: Image list:", image_list
# Image energies and magnetic moments for specific folders
list_image_energies = []
list_image_mags = []
for i in xrange(0,len(image_list)):
append = "0"+str(i)
oszicar = os.path.join(fullpath,append,"OSZICAR")
if not os.path.isfile(oszicar):
return None
val_energy = util2.getEnergy(oszicar)
val_mag = util2.getMag(oszicar)
d["E_"+append]= val_energy
d["mag_"+append]= val_mag
list_image_energies.append(val_energy)
list_image_mags.append(val_mag)
print "TTM DEBUG: first occurrence list_image_mags", list_image_mags
# List of image energies and magnetic moments in order
image_energies = ' '.join(map(str,list_image_energies))
d["image_energies"] = image_energies
# An simple way to visualize relative image energies and magnetic moments
energy_contour = "-x-"
if len(image_list)==0:
return None
for i in xrange(1,len(image_list)):
if(list_image_energies[i]>list_image_energies[i-1]):
energy_contour += "/-x-"
elif list_image_energies[i]<list_image_energies[i-1]:
energy_contour += "\\-x-"
else:
energy_contour += "=-x-"
d["energy_contour"] = energy_contour
print "TTM DEBUG: energy contour:", energy_contour
# Difference between the first and maximum energies and magnetic moments
deltaE_firstmax = max(list_image_energies) - list_image_energies[0]
d["deltaE_firstmax"] = deltaE_firstmax
# Difference between the last and maximum energies and magnetic moments
deltaE_lastmax = max(list_image_energies) - list_image_energies[-1]
d["deltaE_lastmax"] = deltaE_lastmax
# Difference between the endpoint energies and magnetic moments
deltaE_endpoints = list_image_energies[-1] - list_image_energies[0]
d["deltaE_endpoints"] = deltaE_endpoints
# Difference between the minimum and maximum energies and magnetic moments
deltaE_maxmin = max(list_image_energies) - min(list_image_energies)
d["deltaE_maxmin"] = deltaE_maxmin
#INDENT THE NEXT LINES:
if not (list_image_mags[0] == None): #if ISPIN not 2, no mag info
image_mags = ' '.join(map(str,list_image_mags))
d["image_mags"] = image_mags
mag_contour = "-o-"
if len(image_list)==0:
return None
for i in xrange(1,len(image_list)):
if(list_image_mags[i]>list_image_mags[i-1]):
mag_contour += "/-o-"
elif list_image_mags[i]<list_image_mags[i-1]:
mag_contour += "\\-o-"
else:
mag_contour += "=-o-"
d["mag_contour"] = mag_contour
deltaM_firstmax = max(list_image_mags) - list_image_mags[0]
d["deltaM_firstmax"] = deltaM_firstmax
deltaM_lastmax = max(list_image_mags) - list_image_mags[-1]
d["deltaM_lastmax"] = deltaM_lastmax
deltaM_endpoints = list_image_mags[-1] - list_image_mags[0]
d["deltaM_endpoints"] = deltaM_endpoints
deltaM_maxmin = max(list_image_mags) - min(list_image_mags)
d["deltaM_maxmin"] = deltaM_maxmin
d["type"] = "NEB"
return d
except Exception as ex:
logger.error("Error in " + os.path.abspath(dir_name) +
".\nError msg: " + str(ex))
return None
def generate_doc(cls, dir_name, vasprun_files, parse_dos,
additional_fields):
"""Process aflow style and NEB runs."""
print "TTM DEBUG: In generate_doc for NEB task drone."
try:
fullpath = os.path.abspath(dir_name)
#Defensively copy the additional fields first. This is a MUST.
#Otherwise, parallel updates will see the same object and inserts
#will be overridden!!
d = {k: v for k, v in additional_fields.items()} \
if additional_fields else {}
d["dir_name"] = fullpath
print "TTM DEBUG: fullpath: ", fullpath
d["schema_version"] = NEBToDbTaskDrone.__version__
d["calculations"] = [
cls.process_vasprun(dir_name, taskname, filename, parse_dos)
for taskname, filename in vasprun_files.items()
]
d1 = d["calculations"][0]
d2 = d["calculations"][-1]
#Now map some useful info to the root level.
for root_key in [
"completed_at", "nsites", "unit_cell_formula",
"reduced_cell_formula", "pretty_formula", "elements",
"nelements", "cif", "density", "is_hubbard", "hubbards",
"run_type"
]:
d[root_key] = d2[root_key]
d["chemsys"] = "-".join(sorted(d2["elements"]))
d["input"] = {"crystal": d1["input"]["crystal"]}
vals = sorted(d2["reduced_cell_formula"].values())
d["anonymous_formula"] = {
string.ascii_uppercase[i]: float(vals[i])
for i in xrange(len(vals))
}
d["output"] = {
"crystal": d2["output"]["crystal"],
"final_energy": d2["output"]["final_energy"],
"final_energy_per_atom": d2["output"]["final_energy_per_atom"]
}
d["name"] = "aflow"
d["pseudo_potential"] = {
"functional": "pbe",
"pot_type": "paw",
"labels": d2["input"]["potcar"]
}
if len(d["calculations"]) == 2 or \
vasprun_files.keys()[0] != "relax1":
d["state"] = "successful" if d2["has_vasp_completed"] \
else "unsuccessful"
else:
d["state"] = "stopped"
s = Structure.from_dict(d2["output"]["crystal"])
if not s.is_valid():
d["state"] = "errored_bad_structure"
d["analysis"] = get_basic_analysis_and_error_checks(d)
sg = SymmetryFinder(Structure.from_dict(d["output"]["crystal"]),
0.1)
d["spacegroup"] = {
"symbol": sg.get_spacegroup_symbol(),
"number": sg.get_spacegroup_number(),
"point_group": unicode(sg.get_point_group(), errors="ignore"),
"source": "spglib",
"crystal_system": sg.get_crystal_system(),
"hall": sg.get_hall()
}
d["last_updated"] = datetime.datetime.today()
# Process NEB runs. The energy and magnetic moments for each image are listed.
# Some useful values are calculated.
# Number of NEB images
print "TTM DEBUG: At NEB processing stage."
image_list = []
for i in xrange(0, 9):
append = "0" + str(i)
newpath = os.path.join(fullpath, append)
if os.path.exists(newpath):
image_list.append(newpath)
d["num_images"] = len(image_list)
print "TTM DEBUG: Image list:", image_list
# Image energies and magnetic moments for specific folders
list_image_energies = []
list_image_mags = []
for i in xrange(0, len(image_list)):
append = "0" + str(i)
oszicar = os.path.join(fullpath, append, "OSZICAR")
if not os.path.isfile(oszicar):
return None
val_energy = util2.getEnergy(oszicar)
val_mag = util2.getMag(oszicar)
d["E_" + append] = val_energy
d["mag_" + append] = val_mag
list_image_energies.append(val_energy)
list_image_mags.append(val_mag)
print "TTM DEBUG: first occurrence list_image_mags", list_image_mags
# List of image energies and magnetic moments in order
image_energies = ' '.join(map(str, list_image_energies))
d["image_energies"] = image_energies
# An simple way to visualize relative image energies and magnetic moments
energy_contour = "-x-"
if len(image_list) == 0:
return None
for i in xrange(1, len(image_list)):
if (list_image_energies[i] > list_image_energies[i - 1]):
energy_contour += "/-x-"
elif list_image_energies[i] < list_image_energies[i - 1]:
energy_contour += "\\-x-"
else:
energy_contour += "=-x-"
d["energy_contour"] = energy_contour
print "TTM DEBUG: energy contour:", energy_contour
# Difference between the first and maximum energies and magnetic moments
deltaE_firstmax = max(list_image_energies) - list_image_energies[0]
d["deltaE_firstmax"] = deltaE_firstmax
# Difference between the last and maximum energies and magnetic moments
deltaE_lastmax = max(list_image_energies) - list_image_energies[-1]
d["deltaE_lastmax"] = deltaE_lastmax
# Difference between the endpoint energies and magnetic moments
deltaE_endpoints = list_image_energies[-1] - list_image_energies[0]
d["deltaE_endpoints"] = deltaE_endpoints
# Difference between the minimum and maximum energies and magnetic moments
deltaE_maxmin = max(list_image_energies) - min(list_image_energies)
d["deltaE_maxmin"] = deltaE_maxmin
#INDENT THE NEXT LINES:
if not (list_image_mags[0] == None): #if ISPIN not 2, no mag info
image_mags = ' '.join(map(str, list_image_mags))
d["image_mags"] = image_mags
mag_contour = "-o-"
if len(image_list) == 0:
return None
for i in xrange(1, len(image_list)):
if (list_image_mags[i] > list_image_mags[i - 1]):
mag_contour += "/-o-"
elif list_image_mags[i] < list_image_mags[i - 1]:
mag_contour += "\\-o-"
else:
mag_contour += "=-o-"
d["mag_contour"] = mag_contour
deltaM_firstmax = max(list_image_mags) - list_image_mags[0]
d["deltaM_firstmax"] = deltaM_firstmax
deltaM_lastmax = max(list_image_mags) - list_image_mags[-1]
d["deltaM_lastmax"] = deltaM_lastmax
deltaM_endpoints = list_image_mags[-1] - list_image_mags[0]
d["deltaM_endpoints"] = deltaM_endpoints
deltaM_maxmin = max(list_image_mags) - min(list_image_mags)
d["deltaM_maxmin"] = deltaM_maxmin
d["type"] = "NEB"
return d
except Exception as ex:
logger.error("Error in " + os.path.abspath(dir_name) +
".\nError msg: " + str(ex))
return None
def generate_doc(cls, dir_name, vasprun_files, parse_dos,
additional_fields):
"""
Process aflow style runs, where each run is actually a combination of
two vasp runs.
"""
try:
fullpath = os.path.abspath(dir_name)
#Defensively copy the additional fields first. This is a MUST.
#Otherwise, parallel updates will see the same object and inserts
#will be overridden!!
d = {k: v for k, v in additional_fields.items()} \
if additional_fields else {}
d["dir_name"] = fullpath
d["schema_version"] = VaspToDbTaskDrone.__version__
d["calculations"] = [
cls.process_vasprun(dir_name, taskname, filename, parse_dos)
for taskname, filename in vasprun_files.items()
]
d1 = d["calculations"][0]
d2 = d["calculations"][-1]
#Now map some useful info to the root level.
for root_key in [
"completed_at", "nsites", "unit_cell_formula",
"reduced_cell_formula", "pretty_formula", "elements",
"nelements", "cif", "density", "is_hubbard", "hubbards",
"run_type"
]:
d[root_key] = d2[root_key]
d["chemsys"] = "-".join(sorted(d2["elements"]))
d["input"] = {"crystal": d1["input"]["crystal"]}
vals = sorted(d2["reduced_cell_formula"].values())
d["anonymous_formula"] = {
string.ascii_uppercase[i]: float(vals[i])
for i in xrange(len(vals))
}
d["output"] = {
"crystal": d2["output"]["crystal"],
"final_energy": d2["output"]["final_energy"],
"final_energy_per_atom": d2["output"]["final_energy_per_atom"]
}
d["name"] = "aflow"
d["pseudo_potential"] = {
"functional": "pbe",
"pot_type": "paw",
"labels": d2["input"]["potcar"]
}
if len(d["calculations"]) == 2 or \
vasprun_files.keys()[0] != "relax1":
d["state"] = "successful" if d2["has_vasp_completed"] \
else "unsuccessful"
else:
d["state"] = "stopped"
s = Structure.from_dict(d2["output"]["crystal"])
if not s.is_valid():
d["state"] = "errored_bad_structure"
d["analysis"] = get_basic_analysis_and_error_checks(d)
sg = SymmetryFinder(Structure.from_dict(d["output"]["crystal"]),
0.1)
d["spacegroup"] = {
"symbol": sg.get_spacegroup_symbol(),
"number": sg.get_spacegroup_number(),
"point_group": unicode(sg.get_point_group(), errors="ignore"),
"source": "spglib",
"crystal_system": sg.get_crystal_system(),
"hall": sg.get_hall()
}
d["last_updated"] = datetime.datetime.today()
d["type"] = "VASP" #PS
return d
except Exception as ex:
logger.error("Error in " + os.path.abspath(dir_name) +
".\nError msg: " + str(ex))
return None
class SymmetryFinderTest(unittest.TestCase):
def setUp(self):
p = Poscar.from_file(os.path.join(test_dir, 'POSCAR'))
self.structure = p.structure
self.sg = SymmetryFinder(self.structure, 0.001)
parser = CifParser(os.path.join(test_dir, 'Li10GeP2S12.cif'))
self.disordered_structure = parser.get_structures()[0]
self.disordered_sg = SymmetryFinder(self.disordered_structure, 0.001)
s = p.structure.copy()
site = s[0]
del s[0]
s.append(site.species_and_occu, site.frac_coords)
self.sg3 = SymmetryFinder(s, 0.001)
parser = CifParser(os.path.join(test_dir, 'Graphite.cif'))
graphite = parser.get_structures()[0]
graphite.add_site_property("magmom", [0.1] * len(graphite))
self.sg4 = SymmetryFinder(graphite, 0.001)
def test_get_space_symbol(self):
self.assertEqual(self.sg.get_spacegroup_symbol(), "Pnma")
self.assertEqual(self.disordered_sg.get_spacegroup_symbol(),
"P4_2/nmc")
self.assertEqual(self.sg3.get_spacegroup_symbol(), "Pnma")
self.assertEqual(self.sg4.get_spacegroup_symbol(), "R-3m")
def test_get_space_number(self):
self.assertEqual(self.sg.get_spacegroup_number(), 62)
self.assertEqual(self.disordered_sg.get_spacegroup_number(), 137)
self.assertEqual(self.sg4.get_spacegroup_number(), 166)
def test_get_hall(self):
self.assertEqual(self.sg.get_hall(), '-P 2ac 2n')
self.assertEqual(self.disordered_sg.get_hall(), 'P 4n 2n -1n')
def test_get_pointgroup(self):
self.assertEqual(self.sg.get_point_group(), 'mmm')
self.assertEqual(self.disordered_sg.get_point_group(), '4/mmm')
def test_get_symmetry_dataset(self):
ds = self.sg.get_symmetry_dataset()
self.assertEqual(ds['international'], 'Pnma')
def test_get_crystal_system(self):
crystal_system = self.sg.get_crystal_system()
self.assertEqual('orthorhombic', crystal_system)
self.assertEqual('tetragonal', self.disordered_sg.get_crystal_system())
def test_get_symmetry_operations(self):
fracsymmops = self.sg.get_symmetry_operations()
symmops = self.sg.get_symmetry_operations(True)
self.assertEqual(len(symmops), 8)
latt = self.structure.lattice
for fop, op in zip(fracsymmops, symmops):
for site in self.structure:
newfrac = fop.operate(site.frac_coords)
newcart = op.operate(site.coords)
self.assertTrue(np.allclose(latt.get_fractional_coords(newcart),
newfrac))
found = False
newsite = PeriodicSite(site.species_and_occu, newcart, latt,
coords_are_cartesian=True)
for testsite in self.structure:
if newsite.is_periodic_image(testsite, 1e-3):
found = True
break
self.assertTrue(found)
def test_get_refined_structure(self):
for a in self.sg.get_refined_structure().lattice.angles:
self.assertEqual(a, 90)
refined = self.disordered_sg.get_refined_structure()
for a in refined.lattice.angles:
self.assertEqual(a, 90)
self.assertEqual(refined.lattice.a, refined.lattice.b)
parser = CifParser(os.path.join(test_dir, 'Li2O.cif'))
s = parser.get_structures()[0]
sg = SymmetryFinder(s, 0.001)
self.assertEqual(sg.get_refined_structure().num_sites, 4 * s.num_sites)
def test_get_symmetrized_structure(self):
symm_struct = self.sg.get_symmetrized_structure()
for a in symm_struct.lattice.angles:
self.assertEqual(a, 90)
self.assertEqual(len(symm_struct.equivalent_sites), 5)
symm_struct = self.disordered_sg.get_symmetrized_structure()
self.assertEqual(len(symm_struct.equivalent_sites), 8)
self.assertEqual(map(len, symm_struct.equivalent_sites), [16,4,8,4,2,8,8,8])
s1 = symm_struct.equivalent_sites[1][1]
s2 = symm_struct[symm_struct.equivalent_indices[1][1]]
self.assertEqual(s1, s2)
self.assertEqual(self.sg4.get_symmetrized_structure()[0].magmom, 0.1)
def test_find_primitive(self):
"""
F m -3 m Li2O testing of converting to primitive cell
"""
parser = CifParser(os.path.join(test_dir, 'Li2O.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure)
primitive_structure = s.find_primitive()
self.assertEqual(primitive_structure.formula, "Li2 O1")
# This isn't what is expected. All the angles should be 60
self.assertAlmostEqual(primitive_structure.lattice.alpha, 60)
self.assertAlmostEqual(primitive_structure.lattice.beta, 60)
self.assertAlmostEqual(primitive_structure.lattice.gamma, 60)
self.assertAlmostEqual(primitive_structure.lattice.volume,
structure.lattice.volume / 4.0)
def test_get_ir_reciprocal_mesh(self):
grid=self.sg.get_ir_reciprocal_mesh()
self.assertEquals(len(grid), 216)
self.assertAlmostEquals(grid[1][0][0], 0.1)
self.assertAlmostEquals(grid[1][0][1], 0.0)
self.assertAlmostEquals(grid[1][0][2], 0.0)
self.assertEquals(grid[1][1], 2)
def test_get_conventional_standard_structure(self):
parser = CifParser(os.path.join(test_dir, 'bcc_1927.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 9.1980270633769461)
self.assertAlmostEqual(conv.lattice.b, 9.1980270633769461)
self.assertAlmostEqual(conv.lattice.c, 9.1980270633769461)
parser = CifParser(os.path.join(test_dir, 'btet_1915.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 5.0615106678044235)
self.assertAlmostEqual(conv.lattice.b, 5.0615106678044235)
self.assertAlmostEqual(conv.lattice.c, 4.2327080177761687)
parser = CifParser(os.path.join(test_dir, 'orci_1010.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 2.9542233922299999)
self.assertAlmostEqual(conv.lattice.b, 4.6330325651443296)
self.assertAlmostEqual(conv.lattice.c, 5.373703587040775)
parser = CifParser(os.path.join(test_dir, 'orcc_1003.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 4.1430033493799998)
self.assertAlmostEqual(conv.lattice.b, 31.437979757624728)
self.assertAlmostEqual(conv.lattice.c, 3.99648651)
parser = CifParser(os.path.join(test_dir, 'monoc_1028.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 117.53832420192903)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 14.033435583000625)
self.assertAlmostEqual(conv.lattice.b, 3.96052850731)
self.assertAlmostEqual(conv.lattice.c, 6.8743926325200002)
parser = CifParser(os.path.join(test_dir, 'rhomb_1170.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 120)
self.assertAlmostEqual(conv.lattice.a, 3.699919902005897)
self.assertAlmostEqual(conv.lattice.b, 3.699919902005897)
self.assertAlmostEqual(conv.lattice.c, 6.9779585500000003)
def test_get_primitive_standard_structure(self):
parser = CifParser(os.path.join(test_dir, 'bcc_1927.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 109.47122063400001)
self.assertAlmostEqual(prim.lattice.beta, 109.47122063400001)
self.assertAlmostEqual(prim.lattice.gamma, 109.47122063400001)
self.assertAlmostEqual(prim.lattice.a, 7.9657251015812145)
self.assertAlmostEqual(prim.lattice.b, 7.9657251015812145)
self.assertAlmostEqual(prim.lattice.c, 7.9657251015812145)
parser = CifParser(os.path.join(test_dir, 'btet_1915.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 105.015053349)
self.assertAlmostEqual(prim.lattice.beta, 105.015053349)
self.assertAlmostEqual(prim.lattice.gamma, 118.80658411899999)
self.assertAlmostEqual(prim.lattice.a, 4.1579321075608791)
self.assertAlmostEqual(prim.lattice.b, 4.1579321075608791)
self.assertAlmostEqual(prim.lattice.c, 4.1579321075608791)
parser = CifParser(os.path.join(test_dir, 'orci_1010.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 134.78923546600001)
self.assertAlmostEqual(prim.lattice.beta, 105.856239333)
self.assertAlmostEqual(prim.lattice.gamma, 91.276341676000001)
self.assertAlmostEqual(prim.lattice.a, 3.8428217771014852)
self.assertAlmostEqual(prim.lattice.b, 3.8428217771014852)
self.assertAlmostEqual(prim.lattice.c, 3.8428217771014852)
parser = CifParser(os.path.join(test_dir, 'orcc_1003.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 90)
self.assertAlmostEqual(prim.lattice.beta, 90)
self.assertAlmostEqual(prim.lattice.gamma, 164.985257335)
self.assertAlmostEqual(prim.lattice.a, 15.854897098324196)
self.assertAlmostEqual(prim.lattice.b, 15.854897098324196)
self.assertAlmostEqual(prim.lattice.c, 3.99648651)
parser = CifParser(os.path.join(test_dir, 'monoc_1028.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 63.579155761999999)
self.assertAlmostEqual(prim.lattice.beta, 116.42084423747779)
self.assertAlmostEqual(prim.lattice.gamma, 148.47965136208569)
self.assertAlmostEqual(prim.lattice.a, 7.2908007159612325)
self.assertAlmostEqual(prim.lattice.b, 7.2908007159612325)
self.assertAlmostEqual(prim.lattice.c, 6.8743926325200002)
parser = CifParser(os.path.join(test_dir, 'rhomb_1170.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 90)
self.assertAlmostEqual(prim.lattice.beta, 90)
self.assertAlmostEqual(prim.lattice.gamma, 120)
self.assertAlmostEqual(prim.lattice.a, 3.699919902005897)
self.assertAlmostEqual(prim.lattice.b, 3.699919902005897)
self.assertAlmostEqual(prim.lattice.c, 6.9779585500000003)
class SymmetryFinderTest(unittest.TestCase):
def setUp(self):
p = Poscar.from_file(os.path.join(test_dir, 'POSCAR'))
self.structure = p.structure
self.sg = SymmetryFinder(self.structure, 0.001)
parser = CifParser(os.path.join(test_dir, 'Li10GeP2S12.cif'))
self.disordered_structure = parser.get_structures()[0]
self.disordered_sg = SymmetryFinder(self.disordered_structure, 0.001)
s = p.structure.copy()
site = s[0]
del s[0]
s.append(site.species_and_occu, site.frac_coords)
self.sg3 = SymmetryFinder(s, 0.001)
parser = CifParser(os.path.join(test_dir, 'Graphite.cif'))
graphite = parser.get_structures()[0]
graphite.add_site_property("magmom", [0.1] * len(graphite))
self.sg4 = SymmetryFinder(graphite, 0.001)
def test_get_space_symbol(self):
self.assertEqual(self.sg.get_spacegroup_symbol(), "Pnma")
self.assertEqual(self.disordered_sg.get_spacegroup_symbol(),
"P4_2/nmc")
self.assertEqual(self.sg3.get_spacegroup_symbol(), "Pnma")
self.assertEqual(self.sg4.get_spacegroup_symbol(), "R-3m")
def test_get_space_number(self):
self.assertEqual(self.sg.get_spacegroup_number(), 62)
self.assertEqual(self.disordered_sg.get_spacegroup_number(), 137)
self.assertEqual(self.sg4.get_spacegroup_number(), 166)
def test_get_hall(self):
self.assertEqual(self.sg.get_hall(), '-P 2ac 2n')
self.assertEqual(self.disordered_sg.get_hall(), 'P 4n 2n -1n')
def test_get_pointgroup(self):
self.assertEqual(self.sg.get_point_group(), 'mmm')
self.assertEqual(self.disordered_sg.get_point_group(), '4/mmm')
def test_get_symmetry_dataset(self):
ds = self.sg.get_symmetry_dataset()
self.assertEqual(ds['international'], 'Pnma')
def test_get_crystal_system(self):
crystal_system = self.sg.get_crystal_system()
self.assertEqual('orthorhombic', crystal_system)
self.assertEqual('tetragonal', self.disordered_sg.get_crystal_system())
def test_get_symmetry_operations(self):
fracsymmops = self.sg.get_symmetry_operations()
symmops = self.sg.get_symmetry_operations(True)
self.assertEqual(len(symmops), 8)
latt = self.structure.lattice
for fop, op in zip(fracsymmops, symmops):
for site in self.structure:
newfrac = fop.operate(site.frac_coords)
newcart = op.operate(site.coords)
self.assertTrue(
np.allclose(latt.get_fractional_coords(newcart), newfrac))
found = False
newsite = PeriodicSite(site.species_and_occu,
newcart,
latt,
coords_are_cartesian=True)
for testsite in self.structure:
if newsite.is_periodic_image(testsite, 1e-3):
found = True
break
self.assertTrue(found)
def test_get_refined_structure(self):
for a in self.sg.get_refined_structure().lattice.angles:
self.assertEqual(a, 90)
refined = self.disordered_sg.get_refined_structure()
for a in refined.lattice.angles:
self.assertEqual(a, 90)
self.assertEqual(refined.lattice.a, refined.lattice.b)
parser = CifParser(os.path.join(test_dir, 'Li2O.cif'))
s = parser.get_structures()[0]
sg = SymmetryFinder(s, 0.001)
self.assertEqual(sg.get_refined_structure().num_sites, 4 * s.num_sites)
def test_get_symmetrized_structure(self):
symm_struct = self.sg.get_symmetrized_structure()
for a in symm_struct.lattice.angles:
self.assertEqual(a, 90)
self.assertEqual(len(symm_struct.equivalent_sites), 5)
symm_struct = self.disordered_sg.get_symmetrized_structure()
self.assertEqual(len(symm_struct.equivalent_sites), 8)
self.assertEqual(map(len, symm_struct.equivalent_sites),
[16, 4, 8, 4, 2, 8, 8, 8])
s1 = symm_struct.equivalent_sites[1][1]
s2 = symm_struct[symm_struct.equivalent_indices[1][1]]
self.assertEqual(s1, s2)
self.assertEqual(self.sg4.get_symmetrized_structure()[0].magmom, 0.1)
def test_find_primitive(self):
"""
F m -3 m Li2O testing of converting to primitive cell
"""
parser = CifParser(os.path.join(test_dir, 'Li2O.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure)
primitive_structure = s.find_primitive()
self.assertEqual(primitive_structure.formula, "Li2 O1")
# This isn't what is expected. All the angles should be 60
self.assertAlmostEqual(primitive_structure.lattice.alpha, 60)
self.assertAlmostEqual(primitive_structure.lattice.beta, 60)
self.assertAlmostEqual(primitive_structure.lattice.gamma, 60)
self.assertAlmostEqual(primitive_structure.lattice.volume,
structure.lattice.volume / 4.0)
def test_get_ir_reciprocal_mesh(self):
grid = self.sg.get_ir_reciprocal_mesh()
self.assertEquals(len(grid), 216)
self.assertAlmostEquals(grid[1][0][0], 0.1)
self.assertAlmostEquals(grid[1][0][1], 0.0)
self.assertAlmostEquals(grid[1][0][2], 0.0)
self.assertEquals(grid[1][1], 2)
def test_get_conventional_standard_structure(self):
parser = CifParser(os.path.join(test_dir, 'bcc_1927.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 9.1980270633769461)
self.assertAlmostEqual(conv.lattice.b, 9.1980270633769461)
self.assertAlmostEqual(conv.lattice.c, 9.1980270633769461)
parser = CifParser(os.path.join(test_dir, 'btet_1915.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 5.0615106678044235)
self.assertAlmostEqual(conv.lattice.b, 5.0615106678044235)
self.assertAlmostEqual(conv.lattice.c, 4.2327080177761687)
parser = CifParser(os.path.join(test_dir, 'orci_1010.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 2.9542233922299999)
self.assertAlmostEqual(conv.lattice.b, 4.6330325651443296)
self.assertAlmostEqual(conv.lattice.c, 5.373703587040775)
parser = CifParser(os.path.join(test_dir, 'orcc_1003.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 4.1430033493799998)
self.assertAlmostEqual(conv.lattice.b, 31.437979757624728)
self.assertAlmostEqual(conv.lattice.c, 3.99648651)
parser = CifParser(os.path.join(test_dir, 'monoc_1028.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 117.53832420192903)
self.assertAlmostEqual(conv.lattice.gamma, 90)
self.assertAlmostEqual(conv.lattice.a, 14.033435583000625)
self.assertAlmostEqual(conv.lattice.b, 3.96052850731)
self.assertAlmostEqual(conv.lattice.c, 6.8743926325200002)
parser = CifParser(os.path.join(test_dir, 'rhomb_1170.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
conv = s.get_conventional_standard_structure()
self.assertAlmostEqual(conv.lattice.alpha, 90)
self.assertAlmostEqual(conv.lattice.beta, 90)
self.assertAlmostEqual(conv.lattice.gamma, 120)
self.assertAlmostEqual(conv.lattice.a, 3.699919902005897)
self.assertAlmostEqual(conv.lattice.b, 3.699919902005897)
self.assertAlmostEqual(conv.lattice.c, 6.9779585500000003)
def test_get_primitive_standard_structure(self):
parser = CifParser(os.path.join(test_dir, 'bcc_1927.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 109.47122063400001)
self.assertAlmostEqual(prim.lattice.beta, 109.47122063400001)
self.assertAlmostEqual(prim.lattice.gamma, 109.47122063400001)
self.assertAlmostEqual(prim.lattice.a, 7.9657251015812145)
self.assertAlmostEqual(prim.lattice.b, 7.9657251015812145)
self.assertAlmostEqual(prim.lattice.c, 7.9657251015812145)
parser = CifParser(os.path.join(test_dir, 'btet_1915.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 105.015053349)
self.assertAlmostEqual(prim.lattice.beta, 105.015053349)
self.assertAlmostEqual(prim.lattice.gamma, 118.80658411899999)
self.assertAlmostEqual(prim.lattice.a, 4.1579321075608791)
self.assertAlmostEqual(prim.lattice.b, 4.1579321075608791)
self.assertAlmostEqual(prim.lattice.c, 4.1579321075608791)
parser = CifParser(os.path.join(test_dir, 'orci_1010.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 134.78923546600001)
self.assertAlmostEqual(prim.lattice.beta, 105.856239333)
self.assertAlmostEqual(prim.lattice.gamma, 91.276341676000001)
self.assertAlmostEqual(prim.lattice.a, 3.8428217771014852)
self.assertAlmostEqual(prim.lattice.b, 3.8428217771014852)
self.assertAlmostEqual(prim.lattice.c, 3.8428217771014852)
parser = CifParser(os.path.join(test_dir, 'orcc_1003.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 90)
self.assertAlmostEqual(prim.lattice.beta, 90)
self.assertAlmostEqual(prim.lattice.gamma, 164.985257335)
self.assertAlmostEqual(prim.lattice.a, 15.854897098324196)
self.assertAlmostEqual(prim.lattice.b, 15.854897098324196)
self.assertAlmostEqual(prim.lattice.c, 3.99648651)
parser = CifParser(os.path.join(test_dir, 'monoc_1028.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 63.579155761999999)
self.assertAlmostEqual(prim.lattice.beta, 116.42084423747779)
self.assertAlmostEqual(prim.lattice.gamma, 148.47965136208569)
self.assertAlmostEqual(prim.lattice.a, 7.2908007159612325)
self.assertAlmostEqual(prim.lattice.b, 7.2908007159612325)
self.assertAlmostEqual(prim.lattice.c, 6.8743926325200002)
parser = CifParser(os.path.join(test_dir, 'rhomb_1170.cif'))
structure = parser.get_structures(False)[0]
s = SymmetryFinder(structure, symprec=1e-2)
prim = s.get_primitive_standard_structure()
self.assertAlmostEqual(prim.lattice.alpha, 90)
self.assertAlmostEqual(prim.lattice.beta, 90)
self.assertAlmostEqual(prim.lattice.gamma, 120)
self.assertAlmostEqual(prim.lattice.a, 3.699919902005897)
self.assertAlmostEqual(prim.lattice.b, 3.699919902005897)
self.assertAlmostEqual(prim.lattice.c, 6.9779585500000003)
def inter_descript_gen(cif_file, collection, prune_args):
"""
Generates the interstitial descriptor values for the structures
in input cif directory and store them into the database supplied
Args:
cif_file:
cif File
collection:
Mongo database collection
prune_ars:
List of keywords to prune the interstitials
a) anion:
Only the interstitial sites that can be occupied by the
anion are kept
a) cation:
Only the interstitial sites that can be occupied by the
smallest cation are kept
c) [El, oxi_state]:
Only the interstitial sites that can be occupied by the
input ion are kept
Ex: ['Li', 1]
"""
# Use the number as struct identifier
# Store the remaining string as formula
print cif_file
dir, filen = os.path.split(cif_file)
print filen
name = os.path.splitext(filen)[0]
item = name.split('--')
key = item[0]
inter_descript_dict = {'key': key, 'formula': ''.join(item[1].split())}
FAIL = 0
SUCC = 1
#read the file to pymatgen struct
try:
struct = CifParser(cif_file).get_structures(False)[0]
except:
print 'reading ', cif_file, ' failed'
return FAIL
symm_finder = SymmetryFinder(struct)
inter_descript_dict['structure'] = struct
inter_descript_dict['crystal_system'] = symm_finder.get_crystal_system()
inter_descript_dict['spacegroup_no'] = symm_finder.get_spacegroup_number()
no_symmops = len(symm_finder.get_symmetry_operations())
inter_descript_dict['no_symmops'] = no_symmops
try:
struct_val_rad = StructWithValenceIonicRadius(struct)
valences = struct_val_rad.valences.values()
valences.sort()
anion_cation_charge_ratio = abs(valences[-1] / valences[0])
radii = struct_val_rad.radii.values()
radii.sort()
anion_cation_radii_ratio = radii[-1] / radii[0]
except:
print inter_descript_dict['formula']
print "Unable to identify radii and valences"
return FAIL
inter_descript_dict['charge_ratio'] = anion_cation_charge_ratio
inter_descript_dict['radius_ratio'] = anion_cation_radii_ratio
try:
inter = Interstitial(struct_val_rad)
except:
print inter_descript_dict['formula']
print 'interstitial not generated'
return FAIL
if prune_args[0] == "cation":
inter.radius_prune_defectsites(
radii[0]) #smallest element in the structure
elif prune_args[0] == "anion":
inter.radius_prune_defectsites(
radii[-1]) #largest element in the structure
else:
el = prune_args[0]
oxi_state = prune_args[1]
inter.prune_defectsites(el, oxi_state)
inter.prune_close_defectsites()
if inter.defectsite_count() > 10:
inter.reduce_defectsites()
no_inter = inter.defectsite_count()
inter_descript_dict['no_inter'] = no_inter
#print >>sys.stderr, inter_descript_dict[key]['formula'], "No. of inter", no_inter
#Create a list storing a dictionary of properties for each interstitial
inter_list = []
for i in range(no_inter):
inter_dict = {}
inter_dict['coord_no'] = inter.get_defectsite_coordination_number(i)
inter_dict['coord_el'] = list(inter.get_coordinated_elements(i))
inter_dict['radius'] = inter.get_radius(i)
inter_dict['coord_chrg_sum'] = inter.get_coordsites_charge_sum(i)
inter_list.append(inter_dict)
inter_descript_dict['interstitials'] = inter_list
descriptor_id = collection.insert(inter_descript_dict)
return descriptor_id
def inter_descript_gen(cif_file, prune_args):
# Use the number as struct identifier
# Store the remaining string as formula
print cif_file
dir, filen = os.path.split(cif_file)
print filen
name = os.path.splitext(filen)[0]
item = name.split('--')
key = item[0]
inter_descript_dict = {'formula': ''.join(item[1].split())}
#read the file to pymatgen struct
try:
struct = CifParser(cif_file).get_structures(False)[0]
except:
print 'reading ', cif_file, ' failed'
return None, filen
symm_finder = SymmetryFinder(struct, symprec=1e-1)
inter_descript_dict['crystal_system'] = symm_finder.get_crystal_system()
inter_descript_dict['spacegroup_no'] = symm_finder.get_spacegroup_number()
no_symmops = len(symm_finder.get_symmetry_operations())
inter_descript_dict['no_symmops'] = no_symmops
try:
struct_val_rad = StructWithValenceIonicRadius(struct)
except:
print inter_descript_dict['formula']
print "Unable to identify radii and valences"
return None, filen
try:
inter = Interstitial(struct_val_rad)
except:
print inter_descript_dict['formula']
print 'interstitial not generated'
return None, filen
valences = inter.struct_valences.values()
valences.sort()
try:
anion_cation_charge_ratio = abs(valences[-1] / valences[0])
except: #BVAnalyzer fails sometimes and valences are set to 0
print inter_descript_dict['formula']
print valences
anion_cation_charge_ratio = 0
inter_descript_dict['charge_ratio'] = anion_cation_charge_ratio
radii = inter.struct_radii.values()
radii.sort()
try:
anion_cation_radii_ratio = radii[-1] / radii[0]
except:
anion_cation_radii_ratio = 0
inter_descript_dict['radius_ratio'] = anion_cation_radii_ratio
if prune_args[0] == "cation":
inter.radius_prune_defectsites(
radii[0]) #smallest element in the structure
elif prune_args[0] == "anion":
inter.radius_prune_defectsites(
radii[-1]) #largest element in the structure
else:
el = prune_args[0]
oxi_state = prune_args[1]
print el, oxi_state
inter.prune_defectsites(el, oxi_state)
inter.prune_close_defectsites()
if inter.defectsite_count() > 10:
# Something wrong with the symmetry reduction of defects.
# Ignoring the outlier
return None, filen
inter.reduce_defectsites()
no_inter = inter.defectsite_count()
if no_inter > 5:
print "Tag:", key, inter_descript_dict['formula'], no_inter
inter_descript_dict['no_inter'] = no_inter
#print >>sys.stderr, inter_descript_dict[key]['formula'], "No. of inter", no_inter
#ife = InterstitialFormationEnergy(inter)
#Create a list storing a dictionary of properties for each interstitial
inter_list = []
for i in range(no_inter):
inter_dict = {}
inter_dict['coords'] = inter.get_defectsite(i).coords
inter_dict['coord_no'] = inter.get_defectsite_coordination_number(i)
inter_dict['coord_el'] = list(inter.get_coordinated_elements(i))
inter_dict['radius'] = inter.get_radius(i)
inter_dict['coord_chrg_sum'] = inter.get_coordsites_charge_sum(i)
inter_list.append(inter_dict)
inter_descript_dict['interstitials'] = inter_list
return key, inter_descript_dict
