Ejemplo n.º 1
0
def new (gui):

    gui.changed = False
    gui.proj_file = ""

    # clear all collections of groups
    for name, collect in gui.collections.iteritems():

        for i in xrange(len(collect) - 1, -1, -1):
            group = collect[i]
            group.group_widget.setParent(None) # prevent display
            group.group_widget.deleteLater() # remove from list of QGroupBox widgets
            collect.remove(group) # remove from collection

    # add one group to each collection
    atmos_set0 = inputs.atmos(gui)
    gui.atmos_collection.append(dyngui.collect_obj(atmos_set0,
            dyngui.new_group(gui.atmos_list, atmos_set0)))

    galactic_set0 = inputs.galactic(gui)
    gui.galactic_collection.append(dyngui.collect_obj(galactic_set0,
            dyngui.new_group(gui.galactic_list, galactic_set0)))

    mirror_set0 = inputs.mirror(gui)
    gui.mirror_collection.append(dyngui.collect_obj(mirror_set0,
            dyngui.new_group(gui.mirror_list, mirror_set0)))

    zodiac_set0 = inputs.zodiac(gui)
    gui.zodiac_collection.append(dyngui.collect_obj(zodiac_set0,
            dyngui.new_group(gui.zodiac_list, zodiac_set0)))

    signal_set0 = inputs.signal(gui)
    gui.signal_collection.append(dyngui.collect_obj(signal_set0,
            dyngui.new_group(gui.signal_list, signal_set0)))

    compos_set0 = inputs.compos(gui)
    gui.compos_collection.append(dyngui.collect_obj(compos_set0,
            dyngui.new_group_tab(gui.compos_tabs, compos_set0, "New")))
Ejemplo n.º 2
0
    def init_UI(self):

        # setup the window
        self.resize(1000, 580)
        self.center()
        self.showMaximized()
        self.setWindowTitle("Atmospheric Modeling")

        ###
        ### Left Side (input settings)
        ###

        left = QtGui.QVBoxLayout()

        left_tabs = QtGui.QTabWidget()
        left_tabs.setTabPosition(QtGui.QTabWidget.North)
        left_tabs.setFixedWidth(400)
        left.addWidget(left_tabs, 0, QtCore.Qt.AlignLeft)

        ## -- SETTINGS -- ##

        config_panel = QtGui.QWidget()
        left_tabs.addTab(config_panel, "Settings")

        config_layout = QtGui.QVBoxLayout()
        config_panel.setLayout(config_layout)

        config_layout.addWidget(QtGui.QLabel("<h3>Project Configuration</h3>"), 0, QtCore.Qt.AlignHCenter)

        # container holding input controls
        config_area = QtGui.QScrollArea()
        config_area.setFrameShape(QtGui.QFrame.NoFrame) # don't show the border
        config_layout.addWidget(config_area)

        # list of groups of input controls
        config_controls = QtGui.QFormLayout()
        config_area.setLayout(config_controls)

        self.config_sets = inputs.pconfig(self)
        for i, single_set in enumerate(self.config_sets):
             dyngui.new_group(config_controls, single_set)
             self.groups["config" + str(i)] = self.config_sets[i]

        ## -- NOISE -- ##

        noise_panel = QtGui.QWidget()
        left_tabs.addTab(noise_panel, "Noise")
        noise_layout = QtGui.QVBoxLayout()
        noise_panel.setLayout(noise_layout)

        # tabbed control with different types of noise

        noise_tabs = QtGui.QTabWidget()
        noise_tabs.setTabPosition(QtGui.QTabWidget.West)
        noise_layout.addWidget(noise_tabs)

        # Atmospheric Radiance / Transmission

        self.atmos_toplot = [QtGui.QCheckBox("Plot Radiance"), QtGui.QCheckBox("Plot Transmission")]
        self.floating["atmos_toplot0"] = self.atmos_toplot[0]
        self.floating["atmos_toplot1"] = self.atmos_toplot[1]
        self.atmos_list = dyngui.add_tab(
                noise_tabs, "Atmospheric", "Earth's Atmosphere", self.atmos_toplot)[1]
        self.atmos_collection = []

        atmos_set0 = inputs.atmos(self)
        self.atmos_collection.append(dyngui.collect_obj(atmos_set0,
                dyngui.new_group(self.atmos_list, atmos_set0)))
        self.collections["atmos"] = self.atmos_collection

        # Galactic Emission

        self.galactic_toplot, self.galactic_list, ign = dyngui.add_tab(noise_tabs, "Galactic", "Galactic Emission")
        self.floating["galactic_toplot"] = self.galactic_toplot
        self.galactic_collection = []

        galactic_set0 = inputs.galactic(self)
        self.galactic_collection.append(dyngui.collect_obj(galactic_set0,
                dyngui.new_group(self.galactic_list, galactic_set0)))
        self.collections["galactic"] = self.galactic_collection

        # Thermal Mirror Emission

        self.mirror_toplot, self.mirror_list, ign = dyngui.add_tab(noise_tabs, "Mirror", "Thermal Mirror Emission")
        self.floating["mirror_toplot"] = self.mirror_toplot
        self.mirror_collection = []
        self.mirror_groups = []

        mirror_set0 = inputs.mirror(self)
        self.mirror_collection.append(dyngui.collect_obj(mirror_set0,
                dyngui.new_group(self.mirror_list, mirror_set0)))
        self.collections["mirror"] = self.mirror_collection

        # Zodiacal Emission

        self.zodiac_toplot, self.zodiac_list, ign = dyngui.add_tab(noise_tabs, "Zodiacal", "Zodiacal Emission")
        self.floating["zodiac_toplot"] = self.zodiac_toplot
        self.zodiac_collection = []
        self.zodiac_groups = []

        zodiac_set0 = inputs.zodiac(self)
        self.zodiac_collection.append(dyngui.collect_obj(zodiac_set0,
                dyngui.new_group(self.zodiac_list, zodiac_set0)))
        self.collections["zodiac"] = self.zodiac_collection

        # Other Noise

        self.other_toplot, other_list, ign = dyngui.add_tab(noise_tabs, "Other", "Other Noise")
        self.floating["other_toplot"] = self.other_toplot

        self.other_set = inputs.other(self)
        dyngui.new_group(other_list, self.other_set)
        self.groups["other"] = self.other_set

        ## Bottom area
        noise_bottom = QtGui.QWidget()
        noise_layout.addWidget(noise_bottom, 0, QtCore.Qt.AlignHCenter)
        noise_botlo = QtGui.QFormLayout()
        noise_bottom.setLayout(noise_botlo)

        # spectral resolution for noise sources
        self.noise_res = QtGui.QLineEdit(config.spec_res)
        self.floating["noise_res"] = self.noise_res
        noise_botlo.addRow("Resolution:", self.noise_res)

        # what to plot (BLING or Temperature)
        self.noise_whatbox = QtGui.QComboBox()
        self.floating["noise_whatbox"] = self.noise_whatbox
        self.noise_whatbox.addItem("BLING")
        self.noise_whatbox.addItem("Flux")
        self.noise_whatbox.addItem("Temperature")
        self.noise_whatbox.addItem("Diffraction-limited Flux")

        noise_botlo.addRow("Plot:", self.noise_whatbox)

        ## -- SIGNAL -- ##

        self.signal_toplot, self.signal_list, signal_layout = dyngui.add_tab(left_tabs, "Signal", "Signal")
        self.floating["signal"] = self.signal_toplot
        self.signal_collection = []
        self.signal_groups = []

        signal_set0 = inputs.signal(self)
        self.signal_collection.append(dyngui.collect_obj(signal_set0,
                dyngui.new_group(self.signal_list, signal_set0)))
        self.collections["signal"] = self.signal_collection

        ## Bottom area
        signal_bottom = QtGui.QWidget()
        signal_layout.addWidget(signal_bottom, 0, QtCore.Qt.AlignHCenter)
        signal_botlo = QtGui.QFormLayout()
        signal_bottom.setLayout(signal_botlo)

        # spectral resolution for signal
        self.signal_res = QtGui.QLineEdit(config.spec_res)
        self.floating["signal_res"] = self.signal_res
        signal_botlo.addRow("Resolution:", self.signal_res)

        ## -- COMPOSITE -- ##

        compos_panel = QtGui.QWidget()
        left_tabs.addTab(compos_panel, "Composite")

        compos_layout = QtGui.QVBoxLayout()
        compos_panel.setLayout(compos_layout)

        # tabbed control with different types of noise

        self.compos_tabs = QtGui.QTabWidget()
        self.compos_tabs.setTabPosition(QtGui.QTabWidget.West)
        compos_layout.addWidget(self.compos_tabs)

        # collection of widgets
        self.compos_collection = []

        compos_set0 = inputs.compos(self)
        self.compos_collection.append(dyngui.collect_obj(compos_set0,
                dyngui.new_group_tab(self.compos_tabs, compos_set0, "New")))
        self.collections["compos"] = self.compos_collection

        # what to plot
        compos_what = QtGui.QWidget()
        compos_layout.addWidget(compos_what, 0, QtCore.Qt.AlignHCenter)
        compos_whatlo = QtGui.QFormLayout()
        compos_what.setLayout(compos_whatlo)

        self.compos_whatbox = QtGui.QComboBox()
        self.floating["compos_whatbox"] = self.compos_whatbox
        self.compos_whatbox.addItem("Total BLING")
        self.compos_whatbox.addItem("Total Noise Flux")
        self.compos_whatbox.addItem("Total Temperature")
        self.compos_whatbox.addItem("Integration Time")

        compos_whatlo.addRow("Plot:", self.compos_whatbox)

        # changing value of widget causes project to be marked as changed
        for key, widget in self.floating.iteritems():

            if hasattr(widget, "currentIndex"):
                inputs.conn_changed(self, widget, "currentIndexChanged(int)")
            elif hasattr(widget, "checkState"):
                inputs.conn_changed(self, widget, "stateChanged(int)")
            elif hasattr(widget, "text"):
                inputs.conn_changed(self, widget, "textChanged(QString)")

        ###
        ### Right Side (input settings)
        ###

        right = QtGui.QVBoxLayout()

        ## menu bar
        menu_layout = QtGui.QVBoxLayout()
        right.addLayout(menu_layout)

        menu = QtGui.QToolBar()
        menu_layout.addWidget(menu)

        # create new project
        def new_proj ():
            # check for changes
            if self.changed: # ask to save existing project
                self.close_project(lambda: project.new(self), lambda: None)
            else: # no changes to be saved -> just open new project
                project.new(self)

        newprj = QtGui.QAction("&New", self)
        newprj.setToolTip("Reset interface")
        newprj.setShortcut("Ctrl+N")
        newprj.triggered.connect(new_proj)
        menu.addAction(newprj)

        # open project file
        def open_proj ():
            proj_file = QtGui.QFileDialog.getOpenFileName(self, "Open Project",
                    filter="Atmospheric Modeling Project (*.atmodel)")
            if len(proj_file) > 0: # open project file if a file is selected
                project.open(self, proj_file)

        def open_func ():
            # check for changes to existing project first
            if self.changed: # ask to save existing project
                self.close_project(open_proj, lambda: None)
            else: # no changes to be saved -> just open new project
                open_proj()

        openprj = QtGui.QAction("&Open", self)
        openprj.setToolTip("Open project file")
        openprj.setShortcut("Ctrl+O")
        openprj.triggered.connect(open_func)
        menu.addAction(openprj)

        # save project file
        def save_func ():
            if len(self.proj_file) > 0: # currently editing a project already
                project.save(self, self.proj_file)
            else: # no project file opened -- ask for file name
                saveas_func()

        saveprj = QtGui.QAction("&Save", self)
        saveprj.setToolTip("Save project file")
        saveprj.setShortcut("Ctrl+S")
        saveprj.triggered.connect(save_func)
        menu.addAction(saveprj)

        # save project file with different name
        def saveas_func ():
            proj_file = QtGui.QFileDialog.getSaveFileName(self, "Save Project",
                    filter="Atmospheric Modeling Project (*.atmodel)")
            if len(proj_file) > 0: # save project file if a name is selected
                project.save(self, proj_file)

        saveas = QtGui.QAction("Save As", self)
        saveas.setToolTip("Save project file with different name")
        saveas.triggered.connect(saveas_func)
        menu.addAction(saveas)

        # export data
        def export_func ():

            # allow data export only if graph exists
            if hasattr(self.plot, "graph_data"):
                export_file = QtGui.QFileDialog.getSaveFileName(self, "Export Data",
                    filter="Excel Spreadsheet (*.xlsx)")
                self.plot.export(export_file)

        export = QtGui.QAction("Export", self)
        export.setToolTip("Export data in graph")
        export.triggered.connect(export_func)
        menu.addAction(export)

        ## main graph + buttons
        self.plot = Graph()
        right.addWidget(self.plot)

        # buttons
        buttons = QtGui.QGridLayout() #QtGui.QHBoxLayout()
        right.addLayout(buttons)

        # generate graph
        self.gen_btn = QtGui.QPushButton("Generate Graph")
        self.gen_btn.setStyleSheet("background-color: #ffffff; font-weight: bold; height: 1.8em")
        buttons.addWidget(self.gen_btn, 1, 0)

        def do_generate ():
            # start calculations
            self.thread = QtCore.QThread()
            self.worker.moveToThread(self.thread)
            self.thread.started.connect(self.worker.run)
            self.worker.update(generate.process, self)
            self.thread.start()

            # do interface changes to notify of work in progress
            self.in_progress.setText("Working...")
            self.gen_btn.setEnabled(False)

        QtCore.QObject.connect(self.gen_btn,
                QtCore.SIGNAL("clicked()"), do_generate)

        # label stating "in progress"
        self.in_progress = QtGui.QLabel()
        self.in_progress.setFixedWidth(100)
        # give this cell extra column space to no push the navbar
        buttons.addWidget(self.in_progress, 1, 1)

        # add toolbar for graph
        self.toolbar = NavigationToolbar(self.plot, parent=None)
        buttons.addWidget(self.toolbar, 1, 2)

        ###

        # top level container
        top = QtGui.QHBoxLayout()
        top.addLayout(left)
        top.addLayout(right)
        self.setLayout(top)

        self.show()