Пример #1
0
Файл: plot.py Проект: rolk/ert
def createPlotPage(configPanel, parent):
    configPanel.startPage("Plot")

    r = configPanel.addRow(PathChooser(parent, "Output path", "config/plot/path"))
    r.getter = lambda ert : ert.enkf.plot_config_get_path(ert.plot_config)
    r.setter = lambda ert, value : ert.enkf.plot_config_set_path(ert.plot_config, str(value))

    r = configPanel.addRow(ComboChoice(parent, ["PLPLOT", "TEXT"], "Driver", "config/plot/plot_driver"))
    r.getter = lambda ert : ert.enkf.plot_config_get_driver(ert.plot_config)
    r.setter = lambda ert, value : ert.enkf.plot_config_set_driver(ert.plot_config, str(value))

    r = configPanel.addRow(IntegerSpinner(parent, "Errorbar max", "config/plot/plot_errorbar_max", 1, 10000000))
    r.getter = lambda ert : ert.enkf.plot_config_get_errorbar_max(ert.plot_config)
    r.setter = lambda ert, value : ert.enkf.plot_config_set_errorbar_max(ert.plot_config, value)

    r = configPanel.addRow(IntegerSpinner(parent, "Width", "config/plot/width", 1, 10000))
    r.getter = lambda ert : ert.enkf.plot_config_get_width(ert.plot_config)
    r.setter = lambda ert, value : ert.enkf.plot_config_set_width(ert.plot_config, value)

    r = configPanel.addRow(IntegerSpinner(parent, "Height", "config/plot/plot_height", 1, 10000))
    r.getter = lambda ert : ert.enkf.plot_config_get_height(ert.plot_config)
    r.setter = lambda ert, value : ert.enkf.plot_config_set_height(ert.plot_config, value)

    r = configPanel.addRow(PathChooser(parent, "Image Viewer", "config/plot/image_viewer", True))
    r.getter = lambda ert : ert.enkf.plot_config_get_viewer(ert.plot_config)
    r.setter = lambda ert, value : ert.enkf.plot_config_set_viewer(ert.plot_config, str(value))

    r = configPanel.addRow(ComboChoice(parent, ["bmp", "jpg", "png", "tif"], "Image type", "config/plot/image_type"))
    r.getter = lambda ert : ert.enkf.plot_config_get_image_type(ert.plot_config)
    r.setter = lambda ert, value : ert.enkf.plot_config_set_image_type(ert.plot_config, str(value))


    configPanel.endPage()
Пример #2
0
def createEnsemblePage(configPanel, parent):
    configPanel.startPage("Ensemble")

    r = configPanel.addRow(
        IntegerSpinner(parent, "Number of realizations",
                       "config/ensemble/num_realizations", 1, 10000))

    r.getter = lambda ert: ert.enkf.enkf_main_get_ensemble_size(ert.main)
    r.setter = lambda ert, value: ert.enkf.enkf_main_resize_ensemble(
        ert.main, value)

    parent.connect(r, QtCore.SIGNAL("contentsChanged()"),
                   lambda: r.modelEmit("ensembleResized()"))

    configPanel.startGroup("Parameters")
    r = configPanel.addRow(ParameterPanel(parent, "",
                                          ""))  # no help file necessary
    parent.connect(r, QtCore.SIGNAL("contentsChanged()"),
                   lambda: r.modelEmit("ensembleUpdated()"))

    def getEnsembleParameters(ert):
        keys = ert.getStringList(ert.enkf.ensemble_config_alloc_keylist(
            ert.ensemble_config),
                                 free_after_use=True)

        parameters = []
        for key in keys:
            node = ert.enkf.ensemble_config_get_node(ert.ensemble_config, key)
            type = ert.enkf.enkf_config_node_get_impl_type(node)
            data = ert.enkf.enkf_config_node_get_ref(node)
            #print key, type

            model = None
            if type == FieldModel.TYPE:
                model = FieldModel(key)

                field_type = ert.enkf.field_config_get_type(data)
                field_type = enums.field_type[field_type]
                model["type"] = field_type

                truncation = ert.enkf.field_config_get_truncation_mode(data)

                if truncation & enums.truncation_type.TRUNCATE_MAX:
                    model["max"] = ert.enkf.field_config_get_truncation_max(
                        data)

                if truncation & enums.truncation_type.TRUNCATE_MIN:
                    model["min"] = ert.enkf.field_config_get_truncation_min(
                        data)

                model["init"] = ert.enkf.field_config_get_init_transform_name(
                    data)
                model[
                    "output"] = ert.enkf.field_config_get_output_transform_name(
                        data)

                model["init_files"] = ert.enkf.field_config_get_init_file_fmt(
                    data)
                model["min_std"] = ert.enkf.enkf_config_node_get_min_std_file(
                    node)
                model[
                    "enkf_outfile"] = ert.enkf.enkf_config_node_get_enkf_outfile(
                        node)
                model[
                    "enkf_infile"] = ert.enkf.enkf_config_node_get_enkf_infile(
                        node)

            elif type == DataModel.TYPE:
                model = DataModel(key)

                output_format_value = ert.enkf.gen_data_config_get_output_format(
                    data)
                output_format = gen_data_file_format.resolveValue(
                    output_format_value)

                input_format_value = ert.enkf.gen_data_config_get_input_format(
                    data)
                input_format = gen_data_file_format.resolveValue(
                    input_format_value)

                template_file = ert.enkf.gen_data_config_get_template_file(
                    data)
                template_key = ert.enkf.gen_data_config_get_template_key(data)
                init_file_fmt = ert.enkf.gen_data_config_get_init_file_fmt(
                    data)

                model["output_format"] = output_format
                model["input_format"] = input_format
                model["template_file"] = template_file
                model["template_key"] = template_key
                model["init_file_fmt"] = init_file_fmt

                min_std = ert.enkf.enkf_config_node_get_min_std_file(node)
                enkf_outfile = ert.enkf.enkf_config_node_get_enkf_outfile(node)
                enkf_infile = ert.enkf.enkf_config_node_get_enkf_infile(node)

                model["min_std"] = min_std
                model["enkf_outfile"] = enkf_outfile
                model["enkf_infile"] = enkf_infile

            elif type == KeywordModel.TYPE:
                model = KeywordModel(key)
                model["min_std"] = ert.enkf.enkf_config_node_get_min_std_file(
                    node)
                model[
                    "enkf_outfile"] = ert.enkf.enkf_config_node_get_enkf_outfile(
                        node)
                model["template"] = ert.enkf.gen_kw_config_get_template_file(
                    data)
                model["init_file"] = ert.enkf.gen_kw_config_get_init_file_fmt(
                    data)
                model[
                    "parameter_file"] = ert.enkf.gen_kw_config_get_parameter_file(
                        data)
            elif type == SummaryModel.TYPE:
                model = SummaryModel(key)
            else:
                pass  #Unknown type

            model.setValid(ert.enkf.enkf_config_node_is_valid(node))

            parameters.append(model)

        return parameters

    def removeParameter(ert, parameter_key):
        ert.enkf.enkf_main_del_node(ert.main, parameter_key)

    def insertParameter(ert, parameter):
        key = parameter.getName()
        if parameter.getType() == FieldModel.TYPE:
            grid = ert.enkf.ecl_config_get_grid(ert.ecl_config)
            node = ert.enkf.ensemble_config_add_field(ert.ensemble_config, key,
                                                      grid)
            parameter.setValid(ert.enkf.enkf_config_node_is_valid(node))
        elif parameter.getType() == DataModel.TYPE:
            node = ert.enkf.ensemble_config_add_gen_data(
                ert.ensemble_config, key)
            parameter.setValid(ert.enkf.enkf_config_node_is_valid(node))
        elif parameter.getType() == KeywordModel.TYPE:
            node = ert.enkf.ensemble_config_add_gen_kw(ert.ensemble_config,
                                                       key)
            parameter.setValid(ert.enkf.enkf_config_node_is_valid(node))
        elif parameter.getType() == SummaryModel.TYPE:
            parameter.setValid(True)
            b = ert.enkf.ensemble_config_add_summary(ert.ensemble_config, key)
            return b > 0  #0 == NULL
        else:
            print "Unknown type: ", parameter
            return False

        return True

    def updateParameter(ert, parameter_model):
        key = parameter_model.getName()
        node = ert.enkf.ensemble_config_get_node(ert.ensemble_config, key)

        if isinstance(parameter_model, FieldModel):
            type = parameter_model["type"]

            minimum = parameter_model["min"]
            maximum = parameter_model["max"]
            truncate = truncation_type.resolveTruncationType(minimum, maximum)

            if minimum == "":
                minimum = 0.0

            if maximum == "":
                maximum = 0.0

            if type == field_type.ECLIPSE_RESTART:  #dynamic
                ert.enkf.enkf_config_node_update_state_field(
                    node, truncate.value(), float(minimum), float(maximum))
            elif type == field_type.ECLIPSE_PARAMETER:  #parameter
                ert.enkf.enkf_config_node_update_parameter_field(
                    node, ert.nonify(parameter_model["enkf_outfile"]),
                    ert.nonify(parameter_model["init_files"]),
                    ert.nonify(parameter_model["min_std"]), truncate.value(),
                    float(minimum), float(maximum), parameter_model["init"],
                    parameter_model["output"])
            elif type == field_type.GENERAL:  #general
                ert.enkf.enkf_config_node_update_general_field(
                    node, ert.nonify(parameter_model["enkf_outfile"]),
                    ert.nonify(parameter_model["enkf_infile"]),
                    ert.nonify(parameter_model["init_files"]),
                    ert.nonify(parameter_model["min_std"]), truncate.value(),
                    float(minimum), float(maximum), parameter_model["init"],
                    None, parameter_model["output"])

            parameter_model.setValid(ert.enkf.enkf_config_node_is_valid(node))

        elif isinstance(parameter_model, KeywordModel):
            enkf_outfile_fmt = parameter_model["enkf_outfile"]
            template_file = parameter_model["template"]
            parameter_file = parameter_model["parameter_file"]
            min_std_file = parameter_model["min_std"]
            init_file_fmt = parameter_model["init_files"]
            ert.enkf.enkf_config_node_update_gen_kw(
                node, ert.nonify(enkf_outfile_fmt), ert.nonify(template_file),
                ert.nonify(parameter_file), ert.nonify(min_std_file),
                ert.nonify(init_file_fmt))
            parameter_model.setValid(ert.enkf.enkf_config_node_is_valid(node))
        elif isinstance(parameter_model, SummaryModel):
            #should never be called from SummaryModel...
            raise AssertionError("Summary keys can not be updated!")
        elif isinstance(parameter_model, DataModel):
            input_format = gen_data_file_format.resolveName(
                str(parameter_model["input_format"]))
            output_format = gen_data_file_format.resolveName(
                str(parameter_model["output_format"]))
            ert.enkf.enkf_config_node_update_gen_data(
                node, input_format.value(), output_format.value(),
                ert.nonify(parameter_model["init_file_fmt"]),
                ert.nonify(parameter_model["template_file"]),
                ert.nonify(parameter_model["template_key"]),
                ert.nonify(parameter_model["enkf_outfile"]),
                ert.nonify(parameter_model["enkf_infile"]),
                ert.nonify(parameter_model["min_std"]))
            parameter_model.setValid(ert.enkf.enkf_config_node_is_valid(node))
        else:
            raise AssertionError("Type is not supported: %s" %
                                 (parameter_model.__class__))

        if ert.enkf.enkf_config_node_is_valid(node):
            ert.enkf.enkf_main_update_node(ert.main, key)

    r.getter = getEnsembleParameters
    r.remove = removeParameter
    r.insert = insertParameter
    r.setter = updateParameter
    configPanel.endGroup()

    configPanel.endPage()
Пример #3
0
def createAnalysisPage(configPanel, parent):
    configPanel.startPage("Analysis")

    r = configPanel.addRow(CheckBox(parent, "ENKF rerun", "config/analysis/enkf_rerun", "Perform rerun"))
    r.getter = lambda ert : ert.enkf.analysis_config_get_rerun(ert.analysis_config)
    r.setter = lambda ert, value : ert.enkf.analysis_config_set_rerun(ert.analysis_config, value)

    r = configPanel.addRow(IntegerSpinner(parent, "Rerun start", "config/analysis/rerun_start",  0, 100000))
    r.getter = lambda ert : ert.enkf.analysis_config_get_rerun_start(ert.analysis_config)
    r.setter = lambda ert, value : ert.enkf.analysis_config_set_rerun_start(ert.analysis_config, value)

    r = configPanel.addRow(PathChooser(parent, "ENKF schedule file", "config/analysis/enkf_sched_file"))
    r.getter = lambda ert : ert.enkf.model_config_get_enkf_sched_file(ert.enkf.enkf_main_get_model_config(ert.main))
    r.setter = lambda ert, value : ert.enkf.model_config_set_enkf_sched_file(ert.enkf.enkf_main_get_model_config(ert.main), str(value))

    r = configPanel.addRow(ert_gui.widgets.tablewidgets.KeywordList(parent, "Local config", "config/analysis/local_config"))
    r.newKeywordPopup = lambda list : QtGui.QFileDialog.getOpenFileName(r, "Select a path", "")

    def get_local_config_files(ert):
        local_config = ert.enkf.enkf_main_get_local_config(ert.main)
        config_files_pointer = ert.enkf.local_config_get_config_files(local_config)
        return ert.getStringList(config_files_pointer)

    r.getter = get_local_config_files

    def add_config_file(ert, value):
        local_config = ert.enkf.enkf_main_get_local_config(ert.main)
        ert.enkf.local_config_clear_config_files(local_config)

        for file in value:
            ert.enkf.local_config_add_config_file(local_config, file)

    r.setter = add_config_file

    r = configPanel.addRow(PathChooser(parent, "Update log", "config/analysis/update_log"))
    r.getter = lambda ert : ert.enkf.analysis_config_get_log_path(ert.analysis_config)
    r.setter = lambda ert, value : ert.enkf.analysis_config_set_log_path(ert.analysis_config, str(value))


    configPanel.startGroup("EnKF")

    r = configPanel.addRow(DoubleSpinner(parent, "Alpha", "config/analysis/enkf_alpha", 0, 100000, 2))
    r.getter = lambda ert : ert.enkf.analysis_config_get_alpha(ert.analysis_config)
    r.setter = lambda ert, value : ert.enkf.analysis_config_set_alpha(ert.analysis_config, value)

    r = configPanel.addRow(CheckBox(parent, "Merge Observations", "config/analysis/enkf_merge_observations", "Perform merge"))
    r.getter = lambda ert : ert.enkf.analysis_config_get_merge_observations(ert.analysis_config)
    r.setter = lambda ert, value : ert.enkf.analysis_config_set_merge_observations(ert.analysis_config, value)


    enkf_mode_type = {"ENKF_STANDARD" : 10, "ENKF_SQRT" : 20}
    enkf_mode_type_inverted = {10 : "ENKF_STANDARD" , 20 : "ENKF_SQRT"}
    r = configPanel.addRow(ComboChoice(parent, enkf_mode_type.keys(), "Mode", "config/analysis/enkf_mode"))
    r.getter = lambda ert : enkf_mode_type_inverted[ert.enkf.analysis_config_get_enkf_mode(ert.analysis_config)]
    r.setter = lambda ert, value : ert.enkf.analysis_config_set_enkf_mode(ert.analysis_config, enkf_mode_type[str(value)])


    r = configPanel.addRow(DoubleSpinner(parent, "Truncation", "config/analysis/enkf_truncation", 0, 1, 2))
    r.getter = lambda ert : ert.enkf.analysis_config_get_truncation(ert.analysis_config)
    r.setter = lambda ert, value : ert.enkf.analysis_config_set_truncation(ert.analysis_config, value)



    configPanel.endGroup()
    configPanel.endPage()
Пример #4
0
    def __init__(self, parent=None):
        ConfigPanel.__init__(self, parent)

        self.initialized = False

        layout = QtGui.QFormLayout()
        layout.setLabelAlignment(QtCore.Qt.AlignRight)

        def jid(ert):
            """Returns the pointer to the current job (self.job)"""
            jl = ert.enkf.site_config_get_installed_jobs(ert.site_config)
            return ert.job_queue.ext_joblist_get_job(jl, self.job.name)

        self.stdin = PathChooser(self,
                                 "",
                                 "config/systemenv/install_job_stdin",
                                 show_files=True,
                                 must_be_set=False,
                                 must_exist=True)
        self.stdin.setter = lambda ert, value: ert.job_queue.ext_job_set_stdin_file(
            jid(ert), value)
        self.stdin.getter = lambda ert: ert.job_queue.ext_job_get_stdin_file(
            jid(ert))

        self.stdout = PathChooser(self,
                                  "",
                                  "config/systemenv/install_job_stdout",
                                  show_files=True,
                                  must_be_set=True,
                                  must_exist=False)
        self.stdout.setter = lambda ert, value: ert.job_queue.ext_job_set_stdout_file(
            jid(ert), value)
        self.stdout.getter = lambda ert: ert.job_queue.ext_job_get_stdout_file(
            jid(ert))

        self.stderr = PathChooser(self,
                                  "",
                                  "config/systemenv/install_job_stderr",
                                  show_files=True,
                                  must_be_set=True,
                                  must_exist=False)
        self.stderr.setter = lambda ert, value: ert.job_queue.ext_job_set_stderr_file(
            jid(ert), value)
        self.stderr.getter = lambda ert: ert.job_queue.ext_job_get_stderr_file(
            jid(ert))

        self.target_file = PathChooser(
            self,
            "",
            "config/systemenv/install_job_target_file",
            show_files=True,
            must_be_set=False,
            must_exist=False)
        self.target_file.setter = lambda ert, value: ert.job_queue.ext_job_set_target_file(
            jid(ert), value)
        self.target_file.getter = lambda ert: ert.job_queue.ext_job_get_target_file(
            jid(ert))

        self.executable = PathChooser(
            self,
            "",
            "config/systemenv/install_job_executable",
            show_files=True,
            must_be_set=True,
            must_exist=True,
            is_executable_file=True)
        self.executable.setter = lambda ert, value: ert.job_queue.ext_job_set_executable(
            jid(ert), value)
        self.executable.getter = lambda ert: ert.job_queue.ext_job_get_executable(
            jid(ert))

        def setEnv(ert, value):
            job = jid(ert)
            ert.job_queue.ext_job_clear_environment(job)

            for env in value:
                ert.job_queue.ext_job_add_environment(job, env[0], env[1])

        self.env = KeywordTable(self,
                                "",
                                "config/systemenv/install_job_env",
                                colHead1="Variable",
                                colHead2="Value")
        self.env.setter = setEnv
        self.env.getter = lambda ert: ert.getHash(
            ert.job_queue.ext_job_get_environment(jid(ert)))

        self.arglist = StringBox(self, "",
                                 "config/systemenv/install_job_arglist")
        self.arglist.setter = lambda ert, value: ert.job_queue.ext_job_set_private_args_from_string(
            jid(ert), value)
        self.arglist.getter = lambda ert: ert.job_queue.ext_job_get_private_args_as_string(
            jid(ert))

        self.max_running = IntegerSpinner(
            self, "", "config/systemenv/install_job_max_running", 0, 10000)
        self.max_running.setter = lambda ert, value: ert.job_queue.ext_job_set_max_running(
            jid(ert), value)
        self.max_running.getter = lambda ert: ert.job_queue.ext_job_get_max_running(
            jid(ert))

        self.max_running_minutes = IntegerSpinner(
            self, "", "config/systemenv/install_job_max_running_minutes", 0,
            10000)
        self.max_running_minutes.setter = lambda ert, value: ert.job_queue.ext_job_set_max_running_minutes(
            jid(ert), value)
        self.max_running_minutes.getter = lambda ert: ert.job_queue.ext_job_get_max_running_minutes(
            jid(ert))

        self.startPage("Standard")
        self.add("Executable.:", self.executable)
        self.add("Stdout:", self.stdout)
        self.add("Stderr:", self.stderr)
        self.add("Target file:", self.target_file)
        self.add("Arglist.:", self.arglist)
        self.endPage()

        self.startPage("Advanced")
        self.add("Stdin:", self.stdin)
        self.add("Max running:", self.max_running)
        self.max_running.setInfo("(0=unlimited)")
        self.add("Max running minutes:", self.max_running_minutes)
        self.max_running_minutes.setInfo("(0=unlimited)")
        self.add("Env.:", self.env)
        self.endPage()
Пример #5
0
class JobConfigPanel(ConfigPanel):
    def __init__(self, parent=None):
        ConfigPanel.__init__(self, parent)

        self.initialized = False

        layout = QtGui.QFormLayout()
        layout.setLabelAlignment(QtCore.Qt.AlignRight)

        def jid(ert):
            """Returns the pointer to the current job (self.job)"""
            jl = ert.enkf.site_config_get_installed_jobs(ert.site_config)
            return ert.job_queue.ext_joblist_get_job(jl, self.job.name)

        self.stdin = PathChooser(self,
                                 "",
                                 "config/systemenv/install_job_stdin",
                                 show_files=True,
                                 must_be_set=False,
                                 must_exist=True)
        self.stdin.setter = lambda ert, value: ert.job_queue.ext_job_set_stdin_file(
            jid(ert), value)
        self.stdin.getter = lambda ert: ert.job_queue.ext_job_get_stdin_file(
            jid(ert))

        self.stdout = PathChooser(self,
                                  "",
                                  "config/systemenv/install_job_stdout",
                                  show_files=True,
                                  must_be_set=True,
                                  must_exist=False)
        self.stdout.setter = lambda ert, value: ert.job_queue.ext_job_set_stdout_file(
            jid(ert), value)
        self.stdout.getter = lambda ert: ert.job_queue.ext_job_get_stdout_file(
            jid(ert))

        self.stderr = PathChooser(self,
                                  "",
                                  "config/systemenv/install_job_stderr",
                                  show_files=True,
                                  must_be_set=True,
                                  must_exist=False)
        self.stderr.setter = lambda ert, value: ert.job_queue.ext_job_set_stderr_file(
            jid(ert), value)
        self.stderr.getter = lambda ert: ert.job_queue.ext_job_get_stderr_file(
            jid(ert))

        self.target_file = PathChooser(
            self,
            "",
            "config/systemenv/install_job_target_file",
            show_files=True,
            must_be_set=False,
            must_exist=False)
        self.target_file.setter = lambda ert, value: ert.job_queue.ext_job_set_target_file(
            jid(ert), value)
        self.target_file.getter = lambda ert: ert.job_queue.ext_job_get_target_file(
            jid(ert))

        self.executable = PathChooser(
            self,
            "",
            "config/systemenv/install_job_executable",
            show_files=True,
            must_be_set=True,
            must_exist=True,
            is_executable_file=True)
        self.executable.setter = lambda ert, value: ert.job_queue.ext_job_set_executable(
            jid(ert), value)
        self.executable.getter = lambda ert: ert.job_queue.ext_job_get_executable(
            jid(ert))

        def setEnv(ert, value):
            job = jid(ert)
            ert.job_queue.ext_job_clear_environment(job)

            for env in value:
                ert.job_queue.ext_job_add_environment(job, env[0], env[1])

        self.env = KeywordTable(self,
                                "",
                                "config/systemenv/install_job_env",
                                colHead1="Variable",
                                colHead2="Value")
        self.env.setter = setEnv
        self.env.getter = lambda ert: ert.getHash(
            ert.job_queue.ext_job_get_environment(jid(ert)))

        self.arglist = StringBox(self, "",
                                 "config/systemenv/install_job_arglist")
        self.arglist.setter = lambda ert, value: ert.job_queue.ext_job_set_private_args_from_string(
            jid(ert), value)
        self.arglist.getter = lambda ert: ert.job_queue.ext_job_get_private_args_as_string(
            jid(ert))

        self.max_running = IntegerSpinner(
            self, "", "config/systemenv/install_job_max_running", 0, 10000)
        self.max_running.setter = lambda ert, value: ert.job_queue.ext_job_set_max_running(
            jid(ert), value)
        self.max_running.getter = lambda ert: ert.job_queue.ext_job_get_max_running(
            jid(ert))

        self.max_running_minutes = IntegerSpinner(
            self, "", "config/systemenv/install_job_max_running_minutes", 0,
            10000)
        self.max_running_minutes.setter = lambda ert, value: ert.job_queue.ext_job_set_max_running_minutes(
            jid(ert), value)
        self.max_running_minutes.getter = lambda ert: ert.job_queue.ext_job_get_max_running_minutes(
            jid(ert))

        self.startPage("Standard")
        self.add("Executable.:", self.executable)
        self.add("Stdout:", self.stdout)
        self.add("Stderr:", self.stderr)
        self.add("Target file:", self.target_file)
        self.add("Arglist.:", self.arglist)
        self.endPage()

        self.startPage("Advanced")
        self.add("Stdin:", self.stdin)
        self.add("Max running:", self.max_running)
        self.max_running.setInfo("(0=unlimited)")
        self.add("Max running minutes:", self.max_running_minutes)
        self.max_running_minutes.setInfo("(0=unlimited)")
        self.add("Env.:", self.env)
        self.endPage()

    def add(self, label, widget):
        self.addRow(widget, label)

    def setJob(self, job):
        self.job = job

        self.initialize(self.stdin.getModel())

        self.cmproxy = ContentModelProxy(
        )  #Since only the last change matters and no insert and remove is done
        self.cmproxy.proxify(self.stdin, self.stdout, self.stderr,
                             self.target_file, self.executable, self.env,
                             self.arglist, self.max_running,
                             self.max_running_minutes)

        self.stdin.fetchContent()
        self.stdout.fetchContent()
        self.stderr.fetchContent()
        self.target_file.fetchContent()
        self.executable.fetchContent()
        self.env.fetchContent()
        self.arglist.fetchContent()
        self.max_running.fetchContent()
        self.max_running_minutes.fetchContent()

    def saveJob(self):
        if self.executable.isValid() and self.stderr.isValid(
        ) and self.stdout.isValid():
            self.cmproxy.apply()

            ert = self.stdin.getModel()
            jl = ert.enkf.site_config_get_installed_jobs(ert.site_config)
            jid = ert.job_queue.ext_joblist_get_job(jl, self.job.name)
            ert.job_queue.ext_job_save(jid)
            return None
        else:
            return "These fields are required: executable, stdout and stderr!"
Пример #6
0
def createQueueSystemPage(configPanel, parent):
    configPanel.startPage("Queue System")

    r = configPanel.addRow(
        ComboChoice(parent, ["LSF", "RSH", "LOCAL"], "Queue system",
                    "config/queue_system/queue_system"))
    r.getter = lambda ert: ert.enkf.site_config_get_queue_name(ert.site_config)
    r.setter = lambda ert, value: ert.enkf.site_config_set_job_queue(
        ert.site_config, str(value))

    internalPanel = ConfigPanel(parent)

    internalPanel.startPage("LSF")

    r = internalPanel.addRow(
        StringBox(parent, "LSF Queue", "config/queue_system/lsf_queue"))
    r.getter = lambda ert: ert.enkf.site_config_get_lsf_queue(ert.site_config)
    r.setter = lambda ert, value: ert.enkf.site_config_set_lsf_queue(
        ert.site_config, str(value))

    r = internalPanel.addRow(
        IntegerSpinner(parent, "Max running",
                       "config/queue_system/max_running_lsf", 1, 1000))
    r.getter = lambda ert: ert.enkf.site_config_get_max_running_lsf(
        ert.site_config)
    r.setter = lambda ert, value: ert.enkf.site_config_set_max_running_lsf(
        ert.site_config, value)

    r = internalPanel.addRow(
        StringBox(parent, "Resources", "config/queue_system/lsf_resources"))
    r.getter = lambda ert: ert.enkf.site_config_get_lsf_request(ert.site_config
                                                                )
    r.setter = lambda ert, value: ert.enkf.site_config_set_lsf_request(
        ert.site_config, str(value))

    internalPanel.endPage()

    internalPanel.startPage("RSH")

    r = internalPanel.addRow(
        PathChooser(parent,
                    "Command",
                    "config/queue_system/rsh_command",
                    show_files=True,
                    must_exist=True,
                    is_executable_file=True))
    r.getter = lambda ert: ert.enkf.site_config_get_rsh_command(ert.site_config
                                                                )
    r.setter = lambda ert, value: ert.enkf.site_config_set_rsh_command(
        ert.site_config, str(value))

    r = internalPanel.addRow(
        IntegerSpinner(parent, "Max running",
                       "config/queue_system/max_running_rsh", 1, 1000))
    r.getter = lambda ert: ert.enkf.site_config_get_max_running_rsh(
        ert.site_config)
    r.setter = lambda ert, value: ert.enkf.site_config_set_max_running_rsh(
        ert.site_config, value)

    r = internalPanel.addRow(
        KeywordTable(parent, "Host List", "config/queue_system/rsh_host_list",
                     "Host", "Number of jobs"))
    r.getter = lambda ert: ert.getHash(
        ert.enkf.site_config_get_rsh_host_list(ert.site_config), True)

    def add_rsh_host(ert, listOfKeywords):
        ert.enkf.site_config_clear_rsh_host_list(ert.site_config)

        for keyword in listOfKeywords:
            if keyword[1].strip() == "":
                max_running = 1
            else:
                max_running = int(keyword[1])

            ert.enkf.site_config_add_rsh_host(ert.site_config, keyword[0],
                                              max_running)

    r.setter = add_rsh_host

    internalPanel.endPage()

    internalPanel.startPage("LOCAL")

    r = internalPanel.addRow(
        IntegerSpinner(parent, "Max running",
                       "config/queue_system/max_running_local", 1, 1000))
    r.getter = lambda ert: ert.enkf.site_config_get_max_running_local(
        ert.site_config)
    r.setter = lambda ert, value: ert.enkf.site_config_set_max_running_local(
        ert.site_config, value)

    internalPanel.endPage()
    configPanel.addRow(internalPanel)

    configPanel.endPage()
Пример #7
0
    def __init__(self, parent=None):
        ConfigPanel.__init__(self, parent)

        self.initialized = False

        layout = QtGui.QFormLayout()
        layout.setLabelAlignment(QtCore.Qt.AlignRight)

        def jid(ert):
            """Returns the pointer to the current job (self.job)"""
            jl = ert.enkf.site_config_get_installed_jobs(ert.site_config)
            return ert.job_queue.ext_joblist_get_job(jl, self.job.name)

        self.stdin = PathChooser(
            self, "", "config/systemenv/install_job_stdin", show_files=True, must_be_set=False, must_exist=True
        )
        self.stdin.setter = lambda ert, value: ert.job_queue.ext_job_set_stdin_file(jid(ert), value)
        self.stdin.getter = lambda ert: ert.job_queue.ext_job_get_stdin_file(jid(ert))

        self.stdout = PathChooser(
            self, "", "config/systemenv/install_job_stdout", show_files=True, must_be_set=True, must_exist=False
        )
        self.stdout.setter = lambda ert, value: ert.job_queue.ext_job_set_stdout_file(jid(ert), value)
        self.stdout.getter = lambda ert: ert.job_queue.ext_job_get_stdout_file(jid(ert))

        self.stderr = PathChooser(
            self, "", "config/systemenv/install_job_stderr", show_files=True, must_be_set=True, must_exist=False
        )
        self.stderr.setter = lambda ert, value: ert.job_queue.ext_job_set_stderr_file(jid(ert), value)
        self.stderr.getter = lambda ert: ert.job_queue.ext_job_get_stderr_file(jid(ert))

        self.target_file = PathChooser(
            self, "", "config/systemenv/install_job_target_file", show_files=True, must_be_set=False, must_exist=False
        )
        self.target_file.setter = lambda ert, value: ert.job_queue.ext_job_set_target_file(jid(ert), value)
        self.target_file.getter = lambda ert: ert.job_queue.ext_job_get_target_file(jid(ert))

        self.executable = PathChooser(
            self,
            "",
            "config/systemenv/install_job_executable",
            show_files=True,
            must_be_set=True,
            must_exist=True,
            is_executable_file=True,
        )
        self.executable.setter = lambda ert, value: ert.job_queue.ext_job_set_executable(jid(ert), value)
        self.executable.getter = lambda ert: ert.job_queue.ext_job_get_executable(jid(ert))

        def setEnv(ert, value):
            job = jid(ert)
            ert.job_queue.ext_job_clear_environment(job)

            for env in value:
                ert.job_queue.ext_job_add_environment(job, env[0], env[1])

        self.env = KeywordTable(self, "", "config/systemenv/install_job_env", colHead1="Variable", colHead2="Value")
        self.env.setter = setEnv
        self.env.getter = lambda ert: ert.getHash(ert.job_queue.ext_job_get_environment(jid(ert)))

        self.arglist = StringBox(self, "", "config/systemenv/install_job_arglist")
        self.arglist.setter = lambda ert, value: ert.job_queue.ext_job_set_private_args_from_string(jid(ert), value)
        self.arglist.getter = lambda ert: ert.job_queue.ext_job_get_private_args_as_string(jid(ert))

        self.max_running = IntegerSpinner(self, "", "config/systemenv/install_job_max_running", 0, 10000)
        self.max_running.setter = lambda ert, value: ert.job_queue.ext_job_set_max_running(jid(ert), value)
        self.max_running.getter = lambda ert: ert.job_queue.ext_job_get_max_running(jid(ert))

        self.max_running_minutes = IntegerSpinner(
            self, "", "config/systemenv/install_job_max_running_minutes", 0, 10000
        )
        self.max_running_minutes.setter = lambda ert, value: ert.job_queue.ext_job_set_max_running_minutes(
            jid(ert), value
        )
        self.max_running_minutes.getter = lambda ert: ert.job_queue.ext_job_get_max_running_minutes(jid(ert))

        self.startPage("Standard")
        self.add("Executable.:", self.executable)
        self.add("Stdout:", self.stdout)
        self.add("Stderr:", self.stderr)
        self.add("Target file:", self.target_file)
        self.add("Arglist.:", self.arglist)
        self.endPage()

        self.startPage("Advanced")
        self.add("Stdin:", self.stdin)
        self.add("Max running:", self.max_running)
        self.max_running.setInfo("(0=unlimited)")
        self.add("Max running minutes:", self.max_running_minutes)
        self.max_running_minutes.setInfo("(0=unlimited)")
        self.add("Env.:", self.env)
        self.endPage()
Пример #8
0
class JobConfigPanel(ConfigPanel):
    def __init__(self, parent=None):
        ConfigPanel.__init__(self, parent)

        self.initialized = False

        layout = QtGui.QFormLayout()
        layout.setLabelAlignment(QtCore.Qt.AlignRight)

        def jid(ert):
            """Returns the pointer to the current job (self.job)"""
            jl = ert.enkf.site_config_get_installed_jobs(ert.site_config)
            return ert.job_queue.ext_joblist_get_job(jl, self.job.name)

        self.stdin = PathChooser(
            self, "", "config/systemenv/install_job_stdin", show_files=True, must_be_set=False, must_exist=True
        )
        self.stdin.setter = lambda ert, value: ert.job_queue.ext_job_set_stdin_file(jid(ert), value)
        self.stdin.getter = lambda ert: ert.job_queue.ext_job_get_stdin_file(jid(ert))

        self.stdout = PathChooser(
            self, "", "config/systemenv/install_job_stdout", show_files=True, must_be_set=True, must_exist=False
        )
        self.stdout.setter = lambda ert, value: ert.job_queue.ext_job_set_stdout_file(jid(ert), value)
        self.stdout.getter = lambda ert: ert.job_queue.ext_job_get_stdout_file(jid(ert))

        self.stderr = PathChooser(
            self, "", "config/systemenv/install_job_stderr", show_files=True, must_be_set=True, must_exist=False
        )
        self.stderr.setter = lambda ert, value: ert.job_queue.ext_job_set_stderr_file(jid(ert), value)
        self.stderr.getter = lambda ert: ert.job_queue.ext_job_get_stderr_file(jid(ert))

        self.target_file = PathChooser(
            self, "", "config/systemenv/install_job_target_file", show_files=True, must_be_set=False, must_exist=False
        )
        self.target_file.setter = lambda ert, value: ert.job_queue.ext_job_set_target_file(jid(ert), value)
        self.target_file.getter = lambda ert: ert.job_queue.ext_job_get_target_file(jid(ert))

        self.executable = PathChooser(
            self,
            "",
            "config/systemenv/install_job_executable",
            show_files=True,
            must_be_set=True,
            must_exist=True,
            is_executable_file=True,
        )
        self.executable.setter = lambda ert, value: ert.job_queue.ext_job_set_executable(jid(ert), value)
        self.executable.getter = lambda ert: ert.job_queue.ext_job_get_executable(jid(ert))

        def setEnv(ert, value):
            job = jid(ert)
            ert.job_queue.ext_job_clear_environment(job)

            for env in value:
                ert.job_queue.ext_job_add_environment(job, env[0], env[1])

        self.env = KeywordTable(self, "", "config/systemenv/install_job_env", colHead1="Variable", colHead2="Value")
        self.env.setter = setEnv
        self.env.getter = lambda ert: ert.getHash(ert.job_queue.ext_job_get_environment(jid(ert)))

        self.arglist = StringBox(self, "", "config/systemenv/install_job_arglist")
        self.arglist.setter = lambda ert, value: ert.job_queue.ext_job_set_private_args_from_string(jid(ert), value)
        self.arglist.getter = lambda ert: ert.job_queue.ext_job_get_private_args_as_string(jid(ert))

        self.max_running = IntegerSpinner(self, "", "config/systemenv/install_job_max_running", 0, 10000)
        self.max_running.setter = lambda ert, value: ert.job_queue.ext_job_set_max_running(jid(ert), value)
        self.max_running.getter = lambda ert: ert.job_queue.ext_job_get_max_running(jid(ert))

        self.max_running_minutes = IntegerSpinner(
            self, "", "config/systemenv/install_job_max_running_minutes", 0, 10000
        )
        self.max_running_minutes.setter = lambda ert, value: ert.job_queue.ext_job_set_max_running_minutes(
            jid(ert), value
        )
        self.max_running_minutes.getter = lambda ert: ert.job_queue.ext_job_get_max_running_minutes(jid(ert))

        self.startPage("Standard")
        self.add("Executable.:", self.executable)
        self.add("Stdout:", self.stdout)
        self.add("Stderr:", self.stderr)
        self.add("Target file:", self.target_file)
        self.add("Arglist.:", self.arglist)
        self.endPage()

        self.startPage("Advanced")
        self.add("Stdin:", self.stdin)
        self.add("Max running:", self.max_running)
        self.max_running.setInfo("(0=unlimited)")
        self.add("Max running minutes:", self.max_running_minutes)
        self.max_running_minutes.setInfo("(0=unlimited)")
        self.add("Env.:", self.env)
        self.endPage()

    def add(self, label, widget):
        self.addRow(widget, label)

    def initialize(self, ert):
        if not self.initialized:
            ert.prototype("long site_config_get_installed_jobs(long)")
            ert.prototype("char* ext_job_get_stdin_file(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_set_stdin_file(long, char*)", lib=ert.job_queue)
            ert.prototype("char* ext_job_get_stdout_file(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_set_stdout_file(long, char*)", lib=ert.job_queue)
            ert.prototype("char* ext_job_get_stderr_file(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_set_stderr_file(long, char*)", lib=ert.job_queue)
            ert.prototype("char* ext_job_get_target_file(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_set_target_file(long, char*)", lib=ert.job_queue)
            ert.prototype("char* ext_job_get_executable(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_set_executable(long, char*)", lib=ert.job_queue)
            ert.prototype("char* ext_job_get_private_args_as_string(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_set_private_args_from_string(long, char*)", lib=ert.job_queue)
            ert.prototype("int ext_job_get_max_running(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_set_max_running(long, int)", lib=ert.job_queue)
            ert.prototype("int ext_job_get_max_running_minutes(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_set_max_running_minutes(long, int)", lib=ert.job_queue)
            ert.prototype("long ext_job_get_environment(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_add_environment(long, char*, char*)", lib=ert.job_queue)
            ert.prototype("void ext_job_clear_environment(long)", lib=ert.job_queue)
            ert.prototype("void ext_job_save(long)", lib=ert.job_queue)
            ert.prototype("long ext_joblist_get_job(long, char*)", lib=ert.job_queue)

            self.initialized = True

    def setJob(self, job):
        self.job = job

        self.initialize(self.stdin.getModel())

        self.cmproxy = ContentModelProxy()  # Since only the last change matters and no insert and remove is done
        self.cmproxy.proxify(
            self.stdin,
            self.stdout,
            self.stderr,
            self.target_file,
            self.executable,
            self.env,
            self.arglist,
            self.max_running,
            self.max_running_minutes,
        )

        self.stdin.fetchContent()
        self.stdout.fetchContent()
        self.stderr.fetchContent()
        self.target_file.fetchContent()
        self.executable.fetchContent()
        self.env.fetchContent()
        self.arglist.fetchContent()
        self.max_running.fetchContent()
        self.max_running_minutes.fetchContent()

    def saveJob(self):
        if self.executable.isValid() and self.stderr.isValid() and self.stdout.isValid():
            self.cmproxy.apply()

            ert = self.stdin.getModel()
            jl = ert.enkf.site_config_get_installed_jobs(ert.site_config)
            jid = ert.job_queue.ext_joblist_get_job(jl, self.job.name)
            ert.job_queue.ext_job_save(jid)
            return None
        else:
            return "These fields are required: executable, stdout and stderr!"
Пример #9
0
def createSimulationsPage(configPanel, parent):
    configPanel.startPage("Simulations")

    r = configPanel.addRow(
        IntegerSpinner(parent, "Max submit", "config/simulation/max_submit", 1,
                       10000))
    r.getter = lambda ert: ert.enkf.site_config_get_max_submit(ert.site_config)
    r.setter = lambda ert, value: ert.enkf.site_config_set_max_submit(
        ert.site_config, value)

    r = configPanel.addRow(
        IntegerSpinner(parent, "Max resample",
                       "config/simulation/max_resample", 1, 10000))
    r.getter = lambda ert: ert.enkf.model_config_get_max_resample(ert.
                                                                  model_config)
    r.setter = lambda ert, value: ert.enkf.model_config_set_max_resample(
        ert.model_config, value)

    r = configPanel.addRow(ForwardModelPanel(parent))

    def get_forward_model(ert):
        site_config = ert.site_config
        installed_jobs_pointer = ert.enkf.site_config_get_installed_jobs(
            site_config)
        installed_jobs_stringlist_pointer = ert.job_queue.ext_joblist_alloc_list(
            installed_jobs_pointer)
        available_jobs = ert.getStringList(installed_jobs_stringlist_pointer,
                                           free_after_use=True)

        result = {'available_jobs': available_jobs}

        model_config = ert.model_config
        forward_model = ert.enkf.model_config_get_forward_model(model_config)
        name_string_list = ert.job_queue.forward_model_alloc_joblist(
            forward_model)
        job_names = ert.getStringList(name_string_list, free_after_use=True)

        forward_model_jobs = []

        count = 0
        for name in job_names:
            ext_job = ert.job_queue.forward_model_iget_job(
                forward_model, count)
            arg_string = ert.job_queue.ext_job_get_private_args_as_string(
                ext_job)
            help_text = ert.job_queue.ext_job_get_help_text(ext_job)
            forward_model_jobs.append((name, arg_string, help_text))
            count += 1

        result['forward_model'] = forward_model_jobs

        return result

    r.getter = get_forward_model

    def update_forward_model(ert, forward_model):
        forward_model_pointer = ert.enkf.model_config_get_forward_model(
            ert.model_config)
        ert.job_queue.forward_model_clear(forward_model_pointer)

        for job in forward_model:
            name = job[0]
            args = job[1]
            ext_job = ert.job_queue.forward_model_add_job(
                forward_model_pointer, name)
            ert.job_queue.ext_job_set_private_args_from_string(ext_job, args)

    r.setter = update_forward_model

    r = configPanel.addRow(
        PathChooser(parent, "Case table", "config/simulation/case_table"))

    def get_case_table(ert):
        return ert.enkf.model_config_get_case_table_file(ert.model_config)

    r.getter = get_case_table

    def set_case_table(ert, value):
        if os.path.exists(value):
            ert.enkf.enkf_main_set_case_table(ert.model_config,
                                              ert.nonify(value))

    r.setter = set_case_table

    r = configPanel.addRow(
        PathChooser(parent, "License path", "config/simulation/license_path"))
    r.getter = lambda ert: ert.enkf.site_config_get_license_root_path(
        ert.site_config)

    def ls(string):
        if string is None:
            return ""
        else:
            return string

    r.setter = lambda ert, value: ert.enkf.site_config_set_license_root_path(
        ert.site_config, ls(value))

    internalPanel = ConfigPanel(parent)

    internalPanel.startPage("Runpath")

    r = internalPanel.addRow(
        PathChooser(parent,
                    "Runpath",
                    "config/simulation/runpath",
                    path_format=True))

    r.getter = lambda ert: ert.enkf.model_config_get_runpath_as_char(
        ert.model_config)
    r.setter = lambda ert, value: ert.enkf.model_config_set_runpath_fmt(
        ert.model_config, str(value))
    parent.connect(r, QtCore.SIGNAL("contentsChanged()"),
                   lambda: r.modelEmit("runpathChanged()"))

    r = internalPanel.addRow(
        CheckBox(parent, "Pre clear", "config/simulation/pre_clear_runpath",
                 "Perform pre clear"))

    r.getter = lambda ert: ert.enkf.enkf_main_get_pre_clear_runpath(ert.main)
    r.setter = lambda ert, value: ert.enkf.enkf_main_set_pre_clear_runpath(
        ert.main, value)

    r = internalPanel.addRow(
        RunpathMemberPanel(widgetLabel="Retain runpath",
                           helpLabel="config/simulation/runpath_retain"))

    def get_runpath_retain_state(ert):
        ensemble_size = ert.enkf.enkf_main_get_ensemble_size(ert.main)

        result = []
        for index in range(ensemble_size):
            state = ert.enkf.enkf_main_iget_keep_runpath(ert.main, index)
            result.append((index, keep_runpath_type.resolveValue(state)))

        return result

    r.getter = get_runpath_retain_state

    def set_runpath_retain_state(ert, items):
        for item in items:
            ert.enkf.enkf_main_iset_keep_runpath(ert.main, item.member,
                                                 item.runpath_state.value())

    r.setter = set_runpath_retain_state

    internalPanel.endPage()

    internalPanel.startPage("Run Template")

    r = internalPanel.addRow(RunTemplatePanel(parent))

    def get_run_templates(ert):
        templates = ert.enkf.enkf_main_get_templates(ert.main)
        template_list = ert.enkf.ert_template_alloc_list(templates)

        template_names = ert.getStringList(template_list, free_after_use=True)
        result = []
        for name in template_names:
            template = ert.enkf.ert_template_get_template(templates, name)
            template_file = ert.enkf.ert_template_get_template_file(template)
            target_file = ert.enkf.ert_template_get_target_file(template)
            arguments = ert.enkf.ert_template_get_args_as_string(template)
            result.append((name, template_file, target_file, arguments))
        return result

    r.getter = get_run_templates

    def set_run_templates(ert, template_list):
        templates_pointer = ert.enkf.enkf_main_get_templates(ert.main)
        ert.enkf.ert_template_clear(templates_pointer)

        for template in template_list:
            ert.enkf.ert_template_add_template(templates_pointer, template[0],
                                               template[1], template[2],
                                               template[3])

    r.setter = set_run_templates

    #    r = internalPanel.addRow(MultiColumnTable(parent, "", "run_template", ["Template", "Target file", "Arguments"]))
    #    r.getter = lambda ert : ert.getAttribute("run_template")
    #    r.setter = lambda ert, value : ert.setAttribute("run_template", value)

    internalPanel.endPage()
    configPanel.addRow(internalPanel)

    configPanel.endPage()