def recalculate(self):
self.colors=[]
lines=[]
if dat_file_read(self.graph_data,self.graph_path)==True:
#print(self.graph_path)
self.graph_z_max,self.graph_z_min=dat_file_max_min(self.graph_data)
#print(self.graph_z_max,self.graph_z_min)
val=inp_get_token_value("light.inp", "#Psun")
self.suns=float(val)
l=epitaxy_get_layers()-1
for i in range(0,epitaxy_get_layers()):
path=os.path.join(get_materials_path(),epitaxy_get_mat_file(l-i),"mat.inp")
if inp_load_file(lines,path)==True:
red=float(inp_search_token_value(lines, "#Red"))
green=float(inp_search_token_value(lines, "#Green"))
blue=float(inp_search_token_value(lines, "#Blue"))
else:
red=0.0
green=0.0
blue=0.0
self.colors.append(color(red,green,blue))
self.colors.reverse()
self.update()
def code_ctrl_load():
lines = []
global store_enable_webupdates
global store_enable_webbrowser
global store_enable_cluster
global store_enable_betafeatures
lines = inp_load_file(os.path.join(get_inp_file_path(), "ver.inp"),
archive="base.gpvdm")
if lines != False:
store_enable_webupdates = yes_no(
inp_search_token_value(lines, "#enable_webupdates"))
store_enable_webbrowser = yes_no(
inp_search_token_value(lines, "#enable_webbrowser"))
store_enable_cluster = yes_no(
inp_search_token_value(lines, "#enable_cluster"))
store_enable_betafeatures = yes_no(
inp_search_token_value(lines, "#enable_betafeatures"))
if os.path.isdir(os.path.join(get_inp_file_path(),
"enablebeta")) == True:
store_enable_betafeatures = True
else:
print("Can not load ver.inp file")
store_enable_webupdates = False
store_enable_webbrowser = False
store_enable_cluster = False
store_enable_betafeatures = False
def listen(self):
#print("thread !!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
self.running=True
while(1):
understood=False
data = self.recvall(512)
if data==None:
break
print("command=",data,len(data))
if data.startswith(str.encode("gpvdmfile")):
self.rx_file(data)
understood=True
if data.startswith(str.encode("gpvdmpercent")):
lines=data.split("\n")
percent=float(inp_search_token_value(lines, "#percent"))
self.progress_window.set_fraction(percent/100.0)
understood=True
if data.startswith(str.encode("gpvdmjobfinished")):
lines=data.split("\n")
name=inp_search_token_value(lines, "#job_name")
self.label.set_text(gui_print_path("Finished: ",name,60))
understood=True
if data.startswith(str.encode("gpvdmfinished")):
self.stop()
understood=True
if data.startswith(str.encode("gpvdmheadquit")):
self.stop()
print("Server quit!")
understood=True
if data.startswith(str.encode("gpvdmnodelist")):
self.process_node_list(data)
understood=True
if data.startswith(str.encode("gpvdm_sync_packet_two")):
self.process_sync_packet_two(data)
understood=True
if data.startswith(str.encode("gpvdm_sync_packet_one")):
self.process_sync_packet_one(data)
understood=True
if data.startswith(str.encode("gpvdm_job_list")):
self.process_job_list(data)
understood=True
if data.startswith(str.encode("gpvdm_message")):
print(data)
understood=True
if understood==False:
print("Command ",data, "not understood")
def update(self): lines=inp_load_file(os.path.join(get_sim_path(),"fit"+str(self.index)+".inp")) if lines!=False: enabled=str2bool(inp_search_token_value(lines, "#enabled")) if enabled==True: self.tmesh_real.update() self.tmesh.update()
def __init__(self,index):
QTabWidget.__init__(self)
css_apply(self,"tab_default.css")
lines=[]
self.index=index
lines=inp_load_file(os.path.join(get_sim_path(),"fit"+str(self.index)+".inp"))
if lines!=False:
self.tab_name=inp_search_token_value(lines, "#fit_name")
else:
self.tab_name=""
#self.setTabsClosable(True)
#self.setMovable(True)
self.tmesh = fit_window_plot(self.index)
self.addTab(self.tmesh,_("Fit error"))
config=tab_class()
config.init(os.path.join(get_sim_path(),"fit"+str(self.index)+".inp"),self.tab_name)
self.addTab(config,_("Configure fit"))
self.tmesh_real = fit_window_plot_real(self.index)
self.addTab(self.tmesh_real,_("Experimental data"))
self.fit_patch = fit_patch(self.index)
self.addTab(self.fit_patch, _("Fit patch"))
self.matlab_editor = matlab_editor(self.index)
self.addTab(self.matlab_editor, _("MATLAB code"))
def __init__(self,index):
QTabWidget.__init__(self)
self.index=index
lines=[]
if inp_load_file(lines,"pulse"+str(self.index)+".inp")==True:
self.tab_name=inp_search_token_value(lines, "#sim_menu_name")
else:
self.tab_name=""
self.setTabsClosable(True)
self.setMovable(True)
self.tmesh = tab_time_mesh(self.index)
self.addTab(self.tmesh,_("time mesh"))
self.circuit=circuit(self.index)
self.addTab(self.circuit,_("Circuit"))
tab=tab_class()
tab.init("pulse"+str(self.index)+".inp","Configure")
self.addTab(tab,"Configure")
def uid_get():
uid=""
if running_on_linux()==True:
path=os.path.join(expanduser("~"),".gpvdm_uid.inp")
else:
path=os.path.join(get_exe_path(),"uid.inp")
try:
lines=[]
found=False
lines=inp_load_file(path)
if lines!=False:
uid=inp_search_token_value(lines, "#uid")
found=True
if found==False:
uid=str(uuid.uuid4())[0:8]
lines=[]
lines.append("#uid")
lines.append(uid)
lines.append("#ver")
lines.append("1.0")
lines.append("#end")
inp_save(path,lines)
except:
print("uid error")
return uid
def __init__(self, index):
QTabWidget.__init__(self)
css_apply(self, "tab_default.css")
self.index = index
lines = []
self.file_name = os.path.join(get_sim_path(),
"jv" + str(self.index) + ".inp")
lines = inp_load_file(self.file_name)
if lines != False:
self.tab_name = inp_search_token_value(lines, "#sim_menu_name")
else:
self.tab_name = ""
self.setMovable(True)
#self.tmesh = tab_time_mesh(self.index)
#self.addTab(self.tmesh,_("time mesh"))
#self.circuit=circuit(self.index)
#self.addTab(self.circuit,_("Circuit"))
tab = tab_class()
tab.init(self.file_name, _("Configure"))
self.addTab(tab, _("Configure"))
def __init__(self,index):
QTabWidget.__init__(self)
lines=[]
self.index=index
if inp_load_file(lines,"fit"+str(self.index)+".inp")==True:
self.tab_name=inp_search_token_value(lines, "#fit_name")
else:
self.tab_name=""
self.setTabsClosable(True)
self.setMovable(True)
self.tmesh = fit_window_plot(self.index)
self.addTab(self.tmesh,_("Fit error"))
self.tmesh_real = fit_window_plot_real(self.index)
self.addTab(self.tmesh_real,_("Experimental data"))
self.fit_patch = fit_patch(self.index)
self.addTab(self.fit_patch, _("Fit patch"))
config=tab_class()
config.init("fit"+str(self.index)+".inp",self.tab_name)
self.addTab(config,_("Configure fit"))
def code_ctrl_load():
lines=[]
global store_enable_webupdates
global store_enable_webbrowser
global store_enable_cluster
global store_enable_betafeatures
if inp_load_file(lines,os.path.join(get_inp_file_path(),"ver.inp"))==True:
store_enable_webupdates=yes_no(inp_search_token_value(lines, "#enable_webupdates"))
store_enable_webbrowser=yes_no(inp_search_token_value(lines, "#enable_webbrowser"))
store_enable_cluster=yes_no(inp_search_token_value(lines, "#enable_cluster"))
store_enable_betafeatures=yes_no(inp_search_token_value(lines, "#enable_betafeatures"))
else:
print("Can not load ver.inp file")
store_enable_webupdates=False
store_enable_webbrowser=False
store_enable_cluster=False
store_enable_betafeatures=False
def archive_get_file_ver(archive, file_name):
lines = []
exists = read_lines_from_archive(lines, archive, file_name)
if exists == True:
ver = inp_search_token_value(lines, "#ver")
else:
return ""
return ver
def archive_get_file_ver(archive, file_name):
lines = []
lines = read_lines_from_archive(archive, file_name)
if lines != False:
ver = inp_search_token_value(lines, "#ver")
else:
return ""
return ver
def load(self):
self.tab.blockSignals(True)
self.tab.clear()
self.tab.setHorizontalHeaderLabels(
[_("File Name"), _("Width"),
_("Start"), _("Stop")])
layers = epitaxy_get_layers()
for i in range(0, layers):
dos_file = epitaxy_get_dos_file(i)
width = epitaxy_get_width(i)
if dos_file != "none":
lines = []
print("loading", dos_file)
file_name = os.path.join(get_sim_path(), dos_file + ".inp")
lines = inp_load_file(file_name)
if lines != False:
doping_start = float(
inp_search_token_value(lines, "#doping_start"))
doping_stop = float(
inp_search_token_value(lines, "#doping_stop"))
print("add", dos_file)
count = self.tab.rowCount()
self.tab.insertRow(count)
item1 = QTableWidgetItem(str(dos_file))
self.tab.setItem(count, 0, item1)
item2 = QTableWidgetItem(str(width))
self.tab.setItem(count, 1, item2)
item3 = QTableWidgetItem(str(doping_start))
self.tab.setItem(count, 2, item3)
item3 = QTableWidgetItem(str(doping_stop))
self.tab.setItem(count, 3, item3)
self.tab.blockSignals(False)
return
def epitaxy_populate_rgb():
global epi
path = os.path.join(get_materials_path(), epi[-1].mat_file, "mat.inp")
mat_lines = inp_load_file(path)
ret = inp_search_token_array(mat_lines, "#red_green_blue")
if ret != False:
epi[-1].r = float(ret[0])
epi[-1].g = float(ret[1])
epi[-1].b = float(ret[2])
epi[-1].alpha = float(inp_search_token_value(mat_lines, "#mat_alpha"))
def sync_to_electrical_mesh(self): tot=0 for i in range(0,len(self.model)): if yes_no(self.model[i][COLUMN_DEVICE])==True: tot=tot+float(self.model[i][COLUMN_THICKNES]) lines=[] if inp_load_file(lines,os.path.join(os.getcwd(),"mesh_y.inp"))==True: mesh_layers=int(inp_search_token_value(lines, "#mesh_layers")) if mesh_layers==1: inp_update_token_value(os.path.join(os.getcwd(),"mesh_y.inp"), "#mesh_layer_length0", str(tot),1)
def process_sync_packet_two(self, data):
lines = data.split("\n")
target = inp_search_token_value(lines, "#target")
src = inp_search_token_value(lines, "#src")
size = int(inp_search_token_value(lines, "#size"))
packet_len = int(int(size) / int(512) + 1) * 512
data = self.recvall(packet_len)
data = data[0:size]
lines = data.split("\n")
pos = 0
copy_list = []
#print(lines)
for i in range(0, len(lines)):
fname = lines[pos]
pos = pos + 1
if fname != "":
copy_list.append(fname)
self.send_files(target, src, copy_list)
def rx_packet(self,data):
ret=tx_struct()
lines=data.decode("utf-8").split("\n")
ret.file_name=inp_search_token_value(lines, "#file_name")
ret.size=int(inp_search_token_value(lines, "#size"))
ret.target=inp_search_token_value(lines, "#target")
ret.zip=int(inp_search_token_value(lines, "#zip"))
ret.uzipsize=int(inp_search_token_value(lines, "#uzipsize"))
if ret.size!=0:
packet_len=int(int(ret.size)/int(512)+1)*512
ret.data = self.recvall(packet_len)
ret.data=ret.data[0:ret.size]
if ret.zip==1:
ret.data = zlib.decompress(ret.data)
ret.size=len(ret.data)
return ret
def process_sync_packet_two(self,data):
lines=data.split("\n")
target=inp_search_token_value(lines, "#target")
src=inp_search_token_value(lines, "#src")
size=int(inp_search_token_value(lines, "#size"))
packet_len=int(int(size)/int(512)+1)*512
data = self.recvall(packet_len)
data = data[0:size]
lines=data.split("\n")
pos=0
copy_list=[]
#print(lines)
for i in range(0,len(lines)):
fname=lines[pos]
pos=pos+1
if fname!="":
copy_list.append(fname)
self.send_files(target,src,copy_list)
def config_load(self):
lines = inp_load_file("gui_cmp_config.inp")
if lines != False:
if self.snapshot_list.count(
inp_search_token_value(lines, "#entry0")) != 0:
self.entry0.set_active(
self.snapshot_list.index(
inp_search_token_value(lines, "#entry0")))
else:
self.entry0.set_active(0)
if self.snapshot_list.count(
inp_search_token_value(lines, "#entry1")) != 0:
self.entry1.set_active(
self.snapshot_list.index(
inp_search_token_value(lines, "#entry1")))
else:
self.entry1.set_active(0)
self.entry2.set_text(inp_search_token_value(lines, "#entry2"))
self.entry3.set_text(inp_search_token_value(lines, "#entry3"))
else:
self.entry0.set_active(0)
self.entry1.set_active(0)
self.entry2.set_text("n p")
self.entry3.set_text("")
def ver_load_info():
lines = []
global core
global ver_error
global subver
core = ""
ver_error = ""
ver_file_path = os.path.join(get_inp_file_path(), "ver.inp")
lines = inp_load_file(ver_file_path, archive="base.gpvdm")
if lines != False:
core = inp_search_token_value(lines, "#core")
subver = inp_search_token_value(lines, "#sub_ver")
return True
else:
ver_error = "I can not find the file sim.gpvdm/ver.inp.\n\nI have tried looking in " + ver_file_path + "\n\nThe share path is" + get_share_path(
) + "\n\nThe bin path is" + get_bin_path(
) + "\n\nThe current working dir is " + get_sim_path(
) + "\n\nTry reinstalling a new version of gpvdm and/or report the bug to me at [email protected]."
return False
def ver_check_compatibility(file_name):
lines = []
core = ""
lines = read_lines_from_archive(file_name, "ver.inp")
if lines != False:
core = inp_search_token_value(lines, "#core")
if core == ver_core():
return True
else:
return False
return False
def init(self):
total = 0
self.pos = 0
lines = inp_load_file(lines, "mesh_y.inp")
if lines != False:
total = inp_sum_items(lines, "#mesh_layer_points0")
lines = inp_load_file(lines, "dump.inp")
if lines != False:
self.pos = str2bool(
inp_search_token_value(lines, "#dump_energy_slice_pos"))
label = gtk.Label("Energy slice dump")
label.show()
self.pack_start(label, True, True, 0)
check = gtk.CheckButton("Enable")
self.pack_start(check, True, True, 0)
print("total=", total)
adj = gtk.Adjustment(self.pos, 0, total, 1.0, 1.0, 1.0)
adj.connect("value_changed", self.scroll)
self.vscale = gtk.HScale(adj)
self.vscale.set_size_request(150, 30)
self.pack_start(self.vscale, True, True, 0)
self.vscale.show()
self.enable = False
lines = inp_load_file(lines, "dump.inp")
if lines != False:
self.enable = str2bool(
inp_search_token_value(lines, "#dump_energy_slice_switch"))
check.set_active(self.enable)
self.vscale.set_sensitive(self.enable)
check.unset_flags(gtk.CAN_FOCUS)
check.connect("clicked", self.check_clicked)
def load_data(self):
self.tab.setColumnCount(7)
self.tab.clear()
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
lines=[]
self.start_time=0.0
self.fs_laser_time=0.0
self.list=[]
self.tab.setHorizontalHeaderLabels([_("Length"),_("dt"), _("Start Voltage"), _("Stop Voltage"), _("step multiplyer"), _("Suns"),_("Laser")])
file_name="time_mesh_config"+str(self.index)+".inp"
print("loading",file_name)
ret=inp_load_file(lines,file_name)
if ret==True:
if inp_search_token_value(lines, "#ver")=="1.1":
pos=0
token,value,pos=inp_read_next_item(lines,pos)
self.start_time=float(value)
token,value,pos=inp_read_next_item(lines,pos)
self.fs_laser_time=float(value)
token,value,pos=inp_read_next_item(lines,pos)
segments=int(value)
for i in range(0, segments):
token,length,pos=inp_read_next_item(lines,pos)
token,dt,pos=inp_read_next_item(lines,pos)
token,voltage_start,pos=inp_read_next_item(lines,pos)
token,voltage_stop,pos=inp_read_next_item(lines,pos)
token,mul,pos=inp_read_next_item(lines,pos)
token,sun,pos=inp_read_next_item(lines,pos)
token,laser,pos=inp_read_next_item(lines,pos)
tab_add(self.tab,[str(length),str(dt),str(voltage_start),str(voltage_stop),str(mul),str(sun),str(laser)])
return True
else:
print("file "+file_name+"wrong version")
exit("")
return False
else:
print("file "+file_name+" not found")
return False
return False
def init(self):
total=0
self.pos=0
lines=[]
if inp_load_file(lines,"mesh_y.inp")==True:
total=inp_sum_items(lines, "#mesh_layer_points0")
if inp_load_file(lines,"dump.inp")==True:
self.pos=str2bool(inp_search_token_value(lines, "#dump_energy_slice_pos"))
label=gtk.Label("Energy slice dump")
label.show()
self.pack_start(label, True, True, 0)
check = gtk.CheckButton("Enable")
self.pack_start(check, True, True, 0)
print("total=",total)
adj=gtk.Adjustment(self.pos, 0, total, 1.0, 1.0, 1.0)
adj.connect("value_changed", self.scroll)
self.vscale = gtk.HScale(adj)
self.vscale.set_size_request(150, 30)
self.pack_start(self.vscale, True, True, 0)
self.vscale.show()
self.enable=False
if inp_load_file(lines,"dump.inp")==True:
self.enable=str2bool(inp_search_token_value(lines, "#dump_energy_slice_switch"))
check.set_active(self.enable)
self.vscale.set_sensitive(self.enable)
check.unset_flags(gtk.CAN_FOCUS)
check.connect("clicked", self.check_clicked)
def load(self):
self.tab.blockSignals(True)
self.tab.clear()
self.tab.setHorizontalHeaderLabels([_("File Name"), _("Width"), _("Start"), _("Stop")])
layers=epitaxy_get_layers()
for i in range(0,layers):
dos_file=epitaxy_get_dos_file(i)
width=epitaxy_get_width(i)
if dos_file!="none":
lines=[]
print("loading",dos_file)
if inp_load_file(lines,dos_file+".inp")==True:
doping_start=float(inp_search_token_value(lines, "#doping_start"))
doping_stop=float(inp_search_token_value(lines, "#doping_stop"))
print("add",dos_file)
count=self.tab.rowCount()
self.tab.insertRow(count)
item1 = QTableWidgetItem(str(dos_file))
self.tab.setItem(count,0,item1)
item2 = QTableWidgetItem(str(width))
self.tab.setItem(count,1,item2)
item3 = QTableWidgetItem(str(doping_start))
self.tab.setItem(count,2,item3)
item3 = QTableWidgetItem(str(doping_stop))
self.tab.setItem(count,3,item3)
self.tab.blockSignals(False)
return
def rx_packet(self, data):
ret = tx_struct()
lines = data[0:512].decode("utf-8").split("\n")
ret.file_name = inp_search_token_value(lines, "#file_name")
ret.size = int(inp_search_token_value(lines, "#size"))
ret.target = inp_search_token_value(lines, "#target")
ret.zip = int(inp_search_token_value(lines, "#zip"))
ret.uzipsize = int(inp_search_token_value(lines, "#uzipsize"))
#print(ret.file_name,ret.size,ret.uzipsize,len(data))
if ret.size != 0:
packet_len = int(int(ret.size) / int(512) + 1) * 512
ret.data = self.recvall(packet_len)
if len(ret.data) != packet_len:
print("packet len does not match size", len(ret.data),
packet_len)
ret.data = ret.data[0:ret.size]
if ret.zip == 1:
ret.data = zlib.decompress(ret.data)
ret.size = len(ret.data)
return ret
def load_data(self):
self.tab.clear()
self.tab.setColumnCount(4)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tab.setHorizontalHeaderLabels([
_("Frequency start"),
_("Frequency stop"),
_("points"),
_("Multiply")
])
self.tab.setColumnWidth(0, 200)
self.tab.setColumnWidth(1, 200)
lines = []
self.start_fx = 0.0
file_name = "fxmesh" + str(self.index) + ".inp"
lines = inp_load_file(os.path.join(get_sim_path(), file_name))
if lines != False:
if inp_search_token_value(lines, "#ver") == "1.1":
pos = 0
while (1):
token, start, pos = inp_read_next_item(lines, pos)
if token == "#ver" or token == "#end":
break
token, stop, pos = inp_read_next_item(lines, pos)
token, points, pos = inp_read_next_item(lines, pos)
token, mul, pos = inp_read_next_item(lines, pos)
tab_add(self.tab,
[str(start),
str(stop),
str(points),
str(mul)])
return True
else:
print("file " + file_name + "wrong version")
exit("")
return False
else:
print("file " + file_name + " not found")
return False
return False
def update(self):
self.sim_mode.clear()
lines=[]
self.store_list=[]
temp=[]
files=inp_lsdir("sim.gpvdm")
if files!=False:
for i in range(0,len(files)):
if files[i].endswith(".inp") and files[i].count("/")==0:
lines=inp_load_file(files[i])
value=inp_search_token_value(lines, "#sim_menu_name")
if value!=False:
if value.count("@")==1:
temp.append(value)
temp.sort()
for i in range(0,len(temp)):
value=temp[i].rstrip()
command,module=value.split("@")
self.sim_mode.addItem(command)
a=store(command,module)
self.store_list.append(a)
token=inp_get_token_value("sim.inp", "#simmode")
if token.count("@")!=0:
command,module=token.split("@")
else:
command=token
found=False
all_items = [self.sim_mode.itemText(i) for i in range(self.sim_mode.count())]
for i in range(0,len(all_items)):
if all_items[i] == command:
self.sim_mode.setCurrentIndex(i)
found=True
#if there is no known mode, just set it to jv mode
if found==False:
for i in range(0,len(self.store_list)):
if self.store_list[i].token=="jv":
self.sim_mode.setCurrentIndex(i)
inp_update_token_value(os.path.join(get_sim_path(),"sim.inp"), "#simmode", "jv@jv")
break
def update(self):
self.sim_mode.clear()
lines=[]
self.store_list=[]
files=inp_lsdir()
if files!=False:
for i in range(0,len(files)):
if files[i].endswith(".inp"):
inp_load_file(lines,files[i])
value=inp_search_token_value(lines, "#sim_menu_name")
if value!=False:
if value.count("@")==1:
value=value.rstrip()
command,module=value.split("@")
self.sim_mode.addItem(command)
a=store(command,module)
self.store_list.append(a)
token=inp_get_token_value("sim.inp", "#simmode")
if token.count("@")!=0:
command,module=token.split("@")
else:
command=token
found=False
all_items = [self.sim_mode.itemText(i) for i in range(self.sim_mode.count())]
for i in range(0,len(all_items)):
if all_items[i] == command:
self.sim_mode.setCurrentIndex(i)
found=True
#if there is no known mode, just set it to jv mode
if found==False:
for i in range(0,len(self.store_list)):
if self.store_list[i].token=="jv":
self.sim_mode.activated(i)
inp_update_token_value("sim.inp", "#simmode", "jv@jv",1)
break
def load_data(self):
self.tab.clear()
self.tab.setColumnCount(3)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tab.setHorizontalHeaderLabels([_("Frequency segment"), _("dfx"), _("Multiply")])
lines=[]
self.start_fx=0.0
self.list=[]
file_name="fxmesh"+str(self.index)+".inp"
ret=inp_load_file(lines,file_name)
if ret==True:
if inp_search_token_value(lines, "#ver")=="1.0":
pos=0
token,value,pos=inp_read_next_item(lines,pos)
self.fx_start=float(value)
token,value,pos=inp_read_next_item(lines,pos)
segments=int(value)
for i in range(0, segments):
token,length,pos=inp_read_next_item(lines,pos)
token,dfx,pos=inp_read_next_item(lines,pos)
token,mul,pos=inp_read_next_item(lines,pos)
self.list.append((length,dfx,mul))
tab_add(self.tab,[str(length),str(dfx),str(mul)])
return True
else:
print("file "+file_name+"wrong version")
exit("")
return False
else:
print("file "+file_name+" not found")
return False
return False
def init(self,index):
QTabWidget.__init__(self)
self.index=index
lines=[]
if inp_load_file(lines,"fxdomain"+str(self.index)+".inp")==True:
self.tab_name=inp_search_token_value(lines, "#sim_menu_name")
else:
self.tab_name=""
self.setTabsClosable(True)
self.setMovable(True)
self.tmesh = tab_fxmesh(self.index)
self.addTab(self.tmesh,_("Frequency mesh"))
self.circuit=circuit(self.index)
self.addTab(self.circuit,_("Circuit"))
def update(self):
self.sim_mode.clear()
lines=[]
files=inp_lsdir()
if files!=False:
for i in range(0,len(files)):
if files[i].endswith(".inp"):
inp_load_file(lines,files[i])
value=inp_search_token_value(lines, "#laser_name")
if value!=False:
value=value.rstrip()
self.sim_mode.addItem(value)
token=inp_get_token_value(self.config_file, "#pump_laser")
all_items = [self.sim_mode.itemText(i) for i in range(self.sim_mode.count())]
for i in range(0,len(all_items)):
if all_items[i] == token:
self.sim_mode.setCurrentIndex(i)
found=True
def clone_materials(dest,materials=["all"]):
src_dir=os.path.join(get_materials_path())
dest_dir=os.path.join(dest,"materials")
if os.path.isdir(dest_dir)==False:
os.mkdir(dest_dir)
files=os.listdir(src_dir)
for i in range(0,len(files)):
src_file=os.path.join(src_dir,files[i])
dest_file=os.path.join(dest_dir,files[i])
if files[i].endswith(".spectra"):
copyfile(src_file, dest_file)
if os.path.isdir(src_file)==True:
lines=[]
mat_sub_path=os.path.join("materials",files[i],"mat.inp")
if read_lines_from_archive(lines,os.path.join(get_inp_file_path(),"sim.gpvdm"),mat_sub_path)==True:
do_copy=False
mat_type=inp_search_token_value(lines, "#material_type")
if mat_type!=False:
if materials.count("all")!=0:
do_copy=True
if materials.count(mat_type)!=0:
do_copy=True
if do_copy==True:
print("copy",dest_file)
if os.path.isdir(dest_file)==False:
os.mkdir(dest_file)
for copy_file in ["alpha_eq.inp","alpha.omat","dos.inp","info.txt","n_eq.inp","n.omat","alpha_gen.omat","cost.xlsx","fit.inp","mat.inp","n_gen.omat","pl.inp"]:
src_mat_file=os.path.join(src_file,copy_file)
if os.path.isfile(src_mat_file)==True:
copyfile(src_mat_file,os.path.join(dest_file,copy_file))
else:
print("not copy",dest_file)
def init(self, index):
QTabWidget.__init__(self)
self.index = index
lines = []
self.file_name = os.path.join(get_sim_path(),
"fxdomain" + str(self.index) + ".inp")
lines = inp_load_file(self.file_name)
if lines != False:
self.tab_name = inp_search_token_value(lines, "#sim_menu_name")
else:
self.tab_name = ""
self.tmesh = tab_fxmesh(self.index)
self.addTab(self.tmesh, _("Frequency mesh"))
self.circuit = circuit(self.index)
self.addTab(self.circuit, _("Circuit"))
widget = tab_class()
widget.init(self.file_name, _("Configure"))
self.addTab(widget, _("Configure"))
def update(self):
self.sim_mode.clear()
lines = []
files = inp_lsdir("sim.gpvdm")
if files != False:
for i in range(0, len(files)):
if files[i].endswith(".inp"):
lines = inp_load_file(files[i])
value = inp_search_token_value(lines, "#laser_name")
if value != False:
value = value.rstrip()
self.sim_mode.addItem(value)
token = inp_get_token_value(self.config_file, "#pump_laser")
all_items = [
self.sim_mode.itemText(i) for i in range(self.sim_mode.count())
]
for i in range(0, len(all_items)):
if all_items[i] == token:
self.sim_mode.setCurrentIndex(i)
found = True
def config_load(self):
lines=[]
if inp_load_file(lines,"gui_cmp_config.inp")==True:
if self.snapshot_list.count(inp_search_token_value(lines, "#entry0"))!=0:
self.entry0.set_active(self.snapshot_list.index(inp_search_token_value(lines, "#entry0")))
else:
self.entry0.set_active(0)
if self.snapshot_list.count(inp_search_token_value(lines, "#entry1"))!=0:
self.entry1.set_active(self.snapshot_list.index(inp_search_token_value(lines, "#entry1")))
else:
self.entry1.set_active(0)
self.entry2.set_text(inp_search_token_value(lines, "#entry2"))
self.entry3.set_text(inp_search_token_value(lines, "#entry3"))
else:
self.entry0.set_active(0)
self.entry1.set_active(0)
self.entry2.set_text("n p")
self.entry3.set_text("")
def export_as(output):
tex=True
dollar="$"
col=" & "
eol=" \\\\"
ext= os.path.splitext(output)[1]
line=""
if ext==".xlsx":
gen_workbook(os.getcwd(),output)
elif (ext==".pdf") or (ext==".jpg") or (ext==".tex") or (ext==".csv"):
if ext==".csv":
tex=False
dollar=""
col="\t"
eol=""
lines=[]
if tex==True:
line=line+"\\documentclass{article}\n"
line=line+"\\providecommand{\\e}[1]{\\ensuremath{\\times 10^{#1}}}\n"
line=line+"\\begin{document}\n"
line=line+"\\pagenumbering{gobble}\n"
line=line+"\n"
files=[]
f_list=glob.iglob(os.path.join("./", "dos*.inp"))
for in_file in f_list:
files.append(in_file)
print(files)
if tex==True:
line=line+"\\begin{table}[H]\n"
line=line+"\\begin{center}\n"
line=line+" \\begin{tabular}{lll}\n"
line=line+" \\hline\n"
line=line+" Parameter"+col+"label"+col+"unit "+eol+"\n"
if tex==True:
line=line+" \\hline\n"
dos_lines=[]
for i in range(0,len(files)):
lines=[]
inp_load_file(lines,files[i])
dos_lines.append(lines)
t=tokens()
for i in range(0,len(dos_lines[0]),2):
my_token=t.find(dos_lines[0][i])
if my_token!=False:
number=""
if my_token.number_type=="e":
for ii in range(0,len(files)):
if len(files)>0:
sub="_{"+str(ii)+"}"
else:
sub=""
if dos_lines[0][i+1]!=dos_lines[ii][i+1] or ii==0:
if tex==True:
number=to_exp(dos_lines[ii][i+1])
else:
number=dos_lines[ii][i+1]
line=line+my_token.info+sub+col+dollar+number+dollar+col+dollar+pygtk_to_latex_subscript(my_token.units)+dollar+eol+"\n"
if tex==True:
line=line+" \\hline\n"
line=line+"\\end{tabular}\n"
line=line+"\\end{center}\n"
line=line+"\\caption{Density of states}\n"
line=line+"\\end{table}\n"
line=line+"\n"
files=["./device.inp","./led.inp","./device_epitaxy.inp", "./stark.inp", "./materials/redf/fit.inp", "./materials/redf/patch.inp"]
names=["Device", "LED","Device Epitaxy","Stark","Fit redf","Fit patch"]
if tex==True:
line=line+"\\begin{table}[H]\n"
line=line+"\\begin{center}\n"
line=line+" \\begin{tabular}{lll}\n"
line=line+" \\hline\n"
line=line+" Parameter"+col+"label"+col+"unit "+eol+"\n"
if tex==True:
line=line+" \\hline\n"
config_lines=[]
cur_file=0
inp_load_file(config_lines,"latex_export_info.inp")
for cur_file in range(0,len(files)):
if os.path.isfile(files[cur_file])==True:
inp_load_file(lines,files[cur_file])
t=tokens()
for i in range(0,len(lines),2):
dump_token=inp_search_token_value(config_lines, lines[i])
if dump_token=="1":
my_token=t.find(lines[i])
if my_token!=False:
if my_token.number_type=="e":
number=""
if tex==True:
#print lines
#print lines[i]
number=to_exp(dos_lines[ii][i+1])
else:
number=dos_lines[ii][i+1]
line=line+my_token.info+col+dollar+number+dollar+col+dollar+pygtk_to_latex_subscript(my_token.units)+dollar+eol+"\n"
if tex==True:
line=line+" \\hline\n"
line=line+"\\end{tabular}\n"
line=line+"\\end{center}\n"
line=line+"\\caption{"+names[cur_file]+"}\n"
line=line+"\\end{table}\n"
line=line+"\n"
if tex==True:
line=line+"\\end{document}\n"
text_file = open("doc.tex", "w")
text_file.write(line)
text_file.close()
if (ext==".pdf"):
os.system("latex -interaction=batchmode doc")
os.system("dvipdf doc.dvi")
os.system("mv doc.pdf "+output)
if (ext==".jpg"):
os.system("latex -interaction=batchmode doc")
os.system("convert -trim -bordercolor White -border 20x10 +repage -density 300 doc.dvi doc.jpg")
os.system("mv doc.jpg "+output)
if (ext==".tex"):
os.system("mv doc.tex "+output)
if (ext==".csv"):
os.system("mv doc.tex "+output)
def drawWidget(self, qp):
font = QFont('Sans', 11, QFont.Normal)
qp.setFont(font)
emission = False
lines = []
for i in range(0, epitaxy_get_layers()):
if epitaxy_get_pl_file(i) != "none":
lines = inp_load_file(epitaxy_get_pl_file(i) + ".inp")
if lines != False:
if str2bool(lines[1]) == True:
emission = True
tot = 0
for i in range(0, epitaxy_get_layers()):
tot = tot + epitaxy_get_width(i)
pos = 0.0
l = epitaxy_get_layers() - 1
lines = []
for i in range(0, epitaxy_get_layers()):
red = 0.0
green = 0.0
blue = 0.0
thick = 200.0 * epitaxy_get_width(l - i) / tot
pos = pos + thick
path = os.path.join(get_materials_path(),
epitaxy_get_mat_file(l - i), "mat.inp")
lines = inp_load_file(path)
if lines != False:
ret = inp_search_token_array(lines, "#red_green_blue")
if ret != False:
red = float(ret[0])
green = float(ret[1])
blue = float(ret[2])
self.draw_box(qp, 200, 450.0 - pos, thick * 0.9, red, green, blue,
l - i)
step = 50.0
lines = inp_load_file(os.path.join(get_sim_path(), "light.inp"))
if lines != False:
self.sun = float(inp_search_token_value(lines, "#Psun"))
if self.sun <= 0.01:
step = 200
elif self.sun <= 0.1:
step = 100
elif self.sun <= 1.0:
step = 50
elif self.sun <= 10.0:
step = 10
else:
step = 5.0
if self.sun != 0:
for x in range(0, 200, step):
self.draw_photon(qp, 210 + x, 100, False)
if emission == True:
for x in range(0, 200, 50):
self.draw_photon(qp, 240 + x, 140, True)
self.draw_mode(qp, 200, 250)
qp.drawText(40, 540 + 40, "No OpenGL support, using 2D fallback mode")
def listen(self):
#print("thread !!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
self.running = True
while (1):
understood = False
data = self.recvall(512)
if data == None:
break
#print("command=",data,len(data))
if data.startswith(str.encode("gpvdmfile")):
self.rx_file(data)
understood = True
if data.startswith(str.encode("gpvdmpercent")):
lines = data.split("\n")
percent = float(inp_search_token_value(lines, "#percent"))
self.progress_window.set_fraction(percent / 100.0)
understood = True
if data.startswith(str.encode("gpvdmjobfinished")):
lines = data.split("\n")
name = inp_search_token_value(lines, "#job_name")
self.label.set_text(gui_print_path("Finished: ", name, 60))
understood = True
if data.startswith(str.encode("gpvdmfinished")):
self.stop()
understood = True
if data.startswith(str.encode("gpvdmheadquit")):
self.stop()
print("Server quit!")
understood = True
if data.startswith(str.encode("gpvdmnodelist")):
self.process_node_list(data)
self.load_update.emit()
understood = True
if data.startswith(str.encode("gpvdm_sync_packet_two")):
self.process_sync_packet_two(data)
understood = True
if data.startswith(str.encode("gpvdm_sync_packet_one")):
self.process_sync_packet_one(data)
understood = True
if data.startswith(str.encode("gpvdm_job_list")):
self.process_job_list(data)
understood = True
if data.startswith(str.encode("gpvdm_message")):
try:
d = data.decode('UTF-8')
except:
print(data)
sys.exit(0)
d = d.split("\n")
message = inp_search_token_value(d, "#message")
self.new_message.emit(message)
understood = True
if understood == False:
print("Command ", data, "not understood")
def render(self):
#print("do draw")
clear_color()
gl_save_clear()
dos_start = -1
dos_stop = -1
epi_y_len = epitaxy_get_y_len()
dy_layer_offset = 0.05
if epi_y_len <= 0:
return
self.x_mul = 1e3
self.y_mul = 1.4 / epi_y_len
self.z_mul = 1e3
x_len = mesh_get_xlen()
max_gui_device_x = x_len * self.x_mul
max_gui_device_y = 1.0
max_gui_device_z = mesh_get_zlen() * self.z_mul
l = epitaxy_get_layers() - 1
xpoints = int(mesh_get_xpoints())
ypoints = int(mesh_get_ypoints())
zpoints = int(mesh_get_zpoints())
if ypoints > 10:
ypoints = 10
if xpoints > 10:
xpoints = 10
if ypoints > 10:
ypoints = 10
self.emission = False
self.ray_model = False
lines = inp_load_file(os.path.join(get_sim_path(), "led.inp"))
if lines != False:
self.ray_model = val = str2bool(
inp_search_token_value(lines, "#led_on"))
lines = []
for i in range(0, epitaxy_get_layers()):
if epitaxy_get_pl_file(i) != "none":
lines = inp_load_file(
os.path.join(get_sim_path(),
epitaxy_get_pl_file(i) + ".inp"))
if lines != False:
if str2bool(lines[1]) == True:
self.emission = True
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glTranslatef(self.viewpoint.x_pos, self.viewpoint.y_pos,
self.viewpoint.zoom) # Move Into The Screen
glRotatef(self.viewpoint.xRot, 1.0, 0.0, 0.0)
glRotatef(self.viewpoint.yRot, 0.0, 1.0, 0.0)
glRotatef(self.viewpoint.zRot, 0.0, 0.0, 1.0)
glColor3f(1.0, 1.5, 0.0)
glPolygonMode(GL_FRONT, GL_FILL)
threed_files = glob.glob("*.3d")
if len(threed_files) > 0:
gl_save_load()
gl_save_draw()
draw_grid()
return
#glClearColor(0.92, 0.92, 0.92, 0.5) # Clear to black.
glClearColor(0.0, 0.0, 0.0, 0.5)
lines = []
if self.render_photons == True:
self.draw_photons(max_gui_device_x, max_gui_device_z)
pos = 0.0
for i in range(0, epitaxy_get_layers()):
thick = epitaxy_get_width(l - i) * self.y_mul
obj = epitaxy_get_layer(l - i)
red = obj.r
green = obj.g
blue = obj.b
alpha = obj.alpha
if i == l - self.selected_layer:
box_lines(0.0, pos, 0, max_gui_device_x, thick,
max_gui_device_z)
if epitaxy_get_electrical_layer(l - i).startswith(
"dos"
) == True and ypoints != 0 and xpoints != 0 and zpoints != 0:
dy = thick / float(ypoints)
dx = max_gui_device_x / float(xpoints)
dz = max_gui_device_z / float(zpoints)
xshrink = 0.8
zshrink = 0.8
if dos_start == -1:
dos_start = pos
dos_stop = pos + thick
if xpoints == 1:
xshrink = 1.0
if zpoints == 1:
zshrink = 1.0
if xpoints == 1 and zpoints == 1:
box(0.0, pos, 0, max_gui_device_x, thick,
max_gui_device_z, red, green, blue, alpha)
else:
for y in range(0, ypoints):
for x in range(0, xpoints):
for z in range(0, zpoints):
box(dx * x, pos + y * (dy), z * dz,
dx * xshrink, dy * 0.8, dz * zshrink,
red, green, blue, alpha)
tab(0.0, pos, max_gui_device_z, max_gui_device_x, thick,
max_gui_device_z)
elif epitaxy_get_electrical_layer(l -
i).lower() == "contact" and (
i == l or i == 0):
for c in contacts_get_array():
if (c.position == "top"
and i == l) or (c.position == "bottom"
and i == 0):
if xpoints == 1 and zpoints == 1:
xstart = 0.0
xwidth = max_gui_device_x
else:
xstart = max_gui_device_x * (c.start / x_len)
xwidth = max_gui_device_x * (c.width / x_len)
#print("contacts",xstart,xwidth,c.width,x_len)
if (c.start + c.width) > x_len:
xwidth = max_gui_device_x - xstart
if c.depth > 0.0:
etch_depth = c.depth * self.y_mul
if c.position == "top":
box(xstart,
pos - etch_depth - dy_layer_offset, 0,
xwidth, etch_depth, max_gui_device_z,
0.0, 0.0, 1.0, 1.0)
else:
box(xstart, pos + dy_layer_offset + thick,
0, xwidth, etch_depth,
max_gui_device_z, 0.0, 0.0, 1.0, 1.0)
if c.active == True:
box(xstart, pos, 0, xwidth, thick,
max_gui_device_z, 0.0, 1.0, 0.0, alpha)
else:
box(xstart, pos, 0, xwidth, thick,
max_gui_device_z, red, green, blue, alpha)
else:
box(0.0, pos, 0, max_gui_device_x, thick, max_gui_device_z,
red, green, blue, alpha)
if self.render_text == True:
if epitaxy_get_electrical_layer(l - i).startswith(
"dos") == True:
text = epitaxy_get_name(l -
i) + " (" + _("active") + ")"
else:
text = epitaxy_get_name(l - i)
set_color(1.0, 1.0, 1.0, "text")
font = QFont("Arial")
font.setPointSize(18)
if self.viewpoint.zoom > -20:
self.renderText(max_gui_device_x + 0.1,
pos + thick / 2, max_gui_device_z,
text, font)
pos = pos + thick + dy_layer_offset
draw_mode(pos - dy_layer_offset, max_gui_device_z)
draw_rays(self.ray_file, pos - dy_layer_offset, max_gui_device_x,
self.y_mul, max_gui_device_z * 1.05)
#print(self.graph_path)
full_data_range = self.graph_z_max - self.graph_z_min
graph(0.0, dos_start, max_gui_device_z + 0.5, max_gui_device_x,
dos_stop - dos_start, full_data_range, self.graph_data)
if self.render_grid == True:
draw_grid()
if self.viewpoint.zoom < -60:
draw_stars()
def drawWidget(self, qp):
font = QFont("Sans", 11, QFont.Normal)
qp.setFont(font)
emission = False
lines = []
for i in range(0, epitaxy_get_layers()):
if epitaxy_get_pl_file(i) != "none":
if inp_load_file(lines, epitaxy_get_pl_file(i) + ".inp") == True:
if str2bool(lines[1]) == True:
emission = True
tot = 0
for i in range(0, epitaxy_get_layers()):
tot = tot + epitaxy_get_width(i)
pos = 0.0
l = epitaxy_get_layers() - 1
lines = []
for i in range(0, epitaxy_get_layers()):
thick = 200.0 * epitaxy_get_width(l - i) / tot
pos = pos + thick
path = os.path.join(get_materials_path(), epitaxy_get_mat_file(l - i), "mat.inp")
if inp_load_file(lines, path) == True:
red = float(inp_search_token_value(lines, "#Red"))
green = float(inp_search_token_value(lines, "#Green"))
blue = float(inp_search_token_value(lines, "#Blue"))
else:
print("Could not load", path)
red = 0.0
green = 0.0
blue = 0.0
self.draw_box(qp, 200, 450.0 - pos, thick * 0.9, red, green, blue, l - i)
step = 50.0
lines = []
if inp_load_file(lines, os.path.join(os.getcwd(), "light.inp")) == True:
self.sun = float(inp_search_token_value(lines, "#Psun"))
if self.sun <= 0.01:
step = 200
elif self.sun <= 0.1:
step = 100
elif self.sun <= 1.0:
step = 50
elif self.sun <= 10.0:
step = 10
else:
step = 5.0
if self.sun != 0:
for x in range(0, 200, step):
self.draw_photon(qp, 210 + x, 100, False)
if emission == True:
for x in range(0, 200, 50):
self.draw_photon(qp, 240 + x, 140, True)
self.draw_mode(qp, 200, 250)
qp.drawText(40, 540 + 40, "No OpenGL support, using 2D fallback mode")
def plot_load_oplot_file(plot_token,file_name): lines=[] if inp_load_file(lines,file_name)==True: plot_token.logy=str2bool(inp_search_token_value(lines, "#logy")) plot_token.logx=str2bool(inp_search_token_value(lines, "#logx")) plot_token.grid=str2bool(inp_search_token_value(lines, "#grid")) plot_token.invert_y=str2bool(inp_search_token_value(lines, "#invert_y")) plot_token.normalize=str2bool(inp_search_token_value(lines, "#normalize")) plot_token.norm_to_peak_of_all_data=str2bool(inp_search_token_value(lines, "#norm_to_peak_of_all_data")) plot_token.subtract_first_point=str2bool(inp_search_token_value(lines, "#subtract_first_point")) plot_token.add_min=str2bool(inp_search_token_value(lines, "#add_min")) plot_token.file0=inp_search_token_value(lines, "#file0") plot_token.file1=inp_search_token_value(lines, "#file1") plot_token.file2=inp_search_token_value(lines, "#file2") plot_token.tag0=inp_search_token_value(lines, "#tag0") plot_token.tag1=inp_search_token_value(lines, "#tag1") plot_token.tag2=inp_search_token_value(lines, "#tag2") plot_token.legend_pos=inp_search_token_value(lines, "#legend_pos") plot_token.key_units=inp_search_token_value(lines, "#key_units") plot_token.label_data=str2bool(inp_search_token_value(lines, "#label_data")) plot_token.type=inp_search_token_value(lines, "#type") plot_token.x_label=inp_search_token_value(lines, "#x_label") plot_token.y_label=inp_search_token_value(lines, "#y_label") plot_token.x_units=inp_search_token_value(lines, "#x_units") plot_token.y_units=inp_search_token_value(lines, "#y_units") plot_token.x_mul=float(inp_search_token_value(lines, "#x_mul")) plot_token.y_mul=float(inp_search_token_value(lines, "#y_mul")) plot_token.key_units=inp_search_token_value(lines, "#key_units") plot_token.x_start=float(inp_search_token_value(lines, "#x_start")) plot_token.x_stop=float(inp_search_token_value(lines, "#x_stop")) plot_token.x_points=float(inp_search_token_value(lines, "#x_points")) plot_token.y_start=float(inp_search_token_value(lines, "#y_start")) plot_token.y_stop=float(inp_search_token_value(lines, "#y_stop")) plot_token.y_points=float(inp_search_token_value(lines, "#y_points")) plot_token.time=float(inp_search_token_value(lines, "#time")) plot_token.Vexternal=float(inp_search_token_value(lines, "#Vexternal")) return True return False
def draw_graph(self):
self.layer_end=[]
self.layer_name=[]
n=0
self.my_figure.clf()
ax1 = self.my_figure.add_subplot(111)
ax2 = ax1.twinx()
x_pos=0.0
layer=0
color =['r','g','b','y','o','r','g','b','y','o']
start=0.0
for i in range(0,epitaxy_get_layers()):
if epitaxy_get_electrical_layer(i).startswith("dos")==False:
start=start-epitaxy_get_width(i)
else:
break
print("START=",start)
start=start*1e9
x_pos=start
for i in range(0,epitaxy_get_layers()):
# label=epitaxy_get_mat_file(i)
layer_ticknes=epitaxy_get_width(i)
layer_material=epitaxy_get_mat_file(i)
delta=float(layer_ticknes)*1e9
print(epitaxy_get_electrical_layer(i))
if epitaxy_get_electrical_layer(i).startswith("dos")==False:
mat_file=os.path.join(os.getcwd(),'materials',layer_material,'mat.inp')
myfile = open(mat_file)
self.mat_file_lines = myfile.readlines()
myfile.close()
for ii in range(0, len(self.mat_file_lines)):
self.mat_file_lines[ii]=self.mat_file_lines[ii].rstrip()
lumo=-float(self.mat_file_lines[1])
Eg=float(self.mat_file_lines[3])
else:
lines=[]
if inp_load_file(lines,epitaxy_get_electrical_layer(i)+".inp")==True:
lumo=-float(inp_search_token_value(lines, "#Xi"))
Eg=float(inp_search_token_value(lines, "#Eg"))
x = [x_pos,x_pos+delta,x_pos+delta,x_pos]
lumo_delta=lumo-0.1
h**o=lumo-Eg
homo_delta=h**o-0.1
if Eg==0.0:
lumo_delta=-7.0
h**o=0.0
lumo_shape = [lumo,lumo,lumo_delta,lumo_delta]
x_pos=x_pos+delta
self.layer_end.append(x_pos)
self.layer_name.append(layer_material)
ax2.fill(x,lumo_shape, color[layer],alpha=0.4)
ax2.text(x_pos-delta/1.5, lumo-0.4, epitaxy_get_name(i))
if h**o!=0.0:
homo_shape = [h**o,h**o,homo_delta,homo_delta]
ax2.fill(x,homo_shape, color[layer],alpha=0.4)
layer=layer+1
n=n+1
state=plot_state()
get_plot_file_info(state,self.optical_mode_file)
#summary="<big><b>"+self.store[path[0]][0]+"</b></big>\n"+"\ntitle: "+state.title+"\nx axis: "+state.x_label+" ("+latex_to_pygtk_subscript(state.x_units)+")\ny axis: "++" ("+latex_to_pygtk_subscript(state.y_units)+")\n\n<big><b>Double click to open</b></big>"
print("ROD!!!!",state.y_label,self.optical_mode_file)
ax1.set_ylabel(state.y_label+" ("+state.y_units+")")
ax1.set_xlabel('Position (nm)')
ax2.set_ylabel('Energy (eV)')
ax2.set_xlim([start, x_pos])
#ax2.axis(max=)#autoscale(enable=True, axis='x', tight=None)
loaded=False
if os.path.isfile("light_dump.zip"):
zf = zipfile.ZipFile("light_dump.zip", 'r')
lines = zf.read(self.optical_mode_file).split("\n")
zf.close()
loaded=True
elif os.path.isfile(self.optical_mode_file):
print("I want to load",self.optical_mode_file)
f = open(self.optical_mode_file)
lines = f.readlines()
f.close()
loaded=True
if loaded==True:
xx=[]
yy=[]
zz=[]
lines_to_xyz(xx,yy,zz,lines)
t = asarray(xx)
s = asarray(yy)
t=t*1e9
ax1.plot(t,s, 'black', linewidth=3 ,alpha=0.5)
self.my_figure.tight_layout()
def load_data(self):
self.tab.setColumnCount(7)
self.tab.clear()
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
lines = []
self.start_time = 0.0
self.fs_laser_time = 0.0
self.list = []
self.tab.setHorizontalHeaderLabels([
_("Length"),
_("dt"),
_("Start Voltage"),
_("Stop Voltage"),
_("step multiplyer"),
_("Suns"),
_("Laser")
])
print("loading", self.file_name)
lines = inp_load_file(self.file_name)
if lines != False:
if inp_search_token_value(lines, "#ver") == "1.1":
pos = 0
token, value, pos = inp_read_next_item(lines, pos)
self.start_time = float(value)
token, value, pos = inp_read_next_item(lines, pos)
self.fs_laser_time = float(value)
token, value, pos = inp_read_next_item(lines, pos)
segments = int(value)
for i in range(0, segments):
token, length, pos = inp_read_next_item(lines, pos)
token, dt, pos = inp_read_next_item(lines, pos)
token, voltage_start, pos = inp_read_next_item(lines, pos)
token, voltage_stop, pos = inp_read_next_item(lines, pos)
token, mul, pos = inp_read_next_item(lines, pos)
token, sun, pos = inp_read_next_item(lines, pos)
token, laser, pos = inp_read_next_item(lines, pos)
tab_add(self.tab, [
str(length),
str(dt),
str(voltage_start),
str(voltage_stop),
str(mul),
str(sun),
str(laser)
])
return True
else:
print("file " + self.file_name + "wrong version")
exit("")
return False
else:
print("file " + self.file_name + " not found")
return False
return False
def draw_graph(self):
self.layer_end=[]
self.layer_name=[]
self.optical_mode_file=os.path.join(get_sim_path(),"light_dump",self.data_file)
self.my_figure.clf()
ax1 = self.my_figure.add_subplot(111)
ax2 = ax1.twinx()
x_pos=0.0
layer=0
color =['r','g','b','y','o','r','g','b','y','o']
start=0.0
for i in range(0,epitaxy_get_layers()):
if epitaxy_get_electrical_layer(i).startswith("dos")==False:
start=start-epitaxy_get_width(i)
else:
break
start=start*1e9
x_pos=start
for i in range(0,epitaxy_get_layers()):
# label=epitaxy_get_mat_file(i)
layer_ticknes=epitaxy_get_width(i)
layer_material=epitaxy_get_mat_file(i)
lumo=0.0
h**o=0.0
delta=float(layer_ticknes)*1e9
#print(epitaxy_get_electrical_layer(i))
lines=[]
material_type=inp_get_token_value(os.path.join(get_materials_path(),layer_material,'mat.inp'), "#material_type")
if epitaxy_get_electrical_layer(i).startswith("dos")==False:
dos_file=os.path.join(get_materials_path(),layer_material,'dos.inp')
if os.path.isfile(dos_file)==False:
dos_file=os.path.join(get_default_material_path(),"dos.inp")
lines=inp_load_file(dos_file)
if lines!=False:
lumo=-float(inp_search_token_value(lines, "#Xi"))
Eg=float(inp_search_token_value(lines, "#Eg"))
else:
lines=inp_load_file(os.path.join(get_sim_path(),epitaxy_get_electrical_layer(i)+".inp"))
if lines!=False:
lumo=-float(inp_search_token_value(lines, "#Xi"))
Eg=float(inp_search_token_value(lines, "#Eg"))
#print("b")
x = [x_pos,x_pos+delta,x_pos+delta,x_pos]
#print("lumo=",lumo)
lumo_delta=lumo-0.1
h**o=lumo-Eg
homo_delta=h**o-0.1
draw_homo=True
y_name_pos=lumo-Eg/2
if Eg==0.0 or material_type=="metal":
lumo_delta=-7.0
draw_homo=False
y_name_pos=lumo-1.0
x_pos=x_pos+delta
self.layer_end.append(x_pos)
self.layer_name.append(layer_material)
item=ax2.text(x_pos-delta/1.5, y_name_pos, epitaxy_get_name(i))
item.set_fontsize(15)
lumo_shape = [lumo,lumo,lumo_delta,lumo_delta]
ax2.fill(x,lumo_shape, color[layer],alpha=0.4)
item=ax2.text(x_pos-delta/1.5, lumo+0.1, "%.2f eV" % lumo)
item.set_fontsize(15)
if draw_homo==True:
homo_shape = [h**o,h**o,homo_delta,homo_delta]
ax2.fill(x,homo_shape, color[layer],alpha=0.4)
item=ax2.text(x_pos-delta/1.5, lumo-Eg-0.4, "%.2f eV" % h**o)
item.set_fontsize(15)
layer=layer+1
state=dat_file()
if dat_file_read(state,self.optical_mode_file)==True:
ax1.set_ylabel(state.data_label+" ("+state.data_units+")")
ax1.set_xlabel(_("Position")+" (nm)")
ax2.set_ylabel(_("Energy")+" (eV)")
ax2.set_xlim([start, x_pos])
#ax2.axis(max=)#autoscale(enable=True, axis='x', tight=None)
for i in range(0,len(state.y_scale)):
state.y_scale[i]=state.y_scale[i]*1e9
ax1.plot(state.y_scale,state.data[0][0], 'black', linewidth=3 ,alpha=0.5)
self.my_figure.tight_layout()
def export_as(output):
tex = True
dollar = "$"
col = " & "
eol = " \\\\"
ext = os.path.splitext(output)[1]
line = ""
print(ext, output)
if ext == ".xlsx":
gen_workbook(get_sim_path(), output)
elif (ext == ".pdf") or (ext == ".jpg") or (ext == ".tex") or (ext
== ".csv"):
print(ext)
if ext == ".csv":
tex = False
dollar = ""
col = "\t"
eol = ""
lines = []
if tex == True:
line = line + "\\documentclass{article}\n"
line = line + "\\providecommand{\\e}[1]{\\ensuremath{\\times 10^{#1}}}\n"
line = line + "\\begin{document}\n"
line = line + "\\pagenumbering{gobble}\n"
line = line + "\n"
files = []
f_list = glob.iglob(os.path.join("./", "dos*.inp"))
for in_file in f_list:
files.append(in_file)
print(files)
if tex == True:
line = line + "\\begin{table}[H]\n"
line = line + "\\begin{center}\n"
line = line + " \\begin{tabular}{lll}\n"
line = line + " \\hline\n"
line = line + " Parameter" + col + "label" + col + "unit " + eol + "\n"
if tex == True:
line = line + " \\hline\n"
dos_lines = []
for i in range(0, len(files)):
lines = []
lines = inp_load_file(files[i])
dos_lines.append(lines)
t = tokens()
for i in range(0, len(dos_lines[0]), 2):
my_token = t.find(dos_lines[0][i])
if my_token != False:
number = ""
if my_token.number_type == "e":
for ii in range(0, len(files)):
if len(files) > 0:
sub = "_{" + str(ii) + "}"
else:
sub = ""
if dos_lines[0][i + 1] != dos_lines[ii][i +
1] or ii == 0:
if tex == True:
number = to_exp(dos_lines[ii][i + 1])
else:
number = dos_lines[ii][i + 1]
line = line + my_token.info + sub + col + dollar + number + dollar + col + dollar + pygtk_to_latex_subscript(
my_token.units) + dollar + eol + "\n"
if tex == True:
line = line + " \\hline\n"
line = line + "\\end{tabular}\n"
line = line + "\\end{center}\n"
line = line + "\\caption{Density of states}\n"
line = line + "\\end{table}\n"
line = line + "\n"
files = [
"./device.inp", "./led.inp", "./ray.inp", "./device_epitaxy.inp",
"./stark.inp", "./materials/redf/fit.inp",
"./materials/redf/patch.inp"
]
names = [
"Device", "LED", "Ray", "Device Epitaxy", "Stark", "Fit redf",
"Fit patch"
]
if tex == True:
line = line + "\\begin{table}[H]\n"
line = line + "\\begin{center}\n"
line = line + " \\begin{tabular}{lll}\n"
line = line + " \\hline\n"
line = line + " Parameter" + col + "label" + col + "unit " + eol + "\n"
if tex == True:
line = line + " \\hline\n"
config_lines = []
cur_file = 0
config_lines = inp_load_file("latex_export_info.inp")
for cur_file in range(0, len(files)):
if os.path.isfile(files[cur_file]) == True:
lines = inp_load_file(files[cur_file])
t = tokens()
for i in range(0, len(lines), 2):
dump_token = inp_search_token_value(config_lines, lines[i])
if dump_token == "1":
my_token = t.find(lines[i])
if my_token != False:
if my_token.number_type == "e":
number = ""
if tex == True:
#print lines
#print lines[i]
number = to_exp(dos_lines[ii][i + 1])
else:
number = dos_lines[ii][i + 1]
line = line + my_token.info + col + dollar + number + dollar + col + dollar + pygtk_to_latex_subscript(
my_token.units) + dollar + eol + "\n"
if tex == True:
line = line + " \\hline\n"
line = line + "\\end{tabular}\n"
line = line + "\\end{center}\n"
line = line + "\\caption{" + names[cur_file] + "}\n"
line = line + "\\end{table}\n"
line = line + "\n"
if tex == True:
line = line + "\\end{document}\n"
text_file = open("doc.tex", "w")
text_file.write(line)
print(line)
text_file.close()
if (ext == ".pdf"):
os.system("latex -interaction=batchmode doc")
os.system("dvipdf doc.dvi")
os.system("mv doc.pdf " + output)
if (ext == ".jpg"):
os.system("latex -interaction=batchmode doc")
os.system(
"convert -trim -bordercolor White -border 20x10 +repage -density 300 doc.dvi doc.jpg"
)
os.system("mv doc.jpg " + output)
if (ext == ".tex"):
os.system("mv doc.tex " + output)
if (ext == ".csv"):
os.system("mv doc.tex " + output)
def paintGL(self):
if self.failed==False:
dos_start=-1
dos_stop=-1
self.x_mul=1e3
self.z_mul=1e3
width=mesh_get_xlen()*self.x_mul
depth=mesh_get_zlen()*self.z_mul
l=epitaxy_get_layers()-1
xpoints=int(mesh_get_xpoints())
ypoints=int(mesh_get_ypoints())
zpoints=int(mesh_get_zpoints())
x_len=mesh_get_xlen()
self.emission=False
self.ray_model=False
lines=[]
if inp_load_file(lines,"led.inp")==True:
self.ray_model=val=str2bool(inp_search_token_value(lines, "#led_on"))
lines=[]
for i in range(0,epitaxy_get_layers()):
if epitaxy_get_pl_file(i)!="none":
if inp_load_file(lines,epitaxy_get_pl_file(i)+".inp")==True:
if str2bool(lines[1])==True:
self.emission=True
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glTranslatef(self.x_pos, self.y_pos, self.zoom) # Move Into The Screen
glRotatef(self.xRot, 1.0, 0.0, 0.0)
glRotatef(self.yRot, 0.0, 1.0, 0.0)
glRotatef(self.zRot, 0.0, 0.0, 1.0)
glColor3f( 1.0, 1.5, 0.0 )
glPolygonMode(GL_FRONT, GL_FILL);
#glClearColor(0.92, 0.92, 0.92, 0.5) # Clear to black.
glClearColor(0.0, 0.0, 0.0, 0.5)
lines=[]
if self.suns!=0:
if self.suns<=0.01:
den=1.4
elif self.suns<=0.1:
den=0.8
elif self.suns<=1.0:
den=0.6
elif self.suns<=10.0:
den=0.3
else:
den=0.2
x=np.arange(0, width , den)
z=np.arange(0, depth , den)
for i in range(0,len(x)):
for ii in range(0,len(z)):
draw_photon(x[i],z[ii],False)
if self.emission==True and self.ray_model==False:
den=0.6
x=np.arange(0, width , den)
y=np.arange(0, depth , den)
for i in range(0,len(x)):
for ii in range(0,len(y)):
draw_photon(x[i]+0.1,y[ii]+0.1,True)
tot=0
for i in range(0,epitaxy_get_layers()):
tot=tot+epitaxy_get_width(i)
pos=0.0
self.y_mul=0
if tot>0:
self.y_mul=1.5/tot
for i in range(0,epitaxy_get_layers()):
thick=epitaxy_get_width(l-i)*self.y_mul
red=self.colors[l-i].r
green=self.colors[l-i].g
blue=self.colors[l-i].b
if i==l-self.selected_layer:
box_lines(0.0,pos,0,width,thick,depth)
if epitaxy_get_electrical_layer(l-i).startswith("dos")==True:
dy=thick/float(ypoints)
dx=width/float(xpoints)
dz=depth/float(zpoints)
xshrink=0.8
zshrink=0.8
if dos_start==-1:
dos_start=pos
dos_stop=pos+thick
if xpoints==1:
xshrink=1.0
if zpoints==1:
zshrink=1.0
if xpoints==1 and zpoints==1:
box(0.0,pos,0,width,thick,depth,red,green,blue)
else:
for y in range(0,ypoints):
for x in range(0,xpoints):
for z in range(0,zpoints):
box(dx*x,pos+y*(dy),z*dz,dx*xshrink,dy*0.8,dz*zshrink,red,green,blue)
tab(0.0,pos,depth,width,thick,depth)
elif epitaxy_get_electrical_layer(l-i).lower()=="contact" and i==l:
if xpoints==1 and zpoints==1:
box(0.0,pos,0,width,thick,depth,red,green,blue)
else:
for c in contacts_get_array():
xstart=width*(c.start/x_len)
xwidth=width*(c.width/x_len)
#print("contacts",xstart,xwidth,c.width,x_len)
if (c.start+c.width)>x_len:
xwidth=width-xstart
if c.active==True:
box(xstart,pos,0,xwidth,thick,depth,0.0,1.0,0.0)
else:
box(xstart,pos,0,xwidth,thick,depth,red,green,blue)
else:
box(0.0,pos,0,width,thick,depth,red,green,blue)
if epitaxy_get_electrical_layer(l-i).startswith("dos")==True:
text=epitaxy_get_name(l-i)+" (active)"
else:
text=epitaxy_get_name(l-i)
glColor3f(1.0,1.0,1.0)
font = QFont("Arial")
font.setPointSize(18)
if self.zoom>-20:
self.renderText (width+0.1,pos+thick/2,depth, text,font)
pos=pos+thick+0.05
glRotatef(self.tet_rotate, tet_x_rate, tet_y_rate, tet_z_rate)
draw_mode(pos-0.05,depth)
draw_rays(self.ray_fast,pos-0.05,width,self.y_mul,depth*1.05)
#print(self.graph_path)
full_data_range=self.graph_z_max-self.graph_z_min
graph(0.0,dos_start,depth+0.5,width,dos_stop-dos_start,full_data_range,self.graph_data)
draw_grid()
if self.zoom<-60:
draw_stars()
