def populate_from_file(self, filename, human_name=""):
        lines = []
        if filename.endswith(".inp") == False:
            filename = filename + ".inp"

        lines = inp_load_file(filename)
        if human_name == "":
            human_name = filename

        my_token_lib = tokens()

        for i in range(0, len(lines)):
            token = lines[i]
            if len(token) > 0:
                if token[0] == "#":
                    result = my_token_lib.find(token)

                    if result != False:
                        #print(filename,token,result,self.get_human_label(filename,token))
                        if self.get_human_label(filename, token) == "notknown":
                            numbered = ""
                            if bool(re.match(".+_\d+$", token.strip())
                                    ) == True:  #search for function_0
                                numbered = re.search("\d+$", token).group(0)
                            self.add_item(
                                filename, token,
                                os.path.join(human_name, numbered,
                                             result.info))
Esempio n. 2
0
def plot_populate_plot_token(plot_token,file_name):
	if file_name!=None:
		ret=plot_load_info(plot_token,file_name)
		print "ret====",ret
		if ret==True:
			return True

	#check to see if I have been provided with a token

	if plot_token!=None:
		my_token_lib=tokens()
		result0=my_token_lib.find(plot_token.tag0)
		result1=my_token_lib.find(plot_token.tag1)
		print "one=",plot_token.tag0,result0
		print "two=",plot_token.tag1,result1
		if result0!=False:
			plot_token.x_label=result0.info
			plot_token.x_units=result0.units
			plot_token.x_mul=result0.number_mul

			plot_token.y_label=result1.info
			plot_token.y_units=result1.units
			plot_token.y_mul=result1.number_mul

			plot_token.title=result0.info+" "+result1.info

			print "Found tokens",plot_token.tag0,plot_token.tag1
			return True
		else:
			print "Tokens not found",plot_token.tag0,plot_token.tag1

	return False
Esempio n. 3
0
def plot_populate_plot_token(plot_token, file_name):
    if file_name != None:
        ret = plot_load_info(plot_token, file_name)
        print("ret====", ret)
        if ret == True:
            return True

    #check to see if I have been provided with a token

    if plot_token != None:
        my_token_lib = tokens()
        result0 = my_token_lib.find(plot_token.tag0)
        result1 = my_token_lib.find(plot_token.tag1)
        print("one=", plot_token.tag0, result0)
        print("two=", plot_token.tag1, result1)
        if result0 != False:
            plot_token.x_label = result0.info
            plot_token.x_units = result0.units
            plot_token.x_mul = result0.number_mul

            plot_token.data_label = result1.info
            plot_token.data_units = result1.units
            plot_token.data_mul = result1.number_mul

            plot_token.title = result0.info + " " + result1.info

            print("Found tokens", plot_token.tag0, plot_token.tag1)
            return True
        else:
            print("Tokens not found", plot_token.tag0, plot_token.tag1)

    return False
    def gen_plot(self,
                 base_path,
                 file0,
                 token0,
                 file1,
                 token1,
                 output_file=""):
        x = []
        y = []
        plot_labels = []
        my_token_lib = tokens()

        print(base_path, output_file)
        if output_file == "":
            out_file_name = os.path.join(
                base_path,
                os.path.splitext(file0)[0] + token0 + "#" +
                os.path.splitext(file1)[0] + token1 + ".dat")
        else:
            out_file_name = output_file

        sims = search_simulations(base_path)
        out = dat_file()

        t0 = my_token_lib.find(token0)
        t1 = my_token_lib.find(token1)

        out.title = t0.info + " v.s. " + t1.info
        out.y_label = t0.info
        out.data_label = t1.info
        out.y_units = t0.units
        out.data_units = t1.units

        for s in sims:
            f = inp()
            f.load(os.path.join(s, file0))
            x.append(float(f.get_token(token0)))

            f = inp()
            f.load(os.path.join(s, file1))
            y.append(float(f.get_token(token1)))

        x, y = zip(*sorted(zip(x, y)))

        out.x_len = 1
        out.y_len = len(y)
        out.z_len = 1

        out.init_mem()

        for i in range(0, len(x)):
            out.y_scale[i] = x[i]
            out.data[0][0][i] = y[i]

        out.save(out_file_name)

        return [out_file_name], plot_labels, ""
Esempio n. 5
0
def scan_items_populate_from_known_tokens():
    my_token_lib = tokens().get_lib()
    for i in range(0, len(my_token_lib)):
        file_name = my_token_lib[i].file_name
        if file_name != "":
            scan_item_add(
                file_name, my_token_lib[i].token,
                os.path.join(
                    os.path.splitext(file_name)[0], my_token_lib[i].info), 1)
Esempio n. 6
0
def scan_populate_from_file(filename):
    lines = []
    lines = inp_load_file(filename)

    my_token_lib = tokens()

    for i in range(0, len(lines)):
        token = lines[i]
        if len(token) > 0:
            if token[0] == "#":
                result = my_token_lib.find(token)
                if result != False:
                    if scan_items_index_item(token) == -1:
                        scan_item_add(filename, token, result.info, 1)
Esempio n. 7
0
def scan_populate_from_file(filename):
    lines = []
    inp_load_file(lines, filename)

    my_token_lib = tokens()

    for i in range(0, len(lines)):
        token = lines[i]
        if len(token) > 0:
            if token[0] == "#":
                result = my_token_lib.find(token)
                if result != False:
                    if scan_items_index_item(token) == -1:
                        scan_item_add(filename, token, result.info, 1)
Esempio n. 8
0
def scan_populate_from_file(filename, human_name=""):
    lines = []
    lines = inp_load_file(filename)
    if human_name == "":
        human_name = filename

    my_token_lib = tokens()

    for i in range(0, len(lines)):
        token = lines[i]
        if len(token) > 0:
            if token[0] == "#":
                result = my_token_lib.find(token)
                if result != False:
                    if scan_items_index_item(token) == -1:

                        scan_item_add(filename, token,
                                      os.path.join(human_name, result.info), 1)
Esempio n. 9
0
def workbook_from_inp(ws, my_row, filename, title=""):
    lines = []

    lines = inp_load_file(filename)
    if lines == False:
        return my_row

    if title != "":
        ws.cell(column=1, row=my_row, value=title)
        my_row = my_row + 1

    pos = 0
    my_token_lib = tokens()

    while (1):
        ret, pos = inp_get_next_token_array(lines, pos)

        token = ret[0]
        if token == "#ver":
            break

        if token == "#end":
            break

        if token.startswith("#"):
            show = False
            units = "Units"

            value = ret[1]

            result = my_token_lib.find(token)
            if result != False:
                units = result.units
                text_info = result.info
                show = True

            if show == True and is_number(value):
                ws.cell(column=1, row=my_row, value=text_info)
                ws.cell(column=2, row=my_row, value=float(value))
                my_row = my_row + 1

    return my_row
Esempio n. 10
0
def cat_dir():
    my_token_lib = tokens()
    banned = ["dump_file.inp"]
    files = inp_lsdir(os.path.join(get_sim_path(), "sim.gpvdm"))
    h = html_gen()
    h.add_h1(_("Files within sim.gpvdm"))
    for file_name in files:
        if file_name.endswith(".inp") == True and file_name not in banned:
            h.add_collapsible(file_name)
            h.add_div("content")
            f = inp()
            f.load(os.path.join(get_sim_path(), file_name))
            tab = []
            while (1):
                token, vals = f.get_next_token_array()
                if token == False:
                    break

                result = my_token_lib.find(token)
                if result != False:
                    text_info = result.info
                    unit = result.units
                else:
                    text_info = ""
                    unit = ""

                if len(vals) > 0:
                    val = vals[0]
                else:
                    val = ""

                tab.append([token, text_info, val, unit])
            h.add_tab(tab)
            h.end_div()

    h.gen_list()
    h.save(os.path.join(get_sim_path(), "index.html"))
Esempio n. 11
0
    def __init__(self, myserver, status_bar, scan_root_dir, sim_name):
        QWidget.__init__(self)
        self.main_vbox = QVBoxLayout()

        self.tokens = tokens()
        self.sim_name = sim_name
        self.myserver = myserver
        self.status_bar = status_bar
        self.param_list = scan_items_get_list()
        #self.tab_label=tab_label

        self.sim_dir = os.path.join(scan_root_dir, sim_name)

        self.select_param_window = select_param()
        self.select_param_window.set_save_function(self.save_combo)

        toolbar = QToolBar()
        toolbar.setIconSize(QSize(32, 32))

        self.tb_add = QAction(QIcon_load("list-add"),
                              _("Add parameter to scan"), self)
        self.tb_add.triggered.connect(self.callback_add_item)
        toolbar.addAction(self.tb_add)

        self.tb_minus = QAction(QIcon_load("list-remove"), _("Delete item"),
                                self)
        self.tb_minus.triggered.connect(self.callback_delete_item)
        toolbar.addAction(self.tb_minus)

        self.tb_down = QAction(QIcon_load("go-down"), _("Move down"), self)
        self.tb_down.triggered.connect(self.callback_move_down)
        toolbar.addAction(self.tb_down)

        self.tb_up = QAction(QIcon_load("go-up"), _("Move up"), self)
        self.tb_up.triggered.connect(self.callback_move_up)
        toolbar.addAction(self.tb_up)

        #self.tb_notes = QAction(QIcon_load("go-down.png"), _("Notes"), self)
        #self.tb_notes.triggered.connect(self.callback_notes)
        #toolbar.addAction(self.tb_notes)

        #self.tb_notes = QAction(QIcon_load("select"), _("Select parameter to change"), self)
        #self.tb_notes.triggered.connect(self.callback_show_list)
        #toolbar.addAction(self.tb_notes)

        self.tb_command = QAction(QIcon_load("utilities-terminal"),
                                  _("Insert python command"), self)
        self.tb_command.triggered.connect(self.callback_insert_command)
        toolbar.addAction(self.tb_command)

        self.main_vbox.addWidget(toolbar)

        self.tab = QTableWidget()
        #self.tab.resizeColumnsToContents()

        self.tab.verticalHeader().setVisible(False)

        self.select_param_window.init(self.tab)

        self.tab.setColumnCount(5)
        #if enable_betafeatures()==False:
        #	self.tab.setColumnHidden(0, True)
        #	self.tab.setColumnHidden(1, True)

        self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.tab.setColumnWidth(2, 300)
        self.tab.setColumnWidth(3, 200)
        self.load()

        self.tab.cellChanged.connect(self.tab_changed)

        self.main_vbox.addWidget(self.tab)

        self.popMenu = QMenu(self)

        #self.mp_show_list=QAction(_("Select parameter to scan"), self)
        #self.mp_show_list.triggered.connect(self.callback_show_list)
        #self.popMenu.addAction(self.mp_show_list)

        self.popMenu.addSeparator()

        self.mp_delete = QAction(_("Delete item"), self)
        self.mp_delete.triggered.connect(self.callback_delete_item)
        self.popMenu.addAction(self.mp_delete)

        self.mp_copy = QAction(_("Copy"), self)
        self.mp_copy.triggered.connect(self.callback_copy_item)
        self.popMenu.addAction(self.mp_copy)

        self.mp_paste = QAction(_("Paste"), self)
        self.mp_paste.triggered.connect(self.callback_paste_item)
        self.popMenu.addAction(self.mp_paste)

        self.popMenu.addSeparator()

        self.mp_add = QAction(_("Add item"), self)
        self.mp_add.triggered.connect(self.callback_add_item)
        self.popMenu.addAction(self.mp_add)

        self.mp_down = QAction(_("Move down"), self)
        self.mp_down.triggered.connect(self.callback_move_down)
        self.popMenu.addAction(self.mp_down)

        self.mp_down = QAction(_("Move down"), self)
        self.mp_down.triggered.connect(self.callback_move_down)
        self.popMenu.addAction(self.mp_down)

        self.popMenu.addSeparator()
        self.setMinimumSize(700, 500)

        self.setLayout(self.main_vbox)
Esempio n. 12
0
    def init(self, filename, tab_name):
        self.scroll = QScrollArea()
        self.main_box_widget = QWidget()
        self.vbox = QVBoxLayout()
        self.hbox = QHBoxLayout()
        self.hbox.setAlignment(Qt.AlignTop)
        self.file_name = filename
        self.tab_name = tab_name

        self.tab = QGridLayout()
        widget = QWidget()
        widget.setLayout(self.tab)
        self.vbox.addWidget(widget)

        scan_remove_file(filename)

        self.edit_list = []
        self.lines = inp_load_file(filename)
        if self.lines == False:
            error_dlg(self, _("File not found.") + " " + filename)
            return
        n = 0
        pos = 0
        my_token_lib = tokens()
        widget_number = 0

        while (1):
            ret, pos = inp_get_next_token_array(self.lines, pos)

            token = ret[0]
            if token == "#ver":
                break

            if token == "#end":
                break

            if token.startswith("#"):
                show = False
                units = "Units"

                value = ret[1]

                result = my_token_lib.find(token)
                if result != False:
                    units = result.units
                    text_info = result.info
                    show = True

                #self.set_size_request(600,-1)
                if show == True:
                    description = QLabel_click()
                    description.setText(latex_to_html(text_info))
                    if os.path.isfile(
                            os.path.splitext(filename)[0] + "_" + token[1:] +
                            ".ref"):
                        description.setStyleSheet('color: green')

                    description.clicked.connect(
                        functools.partial(self.callback_ref, filename, token,
                                          description))

                    if result.widget == "gtkswitch":
                        edit_box = gtkswitch()
                        edit_box.setFixedSize(300, 25)
                        edit_box.set_value(str2bool(value))
                        edit_box.changed.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))
                    elif result.widget == "leftright":
                        edit_box = leftright()
                        edit_box.setFixedSize(300, 25)
                        edit_box.set_value(str2bool(value))
                        edit_box.changed.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))
                    elif result.widget == "gpvdm_select":
                        edit_box = gpvdm_select(file_box=True)
                        edit_box.setFixedSize(300, 25)
                        edit_box.setText(value)
                        edit_box.edit.textChanged.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))
                    elif result.widget == "QLineEdit":
                        edit_box = QLineEdit()
                        edit_box.setFixedSize(300, 25)
                        if self.editable == False:
                            edit_box.setReadOnly(True)
                        edit_box.setText(value)
                        #edit_box.set_text(self.lines[pos]);
                        edit_box.textChanged.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))
                        #edit_box.show()
                    elif result.widget == "QColorPicker":
                        r = float(ret[1])
                        g = float(ret[2])
                        b = float(ret[3])
                        edit_box = QColorPicker(r, g, b)
                        edit_box.setFixedSize(300, 25)
                        edit_box.changed.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))
                    elif result.widget == "QComboBoxLang":
                        edit_box = QComboBoxLang()
                        edit_box.setFixedSize(300, 25)
                        for i in range(0, len(result.defaults)):
                            edit_box.addItemLang(result.defaults[i][0],
                                                 result.defaults[i][1])

                        edit_box.setValue_using_english(value)

                        edit_box.currentIndexChanged.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))
                    elif result.widget == "QParasitic":
                        edit_box = QParasitic()
                        edit_box.setFixedSize(300, 25)
                        edit_box.setValue(value)
                        edit_box.textChanged.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))

                    elif result.widget == "QChangeLog":
                        edit_box = QChangeLog()
                        edit_box.setMinimumHeight(100)
                        if self.editable == False:
                            edit_box.setReadOnly(True)
                        edit_box.setText(value)
                        edit_box.textChanged.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))
                    else:
                        edit_box = QComboBox()
                        edit_box.setFixedSize(300, 25)
                        for i in range(0, len(result.defaults)):
                            edit_box.addItem(result.defaults[i])

                        all_items = [
                            edit_box.itemText(i)
                            for i in range(edit_box.count())
                        ]
                        for i in range(0, len(all_items)):
                            if all_items[i] == value:
                                edit_box.setCurrentIndex(i)
                                break

                        edit_box.currentIndexChanged.connect(
                            functools.partial(self.callback_edit, filename,
                                              token, edit_box))

                    unit = QLabel()
                    unit.setText(latex_to_html(units))

                    self.tab.addWidget(description, widget_number, 0)
                    self.tab.addWidget(edit_box, widget_number, 1)
                    self.tab.addWidget(unit, widget_number, 2)

                    scan_item_add(filename, token, text_info, 1)

                    widget_number = widget_number + 1

        spacer = QWidget()
        spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.vbox.addWidget(spacer)
        self.main_box_widget.setLayout(self.vbox)

        self.scroll.setWidget(self.main_box_widget)

        self.icon_widget = QWidget()
        self.icon_widget_vbox = QVBoxLayout()
        self.icon_widget.setLayout(self.icon_widget_vbox)

        if self.icon_file != "":
            self.image = QLabel()
            icon = QIcon_load(self.icon_file)
            self.image.setPixmap(icon.pixmap(icon.actualSize(QSize(32, 32))))
            self.icon_widget_vbox.addWidget(self.image)

            spacer2 = QWidget()
            spacer2.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
            self.icon_widget_vbox.addWidget(spacer2)

            self.hbox.addWidget(self.icon_widget)

        self.hbox.addWidget(self.scroll)

        self.setLayout(self.hbox)
Esempio n. 13
0
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)
Esempio n. 14
0
	def init(self,filename,fullname):
		scan_remove_file(filename)
		self.widget_type=[]
		self.file_name=filename
		self.edit_list=[]
		self.line_number=[]
		inp_load_file(self.lines,filename)

		n=0
		pos=0
		my_token_lib=tokens()
		height=27
		for i in range(0, len(self.lines)/2):

			show=False
			units="Units"
			token=self.lines[pos]
			result=my_token_lib.find(token)
			if result!=False:
				units=result.units
				text_info=result.info
				show=True
			pos=pos+1
			self.set_size_request(600,-1)
			if show == True :
				hbox=gtk.HBox()
				hbox.show()
				label = gtk.Label()
				label.set_size_request(400,height)
				label.set_markup(latex_to_pygtk_subscript(text_info))
				label.set_use_markup(True)
				hbox.pack_start(label, False, False, padding=1)
				label.show()

				self.line_number.append(pos)

				if result.opt[0]=="text":
					edit_box=gtk.Entry(max=0)
					edit_box.set_text(self.lines[pos]);
					edit_box.connect("changed", self.callback_edit, token)
					edit_box.show()
					self.widget_type.append("edit")
				else:
					edit_box=gtk.combo_box_new_text()
					index=0
					true_false=False
					if len(result.opt)==2:
						if result.opt[0]==_("true") and result.opt[1]==_("false"):
							true_false=True

					for i in range(0,len(result.opt)):
						edit_box.append_text(result.opt[i])
						if true_false==False:
							if yes_no(self.lines[pos])==yes_no(result.opt[i]):
								index=i
						else:
							if str2bool(self.lines[pos])==True:
								index=0
							else:
								index=1

					edit_box.set_active(index);
					
					edit_box.connect("changed", self.callback_edit, token)
					edit_box.show()
					self.widget_type.append("combo")
				edit_box.set_size_request(300,height)
				self.edit_list.append(edit_box)
				hbox.pack_start(edit_box, False, False, padding=1)

				label = gtk.Label()
				label.set_markup(latex_to_pygtk_subscript(units))
				label.set_use_markup(True)
				label.set_size_request(200,height)
				label.show()
				hbox.pack_start(label, False, False, padding=1)
				label.show()
				self.pack_start(hbox, False, False, padding=1)
				#self.add()
				line=1
				scan_item_add(filename,token,text_info,line)
				
				n=n+1

			pos=pos+1
Esempio n. 15
0
def scan_items_populate_from_known_tokens():
    my_token_lib = tokens().get_lib()
    for i in range(0, len(my_token_lib)):
        if my_token_lib[i].file_name != "":
            scan_item_add(my_token_lib[i].file_name, my_token_lib[i].token,
                          my_token_lib[i].info, 1)
Esempio n. 16
0
def export_as(output):
	tex=True
	dollar="$"
	col=" & "
	eol=" \\\\"
	ext= os.path.splitext(output)[1]
	line=""
	if (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","./ray.inp","./device_epitaxy.inp", "./stark.inp", "./materials/redf/fit.inp", "./materials/redf/patch.inp"]
		names=["Device","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)
Esempio n. 17
0
	def init(self,myserver,tooltips,status_bar,context_id,tab_label,scan_root_dir,sim_name):

		self.tokens=tokens()
		self.config=config()
		self.sim_name=sim_name
		self.clipboard = gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD)
		self.popup_menu = gtk.Menu()

		menu_item = gtk.MenuItem(_("Select parameter to scan"))
		menu_item.connect("activate", self.callback_show_list)
		self.popup_menu.append(menu_item)
		self.popup_menu.show_all()

		menu_item = gtk.SeparatorMenuItem()
		self.popup_menu.append(menu_item)
		self.popup_menu.show_all()

		menu_item = gtk.MenuItem(_("Delete item"))
		menu_item.connect("activate", self.callback_delete_item)
		self.popup_menu.append(menu_item)
		self.popup_menu.show_all()

		menu_item = gtk.MenuItem(_("Add item"))
		menu_item.connect("activate", self.callback_add_item)
		self.popup_menu.append(menu_item)
		self.popup_menu.show_all()

		menu_item = gtk.MenuItem(_("Move down"))
		menu_item.connect("activate", self.callback_move_down)
		self.popup_menu.append(menu_item)
		self.popup_menu.show_all()

		menu_item = gtk.SeparatorMenuItem()
		self.popup_menu.append(menu_item)
		self.popup_menu.show_all()

		menu_item = gtk.MenuItem(_("Copy"))
		menu_item.connect("activate", self.callback_copy_item)
		self.popup_menu.append(menu_item)

		menu_item = gtk.MenuItem(_("Paste"))
		menu_item.connect("activate", self.callback_paste_item)
		self.popup_menu.append(menu_item)

		menu_item = gtk.MenuItem(_("Delete"))
		menu_item.connect("activate", self.callback_delete_item)
		self.popup_menu.append(menu_item)
		self.popup_menu.show_all()


		self.myserver=myserver
		self.tooltips=tooltips
		self.status_bar=status_bar
		self.context_id=context_id
		self.param_list=scan_items_get_list()
		self.tab_label=tab_label
		self.liststore_op_type = gtk.ListStore(str)


		self.sim_dir=os.path.join(scan_root_dir,sim_name)
		self.tab_name=os.path.basename(os.path.normpath(self.sim_dir))

		self.status_bar.push(self.context_id, self.sim_dir)
		self.set_tab_caption(self.tab_name)

		toolbar = gtk.Toolbar()
		toolbar.set_style(gtk.TOOLBAR_ICONS)
		toolbar.set_size_request(-1, 50)
		pos=0

		image = gtk.Image()
   		image.set_from_file(os.path.join(get_image_file_path(),"add.png"))
		add = gtk.ToolButton(image)
		add.connect("clicked", self.callback_add_item)
		self.tooltips.set_tip(add, _("Add parameter to scan"))
		toolbar.insert(add, pos)
		pos=pos+1


		remove = gtk.ToolButton(gtk.STOCK_CLEAR)
		remove.connect("clicked", self.callback_delete_item)
		self.tooltips.set_tip(remove, _("Delete item"))
		toolbar.insert(remove, pos)
		pos=pos+1

		move = gtk.ToolButton(gtk.STOCK_GO_DOWN)
		move.connect("clicked", self.callback_move_down)
		self.tooltips.set_tip(move, _("Move down"))
		toolbar.insert(move, pos)
		pos=pos+1

		notes = gtk.ToolButton(gtk.STOCK_EDIT)
		notes.connect("clicked", self.callback_notes)
		self.tooltips.set_tip(notes, _("Edit notes"))
		toolbar.insert(notes, pos)
		pos=pos+1

		image = gtk.Image()
   		image.set_from_file(os.path.join(get_image_file_path(),"select.png"))
		quick = gtk.ToolButton(image)
		quick.connect("clicked", self.callback_show_list)
		self.tooltips.set_tip(quick, _("Select parameter to change"))
		toolbar.insert(quick, pos)
		pos=pos+1

		sep = gtk.SeparatorToolItem()
		sep.set_draw(True)
		sep.set_expand(False)
		toolbar.insert(sep, pos)
		pos=pos+1

		image = gtk.Image()
		image.set_from_file(os.path.join(get_image_file_path(),"forward.png"))
		tb_simulate = gtk.ToolButton(image)
		tb_simulate.connect("clicked", self.callback_run_simulation)
		self.tooltips.set_tip(tb_simulate, _("Run simulation"))
		toolbar.insert(tb_simulate, pos)
		pos=pos+1

	        image = gtk.Image()
   		image.set_from_file(os.path.join(get_image_file_path(),"pause.png"))
		self.stop = gtk.ToolButton(image)
		self.tooltips.set_tip(self.stop, _("Stop the simulation"))
		self.stop.connect("clicked", self.callback_stop_simulation)
		toolbar.insert(self.stop, pos)
		pos=pos+1

		sep = gtk.SeparatorToolItem()
		sep.set_draw(True)
		sep.set_expand(False)
		toolbar.insert(sep, pos)
		pos=pos+1

		image = gtk.Image()
		image.set_from_file(os.path.join(get_image_file_path(),"plot.png"))
		plot_select = gtk.MenuToolButton(image,"hello")
		plot_select.connect("clicked", self.callback_gen_plot_command)
		self.tooltips.set_tip(plot_select, _("Find a file to plot"))

		self.plotted_graphs = used_files_menu()
		self.plotted_graphs.init(self.sim_dir,self.callback_last_menu_click)
		plot_select.set_menu(self.plotted_graphs.menu)
		toolbar.insert(plot_select, pos)

		pos=pos+1

	        image = gtk.Image()
   		image.set_from_file(self.icon_theme.lookup_icon("view-refresh", 32, 0).get_filename())
		self.plot_open = gtk.ToolButton(image)
		self.plot_open.connect("clicked", self.callback_plot_results)
		self.plot_open.set_sensitive(False)
		self.tooltips.set_tip(self.plot_open, "Replot the graph")
		toolbar.insert(self.plot_open, pos)
		pos=pos+1

		image = gtk.Image()
   		image.set_from_file(os.path.join(get_image_file_path(),"plot_time.png"))
		self.examine = gtk.ToolButton(image)
		self.tooltips.set_tip(self.examine, _("Examine results in time domain"))
		self.examine.connect("clicked", self.callback_examine)
		toolbar.insert(self.examine, pos)
		pos=pos+1

		sep = gtk.SeparatorToolItem()
		sep.set_draw(True)
		sep.set_expand(False)
		toolbar.insert(sep, pos)
		pos=pos+1

		image = gtk.Image()
   		image.set_from_file(os.path.join(get_image_file_path(),"command.png"))
		insert_command = gtk.ToolButton(image)
		insert_command.connect("clicked", self.callback_insert_command)
		self.tooltips.set_tip(insert_command, _("Insert python command"))
		toolbar.insert(insert_command, pos)
		pos=pos+1
		#reopen_xy = gtk.ToolButton(gtk.STOCK_SELECT_COLOR)
		#reopen_xy.connect("clicked", self.callback_reopen_xy_window)
		#self.tooltips.set_tip(reopen_xy, "Reopen xy window selector")
		#toolbar.insert(reopen_xy, pos)
		#pos=pos+1

		toolbar.show_all()
		self.pack_start(toolbar, False, False, 0)#.add()

		liststore_manufacturers = gtk.ListStore(str)
		for i in range(0,len(self.param_list)):
		    liststore_manufacturers.append([self.param_list[i].name])

		self.liststore_combobox = gtk.ListStore(str, str, str, bool)

		self.config.load(self.sim_dir)
		self.visible=self.config.get_value("#visible",True)
		self.reload_liststore()


		self.treeview = gtk.TreeView(self.liststore_combobox)
		self.treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
		self.treeview.connect("button-press-event", self.on_treeview_button_press_event)


		self.select_param_window=select_param()
		self.select_param_window.init(self.liststore_combobox,self.treeview)

		column_text = gtk.TreeViewColumn(_("Values"))
		column_combo = gtk.TreeViewColumn(_("Parameter to change"))
		column_mirror = gtk.TreeViewColumn(_("Opperation"))

		cellrenderer_combo = gtk.CellRendererCombo()
		cellrenderer_combo.set_property("editable", True)
		cellrenderer_combo.set_property("model", liststore_manufacturers)
		cellrenderer_combo.set_property("text-column", 0)
		cellrenderer_combo.connect("edited", self.combo_changed, self.liststore_combobox)

		column_combo.pack_start(cellrenderer_combo, False)
		column_combo.set_min_width(240)
		column_combo.add_attribute(cellrenderer_combo, "text", 0)

		cellrenderer_mirror = gtk.CellRendererCombo()
		cellrenderer_mirror.set_property("editable", True)
		self.rebuild_liststore_op_type()
		cellrenderer_mirror.set_property("model", self.liststore_op_type)
		cellrenderer_mirror.set_property("text-column", 0)

		cellrenderer_mirror.connect("edited", self.combo_mirror_changed, self.liststore_combobox)

		column_mirror.pack_start(cellrenderer_mirror, True)
		column_mirror.set_min_width(200)
		column_mirror.add_attribute(cellrenderer_mirror, "text", 2)

		cellrenderer_text = gtk.CellRendererText()
		cellrenderer_text.set_property("editable", True)
		cellrenderer_text.connect("edited", self.text_changed, self.liststore_combobox)
		cellrenderer_text.props.wrap_width = 400
		cellrenderer_text.props.wrap_mode = gtk.WRAP_WORD

		column_text.pack_start(cellrenderer_text, False)
		column_text.set_min_width(400)
		column_text.add_attribute(cellrenderer_text, "text", 1)

		renderer_enable = gtk.CellRendererToggle()
		#renderer_enable.set_property("activatable", True)
		renderer_enable.set_activatable(True)
		renderer_enable.connect("toggled", self.toggled_cb, self.liststore_combobox)
		column_enable = gtk.TreeViewColumn(_("Enabled"),renderer_enable)
		column_enable.set_max_width(50)
		column_enable.set_visible(False)
	
		column_enable.add_attribute(renderer_enable, "active", 3)
		column_enable.pack_start(renderer_enable, False)

		self.treeview.append_column(column_combo)
		self.treeview.append_column(column_text)
		self.treeview.append_column(column_mirror)
		self.treeview.append_column(column_enable)

		#window.connect("destroy", lambda w: gtk.main_quit())
		scrolled_window = gtk.ScrolledWindow()
		scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
		scrolled_window.add(self.treeview)
		scrolled_window.set_size_request(1000, 500)
		#scrolled_window.set_min_content_height(200)

		self.pack_start(scrolled_window, True, True, 0)
		self.treeview.show()
		self.show_all()

		if self.visible==False:
			self.hide()
Esempio n. 18
0
	def __init__(self,myserver,status_bar,scan_root_dir,sim_name):
		QWidget.__init__(self)
		self.main_vbox = QVBoxLayout()

		self.tokens=tokens()
		self.sim_name=sim_name
		self.myserver=myserver
		self.status_bar=status_bar
		self.param_list=scan_items_get_list()
		#self.tab_label=tab_label

		self.sim_dir=os.path.join(scan_root_dir,sim_name)
		self.tab_name=os.path.basename(os.path.normpath(self.sim_dir))

		self.select_param_window=select_param()

		toolbar=QToolBar()
		toolbar.setIconSize(QSize(48, 48))

		self.tb_add = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add parameter to scan"), self)
		self.tb_add.triggered.connect(self.callback_add_item)
		toolbar.addAction(self.tb_add)

		self.tb_minus = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Delete item"), self)
		self.tb_minus.triggered.connect(self.callback_delete_item)
		toolbar.addAction(self.tb_minus)

		self.tb_down = QAction(QIcon(os.path.join(get_image_file_path(),"down.png")), _("Move down"), self)
		self.tb_down.triggered.connect(self.callback_move_down)
		toolbar.addAction(self.tb_down)

		#self.tb_notes = QAction(QIcon(os.path.join(get_image_file_path(),"down.png")), _("Notes"), self)
		#self.tb_notes.triggered.connect(self.callback_notes)
		#toolbar.addAction(self.tb_notes)

		#self.tb_notes = QAction(QIcon(os.path.join(get_image_file_path(),"select.png")), _("Select parameter to change"), self)
		#self.tb_notes.triggered.connect(self.callback_show_list)
		#toolbar.addAction(self.tb_notes)

		self.tb_simulate = QAction(QIcon(os.path.join(get_image_file_path(),"forward.png")), _("Run simulation"), self)
		self.tb_simulate.triggered.connect(self.callback_run_simulation)
		toolbar.addAction(self.tb_simulate)

		self.tb_stop = QAction(QIcon(os.path.join(get_image_file_path(),"pause.png")), _("Stop the simulation"), self)
		self.tb_stop.triggered.connect(self.callback_stop_simulation)
		toolbar.addAction(self.tb_stop)

		self.tb_plot = QAction(QIcon(os.path.join(get_image_file_path(),"plot.png")), _("Find a file to plot"), self)
		self.tb_plot.triggered.connect(self.callback_gen_plot_command)
		toolbar.addAction(self.tb_plot)

		self.tb_plot_time = QAction(QIcon(os.path.join(get_image_file_path(),"plot_time.png")), _("Examine results in time domain"), self)
		self.tb_plot_time.triggered.connect(self.callback_examine)
		toolbar.addAction(self.tb_plot_time)

		self.tb_command = QAction(QIcon(os.path.join(get_image_file_path(),"command.png")), _("Insert python command"), self)
		self.tb_command.triggered.connect(self.callback_insert_command)
		toolbar.addAction(self.tb_command)

		self.main_vbox.addWidget(toolbar)

		self.tab = QTableWidget()
		#self.tab.resizeColumnsToContents()

		
		self.tab.verticalHeader().setVisible(False)

		self.select_param_window.init(self.tab)
		
		self.tab.setColumnCount(5)
		#if enable_betafeatures()==False:
		#	self.tab.setColumnHidden(0, True)
		#	self.tab.setColumnHidden(1, True)

		self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
		self.tab.setColumnWidth(2, 200)
		self.tab.setColumnWidth(3, 200)
		self.load()

		self.tab.cellChanged.connect(self.tab_changed)

		self.main_vbox.addWidget(self.tab)

		self.popMenu = QMenu(self)

		#self.mp_show_list=QAction(_("Select parameter to scan"), self)
		#self.mp_show_list.triggered.connect(self.callback_show_list)
		#self.popMenu.addAction(self.mp_show_list)

		self.popMenu.addSeparator()

		self.mp_delete=QAction(_("Delete item"), self)
		self.mp_delete.triggered.connect(self.callback_delete_item)
		self.popMenu.addAction(self.mp_delete)

		self.mp_copy=QAction(_("Copy"), self)
		self.mp_copy.triggered.connect(self.callback_copy_item)
		self.popMenu.addAction(self.mp_copy)

		self.mp_paste=QAction(_("Paste"), self)
		self.mp_paste.triggered.connect(self.callback_paste_item)
		self.popMenu.addAction(self.mp_paste)

		self.popMenu.addSeparator()

		self.mp_add=QAction(_("Add item"), self)
		self.mp_add.triggered.connect(self.callback_add_item)
		self.popMenu.addAction(self.mp_add)

		self.mp_down=QAction(_("Move down"), self)
		self.mp_down.triggered.connect(self.callback_move_down)
		self.popMenu.addAction(self.mp_down)

		self.mp_down=QAction(_("Move down"), self)
		self.mp_down.triggered.connect(self.callback_move_down)
		self.popMenu.addAction(self.mp_down)

		self.popMenu.addSeparator()
		self.setMinimumSize(700,500)
		
		self.setLayout(self.main_vbox)
 def __init__(self):
     self.list = []
     self.my_token_lib = tokens().get_lib()
     self.epi = get_epi()
     self.mesh = get_mesh()
Esempio n. 20
0
    def __init__(self, scan_file):
        QWidget.__init__(self)
        self.notebook = QTabWidget()
        self.setWindowTitle(_("Parameter scan editor - (www.gpvdm.com)"))
        self.setWindowIcon(icon_get("scan"))

        self.main_vbox = QVBoxLayout()

        self.scan_tab_vbox = QVBoxLayout()

        self.tokens = tokens()
        self.myserver = server_get()
        self.status_bar = QStatusBar()
        self.param_list = get_scan_human_labels().list
        #self.tab_label=tab_label

        self.scan_io = scan_io()
        self.scan_io.parent_window = self
        #self.scan_io.set_path(self.scan_io.scan_dir)
        self.scan_io.load(scan_file)
        self.scan_io.make_dir()

        toolbar = QToolBar()
        toolbar.setIconSize(QSize(32, 32))

        self.tb_add = QAction(icon_get("list-add"), _("Add parameter to scan"),
                              self)
        self.tb_add.triggered.connect(self.callback_add_item)
        toolbar.addAction(self.tb_add)

        self.tb_minus = QAction(icon_get("list-remove"), _("Delete item"),
                                self)
        self.tb_minus.triggered.connect(self.callback_delete_item)
        toolbar.addAction(self.tb_minus)

        self.tb_down = QAction(icon_get("go-down"), _("Move down"), self)
        self.tb_down.triggered.connect(self.callback_move_down)
        toolbar.addAction(self.tb_down)

        self.tb_up = QAction(icon_get("go-up"), _("Move up"), self)
        self.tb_up.triggered.connect(self.callback_move_up)
        toolbar.addAction(self.tb_up)

        self.tb_command = QAction(icon_get("utilities-terminal"),
                                  _("Insert python command"), self)
        self.tb_command.triggered.connect(self.callback_insert_command)
        toolbar.addAction(self.tb_command)

        self.scan_tab_vbox.addWidget(toolbar)

        self.tab = gpvdm_tab()

        css_apply(self.notebook, "tab_default.css")
        self.notebook.setMovable(True)

        self.tab.verticalHeader().setVisible(False)

        self.tab.setColumnCount(5)
        #if enable_betafeatures()==False:
        #	self.tab.setColumnHidden(0, True)
        #	self.tab.setColumnHidden(1, True)

        self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.tab.setColumnWidth(2, 300)
        self.tab.setColumnWidth(3, 300)
        self.tab.setColumnWidth(4, 300)
        self.load()

        self.tab.cellChanged.connect(self.tab_changed)

        self.scan_tab_vbox.addWidget(self.tab)

        self.notebook.popMenu = QMenu(self)

        #self.mp_show_list=QAction(_("Select parameter to scan"), self)
        #self.mp_show_list.triggered.connect(self.callback_show_list)
        #self.popMenu.addAction(self.mp_show_list)

        self.notebook.popMenu.addSeparator()

        self.mp_delete = QAction(_("Delete item"), self)
        self.mp_delete.triggered.connect(self.callback_delete_item)
        self.notebook.popMenu.addAction(self.mp_delete)

        self.mp_copy = QAction(_("Copy"), self)
        self.mp_copy.triggered.connect(self.callback_copy_item)
        self.notebook.popMenu.addAction(self.mp_copy)

        self.mp_paste = QAction(_("Paste"), self)
        self.mp_paste.triggered.connect(self.callback_paste_item)
        self.notebook.popMenu.addAction(self.mp_paste)

        self.notebook.popMenu.addSeparator()

        self.mp_add = QAction(_("Add item"), self)
        self.mp_add.triggered.connect(self.callback_add_item)
        self.notebook.popMenu.addAction(self.mp_add)

        self.mp_down = QAction(_("Move down"), self)
        self.mp_down.triggered.connect(self.callback_move_down)
        self.notebook.popMenu.addAction(self.mp_down)

        self.mp_down = QAction(_("Move down"), self)
        self.mp_down.triggered.connect(self.callback_move_down)
        self.notebook.popMenu.addAction(self.mp_down)

        self.notebook.popMenu.addSeparator()
        self.notebook.setMinimumSize(700, 500)

        self.program_widget = QWidget()
        self.program_widget.setLayout(self.scan_tab_vbox)
        self.notebook.addTab(self.program_widget, "Commands")

        self.viewer = gpvdm_viewer(self.scan_io.scan_dir)
        self.viewer.show_back_arrow = True
        self.notebook.addTab(self.viewer, "Output")

        self.ribbon = scan_tab_ribbon()
        self.ribbon.tb_simulate.triggered.connect(self.callback_run_simulation)
        self.ribbon.tb_clean.triggered.connect(self.clean_scan_dir)
        self.ribbon.tb_plot.triggered.connect(self.callback_gen_plot_command)
        self.ribbon.tb_notes.triggered.connect(self.callback_notes)

        self.main_vbox.addWidget(self.ribbon)
        self.main_vbox.addWidget(self.notebook)

        self.main_vbox.addWidget(self.status_bar)
        self.setLayout(self.main_vbox)
        self.select_param_window = select_param(self.tab)
Esempio n. 21
0
	def populate(self,lines):

		self.f.lines=lines
		n=0
		pos=0
		my_token_lib=tokens()
		widget_number=0
		bib=bibtex()
		if self.file_name!=None:
			bib.load(os.path.splitext(self.file_name)[0]+".bib")
		while (1):
			token,values=self.f.get_next_token_array()
			if token=="#ver":
				break

			if token=="#end":
				break

			if token.startswith("#"):
				show=False
				units="Units"

				value=values[0]

				result=my_token_lib.find(token)
				if result!=False:
					#print(token,result.info)
					units=result.units
					text_info=result.info
					show=True
					if result.hidden==True:
						show=False
				
				if show == True :
					description=QLabel_click()
					description.setText(latex_to_html(text_info))
					if self.file_name!=None:
						if bib.get_ref(token)!=False:
							description.setStyleSheet('color: green')
						description.clicked.connect(functools.partial(self.callback_ref,token,description))

					#units widget
					if result.units_widget=="QLabel":
						unit=QLabel()
						unit.setText(latex_to_html(units))
					elif result.units_widget=="QPushButton":
						unit=QPushButton()
						unit.setText(latex_to_html(units))
						unit.setFixedSize(50, 25)

					#edit widget
					if result.widget=="gtkswitch":
						edit_box=gtkswitch()
						edit_box.setFixedSize(300, 25)
						edit_box.changed.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="leftright":
						edit_box=leftright()
						edit_box.setFixedSize(300, 25)
						edit_box.changed.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="gpvdm_select":
						edit_box=gpvdm_select(file_box=True)
						edit_box.setFixedSize(300, 25)
						edit_box.edit.textChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="gpvdm_select_material":
						edit_box=gpvdm_select_material(file_box=False)
						edit_box.setFixedSize(300, 25)
						edit_box.edit.textChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))

					elif result.widget=="gpvdm_select_emission":
						edit_box=gpvdm_select_emission(file_box=False)
						edit_box.setFixedSize(300, 25)
						edit_box.edit.textChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))

					elif result.widget=="QLineEdit":
						edit_box=QLineEdit()
						edit_box.setFixedSize(300, 25)
						if self.editable==False:
							edit_box.setReadOnly(True)

						edit_box.textChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
						#edit_box.show()
					elif result.widget=="QColorPicker":
						r=float(values[0])
						g=float(values[1])
						b=float(values[2])
						edit_box=QColorPicker(r,g,b)
						edit_box.setFixedSize(300, 25)
						edit_box.changed.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="QComboBoxLang":
						edit_box=QComboBoxLang()
						edit_box.setFixedSize(300, 25)
						for i in range(0,len(result.defaults)):
							edit_box.addItemLang(result.defaults[i][0],result.defaults[i][1])
								
						edit_box.currentIndexChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="QComboBoxNewtonSelect":
						edit_box=QComboBoxNewtonSelect()
						edit_box.setFixedSize(300, 25)
						for i in range(0,len(result.defaults)):
							edit_box.addItem(result.defaults[i])

						edit_box.currentIndexChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="QComboBoxShape":
						edit_box=QComboBoxShape()
						edit_box.setFixedSize(300, 25)
						edit_box.currentIndexChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))

					elif result.widget=="QParasitic":
						edit_box=QParasitic()
						edit_box.setFixedSize(300, 25)
						edit_box.textChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))

					elif result.widget=="QChangeLog":
						edit_box=QChangeLog(self)
						edit_box.setMinimumHeight(100)
						if self.editable==False:
							edit_box.setReadOnly(True)
						edit_box.textChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="generic_switch":
						edit_box=generic_switch(state0=result.defaults[0][0],state1=result.defaults[1][0],state0_value=result.defaults[0][1],state1_value=result.defaults[1][1],)
						edit_box.setFixedSize(300, 25)
						if value=="exponential":
							unit.setEnabled(False)
						edit_box.changed.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="mobility_widget":
						edit_box=mobility_widget(electrons=result.defaults[0])
						edit_box.setFixedSize(400, 25)
						if token=="#symmetric_mobility_e":
							value = [self.f.get_token(token),self.f.get_token("#mue_z"),self.f.get_token("#mue_x"),self.f.get_token("#mue_y")]
						if token=="#symmetric_mobility_h":
							value = [self.f.get_token(token),self.f.get_token("#muh_z"),self.f.get_token("#muh_x"),self.f.get_token("#muh_y")]
						if token=="#electrical_symmetrical_resistance":
							value = [self.f.get_token(token),self.f.get_token("#electrical_series_z"),self.f.get_token("#electrical_series_x"),self.f.get_token("#electrical_series_y")]

						edit_box.changed.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
					elif result.widget=="shape_dos_switch":
						edit_box=shape_dos_switch()
						edit_box.shape_file=self.file_name
						edit_box.setFixedSize(300, 25)
						edit_box.changed.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))
						if value=="none":
							unit.setEnabled(False)

					else:
						edit_box=QComboBox()
						edit_box.setFixedSize(300, 25)
						for i in range(0,len(result.defaults)):
							edit_box.addItem(result.defaults[i])
						
						edit_box.currentIndexChanged.connect(functools.partial(self.callback_edit,token,edit_box,unit,result))

					widget_set_value(edit_box,value)

					if type(unit)==QPushButton:
						unit.clicked.connect(functools.partial(self.callback_unit_click,token,edit_box,unit))

					a=tab_line()
					a.token=token
					a.label=description
					a.edit_box=edit_box
					a.units=unit
					a.widget=result.widget
					a.hide_on_true_token=result.hide_on_true_token
					a.hide_on_false_token=result.hide_on_false_token
					a.hide_on_token_eq=result.hide_on_token_eq

					self.widget_list.append(a)
					self.tab.addWidget(description,widget_number,0)
					self.tab.addWidget(edit_box,widget_number,1)
					self.tab.addWidget(unit,widget_number,2)
										
					widget_number=widget_number+1

		self.hide_show_widgets()
Esempio n. 22
0
    def init(self, filename, tab_name):
        self.vbox = QVBoxLayout()
        self.file_name = filename
        self.tab_name = tab_name

        self.tab = QGridLayout()
        widget = QWidget()
        widget.setLayout(self.tab)
        self.vbox.addWidget(widget)

        scan_remove_file(filename)

        self.edit_list = []
        inp_load_file(self.lines, filename)

        n = 0
        pos = 0
        my_token_lib = tokens()
        height = 27
        widget_number = 0
        while pos < len(self.lines):
            token = self.lines[pos]
            if token == "#ver":
                break

            if token == "#end":
                break

            if token.startswith("#"):
                show = False
                units = "Units"

                pos = pos + 1
                value = self.lines[pos]

                result = my_token_lib.find(token)
                if result != False:
                    units = result.units
                    text_info = result.info
                    show = True

                    # self.set_size_request(600,-1)
                if show == True:
                    description = QLabel()
                    description.setText(latex_to_html(text_info))

                    if result.opt[0] == "switch":
                        edit_box = gtkswitch()
                        edit_box.set_value(str2bool(value))
                        edit_box.changed.connect(functools.partial(self.callback_edit, filename, token, edit_box))
                    elif result.opt[0] == "leftright":
                        edit_box = leftright()
                        edit_box.set_value(str2bool(value))
                        edit_box.changed.connect(functools.partial(self.callback_edit, filename, token, edit_box))
                    elif result.opt[0] == "text":
                        edit_box = QLineEdit()
                        if self.editable == False:
                            edit_box.setReadOnly(True)
                        edit_box.setText(value)
                        # edit_box.set_text(self.lines[pos]);
                        edit_box.textChanged.connect(functools.partial(self.callback_edit, filename, token, edit_box))
                        # edit_box.show()
                    else:
                        edit_box = QComboBox()
                        for i in range(0, len(result.opt)):
                            edit_box.addItem(result.opt[i])

                        all_items = [edit_box.itemText(i) for i in range(edit_box.count())]
                        for i in range(0, len(all_items)):
                            if all_items[i] == token:
                                edit_box.setCurrentIndex(i)

                        edit_box.currentIndexChanged.connect(
                            functools.partial(self.callback_edit, filename, token, edit_box)
                        )

                    edit_box.setFixedSize(300, 25)
                    unit = QLabel()
                    unit.setText(latex_to_html(units))

                    self.tab.addWidget(description, widget_number, 0)
                    self.tab.addWidget(edit_box, widget_number, 1)
                    self.tab.addWidget(unit, widget_number, 2)

                    scan_item_add(filename, token, text_info, 1)

                    widget_number = widget_number + 1
            pos = pos + 1

        spacer = QWidget()
        spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.vbox.addWidget(spacer)

        self.setLayout(self.vbox)