ferroelectric-diode-model/src/transport_fed.py at main · krishkc5/ferroelectric-diode-model · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
import math

import scipy.constants as constants

from atomicunits import AtomicUnits


class FerroelectricDiode:
    def __init__(
        self,
        insulator_thickness,
        fe_thickness,
        dead_layer_thickness,
        top_electrode,
        bottom_electrode,
        insulator,
        ferroelectric,
        fe_model,
    ):
        self.insulator_thickness = insulator_thickness
        self.fe_thickness = fe_thickness
        self.dl_thickness = dead_layer_thickness
        self.barrier_thickness = insulator_thickness + fe_thickness + dead_layer_thickness
        self.insulator_k = insulator.k
        self.fe_k = ferroelectric.k
        self.dl_k = ferroelectric.k / 2
        self.top_k = top_electrode.k
        self.bottom_k = bottom_electrode.k
        # Optical (high-frequency) permittivities used for image-force lowering
        # (polarization_barrier_coupling.md Eq. 15) and Tsymbal-Kohlstedt metal
        # screening (Eq. 5/6). Metal eps_inf falls back to the lattice k field
        # (k=1 by default for free-electron metals - Drude tail; see audit row 24).
        self.insulator_eps_inf = (
            insulator.eps_inf if insulator.eps_inf is not None else insulator.k
        )
        self.fe_eps_inf = (
            ferroelectric.eps_inf if ferroelectric.eps_inf is not None else ferroelectric.k
        )
        self.top_eps_inf = getattr(top_electrode, "eps_inf", None) or top_electrode.k
        self.bottom_eps_inf = getattr(bottom_electrode, "eps_inf", None) or bottom_electrode.k
        self.insulator_chi = insulator.chi
        self.fe_chi = ferroelectric.chi
        self.top_work_fxn = top_electrode.w_f
        self.bottom_work_fxn = bottom_electrode.w_f
        self.top_fermi_e = top_electrode.e_f
        self.bottom_fermi_e = bottom_electrode.e_f
        self.top_n0 = top_electrode.n0
        self.bottom_n0 = bottom_electrode.n0
        self.insulator_m_eff = insulator.m_eff
        self.fe_m_eff = ferroelectric.m_eff
        self.top_m_eff = top_electrode.m_eff
        self.bottom_m_eff = bottom_electrode.m_eff
        self.fe_trap_depth = ferroelectric.trap_depth
        # HfO_x / Al2O3 deep-trap depth for PF in IL region. Falls back to
        # ferroelectric.trap_depth only if the insulator class lacks the field
        # (parameter_audit_20260506.md punch #4, #8).
        self.insulator_trap_depth = (
            insulator.trap_depth if insulator.trap_depth is not None else ferroelectric.trap_depth
        )
        self.name = (
            f"{top_electrode.name}-{insulator.name}-{ferroelectric.name}-{bottom_electrode.name}"
        )
        self.fe_model = fe_model

        if top_electrode.screening_len is None:
            self.top_screening_len = AtomicUnits.m_to_bohr(
                math.sqrt(
                    top_electrode.k
                    * 2
                    * constants.epsilon_0
                    * AtomicUnits.hartree_to_joule(top_electrode.e_f)
                    / (3 * constants.e**2 * AtomicUnits.convert_back_density(top_electrode.n0))
                )
            )
        else:
            self.top_screening_len = top_electrode.screening_len

        if bottom_electrode.screening_len is None:
            self.bottom_screening_len = AtomicUnits.m_to_bohr(
                math.sqrt(
                    bottom_electrode.k
                    * 2
                    * constants.epsilon_0
                    * AtomicUnits.hartree_to_joule(bottom_electrode.e_f)
                    / (3 * constants.e**2 * AtomicUnits.convert_back_density(bottom_electrode.n0))
                )
            )
        else:
            self.bottom_screening_len = bottom_electrode.screening_len

        self.dl_polarization = 0.0
        self.fe_polarization = self.fe_model.avg_polarization()

    def m_eff(self, x):
        top_screen_region = 5 * self.top_screening_len
        il_end = top_screen_region + self.insulator_thickness
        fe_end = il_end + self.fe_thickness
        dl_end = fe_end + self.dl_thickness

        if x <= top_screen_region:
            return self.top_m_eff
        if x <= il_end:
            return self.insulator_m_eff
        if x <= fe_end:
            return self.fe_m_eff
        if x <= dl_end:
            return self.fe_m_eff
        return self.bottom_m_eff

    def get_polarization(self):
        self.fe_polarization = self.fe_model.avg_polarization()
        return self.fe_polarization