def __init__(self, executable=None, verbose=0): self.executable = executable if executable is None: self.executable = pj(abipy_env.bindir, self._name) self.executable = which(self.executable) if self.executable is None: raise self.Error("%s is not executable" % self.executable) assert basename(self.executable) == self._name self.verbose = int(verbose)
def __init__(self, executable, verbose=0): """ Args: executable: path to the executable. verbose: Verbosity level """ if executable is None: executable = self.name self.executable = which(executable) self.verbose = int(verbose) if self.executable is None: msg = "Cannot find executable %s is PATH\n Use export PATH=/dir_with_exec:$PATH" % executable raise self.Error(msg) assert os.path.basename(self.executable) == self._name
def __init__(self, executable, verbose=0): """ Args: executable: path to the executable. verbose: Verbosity level. """ if executable is None: executable = self.name self.executable = which(executable) self.verbose = int(verbose) if self.executable is None: msg = "Cannot find executable %s is PATH\n Use export PATH=/dir_with_exec:$PATH" % executable raise self.Error(msg) assert os.path.basename(self.executable) == self._name
import numpy as np import warnings from pymatgen.io.vaspio.vasp_input import Poscar from pymatgen.core.sites import PeriodicSite from pymatgen.core.structure import Structure from pymatgen.symmetry.finder import SymmetryFinder from pymatgen.core.periodic_table import DummySpecie from pymatgen.util.io_utils import which from pymatgen.util.decorators import requires logger = logging.getLogger(__name__) @requires(which('multienum.x') and which('makestr.x'), "EnumlibAdaptor requires the executables 'multienum.x' and " "'makestr.x' to be in the path. Please download the library at" "http://enum.sourceforge.net/ and follow the instructions in " "the README to compile these two executables accordingly.") class EnumlibAdaptor(object): """ An adaptor for enumlib. .. attribute:: structures List of all enumerated structures. """ amount_tol = 1e-5 def __init__(self, structure, min_cell_size=1, max_cell_size=1,
__author__ = "Shyue Ping Ong" __copyright__ = "Copyright 2012, The Materials Project" __version__ = "0.1" __maintainer__ = "Shyue Ping Ong" __email__ = "*****@*****.**" __date__ = "Jul 22, 2012" import unittest import os from pymatgen.command_line.bader_caller import BaderAnalysis from pymatgen.util.io_utils import which @unittest.skipIf(not which('bader'), "bader executable not present.") class BaderAnalysisTest(unittest.TestCase): def test_init(self): test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", 'test_files') analysis = BaderAnalysis(os.path.join(test_dir, "CHGCAR.Fe3O4"), os.path.join(test_dir, "POTCAR.Fe3O4")) self.assertEqual(len(analysis.data), 14) self.assertAlmostEqual(analysis.data[0]["charge"], 6.1485) self.assertAlmostEqual(analysis.nelectrons, 96) self.assertAlmostEqual(analysis.vacuum_charge, 0) ans = [-1.8515, -1.8132, -1.8132, -1.5562, -1.8132, -1.8515, 1.3369, 1.3378, 1.3373, 1.3374, 1.3374, 1.3369, 1.3373, 1.3378] for i in range(14): self.assertAlmostEqual(ans[i], analysis.get_charge_transfer(i))
__email__ = "*****@*****.**" __date__ = "Jul 22, 2012" import unittest import os from pymatgen.command_line.enumlib_caller import EnumlibAdaptor from pymatgen import Element, Structure from pymatgen.io.cifio import CifParser from pymatgen.transformations.standard_transformations import \ SubstitutionTransformation from pymatgen.util.io_utils import which from pymatgen.transformations.site_transformations import \ RemoveSitesTransformation enumlib_present = which('multienum.x') and which('makestr.x') @unittest.skipIf(not enumlib_present, "enum_lib not present.") class EnumlibAdaptorTest(unittest.TestCase): def test_init(self): test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", 'test_files') parser = CifParser(os.path.join(test_dir, "LiFePO4.cif")) struct = parser.get_structures(False)[0] subtrans = SubstitutionTransformation({'Li': {'Li': 0.5}}) adaptor = EnumlibAdaptor(subtrans.apply_transformation(struct), 1, 2) adaptor.run() structures = adaptor.structures self.assertEqual(len(structures), 86) for s in structures:
__email__ = "*****@*****.**" __status__ = "Beta" __date__ = "4/5/13" import os import subprocess import tempfile import shutil from pymatgen.io.vaspio.vasp_output import Chgcar from pymatgen.io.vaspio.vasp_input import Potcar from pymatgen.util.io_utils import which from pymatgen.util.decorators import requires @requires(which("bader"), "BaderAnalysis requires the executable bader to be in the path." " Please download the library at http://theory.cm.utexas" ".edu/vasp/bader/ and compile the executable.") class BaderAnalysis(object): """ Bader analysis for a CHGCAR. .. attribute: data Atomic data parsed from bader analysis. Essentially a list of dicts of the form:: [ { "dist": 8.769,
import unittest from pymatgen.command_line.aconvasp_caller import get_num_division_kpoints, \ get_minkowski_red, get_vasp_kpoint_file_sym from pymatgen.core.composition import Composition from pymatgen.core.structure import Lattice, Structure from pymatgen.core.periodic_table import Element from pymatgen.util.io_utils import which aconvasp_present = which('aconvasp') @unittest.skipIf(not aconvasp_present, "aconvasp not present.") class AconvaspCallerTest(unittest.TestCase): def setUp(self): self.si = Element("Si") coords = list() coords.append([0, 0, 0]) coords.append([0.75, 0.5, 0.75]) self.lattice = Lattice([[3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603]]) self.struct = Structure(self.lattice, [self.si, self.si], coords) def test_get_num_division_kpoints(self): self.assertListEqual(get_num_division_kpoints(self.struct, 500), [6, 7, 6]) def test_get_minkowski_red(self): new_struct = get_minkowski_red(self.struct) self.assertAlmostEqual(new_struct.lattice.a, 3.840198)
#!/usr/bin/python import unittest import sys from pymatgen.analysis.defects.point_defects import * from pymatgen.core.structure import Structure from pymatgen.core.periodic_table import Element from pymatgen.util.io_utils import which try: import zeo except ImportError: zeo = None gulp_present = which('gulp') class ValenceIonicRadiusEvaluatorTest(unittest.TestCase): def setUp(self): """ Setup MgO rocksalt structure for testing Vacancy """ mgo_latt = [[4.212, 0, 0], [0, 4.212, 0], [0, 0, 4.212]] mgo_specie = ["Mg"] * 4 + ["O"] * 4 mgo_frac_cord = [[0, 0, 0], [0.5, 0.5, 0], [0.5, 0, 0.5], [0, 0.5, 0.5], [0.5, 0, 0], [0, 0.5, 0], [0, 0, 0.5], [0.5, 0.5, 0.5]] self._mgo_uc = Structure(mgo_latt, mgo_specie, mgo_frac_cord, True, True) self._mgo_valrad_evaluator = ValenceIonicRadiusEvaluator(self._mgo_uc)
import unittest from pymatgen.command_line.aconvasp_caller import get_num_division_kpoints, \ get_minkowski_red, get_vasp_kpoint_file_sym from pymatgen.core.composition import Composition from pymatgen.core.structure import Lattice, Structure from pymatgen.core.periodic_table import Element from pymatgen.util.io_utils import which aconvasp_present = which('aconvasp') @unittest.skipIf(not aconvasp_present, "aconvasp not present.") class AconvaspCallerTest(unittest.TestCase): def setUp(self): self.si = Element("Si") coords = list() coords.append([0, 0, 0]) coords.append([0.75, 0.5, 0.75]) self.lattice = Lattice([[3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603]]) self.struct = Structure(self.lattice, [self.si, self.si], coords) def test_get_num_division_kpoints(self): self.assertListEqual(get_num_division_kpoints(self.struct, 500), [6, 7, 6]) def test_get_minkowski_red(self):
class BoltztrapRunner(): """ This class is used to run Boltztrap on a band structure object """ @requires(which('x_trans'), "BoltztrapRunner requires the executables 'x_trans' to be in " "the path. Please download the Boltztrap at " "http://www.icams.de/content/departments/ams/madsen/boltztrap" ".html and follow the instructions in the README to compile " "Bolztrap accordingly. Then add x_trans to your path") def __init__(self, bs, nelec, dos_type="HISTO", energy_grid=0.005, lpfac=10, sym_nb=None): """ Args: bs: A band structure object nelec: the number of electrons dos_type: two options here for the band structure integration: "HISTO" (histogram) or "TETRA" using the tetrahedon method. TETRA gives typically better results especially for DOSes but takes more time energy_grid: the energy steps used for the integration. in eV lpfac: the number of interpolation points in the real space. By default 10 gives 10 time more points in the real space than the number of kpoints given in reciprocal space sym_nb: ? """ self.lpfac = lpfac self._bs = bs self._nelec = nelec self.dos_type = dos_type self.energy_grid = energy_grid self.sym_nb = sym_nb self.error = [] def _make_energy_file(self, file_name): with open(file_name, 'w') as f: f.write("test\n") f.write(str(len(self._bs.kpoints)) + "\n") for i in range(len(self._bs.kpoints)): tmp_eigs = [] for spin in self._bs._bands: for j in range(int(math.floor(self._bs._nb_bands * 0.9))): tmp_eigs.append( Energy( self._bs._bands[spin][j][i] - self._bs.efermi, "eV").to("Ry")) tmp_eigs.sort() f.write("%12.8f %12.8f %12.8f %d\n" % (self._bs.kpoints[i].frac_coords[0], self._bs.kpoints[i].frac_coords[1], self._bs.kpoints[i].frac_coords[2], len(tmp_eigs))) for j in range(len(tmp_eigs)): f.write("%18.8f\n" % float(tmp_eigs[j])) def _make_struc_file(self, file_name): sym = SymmetryFinder(self._bs._structure, symprec=0.01) with open(file_name, 'w') as f: f.write(self._bs._structure.composition.formula + " " + str(sym.get_spacegroup_symbol()) + "\n") for i in range(3): line = '' for j in range(3): line += "%12.5f" % (Length( self._bs._structure.lattice.matrix[i][j], "ang").to("bohr")) f.write(line + '\n') ops = sym.get_symmetry_dataset()['rotations'] f.write(str(len(ops)) + "\n") for c in ops: f.write('\n'.join( [' '.join([str(int(i)) for i in row]) for row in c])) f.write('\n') def _make_intrans_file(self, file_name, doping=[1e15, 1e16, 1e17, 1e18, 1e19, 1e20]): with open(file_name, 'w') as fout: fout.write("GENE # use generic interface\n") fout.write( "1 0 0 0.0 # iskip (not presently used) idebug setgap shiftgap \n" ) fout.write( "0.0 %f 0.1 %6.1f # Fermilevel (Ry),energygrid,energy span around Fermilevel, number of electrons\n" % (Energy(self.energy_grid, "eV").to("Ry"), self._nelec)) fout.write( "CALC # CALC (calculate expansion coeff), NOCALC read from file\n" ) fout.write( "%d # lpfac, number of latt-points per k-point\n" % self.lpfac) fout.write( "BOLTZ # run mode (only BOLTZ is supported)\n" ) fout.write( ".15 # (efcut) energy range of chemical potential\n" ) fout.write("800. 100. # Tmax, temperature grid\n") fout.write( "-1. # energyrange of bands given DOS output sig_xxx and dos_xxx (xxx is band number)\n" ) fout.write(self.dos_type + "\n") fout.write("1 0 0 -1\n") fout.write(str(2 * len(doping)) + "\n") for d in doping: fout.write(str(d) + "\n") for d in doping: fout.write(str(-d) + "\n") def _make_all_files(self, path): if self._bs.is_spin_polarized: self._make_energy_file(os.path.join(path, "boltztrap.energyso")) else: self._make_energy_file(os.path.join(path, "boltztrap.energy")) self._make_struc_file(os.path.join(path, "boltztrap.struct")) self._make_intrans_file(os.path.join(path, "boltztrap.intrans")) def run(self, prev_sigma=None, path_dir=None): dir_bz_name = "boltztrap" path_dir_orig = path_dir if path_dir is None: temp_dir = tempfile.mkdtemp() path_dir_orig = temp_dir path_dir = os.path.join(temp_dir, dir_bz_name) else: path_dir = os.path.join(path_dir_orig, dir_bz_name) if not os.path.exists(path_dir): os.mkdir(path_dir) else: for c in os.listdir(path_dir): os.remove(path_dir + "/" + c) os.chdir(path_dir) self._make_all_files(path_dir) if self._bs.is_spin_polarized: p = subprocess.Popen(["x_trans", "BoltzTraP", "-so"], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE) p.wait() else: p = subprocess.Popen(["x_trans", "BoltzTraP"], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE) p.wait() for c in p.communicate(): if "STOP error in factorization" in c: raise BoltztrapError("STOP error in factorization") with open(os.path.join(path_dir, dir_bz_name + ".outputtrans")) as f: warning = False for l in f: if "WARNING" in l: warning = True break if warning: print "There was a warning! Increase lpfac to " + \ str(self.lpfac * 2) self.lpfac *= 2 self._make_intrans_file( os.path.join(path_dir, dir_bz_name + ".intrans")) if self.lpfac > 100: raise BoltztrapError( "lpfac higher than 100 and still a warning") self.run(path_dir_orig) #here we check if the doping levels were well computed #sometimes boltztrap mess this up because of two small energy grids analyzer = BoltztrapAnalyzer.from_files(path_dir) doping_ok = True for doping in ['n', 'p']: for c in analyzer.mu_doping[doping]: if len(analyzer.mu_doping[doping][c]) != len( analyzer.doping[doping]): doping_ok = False break if doping == 'p' and \ sorted(analyzer.mu_doping[doping][c], reverse=True) != analyzer.mu_doping[doping][c]: doping_ok = False break if doping == 'n' and sorted(analyzer.mu_doping[doping][c] ) != analyzer.mu_doping[doping][c]: doping_ok = False break if not doping_ok: self.energy_grid /= 10 print "lowers energy grid to " + str(self.energy_grid) if self.energy_grid < 0.00005: raise BoltztrapError( "energy grid lower than 0.00005 and still no good doping") self._make_intrans_file(path_dir + "/" + dir_bz_name + ".intrans") self.run(prev_sigma=None, path_dir=path_dir_orig) analyzer = BoltztrapAnalyzer.from_files(path_dir) #here, we test if a property (eff_mass tensor) converges if prev_sigma is None or \ abs(sum(analyzer.get_eig_average_eff_mass_tensor()['n']) / 3 - prev_sigma)\ / prev_sigma > 0.05: if prev_sigma is not None: print abs(sum(analyzer.get_eig_average_eff_mass_tensor()['n']) / 3 - prev_sigma) / prev_sigma, \ self.lpfac, \ analyzer.get_average_eff_mass_tensor(300, 1e18) self.lpfac *= 2 if self.lpfac > 100: raise BoltztrapError( "lpfac higher than 100 and still not converged") self._make_intrans_file(path_dir + "/" + dir_bz_name + ".intrans") self.run(prev_sigma=sum( analyzer.get_eig_average_eff_mass_tensor()['n']) / 3, path_dir=path_dir_orig) else: print "converged", \ abs(sum(analyzer.get_eig_average_eff_mass_tensor()['n'])/3 - prev_sigma) / prev_sigma, \ self.lpfac, analyzer.get_average_eff_mass_tensor(300, 1e18) return path_dir
import numpy as np import warnings from pymatgen.io.vaspio.vasp_input import Poscar from pymatgen.core.sites import PeriodicSite from pymatgen.core.structure import Structure from pymatgen.symmetry.finder import SymmetryFinder from pymatgen.core.periodic_table import DummySpecie from pymatgen.util.io_utils import which from pymatgen.util.decorators import requires logger = logging.getLogger(__name__) @requires( which('multienum.x') and which('makestr.x'), "EnumlibAdaptor requires the executables 'multienum.x' and " "'makestr.x' to be in the path. Please download the library at" "http://enum.sourceforge.net/ and follow the instructions in " "the README to compile these two executables accordingly.") class EnumlibAdaptor(object): """ An adaptor for enumlib. .. attribute:: structures List of all enumerated structures. """ amount_tol = 1e-5 def __init__(self,
def get_table(): """ Loads a lightweight lambda table for use in unit tests to reduce initialization time, and make unit tests insensitive to changes in the default lambda table. """ data_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", 'test_files', 'struct_predictor') json_file = os.path.join(data_dir, 'test_lambda.json') with open(json_file) as f: lambda_table = json.load(f) return lambda_table if which('multienum.x') and which('makestr.x'): enumlib_present = True else: enumlib_present = False class SuperTransformationTest(unittest.TestCase): def test_apply_transformation(self): tl = [SubstitutionTransformation({"Li+":"Na+"}), SubstitutionTransformation({"Li+":"K+"})] t = SuperTransformation(tl) coords = list() coords.append([0, 0, 0]) coords.append([0.375, 0.375, 0.375]) coords.append([.5, .5, .5])
__date__ = "Jul 22, 2012" import unittest import os from pymatgen.command_line.enumlib_caller import EnumlibAdaptor from pymatgen import Element, Structure from pymatgen.io.cifio import CifParser from pymatgen.transformations.standard_transformations import \ SubstitutionTransformation from pymatgen.util.io_utils import which from pymatgen.transformations.site_transformations import \ RemoveSitesTransformation enumlib_present = which('multienum.x') and which('makestr.x') @unittest.skipIf(not enumlib_present, "enum_lib not present.") class EnumlibAdaptorTest(unittest.TestCase): def test_init(self): test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", 'test_files') parser = CifParser(os.path.join(test_dir, "LiFePO4.cif")) struct = parser.get_structures(False)[0] subtrans = SubstitutionTransformation({'Li': {'Li': 0.5}}) adaptor = EnumlibAdaptor(subtrans.apply_transformation(struct), 1, 2) adaptor.run() structures = adaptor.structures self.assertEqual(len(structures), 86)
def which(program): """Returns full path to a executable. None if not found or not executable.""" return which(program)
""" Created on Jan 22, 2013 @author: Bharat Medasani """ import unittest import os from pymatgen.command_line.gulp_caller import * from pymatgen.core.structure import Structure from pymatgen.util.io_utils import which from pymatgen.io.vaspio.vasp_input import Poscar test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", 'test_files') gulp_present = which('gulp') @unittest.skipIf(not gulp_present, "gulp not present.") class GulpCallerInitTest(unittest.TestCase): def test_default_init(self): gulp_caller = GulpCaller() def test_explicit_path(self): gulp_caller = GulpCaller(gulp_present) @unittest.skipIf(not gulp_present, "gulp not present.") class GulpCallerTest(unittest.TestCase): def setUp(self):