def test2_anatase(self):
filename = path + '/TiO2_mp-390_conventional_standard.cif'
atoms = read(filename)
PC = PrototypeClassification(atoms)
prototype, parameters = PC.get_classification()
prototype_ref = {
'p_name': 'AB2_4_a_e_141',
'structure_name': '141_Ti_a_O_e',
'spacegroup': 141,
'wyckoffs': ['a', 'e'],
'species': ['Ti', 'O']
}
parameters_ref = {
'a': 3.80270954,
'b': 3.80270954,
'c': 9.74775206,
'alpha': 90,
'beta': 90,
'gamma': 90,
'ze1': 0.206163
}
for key, value in prototype_ref.items():
assert prototype[key] == value
for key, value in parameters_ref.items():
assert np.isclose(parameters[key], value, rtol=1e-5)
def test3_manganese_oxide(self):
filename = path + '/Mn3O4_mp-18759_conventional_standard.cif'
atoms = read(filename)
PC = PrototypeClassification(atoms)
prototype, parameters = PC.get_classification()
prototype_ref = {
'p_name': 'A3B4_4_bc_h_141',
'structure_name': '141_Mn_b_Mn_c_O_h',
'spacegroup': 141,
'wyckoffs': ['b', 'c', 'h'],
'species': ['Mn', 'Mn', 'O']
}
parameters_ref = {
'a': 5.87521306,
'b': 5.87521306,
'c': 9.58660398,
'alpha': 90.0,
'beta': 90.0,
'gamma': 90.0,
'yh2': 0.221099,
'zh2': 0.88255
}
for key, value in prototype_ref.items():
print(prototype[key], value)
assert prototype[key] == value
for key, value in parameters_ref.items():
assert np.isclose(parameters[key], value, rtol=1e-5)
def test6_primitive(self):
filename = path + '/Cr2O3_mp-19399_primitive.cif'
atoms = read(filename)
PC = PrototypeClassification(atoms)
prototype, parameters = PC.get_classification()
prototype_ref = {
'p_name': 'A2B3_6_c_e_167',
'structure_name': '167_Cr_c_O_e',
'spacegroup': 167,
'wyckoffs': ['c', 'e'],
'species': ['Cr', 'O']
}
parameters_ref = {
'a': 5.09424496,
'b': 5.09424496,
'c': 13.78071749,
'alpha': 90,
'beta': 90,
'gamma': 120,
'zc0': 0.150269 + 0.5,
'xe1': 0.300642
}
for key, value in prototype_ref.items():
assert prototype[key] == value
for key, value in parameters_ref.items():
assert np.isclose(parameters[key], value, rtol=1e-5)
def test4_nickel_oxide(self):
filename = path + '/NiO_mp-19009_conventional_standard.cif'
atoms = read(filename)
PC = PrototypeClassification(atoms)
prototype, parameters = PC.get_classification()
prototype_ref = {
'p_name': 'AB_4_a_b_225',
'structure_name': '225_Ni_a_O_b',
'spacegroup': 225,
'wyckoffs': ['a', 'b'],
'species': ['Ni', 'O']
}
parameters_ref = {
'a': 4.2042588,
'b': 4.2042588,
'c': 4.2042588,
'alpha': 90.0,
'beta': 90.0,
'gamma': 90.0
}
for key, value in prototype_ref.items():
assert prototype[key] == value
for key, value in parameters_ref.items():
assert np.isclose(parameters[key], value, rtol=1e-5)
def test5_ternary_alloy(self):
filename = path + '/Mn2CrCo_mp-864955_conventional_standard.cif'
atoms = read(filename)
PC = PrototypeClassification(atoms)
prototype, parameters = PC.get_classification()
prototype_ref = {
'p_name': 'ABC2_4_a_b_c_225',
'structure_name': '225_Cr_a_Co_b_Mn_c',
'spacegroup': 225,
'wyckoffs': ['a', 'b', 'c'],
'species': ['Cr', 'Co', 'Mn']
}
parameters_ref = {
'a': 5.74961404,
'b': 5.74961404,
'c': 5.74961404,
'alpha': 90.0,
'beta': 90.0,
'gamma': 90.0
}
for key, value in prototype_ref.items():
assert prototype[key] == value
for key, value in parameters_ref.items():
assert np.isclose(parameters[key], value, rtol=1e-5)
def __init__(
self,
atoms,
basepath,
calc_parameters=None,
):
self.atoms = atoms
PC = PrototypeClassification(self.atoms)
prototype, cell_parameters = PC.get_classification()
self.spacegroup = prototype['spacegroup']
self.wyckoffs = prototype['wyckoffs']
self.species = prototype['species']
self.cell_param_list = []
self.cell_value_list = []
for param in sorted(cell_parameters):
value = cell_parameters[param]
if value in self.cell_value_list or value in [90, 120]:
continue
self.cell_value_list += [cell_parameters[param]]
self.cell_param_list += [param]
self.basepath = basepath
self.calculator = 'vasp'
self.master_parameters = calc_parameters
def test6_all_spacegroups(self):
images = []
spacegroups = range(195, 230)
spacegroups, spacegroup_letters = get_wyckoff_letters(spacegroups)
for sg in spacegroups:
wyckoffs = spacegroup_letters[sg - 1][::-1][:5]
species = metals[:len(wyckoffs)]
print('----------', sg, '------------')
BB = BuildBulk(sg, wyckoffs, species)
atoms = BB.get_atoms(primitive_cell=False)
PC = PrototypeClassification(atoms)
prototype = PC.get_classification(include_parameters=False)
if not prototype['spacegroup'] == sg:
print(' change in spacegroup', sg, '----->',
prototype['spacegroup'])
print(' ', prototype['p_name'])
else:
assert prototype['wyckoffs'] == wyckoffs, \
'{} --->> {}'.format(prototype['wyckoffs'], wyckoffs)
def submit_atoms(self, atoms, ncpus=None, batch_no=None,
calc_parameters=None, **kwargs):
"""Submit a calculation for an atoms object"""
PC = PrototypeClassification(atoms)
prototype, cell_parameters = PC.get_classification()
if self.is_calculated(formula=atoms.get_chemical_formula(),
p_name=prototype['p_name']):
return
Sub = self.Submitter(atoms=atoms,
ncpus=ncpus,
calc_parameters=calc_parameters)
Sub.submit_calculation()
key_value_pairs = {'p_name': prototype['p_name'],
'path': Sub.excpath,
'spacegroup': prototype['spacegroup'],
'wyckoffs': json.dumps(prototype['wyckoffs']),
'species': json.dumps(prototype['species']),
'ncpus': Sub.ncpus}
key_value_pairs.update(kwargs)
if batch_no:
key_value_pairs.update({'batch': batch_no})
self.write_submission(key_value_pairs)
def save_failed_calculation(self, runpath, calcid):
key_value_pairs = {'completed': -1,
'runpath': runpath}
param_dict = params2dict(runpath + '/parameters.json')
atoms = ase.io.read(runpath + '/initial.POSCAR')
PC = PrototypeClassification(atoms)
prototype, cell_parameters = PC.get_classification()
key_value_pairs.update(prototype)
key_value_pairs.update(cell_parameters)
key_value_pairs.update(param_dict)
key_value_pairs = clean_key_value_pairs(
key_value_pairs)
data = {}
if os.path.isfile(runpath + '/err'):
with open(runpath + '/err', 'r') as errorf:
data.update({'error': errorf.read().replace("'", '')})
if os.path.isfile(runpath + '/err.relax'):
with open(runpath + '/err.relax', 'r') as errorf:
data.update({'error_relax': errorf.read().replace("'", '')})
self.ase_db.update(id=calcid,
**key_value_pairs,
data=data)
def save_completed_calculation(self, atoms, runpath, calcid,
read_params=True):
batch_no = self.ase_db.get(id=calcid).get('batch', None)
PC = PrototypeClassification(atoms)
prototype, cell_parameters = PC.get_classification()
key_value_pairs = self.ase_db.get(id=calcid).get('key_value_pairs', {})
key_value_pairs.update({'relaxed': 1,
'completed': 1,
'initial_id': calcid,
'runpath': runpath})
key_value_pairs.update(prototype)
key_value_pairs.update(cell_parameters)
if batch_no:
key_value_pairs.update({'batch': batch_no})
param_dict = {}
if read_params:
param_dict = params2dict(runpath + '/parameters.json')
key_value_pairs.update(param_dict)
atoms = set_calculator_info(atoms, param_dict)
key_value_pairs = clean_key_value_pairs(key_value_pairs)
newcalcid = self.ase_db.write(atoms, key_value_pairs)
self.ase_db.update(id=calcid,
final_id=newcalcid,
completed=1)
return newcalcid
def reclassify(self, tolerance=0.5e-3):
"""Reclassify prototypes of all completed structures"""
self._collect()
con = self.connection or self._connect()
self._initialize(con)
for row in self.ase_db.select(relaxed=1):
PC = PrototypeClassification(row.toatoms())
prototype, cell_parameters = PC.get_classification()
prototype.update(cell_parameters)
prototype = clean_key_value_pairs(prototype)
self.ase_db.update(row.id, **prototype)
def test7_weird_cell(self):
filename = path + '/IrO_167.cif'
atoms = read(filename)
PC = PrototypeClassification(atoms)
prototype_ref, parameters_ref = PC.get_classification()
filename = path + '/000__id-unique_8p8evt9pcg__id-short_207.cif'
atoms = read(filename)
PC = PrototypeClassification(atoms, tolerance=0.09)
prototype, parameters = PC.get_classification()
for key, value in prototype_ref.items():
assert prototype[key] == value
from ase.io import read
from sys import argv
from protosearch.build_bulk.classification import PrototypeClassification
# Script to print structure prototype and parameters
atoms = read(argv[1])
PC = PrototypeClassification(atoms)
prototype, parameters = PC.get_classification()
print('Prototype:', prototype, '\nParameters:', parameters)
