Example #1
0
    def create_model(self):
        self.tab.clear()
        self.tab.setColumnCount(6)
        if enable_betafeatures() == False:
            self.tab.setColumnHidden(5, True)
            self.tab.setColumnHidden(4, True)

        self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.tab.setHorizontalHeaderLabels([
            _("Layer name"),
            _("Thicknes"),
            _("Optical material"),
            _("Layer type"),
            _("DoS Layer"),
            _("PL Layer")
        ])
        self.tab.setColumnWidth(2, 250)
        self.tab.setRowCount(epitaxy_get_layers())

        for i in range(0, epitaxy_get_layers()):
            thick = epitaxy_get_width(i)
            material = epitaxy_get_mat_file(i)
            dos_layer = epitaxy_get_electrical_layer(i)
            pl_file = epitaxy_get_pl_file(i)
            name = epitaxy_get_name(i)

            self.add_row(i, thick, material, dos_layer, pl_file, name)
        return
Example #2
0
def epitaxy_mesh_update():

	if mesh_get_ylayers()==1:
		tot=0.0
		for i in range(0,epitaxy_get_layers()):
			width=float(epitaxy_get_width(i))
			dos_layer=epitaxy_get_electrical_layer(i)
			print(dos_layer,width)
			if dos_layer.startswith("dos")==True:
				tot=tot+width

		mesh_get_ymesh().layers[0].thick=tot
		mesh_save_y()
Example #3
0
    def update(self):
        self.notebook.clear()

        files = epitaxy_get_dos_files()
        for i in range(0, epitaxy_get_layers()):
            dos_layer = epitaxy_get_electrical_layer(i)
            if dos_layer.startswith("dos") == True:
                #add_to_widget=True

                name = "DoS of " + epitaxy_get_name(i)

                widget = tab_class()
                widget.init(dos_layer + ".inp", name)

                self.notebook.addTab(widget, name)
Example #4
0
    def draw_box(self, qp, x, y, h, r, g, b, layer):

        text = ""
        w = 200
        qp.setBrush(QColor(r * 255, g * 255, b * 255))
        qp.drawRect(x, y, 200, h)

        if epitaxy_get_electrical_layer(layer).startswith("dos") == True:
            text = epitaxy_get_name(layer) + " (active)"
            qp.setBrush(QColor(0, 0, 0.7 * 255))
            qp.drawRect(x + w + 5, y, 20, h)
        else:
            text = epitaxy_get_name(layer)

        qp.drawText(x + 200 + 40, y + h / 2, text)

        return
Example #5
0
    def draw_box(self, qp, x, y, h, r, g, b, layer):

        text = ""
        w = 200
        qp.setBrush(QColor(r * 255, g * 255, b * 255))
        qp.drawRect(x, y, 200, h)

        if epitaxy_get_electrical_layer(layer).startswith("dos") == True:
            text = epitaxy_get_name(layer) + " (active)"
            qp.setBrush(QColor(0, 0, 0.7 * 255))
            qp.drawRect(x + w + 5, y, 20, h)
        else:
            text = epitaxy_get_name(layer)

        qp.drawText(x + 200 + 40, y + h / 2, text)

        return
Example #6
0
	def draw_box(self,x,y,z,r,g,b,layer):
		text=""
		self.cr.set_source_rgb(r,g,b)

		points=[(x,y), (x+200,y), (x+200,y+z), (x,y+z)]
		self.cr.move_to(x, y)
		for px,py in points:
			self.cr.line_to(px, py)
		self.cr.fill()

		if epitaxy_get_electrical_layer(layer)=="none":
			text=epitaxy_get_name(layer)
		else:
			text=epitaxy_get_name(layer)+" (active)"
			points=[(x+285,y-60), (x+295,y-60), (x+295,y+z-60), (x+285,y+z-60)]
			self.cr.set_source_rgb(0.0,0.0,0.7)
			self.cr.move_to(points[0][0], points[0][1])
			for px,py in points:
				self.cr.line_to(px, py)
			self.cr.fill()

		r=r*0.5
		g=g*0.5
		b=b*0.5
		self.cr.set_source_rgb(r,g,b)

		points=[(x+200,y-0),(x+200,y+z), (x+200+80,y-60+z),(x+200+80,y-60)]
		self.cr.move_to(points[0][0], points[0][1])
		for px,py in points:
			self.cr.line_to(px, py)
		self.cr.fill()

		r=r*0.5
		g=g*0.5
		b=b*0.5
		self.cr.set_source_rgb(r,g,b)

		points=[(x,y),(x+200,y), (x+200+80,y-60), (x+100,y-60)]
		self.cr.move_to(points[0][0], points[0][1])
		self.cr.move_to(x, y)
		for px,py in points:
			self.cr.line_to(px, py)
		self.cr.fill()
		self.cr.set_font_size(14)
		self.cr.move_to(x+200+80+20, y-60+z/2)
		self.cr.show_text(text)
Example #7
0
	def create_model(self):
		self.tab.clear()
		self.tab.setColumnCount(6)
		if enable_betafeatures()==False:
			self.tab.setColumnHidden(5, True)
			self.tab.setColumnHidden(4, True)

		self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
		self.tab.setHorizontalHeaderLabels([_("Layer name"), _("Thicknes"), _("Optical material"), _("Layer type"), _("DoS Layer"),_("PL Layer")])

		self.tab.setRowCount(epitaxy_get_layers())

		for i in range(0,epitaxy_get_layers()):
			thick=epitaxy_get_width(i)
			material=epitaxy_get_mat_file(i)
			dos_layer=epitaxy_get_electrical_layer(i)
			pl_file=epitaxy_get_pl_file(i)
			name=epitaxy_get_name(i)

			self.add_row(i,thick,material,dos_layer,pl_file,name)
		return
Example #8
0
	def update(self):
		print "DoS update"


		for child in self.notebook.get_children():
				self.notebook.remove(child)

		files=epitaxy_get_dos_files()
		for i in range(0,epitaxy_get_layers()):
			dos_layer=epitaxy_get_electrical_layer(i)
			if dos_layer!="none":
				add_to_widget=True
				tab=tab_class()
				tab.show()
				tab.visible=True
				name="DoS of "+epitaxy_get_name(i)
				print dos_layer,files

				tab.init(dos_layer+".inp",name)
				tab.label_name=name
				self.notebook.append_page(tab, gtk.Label(name))
Example #9
0
	def __create_model(self):

		# create list store
		model = gtk.ListStore(str,str,str,str,str,str,str)

		# add items

		self.rebuild_mat_list()

		for i in range(0,epitaxy_get_layers()):
			thick=epitaxy_get_width(i)
			material=epitaxy_get_mat_file(i)
			dos_layer=epitaxy_get_electrical_layer(i)
			pl_file=epitaxy_get_pl_file(i)
			name=epitaxy_get_name(i)

			dos_file=""

			if dos_layer=="none":
				dos_file=_("no")
			else:
				dos_file=_("yes")

			scan_item_add("epitaxy.inp","#layer"+str(i),_("Material for ")+str(material),2)
			scan_item_add("epitaxy.inp","#layer"+str(i),_("Layer width ")+str(material),1)

			iter = model.append()

			model.set (iter,
			  COLUMN_NAME, str(name),
			  COLUMN_THICKNES, str(thick),
			  COLUMN_MATERIAL, str(material),
			  COLUMN_DEVICE, str(dos_file),
			  COLUMN_DOS_LAYER, str(dos_layer),
			  COLUMN_PL_FILE, str(pl_file)
			)
		return model
Example #10
0
	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)=="none":
				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
			if epitaxy_get_electrical_layer(i)=="none":
				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)
		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()
Example #11
0
File: gl.py Project: mandulaj/gpvdm
		def render(self):
			#print("do draw")
			clear_color()
			glClearColor(self.view.bg_color[0], self.view.bg_color[1], self.view.bg_color[2], 0.5)
			gl_save_clear()


			dos_start=-1
			dos_stop=-1
			epi_y_len=epitaxy_get_y_len()
			
			if epi_y_len<=0:
				return

			self.x_mul=1e3
			self.y_mul=self.gl_device_height/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.view.x_pos, self.view.y_pos, self.view.zoom) # Move Into The Screen
			
			glRotatef(self.view.xRot, 1.0, 0.0, 0.0)
			glRotatef(self.view.yRot, 0.0, 1.0, 0.0)
			glRotatef(self.view.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.

			lines=[]

			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)
					if self.tab_active_layers==True:
						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-self.dy_layer_offset,0,xwidth,etch_depth,max_gui_device_z,0.0,0.0,1.0,1.0)
								else:
									box(xstart,pos+self.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.view.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.view.zoom>-20:
						self.renderText (max_gui_device_x+0.1,pos+thick/2,max_gui_device_z, text,font)

				pos=pos+thick+self.dy_layer_offset

			draw_mode(pos-self.dy_layer_offset,max_gui_device_z)
			draw_rays(self.ray_file,pos-self.dy_layer_offset,max_gui_device_x,self.y_mul,max_gui_device_z*1.05)
			#print(self.graph_path)

			if self.view.render_photons==True:
				#print(pos)
				self.draw_photons(max_gui_device_x,pos,max_gui_device_z)

			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.view.render_grid==True:
				draw_grid()

			if self.view.zoom<-60:
				draw_stars()
Example #12
0
def gen_workbook(input_file_or_dir, output_file):
    if work_book_enabled == False:
        print("python3-openpyxl not found")
        return

    wb = Workbook()
    if os.path.isfile(input_file_or_dir):
        files = [input_file_or_dir]
    if os.path.isdir(input_file_or_dir):
        files = glob.glob(os.path.join(input_file_or_dir, "*.dat"))
    else:
        return

    ws = wb.active
    pos = 1
    for i in range(0, epitaxy_get_layers()):
        dos_layer = epitaxy_get_electrical_layer(i)
        if dos_layer.startswith("dos") == True:
            pos = workbook_from_inp(ws,
                                    pos,
                                    dos_layer + ".inp",
                                    title=epitaxy_get_name(i))

    for my_file in files:
        #print("about to save1",my_file)
        #print(my_file)
        data = dat_file()
        if dat_file_read(data, my_file, guess=False) == True:
            x = []
            y = []
            z = []
            if dat_file_read(data, my_file) == True:
                #print("read",my_file)
                ws = wb.create_sheet(
                    title=title_truncate(os.path.basename(my_file)))
                ws.cell(column=1, row=1, value=data.title)
                ws.cell(column=1,
                        row=2,
                        value=data.x_label + " (" + data.x_units + ") ")
                ws.cell(column=2,
                        row=2,
                        value=data.data_label + " (" + data.data_units + ") ")

                for i in range(0, data.y_len):
                    ws.cell(column=1, row=i + 3, value=data.y_scale[i])
                    ws.cell(column=2, row=i + 3, value=data.data[0][0][i])

                c1 = ScatterChart()
                c1.title = data.title
                c1.style = 13
                c1.height = 20
                c1.width = 20
                c1.y_axis.title = data.data_label + " (" + data.data_units + ") "
                c1.x_axis.title = data.x_label + " (" + data.x_units + ") "

                xdata = Reference(ws,
                                  min_col=1,
                                  min_row=3,
                                  max_row=3 + data.y_len)
                ydata = Reference(ws,
                                  min_col=2,
                                  min_row=3,
                                  max_row=3 + data.y_len)

                series = Series(ydata, xdata, title_from_data=True)
                c1.series.append(series)
                ws.add_chart(c1, "G4")
    #print("about to save1")
    try:
        wb.save(filename=output_file)
    except:
        return False

    return True
Example #13
0
	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()
Example #14
0
		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()