def load(self):
self.contacts=self.epi.contacts
self.tab.clear()
self.tab.setHorizontalHeaderLabels([_("Name"),_("Top/Bottom"),_("Applied\nvoltage"),_("Start")+" (m)", _("Width")+" (m)" , _("Contact resistance\n")+" (Ohms m^2)",_("Shunt resistance")+"\n(Ohms m^2)",_("Charge density/\nFermi-offset"),_("Majority\ncarrier"),_("ve0 (m/s)"),_("vh0 (m/s)"),_("Physical\nmodel"),_("ID")])
self.tab.setColumnHidden(5,True)
self.tab.setColumnHidden(6,True)
self.tab.horizontalHeader().setFixedHeight(60)
self.contacts.load()
if get_mesh().get_zpoints()!=1 or get_mesh().get_xpoints()!=1:
self.hide_cols(False)
else:
self.hide_cols(True)
#contacts_print()
i=0
for c in self.contacts.contacts:
self.add_row()
if c.position=="top" or c.position=="bottom":
start=str(c.x0)
width=str(c.dx)
else:
start=str(c.y0)
width=str(c.dy)
self.set_row(i,str(c.name),c.position,c.applied_voltage_type,c.applied_voltage,start,width,str(c.contact_resistance_sq),c.shunt_resistance_sq,str(c.np),str(c.charge_type),str(c.ve0),str(c.vh0),str(c.physical_model),c.id )
i=i+1
self.show_hide_cols()
def __init__(self):
QWidgetSavePos.__init__(self, "dim_editor")
self.setWindowTitle(
_("xz dimension editor") + " https://www.gpvdm.com")
self.setWindowIcon(icon_get("dimensions"))
self.resize(400, 200)
self.cost_window = False
self.main_vbox = QVBoxLayout()
self.toolbar = QToolBar()
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.toolbar.setIconSize(QSize(42, 42))
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolbar.addWidget(spacer)
self.help = QAction(icon_get("internet-web-browser"), _("Help"), self)
self.toolbar.addAction(self.help)
self.main_vbox.addWidget(self.toolbar)
self.widget0 = QWidget()
self.widget0_hbox = QHBoxLayout()
self.widget0.setLayout(self.widget0_hbox)
self.widget0_label = QLabel("x size")
self.widget0_hbox.addWidget(self.widget0_label)
self.widget0_edit = QLineEdit()
self.widget0_edit.setText(str(get_mesh().get_xlen()))
self.widget0_edit.textChanged.connect(self.apply)
self.widget0_hbox.addWidget(self.widget0_edit)
self.widget0_label = QLabel("m")
self.widget0_hbox.addWidget(self.widget0_label)
self.main_vbox.addWidget(self.widget0)
self.widget1 = QWidget()
self.widget1_hbox = QHBoxLayout()
self.widget1.setLayout(self.widget1_hbox)
self.widget1_label = QLabel("z size")
self.widget1_hbox.addWidget(self.widget1_label)
self.widget1_edit = QLineEdit()
self.widget1_edit.setText(str(get_mesh().get_zlen()))
self.widget1_edit.textChanged.connect(self.apply)
self.widget1_hbox.addWidget(self.widget1_edit)
self.widget1_label = QLabel("m")
self.widget1_hbox.addWidget(self.widget1_label)
self.main_vbox.addWidget(self.widget1)
#self.tab.itemSelectionChanged.connect(self.callback_tab_selection_changed)
self.setLayout(self.main_vbox)
def draw_light_profile(self):
self.gl_objects_remove_regex("light_profile")
name = inp_get_token_value(os.path.join(get_sim_path(), "light.inp"),
"#light_profile")
if name != "box":
epi = get_epi()
s = shape()
s.type = name
s.load_triangles()
s.triangles.data = triangles_remove_below(s.triangles.data, 0.1)
a = gl_base_object()
a.id = ["light_profile"]
a.type = "open_triangles"
a.x = gl_scale.project_m2screen_x(0)
a.y = gl_scale.project_m2screen_y(0)
a.z = gl_scale.project_m2screen_z(0)
a.dx = 1.0
a.dy = scale_get_ymul() * 1.0
a.dz = 1.0
a.r = 0.0
a.g = 1.0
a.b = 0.0
a.alpha = 1.0
my_vec = vec()
my_vec.x = get_mesh().get_xlen()
my_vec.y = epi.ylen() * 1.0
my_vec.z = get_mesh().get_zlen()
t = triangles_mul_vec(s.triangles.data, my_vec)
my_vec = vec()
my_vec.x = 0.0
my_vec.y = -epi.ylen() * 3.0
my_vec.z = 0.0
t = triangles_add_vec(t, my_vec)
a.triangles = scale_trianges_m2screen(t)
#triangles_mul_vec(triangles_flip_in_box(s.triangles.data),my_vec)
#print("bing!",gl_scale.project_m2screen_x(0))
self.gl_objects_add(a)
def device_mask(self,x,y,z): #print(y) mesh=get_mesh() #1D case if mesh.x.points==1 and mesh.z.points==1: return True #check for contact layer=self.get_layer_by_cordinate(y) #print(y,layer) l=self.layers[layer] if l.layer_type=="contact" and layer==0: for c in self.contacts.contacts: if c.position=="top": if x>=c.x0 and x<=c.x0+c.dx: return True return False if l.layer_type=="contact" and layer==len(self.layers)-1: for c in self.contacts.contacts: if c.position=="bottom": if x>=c.x0 and x<=c.x0+c.dx: return True return False return True
def project(self, col0, col1):
mesh = get_mesh().y
x, y = mesh.calculate_points()
lay = mesh.mesh_cal_epi_layers(self.epi)
device_start = self.epi.get_device_start()
line = 0
layer = self.epi.get_next_dos_layer(-1)
for i in range(0, len(x)):
if x[i] + device_start > self.epi.layers[layer].end:
layer = layer + 1
line = line + 1
try:
Nad0 = float(self.tab.item(line, col0).text())
Nad1 = float(self.tab.item(line, col1).text())
except:
Nad0 = 0.0
Nad1 = 0.0
dy = self.epi.layers[layer].dy
y[i] = Nad0 + (Nad1 - Nad0) * (
x[i] - self.epi.layers[layer].start + device_start) / dy
return x, y
def menu_energy_slice_dump(self):
obj = self.gl_objects_get_first_selected()
if obj != None:
s = obj.id_starts_with("mesh").split(":")
x = int(s[1])
y = int(s[2])
z = int(s[3])
if self.dump_energy_slice_xpos == x and self.dump_energy_slice_ypos == y and self.dump_energy_slice_zpos == z:
self.dump_energy_slice_xpos = -1
self.dump_energy_slice_ypos = -1
self.dump_energy_slice_zpos = -1
else:
self.dump_energy_slice_xpos = x
self.dump_energy_slice_ypos = y
self.dump_energy_slice_zpos = z
mesh = get_mesh()
f = inp()
f.load("dump.inp")
f.replace("#dump_energy_slice_xpos", str(x))
f.replace("#dump_energy_slice_ypos",
str(len(mesh.y.points) - 1 - y))
f.replace("#dump_energy_slice_zpos", str(z))
f.save()
self.gl_objects_remove_regex("mesh")
self.draw_mesh()
self.do_draw()
def layer_add(self):
obj=self.gl_objects_get_first_selected()
if obj!=None:
epi=get_epi()
s=epi.find_shape_by_id(obj.id[0])
if type(s)==epi_layer or type(s)==shape:
layer_index=epi.find_layer_by_id(obj.id[0])
new_filename=epi.new_electrical_file("shape")+".inp"
orig_filename=os.path.join(get_default_material_path(),"shape.inp")
inp_copy_file(os.path.join(get_sim_path(),new_filename),os.path.join(get_sim_path(),orig_filename))
mesh=get_mesh()
my_shape=shape()
my_shape.load(new_filename)
my_shape.dy=epi.layers[layer_index].dy
my_shape.dx=mesh.get_xlen()
my_shape.dz=mesh.get_zlen()
my_shape.shape_electrical=epi.gen_new_electrical_file("electrical")
my_shape.shape_nx=1
my_shape.shape_ny=1
my_shape.shape_nz=1
my_shape.name="New shape"
my_shape.save()
epi.layers[layer_index].shapes.append(my_shape)
epi.save()
self.force_redraw()
def change_dir_and_refresh_interface(self, new_dir):
used_files_add(os.path.join(new_dir, "sim.gpvdm"))
self.scan_human_labels.clear()
inp_callbacks_clear()
get_watch().reset()
self.splash.inc_value()
self.scan_human_labels.populate_from_known_tokens()
self.splash.inc_value()
self.splash.inc_value()
set_sim_path(new_dir)
self.splash.inc_value()
calculate_paths()
self.splash.inc_value()
epi = get_epi()
epi.load(get_sim_path())
self.splash.inc_value()
self.splash.inc_value()
if get_mesh().load(epi) == False:
error_dlg(
self,
_("There was a problem loading the electrical mesh, I suspect you are trying to open a file generated in a very old version of gpvdm."
))
return
self.statusBar().showMessage(get_sim_path())
self.splash.inc_value()
self.notebook.load()
self.update_interface()
self.enable_disable_buttons()
self.splash.inc_value()
if self.notebook.terminal != None:
self.my_server.set_terminal(self.notebook.terminal)
if self.notebook.update_display_function != None:
self.my_server.set_display_function(
self.notebook.update_display_function)
self.scan_human_labels.add_item("sim.inp", "#simmode", "sim mode")
self.scan_human_labels.add_item("light.inp", "#Psun",
"light intensity")
#scan_populate_from_file("light.inp")
self.ribbon.update()
self.splash.inc_value()
if self.notebook.is_loaded() == True:
self.l.run()
self.notebook.tab_main.three_d.update()
get_watch().rebase()
def set_m2screen():
global x_mul
global y_mul
global z_mul
global device_x
global device_y
global device_z
global x_start
global y_start
global z_start
mesh_max = 30
epi = get_epi()
x_len = get_mesh().get_xlen()
z_len = get_mesh().get_zlen()
z_mul = scale(z_len)
x_mul = scale(x_len)
#print(x_mul,z_mul)
mul = x_mul
if z_len < x_len:
mul = z_mul
x_mul = mul
z_mul = mul
#print("m",mul)
#z_mul=mul
#x_mul=mul
#print(x_len*x_mul,z_len*z_mul)
if z_len * z_mul > mesh_max:
z_mul = mesh_max / z_len
if x_len * x_mul > mesh_max:
x_mul = mesh_max / x_len
y_mul = device_y / epi.ylen()
device_x = get_mesh().get_xlen() * x_mul
device_z = get_mesh().get_zlen() * z_mul
x_start = -device_x / 2.0
z_start = -device_z / 2.0
y_start = device_y
def save(self): lines=self.gen_output() inp_save(os.path.join(get_sim_path(),"epitaxy.inp"),lines,id="epitaxy") for l in epi.layers: l.save() ymesh=get_mesh().y ymesh.do_remesh(self.ylen_active())
def get_device_start(self):
if get_mesh().y.circuit_model==True:
return 0.0
pos=0.0
for i in range(0, len(self.layers)):
if self.layers[i].dos_file.startswith("dos")==True:
return pos
pos=pos+self.layers[i].dy
return None
def update_dim(self):
if get_mesh().get_xpoints() == 1 and get_mesh().get_zpoints() == 1:
self.one_d.setEnabled(False)
self.two_d.setEnabled(True)
self.three_d.setEnabled(True)
self.emesh_editor_y.setEnabled(True)
self.emesh_editor_x.setEnabled(False)
self.emesh_editor_z.setEnabled(False)
self.emesh_editor_y.show()
self.emesh_editor_x.hide()
self.emesh_editor_z.hide()
if get_mesh().get_xpoints() > 1 and get_mesh().get_zpoints() == 1:
self.one_d.setEnabled(True)
self.two_d.setEnabled(False)
self.three_d.setEnabled(True)
self.emesh_editor_y.setEnabled(True)
self.emesh_editor_x.setEnabled(True)
self.emesh_editor_z.setEnabled(False)
self.emesh_editor_y.show()
self.emesh_editor_x.show()
self.emesh_editor_z.hide()
if get_mesh().get_xpoints() > 1 and get_mesh().get_zpoints() > 1:
self.one_d.setEnabled(True)
self.two_d.setEnabled(True)
self.three_d.setEnabled(False)
self.emesh_editor_y.setEnabled(True)
self.emesh_editor_x.setEnabled(True)
self.emesh_editor_z.setEnabled(True)
self.emesh_editor_y.show()
self.emesh_editor_x.show()
self.emesh_editor_z.show()
self.emit_now()
def epitaxy_mesh_update():
mesh = get_mesh().y
if len(mesh.layers) == 1:
tot = 0.0
for i in range(0, epitaxy_get_layers()):
width = float(epitaxy_get_dy(i))
dos_layer = epitaxy_get_dos_file(i)
print(dos_layer, width)
if dos_layer.startswith("dos") == True:
tot = tot + width
mesh.layers[0].thick = tot
mesh.save()
def shape_layer(self, epi_layer, y_padding=0.0, name="name"):
self.gl_objects_remove_regex(name)
a = gl_base_object()
pos = vec()
pos.x = epi_layer.x0
pos.y = epi_layer.y0
pos.z = epi_layer.z0
epi_layer.dx = get_mesh().get_xlen()
epi_layer.dz = get_mesh().get_zlen()
a.origonal_object = True
self.shape_to_screen(a, pos, epi_layer)
for s in epi_layer.shapes:
n = 0
for pos in s.expand_xyz0(epi_layer):
a = gl_base_object()
if n == 0:
a.origonal_object = True
n = n + 1
self.shape_to_screen(a, pos, s)
def curciut_mesh_add_links(self, z):
epi = get_epi()
mesh = get_mesh()
for zi in range(0, len(z)):
for x_sub_mesh_index in range(0, len(mesh.x.layers)):
xl = mesh.x.layers[x_sub_mesh_index]
if xl.points == 0: #if there is a gap in the mesh
if x_sub_mesh_index != 0 and x_sub_mesh_index != len(
mesh.x.layers
) - 1: #get left and right points to the gap
xl_l = mesh.x.layers[x_sub_mesh_index - 1]
xl_r = mesh.x.layers[x_sub_mesh_index + 1]
x0 = xl_l.mesh[-1]
x1 = xl_r.mesh[
0] #look for a shape which fills the gap
shapes = epi.get_shapes_between_x(x0, x1)
for s in shapes:
if s.shape_electrical != "none":
f = inp()
f.load(s.shape_electrical + ".inp")
component = f.get_token(
"#electrical_component")
nl = epi.find_layer_by_id(s.id)
y0 = epi.layers[nl].start
if component == "link":
a = gl_base_object()
a.id = ["electrical_mesh"]
a.type = "line"
a.xyz.x = gl_scale.project_m2screen_x(x0)
a.xyz.y = gl_scale.project_m2screen_y(y0 +
s.dy)
a.xyz.z = z[zi]
a.dxyz.x = (x1 - x0) * scale_get_xmul()
a.dxyz.y = s.dy * scale_get_ymul() * 0.9
a.dxyz.z = 0.0
a.r = 1.0
a.g = 0.0
a.b = 0.0
a.alpha = 1.0
self.gl_objects_add(a)
def draw_mesh(self): x=[] y=[] z=[] epi=get_epi() device_start=epi.get_device_start() mesh=get_mesh() y,temp=mesh.y.calculate_points() x,temp=mesh.x.calculate_points() z,temp=mesh.z.calculate_points() x=gl_scale.project_m2screen_x(x) y=gl_scale.project_m2screen_y(y) z=gl_scale.project_m2screen_z(z) glLineWidth(3) if mesh.y.circuit_model==False: self.drift_diffusion_mesh()
def project_object_through_electrical_mesh(self, o):
mesh = get_mesh()
mesh_with_gaps = False
for l in mesh.x.layers:
if l.points == 0:
mesh_with_gaps = True
break
if mesh_with_gaps == False:
self.gl_objects_add(o)
else:
for l in mesh.x.layers:
if l.points != 0:
new_obj = gl_base_object()
new_obj.copy(o)
#print(layer,l.start,l.end-l.start)
new_obj.xyz.x = gl_scale.project_m2screen_x(l.start)
new_obj.dxyz.x = (l.end - l.start) * scale_get_xmul()
#print(layer,o.xyz.x,o.dxyz.x)
self.gl_objects_add(new_obj)
def load_data(self):
lines = []
val = inp_get_token_value(
os.path.join(get_sim_path(), "light.inp"), "#Psun")
self.dump_energy_slice_xpos = int(
inp_get_token_value(os.path.join(get_sim_path(), "dump.inp"),
"#dump_energy_slice_xpos"))
self.dump_energy_slice_ypos = int(
inp_get_token_value(os.path.join(get_sim_path(), "dump.inp"),
"#dump_energy_slice_ypos"))
self.dump_energy_slice_zpos = int(
inp_get_token_value(os.path.join(get_sim_path(), "dump.inp"),
"#dump_energy_slice_zpos"))
self.light_illuminate_from = inp_get_token_value(
os.path.join(get_sim_path(), "light.inp"),
"#light_illuminate_from")
self.dump_1d_slice_xpos = int(
inp_get_token_value(os.path.join(get_sim_path(), "dump.inp"),
"#dump_1d_slice_xpos"))
self.dump_1d_slice_zpos = int(
inp_get_token_value(os.path.join(get_sim_path(), "dump.inp"),
"#dump_1d_slice_zpos"))
self.dump_verbose_electrical_solver_results = str2bool(
inp_get_token_value(os.path.join(get_sim_path(), "dump.inp"),
"#dump_verbose_electrical_solver_results"))
try:
self.suns = float(val)
except:
self.suns = 0.0
#self.y_mesh=get_mesh().y
#self.x_mesh=get_mesh().x
#self.z_mesh=get_mesh().z
self.x_len = get_mesh().get_xlen()
if os.path.isdir(
os.path.join(os.path.join(get_sim_path(),
"ray_trace"))) == True:
self.view.render_photons = False
def new_shape_file(self,layer):
new_filename=self.gen_new_electrical_file("shape")
mesh=get_mesh()
my_shape=shape()
my_shape.load(os.path.join(get_sim_path(),new_filename)+".inp")
if layer!=None:
my_shape.dy=layer.dy
my_shape.dx=mesh.get_xlen()
my_shape.dz=mesh.get_zlen()
my_shape.shape_electrical=self.gen_new_electrical_file("electrical")
my_shape.shape_nx=1
my_shape.shape_ny=1
my_shape.shape_nz=1
my_shape.name="New shape"
my_shape.optical_material="blends/p3htpcbm"
my_shape.save()
return my_shape
def load(self):
self.clear()
self.last_page = 0
#self.setTabsClosable(True)
self.setMovable(True)
if (os.path.isfile(os.path.join(get_sim_path(), "sim.gpvdm")) == True):
self.tab_main = tab_main()
self.addTab(self.tab_main, _("Device structure"))
mesh = get_mesh()
if mesh.y.circuit_model == True: # or mesh.x.tot_points!=1 or mesh.z.tot_points!=1:
self.display_mesh = display_mesh()
if mesh.y.circuit_model == True:
self.addTab(self.display_mesh, _("Circuit diagram"))
else:
self.addTab(self.display_mesh, _("Electrical mesh"))
self.update_display_function = self.tab_main.update
#self.tab_main.three_d.display.force_redraw()
self.terminal = tab_terminal()
self.terminal.init()
self.addTab(self.terminal, _("Terminal"))
self.terminal.run(
os.getcwd(),
get_exe_command() + " --version2 " + get_exe_args())
global_object_register("terminal", self.terminal)
widget = tab_view()
self.addTab(widget, _("Output"))
self.add_docs_page()
self.state_loaded = True
else:
self.add_info_page()
self.goto_page(_("Information"))
self.state_loaded = False
def apply(self):
try:
val = float(self.widget0_edit.text())
if val <= 0:
return
except:
return
get_mesh().set_xlen(val)
try:
val = float(self.widget1_edit.text())
if val <= 0:
return
except:
return
get_mesh().set_zlen(val)
get_mesh().x.save()
get_mesh().z.save()
global_object_run("mesh_update")
global_object_run("gl_force_redraw")
def draw_mesh(self):
x = []
y = []
z = []
epi = get_epi()
device_start = epi.get_device_start()
mesh = get_mesh()
y, temp = mesh.y.calculate_points()
x, temp = mesh.x.calculate_points()
z, temp = mesh.z.calculate_points()
old_layer = -1
components = []
component = ""
for i in range(0, len(y)):
y[i] = y[i] + device_start
layer = epi.get_layer_by_cordinate(y[i])
if old_layer != layer:
old_layer = layer
f = inp()
f.load(epi.layers[layer].electrical_file + ".inp")
component = f.get_token("#electrical_component")
if component == "resistance":
component = "resistor"
components.append(component)
x = gl_scale.project_m2screen_x(x)
y = gl_scale.project_m2screen_y(y)
z = gl_scale.project_m2screen_z(z)
glLineWidth(3)
if mesh.y.circuit_model == False:
self.drift_diffusion_mesh()
else:
self.circuit_mesh()
def __init__(self):
self.list = []
self.my_token_lib = tokens().get_lib()
self.epi = get_epi()
self.mesh = get_mesh()
def draw_contacts(self):
#print("draw contacts")
epi = get_epi()
box = vec()
pos = vec()
y_mesh = get_mesh().y
x_mesh = get_mesh().x
z_mesh = get_mesh().z
self.gl_objects_remove_regex("contact")
top_contact_layer = epi.get_top_contact_layer()
btm_contact_layer = epi.get_btm_contact_layer()
for c in epi.contacts.contacts:
if c.shape_enabled == True:
a = gl_base_object()
a.id = [c.id]
if c.position == "left":
if len(x_mesh.points) > 1:
sticking_out_bit = 0.2
a.type = "solid_and_mesh"
a.xyz.x = gl_scale.project_m2screen_x(
0) - sticking_out_bit
a.xyz.y = gl_scale.project_m2screen_y(c.y0)
a.xyz.z = gl_scale.project_m2screen_z(0)
a.dxyz.x = 1.0
a.dxyz.y = scale_get_ymul() * c.dy
a.dxyz.z = scale_get_device_z()
a.r = c.r
a.g = c.g
a.b = c.b
a.alpha = 1.0
my_vec = vec()
my_vec.x = sticking_out_bit / scale_get_xmul(
) #+c.ingress
my_vec.y = c.dy
my_vec.z = get_mesh().get_zlen()
if c.triangles != None:
a.triangles = triangles_flip_in_box(
c.triangles.data)
a.triangles = triangles_mul_vec(a.triangles, box)
a.triangles = triangles_add_vec(a.triangles, pos)
a.triangles = scale_trianges_m2screen(a.triangles)
self.gl_objects_add(a)
elif c.position == "top":
if top_contact_layer != -1:
#if epi.layers[0].name!="air":
box = vec()
if len(x_mesh.points) == 1 and len(z_mesh.points) == 1:
xstart = 0
box.x = get_mesh().get_xlen()
else:
xstart = c.x0
box.x = c.dx
box.y = epi.layers[0].dy #+c.ingress
box.z = get_mesh().get_zlen()
if self.draw_device_cut_through == False:
a.type = "solid_and_mesh"
else:
a.type = "solid_and_mesh_cut_through"
a.xyz.x = gl_scale.project_m2screen_x(xstart)
if c.shape_flip_y == False:
a.xyz.y = gl_scale.project_m2screen_y(
epi.get_layer_start(0))
else:
a.xyz.y = gl_scale.project_m2screen_y(
epi.get_layer_end(0))
a.xyz.z = gl_scale.project_m2screen_z(0.0)
a.dxyz.x = box.x * scale_get_xmul()
a.dxyz.y = box.y * scale_get_ymul()
a.dxyz.z = scale_get_device_z()
if c.shape_flip_y == False:
a.dxyz.y = a.dxyz.y * -1.0
a.r = c.r
a.g = c.g
a.b = c.b
a.alpha = 1.0
if c.triangles != None:
a.triangles = triangles_mul_vec(
c.triangles.data, box)
if c.shape_flip_y == True:
a.triangles = triangles_flip(a.triangles)
a.triangles = scale_trianges_m2screen(a.triangles)
self.gl_objects_add(a)
elif c.position == "bottom":
if btm_contact_layer != -1:
if len(x_mesh.points) == 1 and len(z_mesh.points) == 1:
xstart = 0
box.x = get_mesh().get_xlen()
else:
xstart = c.x0
box.x = c.dx
box.y = epi.layers[len(epi.layers) - 1].dy #+c.ingress
box.z = get_mesh().get_zlen()
a.type = "solid_and_mesh"
pos.x = xstart
pos.y = epi.get_layer_start(len(epi.layers) - 1)
pos.z = 0
a.xyz.x = gl_scale.project_m2screen_x(pos.x)
a.xyz.y = gl_scale.project_m2screen_y(pos.y)
a.xyz.z = gl_scale.project_m2screen_z(pos.z)
a.dxyz.x = box.x * scale_get_xmul()
a.dxyz.y = -box.y * scale_get_ymul()
a.dxyz.z = scale_get_device_z()
a.r = epi.layers[len(epi.layers) - 1].r
a.g = epi.layers[len(epi.layers) - 1].g
a.b = epi.layers[len(epi.layers) - 1].b
a.alpha = 1.0
my_vec = vec()
my_vec.x = c.dx
my_vec.y = epi.layers[len(epi.layers) - 1].dy
my_vec.z = get_mesh().get_zlen()
a.r = c.r
a.g = c.g
a.b = c.b
a.alpha = 1.0
a.triangles = triangles_flip_in_box(c.triangles.data)
a.triangles = triangles_mul_vec(a.triangles, box)
#a.triangles=triangles_add_vec(a.triangles,pos)
a.triangles = scale_trianges_m2screen(a.triangles)
self.gl_objects_add(a)
def gl_objects_move(self, dx, dy):
i = 0
epi = get_epi()
min, max = self.gl_objects_selected_min_max_vec()
x_min_new_screen = min.x + dx
x_min_new_m = gl_scale.project_screen_x_to_m(x_min_new_screen)
x_max_new_screen = max.x + dx
x_max_new_m = gl_scale.project_screen_x_to_m(x_max_new_screen)
y_min_new_screen = min.y + dy
y_max_new_m = gl_scale.project_screen_y_to_m(y_min_new_screen)
y_max_new_screen = max.y + dy
y_min_new_m = gl_scale.project_screen_y_to_m(y_max_new_screen)
move_x = True
move_y = True
for obj in self.objects:
if obj.selected == True:
s = None
if len(obj.id) > 0:
s = epi.find_shape_by_id(obj.id[0])
if type(s) == shape:
nl = epi.find_layer_by_id(obj.id[0])
y_start = epi.get_layer_start(nl)
y_stop = epi.get_layer_end(nl)
x_stop = get_mesh().get_xlen()
if x_min_new_m < 0:
move_x = False
if y_min_new_m < y_start:
move_y = False
if y_max_new_m >= y_stop:
move_y = False
if x_max_new_m >= x_stop:
move_x = False
else:
move_x = False
move_y = False
if move_y == True:
for obj in self.objects:
if obj.selected == True:
s = epi.find_shape_by_id(obj.id[0])
if type(s) == shape:
obj.xyz.y = obj.xyz.y + dy
s.y0 = gl_scale.project_screen_y_to_m(obj.xyz.y)
if move_x == True:
for obj in self.objects:
if obj.selected == True:
s = epi.find_shape_by_id(obj.id[0])
if type(s) == shape:
obj.xyz.x = obj.xyz.x + dx
if obj.origonal_object == True:
s.x0 = gl_scale.project_screen_x_to_m(obj.xyz.x)
def drift_diffusion_mesh(self):
x = []
y = []
z = []
epi = get_epi()
device_start = epi.get_device_start()
mesh = get_mesh()
y, temp = mesh.y.calculate_points()
x, temp = mesh.x.calculate_points()
z, temp = mesh.z.calculate_points()
for i in range(0, len(y)):
y[i] = y[i] + device_start
x = gl_scale.project_m2screen_x(x)
y = gl_scale.project_m2screen_y(y)
z = gl_scale.project_m2screen_z(z)
glLineWidth(3)
for zi in range(0, len(z)):
for xi in range(0, len(x)):
for yi in range(0, len(y)):
name = "mesh:" + str(xi) + ":" + str(yi) + ":" + str(zi)
if yi == self.dump_energy_slice_ypos and xi == self.dump_energy_slice_xpos and zi == self.dump_energy_slice_zpos:
a = gl_base_object()
a.id = [name]
a.type = "ball"
a.x = x[xi]
a.y = y[yi]
a.z = z[zi]
a.dx = 0.08
a.r = 0.0
a.g = 1.0
a.b = 0.0
self.gl_objects_add(a)
elif xi == self.dump_1d_slice_xpos and zi == self.dump_1d_slice_zpos:
a = gl_base_object()
a.id = [name]
a.type = "ball"
a.x = x[xi]
a.y = y[yi]
a.z = z[zi]
a.dx = 0.05
a.r = 0.0
a.g = 0.0
a.b = 1.0
self.gl_objects_add(a)
else:
a = gl_base_object()
a.id = [name]
a.type = "ball"
a.x = x[xi]
a.y = y[yi]
a.z = z[zi]
a.dx = 0.05
if self.dump_verbose_electrical_solver_results == False:
a.alpha = 0.5
else:
a.alpha = 0.9
a.r = 1.0
a.g = 0.0
a.b = 0.0
self.gl_objects_add(a)
if yi != len(y) - 1:
a = gl_base_object()
a.id = ["electrical_mesh"]
a.type = "line"
a.x = x[xi]
a.y = y[yi]
a.z = z[zi]
a.dx = 0.0
a.dy = y[yi + 1] - y[yi]
a.dz = 0.0
a.r = 1.0
a.g = 0.0
a.b = 0.0
self.gl_objects_add(a)
if xi != len(x) - 1:
a = gl_base_object()
a.id = ["electrical_mesh"]
a.type = "line"
a.x = x[xi]
a.y = y[yi]
a.z = z[zi]
a.dx = x[xi + 1] - x[xi]
a.dy = 0.0
a.dz = 0.0
a.r = 1.0
a.g = 0.0
a.b = 0.0
self.gl_objects_add(a)
if zi != len(z) - 1:
a = gl_base_object()
a.id = ["electrical_mesh"]
a.type = "line"
a.x = x[xi]
a.y = y[yi]
a.z = z[zi]
a.dx = 0.0
a.dy = 0.0
a.dz = z[zi + 1] - z[zi]
a.r = 1.0
a.g = 0.0
a.b = 0.0
self.gl_objects_add(a)
def circuit_mesh(self):
x = []
y = []
z = []
epi = get_epi()
mesh = get_mesh()
y, temp = mesh.y.calculate_points()
x, temp = mesh.x.calculate_points()
z, temp = mesh.z.calculate_points()
old_layer = -1
components = []
component = ""
for l in epi.layers:
f = inp()
f.load(l.electrical_file + ".inp")
component = f.get_token("#electrical_component")
if component == "resistance":
component = "resistor"
if component == "resistor":
components.append("resistor")
components.append("resistor")
if component == "diode":
components.append("resistor")
components.append("diode")
x = gl_scale.project_m2screen_x(x)
y = gl_scale.project_m2screen_y(y)
z = gl_scale.project_m2screen_z(z)
glLineWidth(3)
mask = mesh.build_device_shadow()
for zi in range(0, len(z)):
xi = 0
for x_sub_mesh_index in range(0, len(mesh.x.layers)):
#print(len(xl.mesh))
xl = mesh.x.layers[x_sub_mesh_index]
for x_point in range(0, len(xl.mesh)):
mid_point = 0
for yi in range(0, len(y)):
name = "mesh:" + str(xi) + ":" + str(yi) + ":" + str(
zi)
block_y = False
block_x = False
block_z = False
#layer=epi.get_layer_by_cordinate(y[yi])
#l=epi.layers[layer]
if x_point == len(
xl.mesh
) - 1: #if we are at the end of the submesh
if x_sub_mesh_index != len(mesh.x.layers) - 1:
if mesh.x.layers[x_sub_mesh_index +
1].points == 0:
block_x = True
if mask[zi][xi][yi] == False:
block_y = True
if xi != len(x) - 1:
if mask[zi][xi + 1][yi] == False:
block_x = True
if yi != len(y) - 1:
if mask[zi][xi][yi + 1] == False:
block_y = True
if mask[zi][xi][yi] == False:
block_x = True
block_z = True
if mid_point == 0:
block_x = True
if yi != len(y) - 1 and block_y == False:
a = gl_base_object()
a.id = ["electrical_mesh"]
a.type = components[yi]
a.xyz.x = x[xi]
a.xyz.y = y[yi]
a.xyz.z = z[zi]
a.dxyz.x = 0.0
a.dxyz.y = y[yi + 1] - y[yi]
a.dxyz.z = 0.0
a.r = 1.0
a.g = 0.0
a.b = 0.0
a.alpha = 1.0
self.gl_objects_add(a)
if xi != len(x) - 1 and block_x == False:
#print(yi,y[yi],mid_point,block_x)
a = gl_base_object()
a.id = ["electrical_mesh"]
a.type = "resistor"
a.xyz.x = x[xi]
a.xyz.y = y[yi]
a.xyz.z = z[zi]
a.dxyz.x = x[xi + 1] - x[xi]
a.dxyz.y = 0.0
a.dxyz.z = 0.0
a.r = 1.0
a.g = 0.0
a.b = 0.0
a.alpha = 1.0
self.gl_objects_add(a)
if zi != len(z) - 1 and block_z == False:
a = gl_base_object()
a.id = ["electrical_mesh"]
a.type = "resistor"
a.xyz.x = x[xi]
a.xyz.y = y[yi]
a.xyz.z = z[zi]
a.dxyz.x = 0.0
a.dxyz.y = 0.0
a.dxyz.z = z[zi + 1] - z[zi]
a.r = 1.0
a.g = 0.0
a.b = 0.0
a.alpha = 1.0
self.gl_objects_add(a)
mid_point = mid_point + 1
if mid_point == 2:
mid_point = 0
xi = xi + 1
self.curciut_mesh_add_links(z)
def __init__(self, xyz):
self.xyz = xyz
QGroupBox.__init__(self)
rcParams.update({'figure.autolayout': True})
self.setTitle(self.xyz)
self.setStyleSheet("QGroupBox { border: 1px solid gray;}")
vbox = QVBoxLayout()
self.setLayout(vbox)
self.toolbar = QToolBar()
self.toolbar.setIconSize(QSize(32, 32))
vbox.addWidget(self.toolbar)
self.tab = gpvdm_tab(toolbar=self.toolbar)
self.tab.tb_add.triggered.connect(self.on_add_mesh_clicked)
self.tab.tb_down.triggered.connect(self.on_move_down)
self.tab.tb_up.triggered.connect(self.on_move_up)
self.tab.user_remove_rows.connect(self.callback_remove_rows)
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.tab.clear()
self.tab.setColumnCount(4)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tab.cellChanged.connect(self.tab_changed)
vbox.addWidget(self.tab)
self.fig = Figure(figsize=(5, 2), dpi=100)
self.canvas = FigureCanvas(self.fig)
self.canvas.figure.patch.set_facecolor('white')
self.fig.subplots_adjust(bottom=0.2)
self.fig.subplots_adjust(left=0.1)
self.ax1 = self.fig.add_subplot(111)
self.ax1.ticklabel_format(useOffset=False)
vbox.addWidget(self.canvas)
if self.xyz == "y":
self.mesh = get_mesh().y
get_watch().add_call_back("mesh_y.inp", self.load)
elif self.xyz == "x":
self.mesh = get_mesh().x
get_watch().add_call_back("mesh_x.inp", self.load)
elif self.xyz == "z":
self.mesh = get_mesh().z
get_watch().add_call_back("mesh_z.inp", self.load)
if self.mesh.circuit_model == True:
self.tab.tb_add.setEnabled(False)
self.tab.tb_remove.setEnabled(False)
self.tab.tb_down.setEnabled(False)
self.tab.tb_up.setEnabled(False)
self.tab.setEnabled(False)
self.load()
def __init__(self):
QWidget.__init__(self)
self.complex_display = False
self.hbox = QVBoxLayout()
self.data = dat_file()
self.my_server = server_get()
mesh = get_mesh()
if mesh.y.circuit_model == True and mesh.x.tot_points == 1 and mesh.z.tot_points == 1:
self.display = circuit_editor()
epi = get_epi()
pos = 3
self.display.ersatzschaltbild.add_object(pos, 3, pos + 1, 3, "bat")
pos = pos + 1
for l in epi.layers:
f = inp()
f.load(
os.path.join(get_sim_path(), l.shape_electrical + ".inp"))
component = f.get_token("#electrical_component")
if component == "resistance":
self.display.ersatzschaltbild.add_object(
pos, 3, pos + 1, 3, "resistor")
if component == "diode":
self.display.ersatzschaltbild.add_object(
pos, 3, pos + 1, 3, "diode")
pos = pos + 1
self.display.ersatzschaltbild.add_object(pos, 3, pos + 1, 3,
"ground")
self.display.ersatzschaltbild.objects_push()
if inp().isfile(os.path.join(get_sim_path(),
"diagram.inp")) == True:
self.display.ersatzschaltbild.load()
else:
toolbar = QToolBar()
toolbar.setIconSize(QSize(42, 42))
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.tb_refresh = QAction(icon_get("view-refresh"), _("Refresh"),
self)
self.tb_refresh.triggered.connect(self.rebuild_mesh)
toolbar.addAction(self.tb_refresh)
self.xy = QAction(icon_get("xy"), _("xy"), self)
self.xy.triggered.connect(self.callback_xy)
toolbar.addAction(self.xy)
self.yz = QAction(icon_get("yz"), _("yz"), self)
self.yz.triggered.connect(self.callback_yz)
toolbar.addAction(self.yz)
self.xz = QAction(icon_get("xz"), _("xz"), self)
self.xz.triggered.connect(self.callback_xz)
toolbar.addAction(self.xz)
self.tb_rotate = QAction(icon_get("rotate.png"), _("Rotate"), self)
self.tb_rotate.triggered.connect(self.tb_rotate_click)
toolbar.addAction(self.tb_rotate)
self.tb_rotate.setEnabled(True)
self.hbox.addWidget(toolbar)
self.display = glWidget(self)
#self.data.load(os.path.join(get_sim_path(),"electrical_mesh.dat")
#self.display.pre_built_scene=gl_scale.project_base_objects_from_m_2_screen(self.data.data)
self.display.draw_electrical_mesh = False
self.display.view.draw_device = False
self.display.enable_draw_ray_mesh = False
self.display.enable_draw_light_source = False
self.display.enable_draw_rays = False
self.display.view.render_photons = False
self.display.force_redraw()
#global_object_register("display_mesh_recalculate",self.recalculate)
self.hbox.addWidget(self.display)
self.setLayout(self.hbox)
def build_top_widget(self):
self.items=[]
#input description+units //output label // Output unit// equation to si //mull si to display //Need area
self.items.append([_("Wavelength"),"nm",_("Wavelength"),"nm","1e-9",1e9,False])
self.items.append([_("Wavelength"),"um",_("Wavelength"),"nm","1e-6",1e9,False])
self.items.append([_("Wavelength"),"cm",_("Wavelength"),"nm","1e-3",1e9,False])
self.items.append([_("Wavelength"),"m",_("Wavelength"),"nm","1.0",1e9,False])
self.items.append([_("J"),"mA/cm2",_("J"),"A/m2","10000.0/1000.0",1.0,False])
self.items.append([_("J"),"A/m2",_("J"),"A/m2","1.0",1.0,False])
self.items.append([_("Amps"),"A",_("J"),"A/m2","1.0/(self.get_area())",1.0,True])
self.items.append([_("Amps - no convert"),"A",_("I"),"A","1.0",1.0,True])
self.items.append([_("Voltage"),"V",_("Voltage"),"V","1.0",1.0,False])
self.items.append([_("-Voltage"),"V",_("Voltage"),"V","-1.0",1.0,False])
self.items.append([_("Voltage"),"mV",_("Voltage"),"V","1e-3",1.0,False])
self.items.append([_("Refractive index"),"au",_("Refractive index"),"au","1.0",1.0,False])
self.items.append([_("Absorption"),"m^{-1}",_("Absorption"),"m^{-1}","1.0",1.0,False])
self.items.append([_("Absorption"),"m^{-cm}",_("Absorption"),"m^{-1}","1.0",1e2,False])
self.items.append([_("Attenuation coefficient"),"au",_("Absorption"),"m^{-1}","4*3.14159/y",1.0,False])
self.items.append([_("Time"),"s",_("Time"),"s","1.0",1.0,False])
self.items.append([_("Suns"),"Suns",_("Suns"),"Suns","1.0",1.0,False])
self.items.append([_("Intensity"),"um^{-1}.Wm^{-2}",_("Intensity"),"m^{-1}.Wm^{-2}","1e6",1.0,False])
self.items.append([_("Charge density"),"m^{-3}",_("Charge density"),"m^{-3}","1.0",1.0,False])
i=0
self.x_label=self.items[i][2]
self.x_units=self.items[i][3]
self.x_mul_to_si=self.items[i][4]
self.x_disp_mul=self.items[i][5]
self.data_label=self.items[i][2]
self.data_units=self.items[i][3]
self.data_mul_to_si=self.items[i][4]
self.data_disp_mul=self.items[i][5]
self.top_widget=QWidget()
self.top_vbox=QVBoxLayout()
self.x_combo=QComboBox()
self.add_units(self.x_combo)
self.data_combo=QComboBox()
self.add_units(self.data_combo)
self.units_x_label=QLabel(_("x units:"))
self.units_data_label=QLabel(_("y units:"))
self.x_combo.currentIndexChanged.connect(self.callback_edited)
self.data_combo.currentIndexChanged.connect(self.callback_edited)
self.title_widget=QWidget()
self.title_hbox=QHBoxLayout()
self.title_label=QLabel(_("Title:"))
self.title_entry=QLineEdit()
self.title_hbox.addWidget(self.title_label)
self.title_hbox.addWidget(self.title_entry)
self.title_widget.setLayout(self.title_hbox)
self.top_vbox.addWidget(self.title_widget)
self.xlabel_widget=QWidget()
self.xlabel_hbox=QHBoxLayout()
self.xlabel_label=QLabel(_("x-label:"))
self.xlabel_entry=QLineEdit()
self.x_column_label=QLabel(_("x-column:"))
self.x_spin=QSpinBox()
self.x_spin.setValue(0)
self.x_spin.valueChanged.connect(self.callback_edited)
self.x_invert=QCheckBox("invert")
self.xlabel_hbox.addWidget(self.xlabel_label)
self.xlabel_hbox.addWidget(self.xlabel_entry)
self.xlabel_hbox.addWidget(self.x_column_label)
self.xlabel_hbox.addWidget(self.x_spin)
self.xlabel_hbox.addWidget(self.units_x_label)
self.xlabel_hbox.addWidget(self.x_combo)
self.xlabel_hbox.addWidget(self.x_invert)
self.xlabel_widget.setLayout(self.xlabel_hbox)
self.top_vbox.addWidget(self.xlabel_widget)
self.data_label_widget=QWidget()
self.data_label_hbox=QHBoxLayout()
self.data_label_label=QLabel(_("y-label:"))
self.data_label_entry=QLineEdit()
self.data_column_label=QLabel(_("y-column:"))
self.data_spin=QSpinBox()
self.data_spin.setValue(1)
self.data_spin.valueChanged.connect(self.callback_edited)
self.data_invert=QCheckBox("invert")
self.data_label_hbox.addWidget(self.data_label_label)
self.data_label_hbox.addWidget(self.data_label_entry)
self.data_label_hbox.addWidget(self.data_column_label)
self.data_label_hbox.addWidget(self.data_spin)
self.data_label_hbox.addWidget(self.units_data_label)
self.data_label_hbox.addWidget(self.data_combo)
self.data_label_hbox.addWidget(self.data_invert)
self.data_label_widget.setLayout(self.data_label_hbox)
self.top_vbox.addWidget(self.data_label_widget)
self.area_widget=QWidget()
self.area_hbox=QHBoxLayout()
self.area_label=QLabel(_("device area:"))
self.area_hbox.addWidget(self.area_label)
self.area_entry=QLineEdit()
self.area_entry.setText(str(round(get_mesh().get_xlen()*get_mesh().get_zlen()*100*100, 3)))
self.area_hbox.addWidget(self.area_entry)
self.area_units=QLabel("cm2")
self.area_hbox.addWidget(self.area_units)
self.area_widget.setLayout(self.area_hbox)
self.top_vbox.addWidget(self.area_widget)
self.area_widget.hide()
self.xlabel_entry.textEdited.connect(self.callback_edited)
self.data_label_entry.textEdited.connect(self.callback_edited)
self.title_entry.textEdited.connect(self.callback_edited)
self.area_entry.textEdited.connect(self.callback_edited)
self.x_invert.stateChanged.connect(self.callback_edited)
self.data_invert.stateChanged.connect(self.callback_edited)
self.top_widget.setLayout(self.top_vbox)
