def test_get_xrd_data(self): a = 4.209 latt = Lattice.cubic(a) structure = Structure(latt, ["Cs", "Cl"], [[0, 0, 0], [0.5, 0.5, 0.5]]) c = XRDCalculator() data = c.get_xrd_data(structure, two_theta_range=(0, 90)) #Check the first two peaks self.assertAlmostEqual(data[0][0], 21.107738329639844) self.assertAlmostEqual(data[0][1], 36.483184003748946) self.assertEqual(data[0][2], {(1, 0, 0): 6}) self.assertAlmostEqual(data[0][3], 4.2089999999999996) self.assertAlmostEqual(data[1][0], 30.024695921112777) self.assertAlmostEqual(data[1][1], 100) self.assertEqual(data[1][2], {(1, 1, 0): 12}) self.assertAlmostEqual(data[1][3], 2.976212442014178) s = read_structure(os.path.join(test_dir, "LiFePO4.cif")) data = c.get_xrd_data(s, two_theta_range=(0, 90)) self.assertAlmostEqual(data[1][0], 17.03504233621785) self.assertAlmostEqual(data[1][1], 50.400928948337075) s = read_structure(os.path.join(test_dir, "Li10GeP2S12.cif")) data = c.get_xrd_data(s, two_theta_range=(0, 90)) self.assertAlmostEqual(data[1][0], 14.058274883353876) self.assertAlmostEqual(data[1][1], 4.4111123641667671) # Test a hexagonal structure. s = read_structure(os.path.join(test_dir, "Graphite.cif"), primitive=False) data = c.get_xrd_data(s, two_theta_range=(0, 90)) self.assertAlmostEqual(data[0][0], 7.929279053132362) self.assertAlmostEqual(data[0][1], 100) self.assertAlmostEqual(len(list(data[0][2].keys())[0]), 4) #Add test case with different lengths of coefficients. #Also test d_hkl. coords = [[0.25, 0.25, 0.173], [0.75, 0.75, 0.827], [0.75, 0.25, 0], [0.25, 0.75, 0], [0.25, 0.25, 0.676], [0.75, 0.75, 0.324]] sp = ["Si", "Si", "Ru", "Ru", "Pr", "Pr"] s = Structure(Lattice.tetragonal(4.192, 6.88), sp, coords) data = c.get_xrd_data(s) self.assertAlmostEqual(data[0][0], 12.86727341476735) self.assertAlmostEqual(data[0][1], 31.448239816769796) self.assertAlmostEqual(data[0][3], 6.88) self.assertEqual(len(data), 42) data = c.get_xrd_data(s, two_theta_range=[0, 60]) self.assertEqual(len(data), 18) #Test with and without Debye-Waller factor tungsten = Structure(Lattice.cubic(3.1653), ["W"] * 2, [[0, 0, 0], [0.5, 0.5, 0.5]]) data = c.get_xrd_data(tungsten, scaled=False) self.assertAlmostEqual(data[0][0], 40.294828554672264) self.assertAlmostEqual(data[0][1], 2414237.5633093244) self.assertAlmostEqual(data[0][3], 2.2382050944897789) c = XRDCalculator(debye_waller_factors={"W": 0.1526}) data = c.get_xrd_data(tungsten, scaled=False) self.assertAlmostEqual(data[0][0], 40.294828554672264) self.assertAlmostEqual(data[0][1], 2377745.2296686019) self.assertAlmostEqual(data[0][3], 2.2382050944897789)
def test_fit(self): """ Take two known matched structures 1) Ensure match 2) Ensure match after translation and rotations 3) Ensure no-match after large site translation 4) Ensure match after site shuffling """ sm = StructureMatcher() self.assertTrue(sm.fit(self.struct_list[0], self.struct_list[1])) # Test rotational/translational invariance op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 30, False, np.array([0.4, 0.7, 0.9])) self.struct_list[1].apply_operation(op) self.assertTrue(sm.fit(self.struct_list[0], self.struct_list[1])) #Test failure under large atomic translation self.struct_list[1].translate_sites([0], [.4, .4, .2], frac_coords=True) self.assertFalse(sm.fit(self.struct_list[0], self.struct_list[1])) self.struct_list[1].translate_sites([0], [-.4, -.4, -.2], frac_coords=True) # random.shuffle(editor._sites) self.assertTrue(sm.fit(self.struct_list[0], self.struct_list[1])) #Test FrameworkComporator sm2 = StructureMatcher(comparator=FrameworkComparator()) lfp = read_structure(os.path.join(test_dir, "LiFePO4.cif")) nfp = read_structure(os.path.join(test_dir, "NaFePO4.cif")) self.assertTrue(sm2.fit(lfp, nfp)) self.assertFalse(sm.fit(lfp, nfp)) #Test anonymous fit. self.assertEqual(sm.fit_anonymous(lfp, nfp), {Composition("Li"): Composition("Na")}) self.assertAlmostEqual(sm.get_minimax_rms_anonymous(lfp, nfp)[0], 0.096084154118549828) #Test partial occupancies. s1 = Structure([[3, 0, 0], [0, 3, 0], [0, 0, 3]], [{"Fe": 0.5}, {"Fe": 0.5}, {"Fe": 0.5}, {"Fe": 0.5}], [[0, 0, 0], [0.25, 0.25, 0.25], [0.5, 0.5, 0.5], [0.75, 0.75, 0.75]]) s2 = Structure([[3, 0, 0], [0, 3, 0], [0, 0, 3]], [{"Fe": 0.25}, {"Fe": 0.5}, {"Fe": 0.5}, {"Fe": 0.75}], [[0, 0, 0], [0.25, 0.25, 0.25], [0.5, 0.5, 0.5], [0.75, 0.75, 0.75]]) self.assertFalse(sm.fit(s1, s2)) self.assertFalse(sm.fit(s2, s1)) s2 = Structure([[3, 0, 0], [0, 3, 0], [0, 0, 3]], [{"Fe": 0.25}, {"Fe": 0.25}, {"Fe": 0.25}, {"Fe": 0.25}], [[0, 0, 0], [0.25, 0.25, 0.25], [0.5, 0.5, 0.5], [0.75, 0.75, 0.75]]) self.assertEqual(sm.fit_anonymous(s1, s2), {Composition("Fe0.5"): Composition("Fe0.25")}) self.assertAlmostEqual(sm.get_minimax_rms_anonymous(s1, s2)[0], 0)
def test_electronegativity(self): sm = StructureMatcher(ltol=0.2, stol=0.3, angle_tol=5) s1 = read_structure(os.path.join(test_dir, "Na2Fe2PAsO4S4.cif")) s2 = read_structure(os.path.join(test_dir, "Na2Fe2PNO4Se4.cif")) self.assertAlmostEqual(sm.fit_with_electronegativity(s1, s2), {Composition('S'): Composition('Se'), Composition('As'): Composition('N')})
def test_supercell_fit(self): sm = StructureMatcher(attempt_supercell=False) s1 = read_structure(os.path.join(test_dir, "Al3F9.cif")) s2 = read_structure(os.path.join(test_dir, "Al3F9_distorted.cif")) self.assertFalse(sm.fit(s1, s2)) sm = StructureMatcher(attempt_supercell=True) self.assertTrue(sm.fit(s1, s2))
def test_read_structure(self): test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", 'test_files') for fname in ("Li2O.cif", "Li2O2.cif", "vasprun.xml", "vasprun_Si_bands.xml", "Si.cssr"): filename = os.path.join(test_dir, fname) struct = read_structure(filename) self.assertIsInstance(struct, Structure) prim = read_structure(filename, primitive=True) self.assertLessEqual(len(prim), len(struct)) sorted_s = read_structure(filename, sort=True) self.assertEqual(sorted_s, sorted_s.get_sorted_structure())
def scaleCell(path,volume): poscar = os.path.join(path,'POSCAR') refcar = os.path.join(path,'REFCAR') potcar = Potcar() assert os.path.isfile(poscar) struct = read_structure(poscar) struct.scale_lattice(volume) species = [ pot.element for pot in potcar.from_file('POTCAR') ] reprule = { old:new for old,new in zip(struct.composition.elements,species) } struct.replace_species(reprule) p = Poscar(struct) with open(poscar) as f: poscomment = f.readline().strip() p.comment = poscomment p.write_file(poscar,vasp4_compatible=True) if os.path.isfile(refcar): tmp = os.path.join(path,'POSCARtmp') # copy Poscar to temporary file and refcar to poscar copyfile(poscar,tmp) copyfile(refcar,poscar) struct = read_structure(poscar) struct.scale_lattice(volume) species = [ pot.element for pot in potcar.from_file('POTCAR') ] reprule = { old:new for old,new in zip(struct.composition.elements,species) } struct.replace_species(reprule) r = Poscar(struct) with open(poscar) as f: poscomment = f.readline().strip() r.comment = poscomment r.write_file(poscar,vasp4_compatible=True) with open(refcar) as f: poscomment = f.readline().strip() r.comment = poscomment r.write_file(refcar,vasp4_compatible=True) # replace poscar with its original move(tmp,poscar) else: print 'No REFCAR found.'
def test_electronegativity(self): sm = StructureMatcher(ltol=0.2, stol=0.3, angle_tol=5) s1 = read_structure(os.path.join(test_dir, "Na2Fe2PAsO4S4.cif")) s2 = read_structure(os.path.join(test_dir, "Na2Fe2PNO4Se4.cif")) self.assertEqual(sm.get_best_electronegativity_anonymous_mapping(s1, s2), {Element('S'): Element('Se'), Element('As'): Element('N'), Element('Fe'): Element('Fe'), Element('Na'): Element('Na'), Element('P'): Element('P'), Element('O'): Element('O'),}) self.assertEqual(len(sm.get_all_anonymous_mappings(s1, s2)), 2)
def test_electronegativity(self): sm = StructureMatcher(ltol=0.2, stol=0.3, angle_tol=5) s1 = read_structure(os.path.join(test_dir, "Na2Fe2PAsO4S4.cif")) s2 = read_structure(os.path.join(test_dir, "Na2Fe2PNO4Se4.cif")) self.assertEqual( sm.get_best_electronegativity_anonymous_mapping(s1, s2), { Element('S'): Element('Se'), Element('As'): Element('N'), Element('Fe'): Element('Fe'), Element('Na'): Element('Na'), Element('P'): Element('P'), Element('O'): Element('O'), }) self.assertEqual(len(sm.get_all_anonymous_mappings(s1, s2)), 2)
def asabistructure(obj): """ Convert obj into an AbiStructure object. Accepts: - AbiStructure instance - Subinstances of pymatgen. - File paths """ if isinstance(obj, AbiStructure): return obj if isinstance(obj, Structure): # Promote return AbiStructure(obj) if is_string(obj): # Handle file paths. if os.path.isfile(obj): if obj.endswith(".nc"): structure = structure_from_etsf_file(obj) #print(structure._sites) else: structure = read_structure(obj) # Promote return AbiStructure(structure) raise ValueError("Don't know how to convert object %s to an AbiStructure structure" % str(obj))
def from_file(cls, filepath): """ Return a new Structure instance from a NetCDF file Args: filename: netcdf file with crystallographic data in the ETSF-IO format. or any other file format supported by `pymatgen.io.smartio`. """ if filepath.endswith(".nc"): file, closeit = as_etsfreader(filepath) new = file.read_structure() # Change the class of new. new.__class__ = cls new.set_spacegroup(SpaceGroup.from_file(file)) if closeit: file.close() else: # TODO: Spacegroup is missing here. from pymatgen.io.smartio import read_structure new = read_structure(filepath) # Change the class of new. new.__class__ = cls return new
def test_read_structure(self): for fname in ("Li2O.cif", "Li2O2.cif", "vasprun.xml", "vasprun_Si_bands.xml", "Si.cssr"): filename = os.path.join(test_dir, fname) struct = read_structure(filename) self.assertIsInstance(struct, Structure) print struct
def asabistructure(obj): """ Convert obj into an AbiStructure object. Accepts: - AbiStructure instance - Subinstances of pymatgen. - File paths """ if isinstance(obj, AbiStructure): return obj if isinstance(obj, Structure): # Promote return AbiStructure(obj) if isinstance(obj, str): # Handle file paths. if os.path.isfile(obj): if obj.endswith(".nc"): from .netcdf import structure_from_etsf_file structure = structure_from_etsf_file(obj) print(structure._sites) else: from pymatgen.io.smartio import read_structure structure = read_structure(obj) # Promote return AbiStructure(structure) raise ValueError("Don't know how to convert object %s to an AbiStructure structure" % str(obj))
def test_apply_transformation(self): trans = MagOrderingTransformation({"Fe": 5}) p = Poscar.from_file(os.path.join(test_dir, 'POSCAR.LiFePO4'), check_for_POTCAR=False) s = p.structure alls = trans.apply_transformation(s, 10) self.assertEqual(len(alls), 3) f = SymmetryFinder(alls[0]["structure"], 0.1) self.assertEqual(f.get_spacegroup_number(), 31) model = IsingModel(5, 5) trans = MagOrderingTransformation({"Fe": 5}, energy_model=model) alls2 = trans.apply_transformation(s, 10) #Ising model with +J penalizes similar neighbor magmom. self.assertNotEqual(alls[0]["structure"], alls2[0]["structure"]) self.assertEqual(alls[0]["structure"], alls2[2]["structure"]) from pymatgen.io.smartio import read_structure s = read_structure(os.path.join(test_dir, 'Li2O.cif')) #Li2O doesn't have magnetism of course, but this is to test the # enumeration. trans = MagOrderingTransformation({"Li+": 1}, max_cell_size=3) alls = trans.apply_transformation(s, 100) self.assertEqual(len(alls), 10)
def generate_diffraction_plot(args): s = read_structure(args.filenames[0]) c = XRDCalculator() if args.outfile: c.get_xrd_plot(s).savefig(args.outfile[0]) else: c.show_xrd_plot(s)
def __init__(self, workdir, runmode, structure_or_cif, pseudos, kppa, spin_mode="polarized", smearing="fermi_dirac:0.1 eV", accuracy="normal", ecut=None, ecutsm=0.05, chksymbreak=0): # FIXME Hack super(DeltaTest, self).__init__(workdir, runmode) if isinstance(structure_or_cif, Structure): structure = structure_or_cif else: # Assume CIF file structure = read_structure(structure_or_cif) structure = AbiStructure.asabistructure(structure) smearing = Smearing.assmearing(smearing) self._input_structure = structure v0 = structure.volume self.volumes = v0 * np.arange(90, 112, 2) / 100. for vol in self.volumes: new_lattice = structure.lattice.scale(vol) new_structure = Structure(new_lattice, structure.species, structure.frac_coords) new_structure = AbiStructure.asabistructure(new_structure) extra_abivars = { "ecutsm": ecutsm, "prtwf": 0, } if ecut is not None: extra_abivars.update({"ecut": ecut}) ksampling = KSampling.automatic_density(new_structure, kppa, chksymbreak=chksymbreak) scf_strategy = ScfStrategy(new_structure, pseudos, ksampling, accuracy=accuracy, spin_mode=spin_mode, smearing=smearing, **extra_abivars) self.register_task(scf_strategy)
def parse_view(args): from pymatgen.vis.structure_vtk import StructureVis excluded_bonding_elements = args.exclude_bonding[0].split(",") \ if args.exclude_bonding else [] s = read_structure(args.filename[0]) vis = StructureVis(excluded_bonding_elements=excluded_bonding_elements) vis.set_structure(s) vis.show()
def setUp(self): with open(os.path.join(test_dir, "TiO2_entries.json"), 'r') as fp: entries = json.load(fp, cls=PMGJSONDecoder) self.struct_list = [e.structure for e in entries] self.oxi_structs = [ read_structure(os.path.join(test_dir, fname)) for fname in ["Li2O.cif", "POSCAR.Li2O"] ]
def test_read_structure(self): test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", 'test_files') for fname in ("Li2O.cif", "Li2O2.cif", "vasprun.xml", "vasprun_Si_bands.xml", "Si.cssr"): filename = os.path.join(test_dir, fname) struct = read_structure(filename) self.assertIsInstance(struct, Structure)
def convert_fmt(args): iformat = args.input_format[0] oformat = args.output_format[0] filename = args.input_filename[0] out_filename = args.output_filename[0] try: if iformat == "smart": structure = read_structure(filename) if iformat == "POSCAR": p = Poscar.from_file(filename) structure = p.structure elif iformat == "CIF": r = CifParser(filename) structure = r.get_structures()[0] elif iformat == "CSSR": structure = Cssr.from_file(filename).structure if oformat == "smart": write_structure(structure, out_filename) elif oformat == "POSCAR": p = Poscar(structure) p.write_file(out_filename) elif oformat == "CIF": w = CifWriter(structure) w.write_file(out_filename) elif oformat == "CSSR": c = Cssr(structure) c.write_file(out_filename) elif oformat == "VASP": input_set = MPVaspInputSet() ts = TransformedStructure(structure, [], history=[{ "source": "file", "datetime": str(datetime.datetime.now()), "original_file": open(filename).read() }]) ts.write_vasp_input(input_set, output_dir=out_filename) elif oformat == "MITVASP": input_set = MITVaspInputSet() ts = TransformedStructure(structure, [], history=[{ "source": "file", "datetime": str(datetime.datetime.now()), "original_file": open(filename).read() }]) ts.write_vasp_input(input_set, output_dir=out_filename) except Exception as ex: print "Error converting file. Are they in the right format?" print str(ex)
def test_get_energy(self): m = IsingModel(5, 6) from pymatgen.core.periodic_table import Specie s = read_structure(os.path.join(test_dir, "LiFePO4.cif")) s.replace_species({"Fe": Specie("Fe", 2, {"spin": 4})}) self.assertEqual(m.get_energy(s), 172.81260515787977) s[4] = Specie("Fe", 2, {"spin": -4}) s[5] = Specie("Fe", 2, {"spin": -4}) self.assertAlmostEqual(m.get_energy(s), 51.97424405382921)
def test_get_energy(self): m = IsingModel(5, 6) from pymatgen.core.periodic_table import Specie s = read_structure(os.path.join(test_dir, "LiFePO4.cif")) s.replace_species({"Fe": Specie("Fe", 2, {"spin": 4})}) self.assertEqual(m.get_energy(s), 172.81260515787977) s.replace(4, Specie("Fe", 2, {"spin": -4})) s.replace(5, Specie("Fe", 2, {"spin": -4})) self.assertAlmostEqual(m.get_energy(s), 51.97424405382921)
def test_read_structure(self): test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", 'test_files') for fname in ("Li2O.cif", "vasprun.xml", "vasprun_Si_bands.xml", "Si.cssr"): filename = os.path.join(test_dir, fname) struct = read_structure(filename) self.assertIsInstance(struct, Structure) prim = read_structure(filename, primitive=True) self.assertLessEqual(len(prim), len(struct)) sorted_s = read_structure(filename, sort=True) self.assertEqual(sorted_s, sorted_s.get_sorted_structure()) m = StructureMatcher() for ext in [".cif", ".json", ".cssr"]: fn = "smartio_structure_test" + ext write_structure(struct, fn) back = read_structure(fn) self.assertTrue(m.fit(back, struct)) os.remove(fn)
def test_mix(self): structures = [] for fname in ["POSCAR.Li2O", "Li2O.cif", "Li2O2.cif", "LiFePO4.cif", "POSCAR.LiFePO4"]: structures.append(read_structure(os.path.join(test_dir, fname))) sm = StructureMatcher(comparator=ElementComparator()) groups = sm.group_structures(structures) for g in groups: formula = g[0].composition.reduced_formula if formula in ["Li2O", "LiFePO4"]: self.assertEqual(len(g), 2) else: self.assertEqual(len(g), 1)
def convert_fmt(args): iformat = args.input_format[0] oformat = args.output_format[0] filename = args.input_filename[0] out_filename = args.output_filename[0] try: if iformat == "smart": structure = read_structure(filename) if iformat == "POSCAR": p = Poscar.from_file(filename) structure = p.structure elif iformat == "CIF": r = CifParser(filename) structure = r.get_structures()[0] elif iformat == "CSSR": structure = Cssr.from_file(filename).structure if oformat == "smart": write_structure(structure, out_filename) elif oformat == "POSCAR": p = Poscar(structure) p.write_file(out_filename) elif oformat == "CIF": w = CifWriter(structure) w.write_file(out_filename) elif oformat == "CSSR": c = Cssr(structure) c.write_file(out_filename) elif oformat == "VASP": input_set = MPVaspInputSet() ts = TransformedStructure( structure, [], history=[ {"source": "file", "datetime": str(datetime.datetime.now()), "original_file": open(filename).read()} ], ) ts.write_vasp_input(input_set, output_dir=out_filename) elif oformat == "MITVASP": input_set = MITVaspInputSet() ts = TransformedStructure( structure, [], history=[ {"source": "file", "datetime": str(datetime.datetime.now()), "original_file": open(filename).read()} ], ) ts.write_vasp_input(input_set, output_dir=out_filename) except Exception as ex: print "Error converting file. Are they in the right format?" print str(ex)
def test_zero_spin_case(self): #ensure that zero spin case maintains sites and formula from pymatgen.io.smartio import read_structure s = read_structure(os.path.join(test_dir, 'Li2O.cif')) trans = MagOrderingTransformation({"Li+": 0.0}, 0.5) alls = trans.apply_transformation(s) #compositions will not be equal due to spin assignment #structure representations will be the same self.assertEqual(str(s), str(alls)) #Ensure s does not have a spin property self.assertFalse('spin' in s.sites[0].specie._properties) #ensure sites are assigned a spin property in alls self.assertTrue('spin' in alls.sites[0].specie._properties)
def setup(self): """ Performs initial setup for VaspJob, including overriding any settings and backing up. """ files = os.listdir(".") num_structures = 0 if not set(files).issuperset(VASP_INPUT_FILES): for f in files: try: struct = read_structure(f) num_structures += 1 except: pass if num_structures != 1: raise RuntimeError("{} structures found. Unable to continue." .format(num_structures)) else: self.default_vis.write_input(struct, ".") if self.backup: for f in VASP_INPUT_FILES: shutil.copy(f, "{}.orig".format(f)) if self.auto_npar: try: incar = Incar.from_file("INCAR") #Only optimized NPAR for non-HF and non-RPA calculations. if not (incar.get("LHFCALC") or incar.get("LRPA") or incar.get("LEPSILON")): if incar.get("IBRION") in [5, 6, 7, 8]: # NPAR should not be set for Hessian matrix # calculations, whether in DFPT or otherwise. del incar["NPAR"] else: import multiprocessing # try sge environment variable first # (since multiprocessing counts cores on the current machine only) ncores = os.environ.get('NSLOTS') or multiprocessing.cpu_count() ncores = int(ncores) for npar in range(int(round(math.sqrt(ncores))), ncores): if ncores % npar == 0: incar["NPAR"] = npar break incar.write_file("INCAR") except: pass if self.settings_override is not None: VaspModder().apply_actions(self.settings_override)
def parse_symmetry(args): tolerance = float(args.tolerance[0]) for filename in args.filenames: s = read_structure(filename) if args.spacegroup: finder = SymmetryFinder(s, tolerance) dataset = finder.get_symmetry_dataset() print filename print "Spacegroup : {}".format(dataset["international"]) print "Int number : {}".format(dataset["number"]) print "Hall symbol : {}".format(dataset["hall"]) print
def setup(self): files = os.listdir(".") num_structures = 0 if not set(files).issuperset(VASP_INPUT_FILES): for f in files: try: struct = read_structure(f) num_structures += 1 except: pass if num_structures != 1: raise RuntimeError("{} structures found. Unable to continue." .format(num_structures)) else: self.default_vis.write_input(struct, ".") if self.backup: for f in VASP_INPUT_FILES: shutil.copy(f, "{}.orig".format(f)) if self.auto_npar: try: vi = VaspInput.from_directory(".") incar = vi["INCAR"] #Only optimized NPAR for non-HF and non-RPA calculations. if (not incar.get("LHFCALC")) and (not incar.get("LRPA")): import multiprocessing ncores = multiprocessing.cpu_count() for npar in range(int(round(math.sqrt(ncores))), ncores): if ncores % npar == 0: incar["NPAR"] = npar break incar.write_file("INCAR") except: pass if self.settings_override is not None: vi = VaspInput.from_directory(".") m = Modder([FileActions, DictActions]) modified = [] for a in self.settings_override: if "dict" in a: modified.append(a["dict"]) vi[a["dict"]] = m.modify_object(a["action"], vi[a["dict"]]) elif "filename" in a: m.modify(a["action"], a["filename"]) for f in modified: vi[f].write_file(f)
def __init__(self, workdir, runmode, structure_or_cif, pseudos, kppa, spin_mode="polarized", toldfe=1.e-8, smearing="fermi_dirac:0.1 eV", accuracy="normal", ecut=None, ecutsm=0.05, chksymbreak=0): # FIXME Hack super(DeltaTest, self).__init__(workdir, runmode) if isinstance(structure_or_cif, Structure): structure = structure_or_cif else: # Assume CIF file structure = read_structure(structure_or_cif) structure = AbiStructure.asabistructure(structure) smearing = Smearing.assmearing(smearing) self._input_structure = structure v0 = structure.volume # From 94% to 106% of the equilibrium volume. self.volumes = v0 * np.arange(94, 108, 2) / 100. for vol in self.volumes: new_lattice = structure.lattice.scale(vol) new_structure = Structure(new_lattice, structure.species, structure.frac_coords) new_structure = AbiStructure.asabistructure(new_structure) extra_abivars = { "ecutsm": ecutsm, "toldfe": toldfe, "prtwf" : 0, "paral_kgb": 0, } if ecut is not None: extra_abivars.update({"ecut": ecut}) ksampling = KSampling.automatic_density(new_structure, kppa, chksymbreak=chksymbreak) scf_strategy = ScfStrategy(new_structure, pseudos, ksampling, accuracy=accuracy, spin_mode=spin_mode, smearing=smearing, **extra_abivars) self.register_task(scf_strategy)
def test_get_energy(self): coords = [[0, 0, 0], [0.75, 0.75, 0.75], [0.5, 0.5, 0.5], [0.25, 0.25, 0.25]] lattice = Lattice([[3.0, 0.0, 0.0], [1.0, 3.0, 0.00], [0.00, -2.0, 3.0]]) s = Structure(lattice, [{"Si4+": 0.5, "O2-": 0.25, "P5+": 0.25}, {"Si4+": 0.5, "O2-": 0.25, "P5+": 0.25}, {"Si4+": 0.5, "O2-": 0.25, "P5+": 0.25}, {"Si4+": 0.5, "O2-": 0.25, "P5+": 0.25}], coords) m = EwaldElectrostaticModel() self.assertAlmostEqual(m.get_energy(s), 44.1070954178) s2 = read_structure(os.path.join(test_dir, "Li2O.cif")) self.assertAlmostEqual(m.get_energy(s2), -36.3476248117)
def askopenfile_name(self): """Returns an opened file in read mode. This time the dialog just returns a filename and the file is opened by your own code. """ self.clear_text() #get filename file_name = tkFileDialog.askopenfilename(**self.file_opt) self.source = file_name if file_name == '' or file_name==(): return self.cif_ent.insert(0, file_name) file_type = file_name.split(".")[-1] if file_type == 'cif': r = CifParser(self.source) self.fstruc = r.get_structures()[0] else: self.fstruc = read_structure(file_name)
def convert_fmt(args): iformat = args.input_format[0] oformat = args.output_format[0] filename = args.input_filename[0] out_filename = args.output_filename[0] try: if iformat == "smart": structure = read_structure(filename) if iformat == "POSCAR": p = Poscar.from_file(filename) structure = p.structure elif iformat == "CIF": r = CifParser(filename) structure = r.get_structures()[0] elif iformat == "CSSR": structure = Cssr.from_file(filename).structure if oformat == "smart": write_structure(structure, out_filename) elif oformat == "POSCAR": p = Poscar(structure) p.write_file(out_filename) elif oformat == "CIF": w = CifWriter(structure) w.write_file(out_filename) elif oformat == "CSSR": c = Cssr(structure) c.write_file(out_filename) elif oformat == "VASP": input_set = MaterialsProjectVaspInputSet() transmuter = StandardTransmuter.from_structures([structure], []) transmuter.write_vasp_input(input_set, output_dir=out_filename) except Exception as ex: print "Error converting file. Are they in the right format?" print str(ex)
def finite_size_scale(standard, ssize, primordial, fsize, psize=[1, 1, 1]): """Function to perform finite size scaling for defect structure relaxation Inputs: standard = POSCAR file of structure containing defect ssize = Supercell size of structure with defect (list of size 3) primordial = POSCAR file of structure for basic unit of perfect cell psize = Supercell size of structure for padding. Default = [1,1,1] (list of size 3) fsize = Desired supercell size of final structure (list of size 3) Outputs: POSCAR file of structure containing defect and padding""" # Check if the input sizes work out with the desired final size padding = [0, 0, 0] for i in range(3): diff = fsize[i] - ssize[i] if diff < 0: raise RuntimeError( 'Desired final size of the structure must be larger than \ existing defect structure size. Defect Size = ' + repr(ssize) + ' Final Size = ' + repr(fsize)) elif diff >= 0: if math.fmod(diff, psize[i]): raise RuntimeError( 'Primordial structure and defect structure sizes cannot \ be used to form desired final size. Reduce size of primordial structure. Defect Size = ' + repr(ssize) + ' Final Size = ' + repr(fsize) + ' Primordial size = ' + repr(psize)) else: padding[i] = diff / psize[i] # Load the defect structure and primordial structure try: defst = read_structure(standard) except: raise RuntimeError('Error: Unable to read standard structure. Please check file. Filename: '+\ standard) try: pst = read_structure(primordial) except: raise RuntimeError('Error: Unable to read primordial structure. Please check file. Filename: '+\ primordial) # Pad the structure positions = [site.coords for site in pst] syms = [str(site.specie.symbol) for site in pst] lv = [one / ssize for one in defst.lattice.matrix] vect = [] for m0 in range(padding[0]): for m1 in numpy.arange(0, fsize[1], psize[1]): for m2 in numpy.arange(0, fsize[2], psize[2]): vect.append([ssize[0] + m0 * psize[0], m1, m2]) for m1 in range(padding[1]): for m0 in numpy.arange(0, ssize[0], psize[0]): for m2 in numpy.arange(0, fsize[2], psize[2]): vect.append([m0, ssize[1] + m1 * psize[1], m2]) for m2 in range(padding[2]): for m0 in numpy.arange(0, ssize[0], psize[0]): for m1 in numpy.arange(0, ssize[1], psize[1]): vect.append([m0, m1, ssize[2] + m2 * psize[2]]) #Construct a new structure with desired size new_lat = Lattice(numpy.array([fsize[c] * lv[c] for c in range(3)])) final = Structure(new_lat, defst.species_and_occu, defst.cart_coords, coords_are_cartesian=True) for m0, m1, m2 in vect: npos = positions + numpy.dot((m0, m1, m2), lv) for i in range(len(npos)): final.append(syms[i], npos[i], coords_are_cartesian=True) #Check for periodic issues in final structure final = check_periodic(final, defst) # Write output as POSCAR write_structure(final, 'POSCAR_Final') return final
def test_get_energy(self): m = SymmetryModel() s2 = read_structure(os.path.join(test_dir, "Li2O.cif")) self.assertEqual(m.get_energy(s2), -225)
def test_get_conversion_factor(self): filepath = os.path.join(test_dir, 'LiFePO4.cif') s = read_structure(filepath) self.assertAlmostEqual(41370704.1173, get_conversion_factor(s, "Li", 600), 4)
############################################################## # This code is part of the MAterials Simulation Toolkit (MAST) # # Maintainer: Wei Xie # Last updated: 2014-02-07 ############################################################## import sys, getopt, os import shutil import matplotlib.pyplot as plt import numpy as np import scipy as sp from pymatgen import Lattice, Structure from pymatgen.io.smartio import read_structure, write_structure stdX = read_structure("POSCAR_std") prmX = read_structure("POSCAR_prm") stdL = Structure.lattice(stdX) prmL = Structure.lattice(stdX) def finite_size_scale(standard, ssize, primordial, fsize, psize=[1, 1, 1]): """Function to perform finite size scaling for defect structure relaxation Inputs: standard = POSCAR file of structure containing defect ssize = Supercell size of structure with defect (list of size 3) primordial = POSCAR file of structure for basic unit of perfect cell psize = Supercell size of structure for padding. Default = [1,1,1] (list of size 3) fsize = Desired supercell size of final structure (list of size 3) Outputs: POSCAR file of structure containing defect and padding"""
def get_structure_from_file(filename): return sio.read_structure(filename)
def setUp(self): with open(os.path.join(test_dir, "TiO2_entries.json"), 'r') as fp: entries = json.load(fp, cls=PMGJSONDecoder) self.struct_list = [e.structure for e in entries] self.oxi_structs = [read_structure(os.path.join(test_dir, fname)) for fname in ["Li2O.cif", "POSCAR.Li2O"]]
def test_left_handed_lattice(self): """Ensure Left handed lattices are accepted""" sm = StructureMatcher() s = read_structure(os.path.join(test_dir, "Li3GaPCO7.cif")) self.assertTrue(sm.fit(s, s))