示例#1
0
def calculate(args):
    Si, Electrode, T, V_p = args
    sample_data_dir = join(dirname(__file__), '03-data')
    db_name = '03_Au_nSi_BW_transient' + '_%02.2fVp_%02.2fVrb_%03.2fK' % (
        V_p, abs(V_rb), T) + '.db'
    db_name = join(sample_data_dir, db_name)
    MyProject = Project(db_name=db_name,
                        backend='sqlite',
                        hostname='',
                        overwrite=False)
    MyDiode = SchottkyDiode(MyProject,
                            'Au-Si_BW',
                            Electrode,
                            Si,
                            DeadLayer=1.5e-7,
                            L=5e-6)
    MyDiode.set_T(T)
    MyDiode.set_Va(V_p)
    print T

    type_sign = -1 if MyDiode.Semiconductor.dop_type == 'n' else 1
    Psi = Psi_approx(MyDiode.L, -(MyDiode.V_bi(eV=True) + type_sign * V_p),
                     0.0)

    Psi, E, z_nodes, rho_err_points, Vd, Vd_err, J, J_err, \
        BI_F, dopants_F, ic_id = Poisson.Reccurent_Poisson_solver(MyDiode, Psi, Vd_error=1e-6,
                                                                  equilibrium_filling=True, t=mp.inf,
                                                                  initial_condition_id=-1,
                                                                  rho_rel_err=Poisson_rel_err, max_iter=100,
                                                                  debug=False)
    return db_name
示例#2
0
def calculate(args):
    Si, Electrode, T, V_p, V_rb = args
    sample_data_dir = join(dirname(__file__), '03-data')
    db_name = '03_Au_nSi_BW_transient' + '_%02.2fVp_%02.2fVrb_%03.2fK' % (
        V_p, abs(V_rb), T) + '.db'
    db_name = join(sample_data_dir, db_name)
    MyProject = Project(db_name=db_name,
                        backend='sqlite',
                        hostname='',
                        overwrite=False)
    MyDiode = SchottkyDiode(MyProject,
                            'Au-Si_BW',
                            Electrode,
                            Si,
                            DeadLayer=1.5e-7,
                            L=5e-6)
    MyDiode.set_T(T)
    MyDiode.set_Va(V_p)

    type_sign = -1 if MyDiode.Semiconductor.dop_type == 'n' else 1
    Psi = Psi_approx(MyDiode.L, -(MyDiode.V_bi(eV=True) + type_sign * V_p),
                     0.0)

    Psi, E, z_nodes, rho_err_points, Vd, Vd_err, J, J_err, \
        BI_F, dopants_F, ic_id = Poisson.Reccurent_Poisson_solver(MyDiode, Psi, Vd_error=1e-6,
                                                                  equilibrium_filling=True, t=mp.inf,
                                                                  initial_condition_id=-1,
                                                                  rho_rel_err=Poisson_rel_err, max_iter=100,
                                                                  debug=False)

    #plt.plot(z_nodes, -Psi(z_nodes), 'r-o')
    #plt.show()

    MyDiode.set_Va(V_rb)
    Psi, E, z_nodes, rho_err_points, Vd, Vd_err, J, J_err, \
        BI_F, dopants_F, ic_id = Poisson.Reccurent_Poisson_solver(MyDiode, Psi, Vd_error=1e-6,
                                                                  equilibrium_filling=False, fast_traps=['Phosphorus'],
                                                                  t=0.0,
                                                                  initial_condition_id=ic_id,
                                                                  rho_rel_err=Poisson_rel_err, max_iter=100,
                                                                  debug=False)

    #plt.plot(z_nodes, -Psi(z_nodes), 'r-o')
    #plt.show()

    t_points, potential_t, field_d, z_t, diode_voltage_drop_t, current_density_t, \
        bonding_interfaces_f_t, dopants_f_t, last_state_id = Kinetics.traps_kinetics(MyDiode, ic_id,
                                                                                     1e-9, 10e-3, 100e-3,
                                                                                     fast_traps=['Phosphorus'],
                                                                                     rho_rel_err=Poisson_rel_err,
                                                                                     df_threshold=1e-2, debug=True)

    return [T, t_points, bonding_interfaces_f_t, dopants_f_t]
示例#3
0
print(db_name)
MyProject = Project(db_name=db_name,
                    backend='sqlite',
                    hostname='',
                    overwrite=False)
MyDiode = SchottkyDiode(MyProject,
                        'Au-Si_BW',
                        Electrode,
                        Si,
                        DeadLayer=1.5e-7,
                        L=5e-6)
MyDiode.set_T(T)
MyDiode.set_Va(V_p)

type_sign = -1 if MyDiode.Semiconductor.dop_type == 'n' else 1
Psi = Psi_approx(MyDiode.L, -(MyDiode.V_bi(eV=True) + type_sign * V_p), 0.0)

Psi, E, z_nodes, rho_err_points, Vd, Vd_err, J, J_err, \
    BI_F, dopants_F, ic_id = Poisson.Reccurent_Poisson_solver(MyDiode, Psi, Vd_error=1e-6,
                                                              equilibrium_filling=True, t=mp.inf,
                                                              initial_condition_id=-1,
                                                              rho_rel_err=Poisson_rel_err, max_iter=100,
                                                              debug=False)
z_nodes = np.linspace(0, 3e-6, num=500, dtype=np.float)
_, (ax1, ax2) = plt.subplots(2, sharex=True)
Visual.BandsBendingDiagram(ax1,
                           MyDiode,
                           Psi,
                           Vd,
                           z_nodes,
                           BI_F,
示例#4
0
def calculate_for_temperature(args):
    silicon, electrode, temperature, voltage_range = args
    print temperature
    db_name = prefix + '_dc_%03.2fK.db' % temperature
    db_name = join(data_dir, db_name)
    project = Project(db_name=db_name,
                      backend='sqlite',
                      hostname='',
                      overwrite=False)
    diode = SchottkyDiode(project,
                          'Au-nSi_BW',
                          electrode,
                          silicon,
                          DeadLayer=1.5e-7,
                          L=5e-6)
    diode.set_T(temperature)
    potential = []
    field = []
    diode_voltage = []
    diode_voltage_error = []
    current_density = []
    current_density_error = []
    bonding_interface_f = {}
    dopants_f_sum = {}
    z = []
    dopants_f = []
    for voltage in voltage_range:
        diode.set_Va(voltage)
        type_sign = -1 if silicon.dop_type == 'n' else 1
        potential_i = Psi_approx(diode.L,
                                 -(diode.V_bi(eV=True) + type_sign * voltage),
                                 0.0)
        potential_i, field_i, z_nodes, rho_err_points, \
            diode_voltage_i, diode_voltage_error_i, \
            current_density_i, current_density_error_i, \
            bonding_interface_f_i, dopants_f_i, \
            measurement_id = Poisson.Reccurent_Poisson_solver(diode, potential_i, Vd_error=1e-6,
                                                              equilibrium_filling=True, t=mp.inf,
                                                              initial_condition_id=-1,
                                                              rho_rel_err=poisson_relative_error, max_iter=100,
                                                              debug=False)
        potential.append(potential_i)
        field.append(field_i)
        diode_voltage.append(diode_voltage_i)
        diode_voltage_error.append(diode_voltage_error_i)
        current_density.append(current_density_i)
        current_density_error.append(current_density_i)
        z.append(z_nodes)
        dopants_f.append(dopants_f_i)
        for trap_key in bonding_interface_f_i.keys():
            try:
                bonding_interface_f[trap_key].append(
                    bonding_interface_f_i[trap_key])
            except KeyError:
                bonding_interface_f[trap_key] = [
                    bonding_interface_f_i[trap_key]
                ]
        for dopant_key in dopants_f_i.keys():
            try:
                dopants_f_sum[dopant_key].append(
                    np.sum(dopants_f_i[dopant_key]))
            except KeyError:
                dopants_f_sum[dopant_key] = [np.sum(dopants_f_i[dopant_key])]

    data = {
        temperature: {
            'applied_voltage': voltage_range,
            'diode_voltage': diode_voltage,
            'diode_voltage_error': diode_voltage_error,
            'current_density': current_density,
            'current_density_error': current_density_error
        }
    }
    for trap_key in bonding_interface_f.keys():
        data[temperature][trap_key] = bonding_interface_f[trap_key]
    for dopant_key in dopants_f_sum.keys():
        data[temperature][dopant_key + '_sum'] = dopants_f_sum[dopant_key]
    return potential, field, data, z, dopants_f