예제 #1
0
    def test_InP_isotropic_E(self):
        print('\ntesting test_InP_isotropic_E...')
        expected_mu = {
            'ACD': 495952.86374,
            'IMP': 2066608.8522,
            'PIE': 1344563.563591,
            'POP': 34941.917715,
            'average': 31384.4998,
            'overall': 32195.345065
        }

        amset = Amset(calc_dir=self.temp_dir,
                      vasprun_file=os.path.join(self.InP_dir, 'vasprun.xml'),
                      material_params=self.InP_params,
                      model_params=self.model_params,
                      performance_params=self.performance_params,
                      dopings=[-2e15],
                      temperatures=[300],
                      integration='e',
                      loglevel=LOGLEVEL)
        amset.run(os.path.join(self.InP_dir, 'fort.123'),
                  kgrid_tp='very coarse')

        # check isotropy of transport and mobility values
        for mu in expected_mu.keys():
            self.assertLessEqual(
                np.std(amset.mobility['n'][mu][-2e15][300]) / \
                np.mean(amset.mobility['n'][mu][-2e15][300]), 0.06
            )
            self.assertLessEqual(
                abs(amset.mobility['n'][mu][-2e15][300][0] / expected_mu[mu] -
                    1), 0.02)
예제 #2
0
    def test_defaults(self):
        print('\ntesting test_defaults...')
        cal_dir = self.temp_dir
        data_dir = os.path.join(cal_dir, "run_data")
        amset = Amset(cal_dir, material_params={'epsilon_s': 12.9})
        amset.write_input_files()
        with open(os.path.join(data_dir, "material_params.json"), "r") as fp:
            material_params = json.load(fp)
        with open(os.path.join(data_dir, "model_params.json"), "r") as fp:
            model_params = json.load(fp)
        with open(os.path.join(data_dir, "performance_params.json"),
                  "r") as fp:
            performance_params = json.load(fp)

        self.assertEqual(material_params['epsilon_inf'], None)
        self.assertEqual(material_params['W_POP'], None)
        self.assertEqual(material_params['scissor'], 0.0)
        self.assertEqual(material_params['P_PIE'], 0.15)
        self.assertEqual(material_params['E_D'], None)
        self.assertEqual(material_params['N_dis'], 0.1)

        self.assertEqual(model_params['bs_is_isotropic'], True)
        self.assertEqual(model_params['elastic_scats'], ['IMP', 'PIE'])
        self.assertEqual(model_params['inelastic_scats'], [])

        self.assertEqual(performance_params['max_nbands'], None)
        self.assertEqual(performance_params['max_normk0'], None)
        self.assertEqual(performance_params['dE_min'], 0.0001)
        self.assertEqual(performance_params['dos_kdensity'], 5500)
        self.assertEqual(performance_params['dos_bwidth'], 0.075)
예제 #3
0
    def test_GaAs_isotropic_E_plus_serialize_deserialize(self):
        expected_mu = {
            'ACD': 459623.2946,
            'IMP': 2932848.2466,
            'PIE': 2142320.5897,
            'POP': 16329.22998,
            'average': 15570.668,
            'overall': 15750.11293,
        }
        expected_seebeck = -1013.54825
        performance_params = deepcopy(self.performance_params)
        performance_params['max_nvalleys'] = 1
        coeff_file = os.path.join(self.GaAs_dir, 'fort.123')
        amset = Amset.from_vasprun(os.path.join(self.GaAs_dir, 'vasprun.xml'),
                                   self.GaAs_params,
                                   interpolation='boltztrap1',
                                   kgrid_type='very coarse',
                                   coeff_file=coeff_file,
                                   calc_dir=self.temp_dir,
                                   model_params=self.model_params,
                                   performance_params=performance_params,
                                   dopings=[-2e15],
                                   temperatures=[300],
                                   integration='e',
                                   log_level=LOGLEVEL)
        amset.run()
        kgrid = amset.kgrid

        # check general characteristics of the grid
        self.assertEqual(kgrid['n']['velocity'][0].shape[0], 78)
        mean_v = np.mean(kgrid['n']['velocity'][0], axis=0)
        self.assertLessEqual(np.std(mean_v),
                             50.00)  # isotropic BS after removing points
        self.assertAlmostEqual(mean_v[0], 113757441.8667, places=1)  # velocity

        # check mobility values
        for mu in expected_mu.keys():
            self.assertLessEqual(
                np.std(  # test isotropic
                    amset.mobility['n'][mu][-2e15][300]) /
                np.mean(amset.mobility['n'][mu][-2e15][300]),
                0.1)
            self.assertLessEqual(
                abs(amset.mobility['n'][mu][-2e15][300][0] / expected_mu[mu] -
                    1), 0.01)
        self.assertLess(
            abs(amset.seebeck['n'][-2e15][300][0] / expected_seebeck - 1),
            0.04)

        # just testing write to file methods:
        amset.as_dict()
        filepath = amset.to_file(directory='run_data')
        amset.to_csv()
        amset.grids_to_json()

        # deserialization test:
        amset.from_file(filepath)
예제 #4
0
    def test_parabolic_bands(self):
        print('\ntesting test_parabolic_bands...')
        mass = 0.25
        c = -2e15
        temperatures = [300]
        model_params = deepcopy(self.model_params)
        model_params['parabolic_bands'] = [[[[0.0, 0.0, 0.0], [0.0, mass]]]]
        amset = Amset(calc_dir=self.temp_dir,
                      vasprun_file=os.path.join(self.GaAs_dir, 'vasprun.xml'),
                      material_params=self.GaAs_params,
                      model_params=model_params,
                      performance_params=self.performance_params,
                      dopings=[c],
                      temperatures=temperatures,
                      integration='k',
                      loglevel=LOGLEVEL)
        amset.run(os.path.join(self.GaAs_dir, 'fort.123'), kgrid_tp='coarse')

        # check fermi level
        # density calculation source: http://hib.iiit-bh.ac.in/Hibiscus/docs/iiit/NBDB/FP008/597_Semiconductor%20in%20Equilibrium&pn%20junction1.pdf
        # density of states source: http://web.eecs.umich.edu/~fredty/public_html/EECS320_SP12/DOS_Derivation.pdf
        for T in temperatures:
            N_c = 2 * (2 * np.pi * mass * 9.11e-31 * 1.3806e-23 * T /
                       ((6.626e-34)**2))**1.5
            expected_fermi_level = amset.cbm_vbm['n']["energy"] - (
                1.3806e-23 * T * np.log(N_c / (-c * 1e6)) * 6.242e18)

            diff = abs(amset.fermi_level[c][T] - expected_fermi_level)
            avg = (amset.fermi_level[c][T] + expected_fermi_level) / 2

            # setting kgrid_tp tp fine or very fine would drive the difference
            # closer to zero; however we set a loose 6.5% for quicker testing:
            self.assertTrue(diff / avg < 0.065)

            diff = abs(np.array(amset.mobility['n']['ACD'][c][T]) - \
                       np.array(amset.mobility['n']['SPB_ACD'][c][T]))
            avg = (amset.mobility['n']['ACD'][c][T] + \
                   amset.mobility['n']['SPB_ACD'][c][T]) / 2
            self.assertTrue((diff / avg <= 0.025).all())
예제 #5
0
    def test_GaAs_anisotropic(self):
        print('\ntesting test_GaAs_anisotropic...')
        expected_mu = {
            'ACD': 378435.7259,
            'IMP': 2525835.398584,
            'PIE': 924827.3862,
            'POP': 22861.9211,
            'average': 20894.0549,
            'overall': 21184.02287,
        }
        expected_seebeck = -1026.62730
        amset = Amset(calc_dir=self.temp_dir,
                      vasprun_file=os.path.join(self.GaAs_dir, 'vasprun.xml'),
                      material_params=self.GaAs_params,
                      model_params={
                          'bs_is_isotropic': False,
                          'elastic_scats': ['ACD', 'IMP', 'PIE'],
                          'inelastic_scats': ['POP']
                      },
                      performance_params=self.performance_params,
                      dopings=[-2e15],
                      temperatures=[300],
                      integration='e',
                      loglevel=LOGLEVEL)
        amset.run(os.path.join(self.GaAs_dir, 'fort.123'), kgrid_tp='coarse')

        # check mobility values
        for mu in expected_mu.keys():
            self.assertLessEqual(np.std(  # GaAs band structure is isotropic
                amset.mobility['n'][mu][-2e15][300]), 0.08*\
                np.mean(amset.mobility['n'][mu][-2e15][300]))
            self.assertLess(
                abs(amset.mobility['n'][mu][-2e15][300][0] - expected_mu[mu]) /
                expected_mu[mu], 0.06)
        self.assertLess(
            abs(amset.seebeck['n'][-2e15][300][0] / expected_seebeck - 1),
            0.06)
예제 #6
0
    def test_GaAs_isotropic_k(self):
        print('\ntesting test_GaAs_isotropic_k...')
        expected_mu = {
            'ACD': 1303937.379,
            'IMP': 2414.127,
            'PIE': 2979626.74,
            'POP': 18309.123,
            'average': 2127.893,
            'overall': 2120.471
        }
        performance_params = dict(self.performance_params)
        performance_params['fermi_kgrid_tp'] = 'very coarse'
        amset = Amset(calc_dir=self.temp_dir,
                      vasprun_file=os.path.join(self.GaAs_dir, 'vasprun.xml'),
                      material_params=self.GaAs_params,
                      model_params=self.model_params,
                      performance_params=performance_params,
                      dopings=[-3e13],
                      temperatures=[300],
                      integration='k',
                      loglevel=LOGLEVEL)
        amset.run(os.path.join(self.GaAs_dir, 'fort.123'),
                  kgrid_tp='very coarse')
        mobility = amset.mobility
        self.assertAlmostEqual(  # compare with normalized fermi w.r.t. the CBM
            amset.fermi_level[-3e13][300] - amset.cbm_vbm["n"]["energy"],
            -0.3429418, 3)

        # check mobility values
        for mu in expected_mu.keys():
            diff = np.std(mobility['n'][mu][-3e13][300])
            avg = np.mean(mobility['n'][mu][-3e13][300])
            self.assertLess(diff / avg, 0.005)
            self.assertLessEqual(
                abs(amset.mobility['n'][mu][-3e13][300][0] / expected_mu[mu] -
                    1), 0.01)
예제 #7
0
    def test_GaAs_isotropic_E_plus_serialize_deserialize(self):
        print('\ntesting test_GaAs_isotropic_E_plus_serialize_deserialize...')
        expected_mu = {
            'ACD': 459623.2946,
            'IMP': 2932848.2466,
            'PIE': 2142320.5897,
            'POP': 16329.22998,
            'average': 15570.668,
            'overall': 15750.11293,
        }
        expected_seebeck = -1013.54825
        performance_params = deepcopy(self.performance_params)
        performance_params['max_nvalleys'] = 1
        amset = Amset(calc_dir=self.temp_dir,
                      vasprun_file=os.path.join(self.GaAs_dir, 'vasprun.xml'),
                      material_params=self.GaAs_params,
                      model_params=self.model_params,
                      performance_params=performance_params,
                      dopings=[-2e15],
                      temperatures=[300],
                      integration='e',
                      loglevel=LOGLEVEL)
        amset.run(os.path.join(self.GaAs_dir, 'fort.123'),
                  kgrid_tp='very coarse')
        kgrid = amset.kgrid

        # check general characteristics of the grid
        self.assertEqual(kgrid['n']['velocity'][0].shape[0], 78)
        mean_v = np.mean(kgrid['n']['velocity'][0], axis=0)
        self.assertLessEqual(np.std(mean_v),
                             50.00)  # isotropic BS after removing points
        self.assertAlmostEqual(mean_v[0], 113757441.8667, places=1)  # velocity

        # check mobility values
        for mu in expected_mu.keys():
            self.assertLessEqual(
                np.std(  # test isotropic
                    amset.mobility['n'][mu][-2e15][300]) /
                np.mean(amset.mobility['n'][mu][-2e15][300]),
                0.1)
            self.assertLessEqual(
                abs(amset.mobility['n'][mu][-2e15][300][0] / expected_mu[mu] -
                    1), 0.01)
        self.assertLess(
            abs(amset.seebeck['n'][-2e15][300][0] / expected_seebeck - 1),
            0.04)

        # just testing write to file methods:
        amset.as_dict()
        amset.to_file(dir_name='run_data')
        amset.to_csv()
        amset.to_json()

        # deserialization test:
        amset.from_file(path=os.path.join(amset.calc_dir, 'run_data'))

        print(
            '\ntesting test_GaAs_isotropic_E_... w/ boltztrap2 interpolation')
        # test boltztrap2 once & its consistency with boltztrap1 interpolations
        # the difference seem to originate from the difference in Fermi levels
        performance_params["interpolation"] = "boltztrap2"
        amset = Amset(calc_dir=self.temp_dir,
                      vasprun_file=os.path.join(self.GaAs_dir, 'vasprun.xml'),
                      material_params=self.GaAs_params,
                      model_params=self.model_params,
                      performance_params=performance_params,
                      dopings=[-2e15],
                      temperatures=[300],
                      integration='e',
                      loglevel=LOGLEVEL)
        amset.run(os.path.join(self.GaAs_dir, 'fort.123'),
                  kgrid_tp='very coarse')
        kgrid = amset.kgrid

        # check general characteristics of the grid
        self.assertEqual(kgrid['n']['velocity'][0].shape[0], 78)
        mean_v = np.mean(kgrid['n']['velocity'][0], axis=0)
        self.assertLessEqual(np.std(mean_v),
                             50.00)  # isotropic BS after removing points
        self.assertLessEqual(abs(mean_v[0] / 113757441.8667 - 1),
                             0.03)  # velocity

        # check mobility values
        for mu in expected_mu.keys():
            self.assertLessEqual(
                np.std(  # test isotropic
                    amset.mobility['n'][mu][-2e15][300]) /
                np.mean(amset.mobility['n'][mu][-2e15][300]),
                0.1)
            self.assertLessEqual(
                abs(amset.mobility['n'][mu][-2e15][300][0] / expected_mu[mu] -
                    1), 0.07)
        self.assertLess(
            abs(amset.seebeck['n'][-2e15][300][0] / expected_seebeck - 1), 0.2)
예제 #8
0
"""
This example shows how to read a calculations from files for post-processing.
For example for plotting various scattering rates at difference concentrations
and temperatures.

Note that this should be run after GaAs example is run with the .to_file()
method called after the calculation.
"""
import os
from amset.core import Amset

if __name__ == "__main__":
    amset = Amset.from_file(path=os.path.join("..", "GaAs", "run_data"),
                            filename="amsetrun.json")

    amset.plot(k_plots=['energy', 'velocity'],
               e_plots=['velocity', 'ACD', 'S_i', 'S_o'] + amset.elastic_scats,
               direction=['x', 'z'],
               carrier_types=amset.all_types)
예제 #9
0
파일: PbTe.py 프로젝트: fraricci/amset
    model_params = {"bs_is_isotropic": True,
                    "elastic_scatterings": ["ACD", "IMP", "PIE"],
                    "inelastic_scatterings": ["POP"]}

    material_params = {"epsilon_s": 44.4,
                       "epsilon_inf": 25.6,
                       "W_POP": 10.0,
                       "C_el": 128.8,
                       "E_D": {"n": 4.0, "p": 4.0}}
    PbTe_dir = os.path.join("..", "..", "test_files", "PbTe_mp-19717")
    coeff_file = os.path.join(PbTe_dir, "fort.123")

    amset = Amset(calc_dir='.',
                  vasprun_file=os.path.join(PbTe_dir, "vasprun.xml"),
                  material_params=material_params,
                  model_params = model_params,
                  performance_params={"max_nbands": 1, "max_nvalleys": 1},
                  dopings= [1e19],
                  temperatures=[300, 600])

    # running Amset
    amset.run_profiled(coeff_file=coeff_file, kgrid_tp="coarse")

    # generating files and outputs
    amset.write_input_files()
    amset.to_csv()
    amset.plot(k_plots=['energy'], e_plots='all',
               show_interactive=True,
               carrier_types=amset.all_types)
    amset.to_file()
    amset.to_json(kgrid=True, trimmed=True, max_ndata=50, n0=0)
예제 #10
0
LINE_DENSITY = 30


if __name__ == '__main__':
    test_dir = os.path.join(abs_dir, '..', 'test_files')
    vrun_file = os.path.join(test_dir, comp_to_dirname[COMPOUND], 'vasprun.xml')
    coeff_file = os.path.join(test_dir, comp_to_dirname[COMPOUND], 'fort.123')
    vrun = Vasprun(vrun_file)
    formula = vrun.final_structure.composition.reduced_formula

    dopings = [1e20, -1e20]
    temperatures = global_temperatures[formula]
    word_map = {'p': 'vb0', 'n': 'cb0'}

    amset = Amset(calc_dir='.', material_params={'epsilon_s': 12.9},
              temperatures=temperatures, dopings=dopings,
              performance_params={'Ecut': 1.0}
                  )
    amset.read_vrun(vasprun_file=vrun_file)
    amset.update_cbm_vbm_dos(coeff_file)
    extrema = amset.find_all_important_points(coeff_file,
                                              nbelow_vbm=0,
                                              nabove_cbm=0,
                                              interpolation="boltztrap1",
                                              line_density=LINE_DENSITY
                                              )

    hsk = HighSymmKpath(vrun.final_structure)
    hs_kpoints , _ = hsk.get_kpoints(line_density=LINE_DENSITY)
    hs_kpoints = kpts_to_first_BZ(hs_kpoints)

    bs = vrun.get_band_structure()