def running(temp, pre, crt):
# -- Run AIMD at (run00, run01, ...)
# -- First step is heat-up.
total_try = 1
#pre_dir = ("run%2d" % pre).replace(" ", "0")
#crt_dir = ("run%2d" % crt).replace(" ", "0")
pre_dir = ("run%03d" % pre)
crt_dir = ("run%03d" % crt)
# -- initiating
if crt == 0:
structure = IStructure.from_file("../" + structure_filename)
crt_nsw = heating_nsw
user_incar["SMASS"] = -1
inputset = MITMDSet(structure,
100.0,
float(temp),
heating_nsw,
user_incar_settings=user_incar)
inputset.write_input(crt_dir)
# -- run
else:
run = Vasprun("%s/vasprun.xml.gz" % pre_dir,
parse_dos=False,
parse_eigen=False)
structure = run.final_structure
crt_nsw = nsw
#structure = IStructure.from_file("%s/CONTCAR" % pre_dir)
user_incar["SMASS"] = 0
inputset = MITMDSet(structure,
float(temp),
float(temp),
nsw,
user_incar_settings=user_incar)
inputset.write_input(crt_dir)
os.system("cp %s/WAVECAR %s" % (pre_dir, crt_dir))
os.chdir(crt_dir)
os.system("mpirun -np $NSLOTS %s < /dev/null > vasp.out" % vasp)
time.sleep(5)
os.system("gzip OUTCAR vasprun.xml")
os.system("rm -rf DOSCAR XDATCAR")
write_log("try: %d" % total_try)
properly_terminated = terminated_check(crt_nsw)
while not properly_terminated:
total_try += 1
os.system("mpirun -np $NSLOTS %s < /dev/null > vasp.out" % vasp)
time.sleep(5)
os.system("gzip OUTCAR vasprun.xml")
os.system("rm -rf DOSCAR XDATCAR")
write_log("try: %d" % total_try)
properly_terminated = terminated_check(crt_nsw)
os.system("touch vasp.done")
os.chdir("../")
os.system("rm -rf %s/WAVECAR" %
pre_dir) # remove WAVECAR in previous dir to reduce storage
def __init__(self, filename, grid_size=1):
structure = IStructure.from_file(filename)
self.grid_size = grid_size
self.sites = structure.sites
self.all_species = [site.specie.number for site in self.sites]
self.all_coords = [site.coords for site in self.sites]
lattice = structure.lattice
a, b, c = lattice.a, lattice.b, lattice.c
self.grid_a = self.get_grid_length(a, self.grid_size)
self.grid_b = self.get_grid_length(b, self.grid_size)
self.grid_c = self.get_grid_length(c, self.grid_size)
# total_atom_info = get_cgcnn_atom_info()
total_atom_info = atomic_info()
empty_info = np.full(total_atom_info[0].shape, -1)
empty_info = np.array([empty_info])
self.total_atom_info = np.concatenate((empty_info, total_atom_info),
axis=0)
def get_data(normalize_y, sample_size):
radius = 3
max_neighbor_num = 10
training = 0.9
test = 0.1
df = pd.read_csv("./Data/metal-alloy-db.v2/00Total_DB.csv")
# df = df.sample(n=len(df))
df = df.sample(n=sample_size)
cifs = "./Data/metal-alloy-db.v2/" + df['DBname'] + ".cif"
structures = [IStructure.from_file(cif) for cif in cifs]
encoded_structures = [
structure_encoder(structure, radius, max_neighbor_num)
for structure in structures
]
x_data = np.array(encoded_structures)
formation_energy = df['FormationEnergy']
if normalize_y:
mean = formation_energy.mean()
std = formation_energy.std()
norm_form_energy = (df['FormationEnergy'] - mean) / std
def norm_back(val, mean, std):
return val * std + mean
y_data = [[val] for val in norm_form_energy]
else:
y_data = [[val] for val in formation_energy]
y_data = np.array(y_data)
total = len(df)
train = int(float(total) * training)
test = int(float(total) * test)
x_train = x_data[:train]
y_train = y_data[:train]
x_test = x_data[train:train + test]
y_test = y_data[train:train + test]
return x_train, y_train, x_test, y_test
return batch_x, batch_y
if __name__ == "__main__":
radius = 3
max_neighbor_num = 10
training = 0.9
test = 0.1
df = pd.read_csv("./Data/metal-alloy-db.v1/00Total_DB.csv")
# df = df.sample(n=len(df))
df = df.sample(n=500)
cifs = "./Data/metal-alloy-db.v1/" + df['DBname'] + ".cif"
structures = [IStructure.from_file(cif) for cif in cifs]
encoded_structures = [structure_encoder(structure, radius, max_neighbor_num) for structure in structures]
x_data = np.array(encoded_structures)
x_data = np.expand_dims(x_data, axis=4)
formation_energy = df['FormationEnergy']
y_normalization = False
if y_normalization:
mean = formation_energy.mean()
std = formation_energy.std()
norm_form_energy = (df['FormationEnergy'] - mean) / std
def norm_back(val, mean, std):
return val * std + mean
y_data = [[val] for val in norm_form_energy]
def check_converged(crt_step, RSD, ASD):
converged = False
if crt_step >= min_step:
if RSD <= min_RSD:
if ASD <= min_ASD:
converged = True
if crt_step >= 300:
converged = True
return converged
if __name__ == "__main__":
structure = IStructure.from_file(structure_filename)
# -- Find neighboring specie distance
sites = structure.sites
specie_sites = [s for s in sites if str(s.specie) == specie]
distance = []
for specie_site in specie_sites:
nbrs = structure.get_neighbors(specie_site, 5)
nbrs = [nbr for nbr in nbrs if str(nbr[0].specie) == specie]
for nbr in nbrs:
distance.append(nbr[1])
distance = np.array(distance)
avg_specie_distance = distance.mean()
working_dir = "%dK" % temp
mkdir(working_dir)
os.chdir(working_dir)
Created on September 10, 2013
@author: Qimin
'''
import sys
import pymatgen
from math import *
from pymatgen.symmetry.finder import SpacegroupAnalyzer
from pymatgen.core.structure import IStructure
file = str(sys.argv[1])
spacegroup = str(sys.argv[2])
max = float(sys.argv[3])
min = float(sys.argv[4])
iter = float(sys.argv[5])
s = IStructure.from_file(file)
def getLowSymPrec(s,max,min,spacegroup,iter):
SG = str(spacegroup)
if SG!=str(SpacegroupAnalyzer(s,symprec=max).get_spacegroup_number()):
print "Not reasonable spacegroup or max too large"
return -1
elif SG==str(SpacegroupAnalyzer(s,symprec=min).get_spacegroup_number()):
return min
else:
upperbound = max
lowerbound = min
i=0
while i<iter:
trial = 10**((log(upperbound,10)+log(lowerbound,10))/2)
if SG==str(SpacegroupAnalyzer(s,symprec=trial).get_spacegroup_number()):
def find_unique_structures(base_crystal_path, directory):
"""
DESCRIPTION: Given a base crystal structure along with a directory containing CIF structures, determine how many unique configurations are in the directory,
and assign a configuration ID number to each CIF structure in the directory. Results can be seen in the outputted unique.csv file. The function
uses the base crystal structure provided to find the space group and associated symmetry operations, which are then used to see whether the CIF
structures in the directory are equivalent.
PARAMETERS:
base_crystal_path: string
The path to the base crystal CIF structure. Note that this structure should contain the space group that you want to check all other structures to.
If the symmetry of this structure is incorrect, you will get unexpected results.
directory: string
The path to the directory containing the CIF structures to compare. Note that this function assumes that the CIF names are all prefixed by a dash
and followed by an interger, ie "LiCoO2-1", "LiCoO2-2", "LiCoO2-3"..., ect.
RETURNS: None
"""
# convert all files (they should all be cif files) in the directory into Structures and place them into a list
cif_file_names = [
os.path.splitext(os.path.basename(path))[0]
for path in os.listdir(directory) if path.endswith('.cif')
]
cif_files = [
directory + path for path in os.listdir(directory)
if path.endswith('.cif')
]
cif_files = sorted(cif_files,
key=lambda x: int(x.split("-")[-1].replace(".cif", "")))
cif_file_names = sorted(cif_file_names,
key=lambda x: int(x.split("-")[-1]))
structures = [IStructure.from_file(path) for path in cif_files]
print(cif_file_names)
# Get the base crystal structure
base_crystal = IStructure.from_file(base_crystal_path)
# Get the space group of the base crystal
analyzer = SpacegroupAnalyzer(base_crystal)
spacegroup = analyzer.get_space_group_operations()
print(spacegroup)
id = 1
num_structures = len(structures)
config_dict = {}
unique_structs = []
for i in range(num_structures):
config1 = structures[i]
unique_cif_name = cif_file_names[i]
if not unique_cif_name in config_dict:
config_dict[unique_cif_name] = id
print("%s Unique Structures Found..." % (id))
unique_structs.append(config1)
id += 1
for j in range(num_structures):
cif_name = cif_file_names[j]
config2 = structures[j]
if not cif_name in config_dict:
isEquivalent = spacegroup.are_symmetrically_equivalent(
config1, config2)
if isEquivalent:
config_dict[cif_name] = config_dict[unique_cif_name]
print("----------------------------------------------")
print("%s Total Unique Structures Found" % (id - 1))
print("----------------------------------------------")
with open('unique.csv', 'w') as f:
for key in config_dict.keys():
f.write("%s,%s\n" % (key, config_dict[key]))
crystal_name = os.path.splitext(os.path.basename(base_crystal_path))[0]
directory_path = "{}-unique".format(crystal_name)
if not os.path.isdir(directory_path):
os.mkdir(directory_path)
num_unique_structures = len(unique_structs)
for i in range(num_unique_structures):
config = unique_structs[i]
#Save to CIF
filename = crystal_name + '_ewald' + '_{}'.format(i + 1)
w = CifWriter(config)
w.write_file(directory_path + '/' + filename + '.cif')
# print("Cif file saved to {}.cif".format(filename))
#Save to POSCAR
poscar = Poscar(config)
poscar.write_file(directory_path + '/' + filename)
#ComputedEntry(composition: pymatgen.core.composition.Composition, energy: float, correction: float = 0.0, energy_adjustments: list = None, parameters: dict = None, data: dict = None, entry_id: object = None)
#IStructure.from_file('LiB-42129-4374-9-out.cif')
#ComputedStructureEntry(structure=IStructure.from_file('LiB-42129-4374-9-out.cif'),energy=1,entry_id='from castep for airss')
import os
current_dir = os.getcwd()
entries=[]
for filename in os.listdir(current_dir):
if filename.endswith(".res"):
print('loading ', filename)
#read enthalpy, did not correct enthalpy for pressure
f = open(filename, "r")
enthalpy=f.readline().split()[4]
f.close()
#load structure and composition, cabal in airss is needed
os.system("cabal res poscar < "+filename+" > POSCAR")
entries.append(ComputedStructureEntry(structure=IStructure.from_file('POSCAR'), energy=float(enthalpy)))
os.system("rm POSCAR")
#pd=PhaseDiagram(entries)
#pd.show()
#li_entries = [e for e in entries if e.composition.reduced_formula == "Li"]
#uli0 = min(li_entries, key=lambda e: e.energy_per_atom).energy_per_atom
#gpd=GrandPotentialPhaseDiagram(entries,chempots=)
from pymatgen.core.structure import IStructure
from pymatgen.electronic_structure.bandstructure import BandStructure, BandStructureSymmLine, Kpoint
vasp = Vasprun(
'vasprun.xml'
) #,ionic_step_skip=1,ionic_step_offset=1,parse_dos=True,parse_eigen=True,occu_tol=1e-8)
efermi = vasp.efermi
eigenvals = vasp.eigenvalues
bs = vasp.get_band_structure(kpoints_filename='KPOINTS',
efermi=efermi,
line_mode=True)
#kpoints_modes = Kpoints_support_modes(3) #Line mode
kpoints = Kpoints.from_file('KPOINTS')
poscar = Poscar.from_file('POSCAR')
incar = Incar.from_file(('INCAR'))
struc = IStructure.from_file('POSCAR')
lattice = struc.lattice
labels = kpoints.labels
space_group = struc.get_space_group_info()
#coords = struc.frac_coords()
BS = BandStructure(kpoints.kpts, eigenvals, lattice, efermi,
structure=struc) #kpoints.kpts
labels_dict = BS.labels_dict
BSSL = BandStructureSymmLine(kpoints.kpts,
eigenvals,
lattice,
efermi,
labels_dict,
structure=struc)
b = vasp.eigenvalue_band_properties
vbm = BS.get_vbm()
all_sites_atom_info = [atom_info[num - 1] for num in all_sites_atom_num]
all_sites_atom_info = np.array(all_sites_atom_info)
all_sites_atom_info = np.expand_dims(all_sites_atom_info, axis=1)
all_sites_atom_info = np.tile(all_sites_atom_info,
[1, max_neighbor_num, 1])
neighbor_atom_info = []
for each_neighbor in neighbor_atom_num:
neighbor_atom_info.append(
[atom_info[num - 1] for num in each_neighbor])
neighbor_atom_info = np.array(neighbor_atom_info)
features = (all_sites_atom_info, neighbor_atom_info,
onehot_neighbor_distance)
encoded_structure = np.concatenate(features, axis=2)
# shape= (num_sites) (num_sites, max_neighbor_num) (num_sites, max_neighbor_num, onehot_length)
# ex. (8, 10, 47) (8, 10, 47) (8, 10, 10)
#return (all_sites_atom_info, neighbor_index, onehot_neighbor_distance)
return encoded_structure
if __name__ == "__main__":
radius = 3
max_neighbor_num = 10
cifs = ["./Data/" + f for f in os.listdir("./Data") if ".cif" in f]
structures = [IStructure.from_file(cif) for cif in cifs]
structure = IStructure.from_file("./Data/from_cgcnn/9009743.cif")
encoded_structure = structure_encoder(structure, radius, max_neighbor_num)
print(encoded_structure.shape)