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()
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.keywordModel = KeywordModel("")
self.min_std = PathChooser(self,
"",
"config/ensemble/gen_kw_min_std",
True,
must_be_set=False)
self.modelWrap(self.min_std, "min_std")
self.template = PathChooser(self, "",
"config/ensemble/gen_kw_template", True)
self.modelWrap(self.template, "template")
self.enkf_outfile = PathChooser(self,
"",
"config/ensemble/gen_kw_enkf_outfile",
True,
must_be_set=False)
self.modelWrap(self.enkf_outfile, "enkf_outfile")
self.init_files = PathChooser(self,
"",
"config/ensemble/gen_kw_init_files",
True,
must_be_set=False)
self.modelWrap(self.init_files, "init_files")
self.parameter_file = PathChooser(
self,
"",
"config/ensemble/gen_kw_parameter_file",
True,
must_be_set=False)
self.modelWrap(self.parameter_file, "parameter_file")
layout.addRow("Parameter file:", self.parameter_file)
layout.addRow("Include file:", self.enkf_outfile)
layout.addRow("Template:", self.template)
layout.addRow("Minimum std:", self.min_std)
layout.addRow("Init files:", self.init_files)
button = QtGui.QPushButton()
button.setText("Reload")
button.setMaximumWidth(70)
self.connect(button, QtCore.SIGNAL('clicked()'), self._reload)
layout.addRow("Reload files:", button)
self.setLayout(layout)
class KeywordPanel(QtGui.QFrame):
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.keywordModel = KeywordModel("")
self.min_std = PathChooser(self, "", "config/ensemble/gen_kw_min_std", True , must_be_set = False)
self.modelWrap(self.min_std, "min_std")
self.template = PathChooser(self, "", "config/ensemble/gen_kw_template", True)
self.modelWrap(self.template, "template")
self.enkf_outfile = PathChooser(self, "", "config/ensemble/gen_kw_enkf_outfile", True, must_be_set=False)
self.modelWrap(self.enkf_outfile, "enkf_outfile")
self.init_files = PathChooser(self, "", "config/ensemble/gen_kw_init_files", True, must_be_set=False)
self.modelWrap(self.init_files, "init_files")
self.parameter_file = PathChooser(self, "", "config/ensemble/gen_kw_parameter_file", True, must_be_set=False)
self.modelWrap(self.parameter_file, "parameter_file")
layout.addRow("Parameter file:" , self.parameter_file)
layout.addRow("Include file:" , self.enkf_outfile)
layout.addRow("Template:" , self.template)
layout.addRow("Minimum std:" , self.min_std)
layout.addRow("Init files:" , self.init_files)
button = QtGui.QPushButton()
button.setText("Reload")
button.setMaximumWidth(70)
self.connect(button, QtCore.SIGNAL('clicked()'), self._reload)
layout.addRow("Reload files:", button)
self.setLayout(layout)
def _reload(self):
self.keywordModel.emitUpdate()
def setKeywordModel(self, keywordModel):
self.keywordModel = keywordModel
self.min_std.fetchContent()
self.template.fetchContent()
self.enkf_outfile.fetchContent()
self.init_files.fetchContent()
self.parameter_file.fetchContent()
def modelWrap(self, widget, attribute):
widget.initialize = ContentModel.emptyInitializer
widget.setter = lambda model, value: self.keywordModel.set(attribute, value)
widget.getter = lambda model: self.keywordModel[attribute]
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.fieldModel = FieldModel("")
self.fieldType = ComboChoice(self, field_type.values(), "", "config/ensemble/field_type")
self.fieldType.setter = lambda model, value: self.typeChanged(field_type[str(value)])
self.fieldType.getter = lambda model: str(self.fieldModel["type"])
self.fieldType.initialize = ContentModel.emptyInitializer
self.min = DoubleBox(self, "", "config/ensemble/field_min")
self.modelWrap(self.min, "min")
self.max = DoubleBox(self, "", "config/ensemble/field_max")
self.modelWrap(self.max, "max")
self.init = ComboChoice(self, ["None", "EXP", "EXP0", "LOG", "LN","LN0", "POW10", "ADD", "MUL", "RANDINT", "RANDFLOAT"], "", "config/ensemble/field_init")
self.modelWrap(self.init, "init")
self.output = ComboChoice(self, ["None", "EXP", "EXP0", "LOG", "LN","LN0", "POW10", "ADD", "MUL", "RANDINT", "RANDFLOAT"], "", "config/ensemble/field_output")
self.modelWrap(self.output, "output")
self.init_files = PathChooser(self, "", "config/ensemble/field_init_files", True)
self.modelWrap(self.init_files, "init_files")
self.file_generated_by_enkf = PathChooser(self, "", "config/ensemble/field_file_generated_by_enkf", True)
self.modelWrap(self.file_generated_by_enkf, "enkf_outfile")
self.file_loaded_by_enkf = PathChooser(self, "", "config/ensemble/field_file_loaded_by_enkf", True)
self.modelWrap(self.file_loaded_by_enkf, "enkf_infile")
self.min_std = PathChooser(self, "", "config/ensemble/field_min_std", True, must_be_set=False)
self.modelWrap(self.min_std, "min_std")
layout.addRow("Field type:", self.fieldType)
layout.addRow("Include file:", self.file_generated_by_enkf) # generated by ERT
layout.addRow("Init files:", self.init_files)
layout.addRow("Min:", self.min)
layout.addRow("Max:", self.max)
layout.addRow("Init transformation:", self.init)
layout.addRow("Output transformation:", self.output)
layout.addRow("Min. std.:", self.min_std)
layout.addRow("File loaded by EnKF:", self.file_loaded_by_enkf)
self.setLayout(layout)
self.typeChanged(field_type.ECLIPSE_RESTART)
def createWidgets(self, parent):
self.searchableList = SearchableList(parent,
list_height=200,
list_width=150,
ignore_case=True)
self.addWidget(self.searchableList)
self.connect(
self.searchableList,
QtCore.SIGNAL(
'currentItemChanged(QListWidgetItem, QListWidgetItem)'),
self.changeParameter)
self.connect(self.searchableList, QtCore.SIGNAL('addItem(list)'),
self.addItem)
self.connect(self.searchableList, QtCore.SIGNAL('removeItem(list)'),
self.removeItem)
self.jobPanel = ert_gui.widgets.util.createEmptyPanel()
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.jobpath = PathChooser(self,
"",
"config/systemenv/install_job_path",
show_files=True,
must_be_set=True)
self.jobpath.initialize = ContentModel.emptyInitializer
self.jobpath.setter = self.setPath
self.jobpath.getter = lambda model: self.job.path
layout.addRow("Job:", self.jobpath)
layout.addRow(ert_gui.widgets.util.createSpace(20))
self.validationInfo = ValidationInfo(ValidationInfo.EXCLAMATION)
self.validationInfo.setMessage(
"Pressing edit will create a job that does not exist.")
self.editButton = QtGui.QPushButton(self)
self.editButton.setToolTip("Edit job")
self.editButton.setIcon(ert_gui.widgets.util.resourceIcon("cog"))
self.editButton.setText("Edit")
self.connect(self.editButton, QtCore.SIGNAL('clicked()'), self.editJob)
layout.addRow(ert_gui.widgets.util.centeredWidget(self.editButton))
layout.addRow(ert_gui.widgets.util.centeredWidget(self.validationInfo))
self.jobPanel.setLayout(layout)
def createWidgets(self, parent):
self.searchableList = SearchableList(parent,
list_height=150,
list_width=150,
ignore_case=True)
self.addWidget(self.searchableList)
self.connect(
self.searchableList,
QtCore.SIGNAL(
'currentItemChanged(QListWidgetItem, QListWidgetItem)'),
self.changeParameter)
self.connect(self.searchableList, QtCore.SIGNAL('addItem(list)'),
self.addItem)
self.connect(self.searchableList, QtCore.SIGNAL('removeItem(list)'),
self.removeItem)
self.run_template_panel = ert_gui.widgets.util.createEmptyPanel()
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.run_template_file = PathChooser(
self, "", "config/simulation/run_template_file", show_files=True)
self.run_template_file.initialize = ContentModel.emptyInitializer
self.run_template_file.setter = self.setTemplateFile
self.run_template_file.getter = lambda model: self.run_template.template_file
self.run_template_target = PathChooser(
self, "", "config/simulation/run_template_target", show_files=True)
self.run_template_target.initialize = ContentModel.emptyInitializer
self.run_template_target.setter = self.setTargetFile
self.run_template_target.getter = lambda model: self.run_template.target_file
self.run_template_args = StringBox(
self, "", "config/simulation/run_template_arguments")
self.run_template_args.initialize = ContentModel.emptyInitializer
self.run_template_args.setter = self.setArguments
self.run_template_args.getter = lambda model: self.run_template.arguments
layout.addRow("Template file:", self.run_template_file)
layout.addRow("Target file:", self.run_template_target)
layout.addRow("Arguments:", self.run_template_args)
layout.addRow(ert_gui.widgets.util.createSpace(20))
self.run_template_panel.setLayout(layout)
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.fieldModel = FieldModel("")
self.fieldType = ComboChoice(self, field_type.values(), "", "config/ensemble/field_type")
self.fieldType.setter = lambda model, value: self.typeChanged(field_type[str(value)])
self.fieldType.getter = lambda model: str(self.fieldModel["type"])
self.fieldType.initialize = ContentModel.emptyInitializer
self.min = DoubleBox(self, "", "config/ensemble/field_min")
self.modelWrap(self.min, "min")
self.max = DoubleBox(self, "", "config/ensemble/field_max")
self.modelWrap(self.max, "max")
self.init = ComboChoice(self, ["None", "EXP", "LOG", "POW10", "ADD", "MUL", "RANDINT", "RANDFLOAT"], "", "config/ensemble/field_init")
self.modelWrap(self.init, "init")
self.output = ComboChoice(self, ["None", "EXP", "LOG", "POW10", "ADD", "MUL", "RANDINT", "RANDFLOAT"], "", "config/ensemble/field_output")
self.modelWrap(self.output, "output")
self.init_files = PathChooser(self, "", "config/ensemble/field_init_files", True)
self.modelWrap(self.init_files, "init_files")
self.file_generated_by_enkf = PathChooser(self, "", "config/ensemble/field_file_generated_by_enkf", True)
self.modelWrap(self.file_generated_by_enkf, "enkf_outfile")
self.file_loaded_by_enkf = PathChooser(self, "", "config/ensemble/field_file_loaded_by_enkf", True)
self.modelWrap(self.file_loaded_by_enkf, "enkf_infile")
self.min_std = PathChooser(self, "", "config/ensemble/field_min_std", True, must_be_set=False)
self.modelWrap(self.min_std, "min_std")
layout.addRow("Field type:", self.fieldType)
layout.addRow("Include file:", self.file_generated_by_enkf) # generated by ERT
layout.addRow("Init files:", self.init_files)
layout.addRow("Min:", self.min)
layout.addRow("Max:", self.max)
layout.addRow("Init transformation:", self.init)
layout.addRow("Output transformation:", self.output)
layout.addRow("Min. std.:", self.min_std)
layout.addRow("File loaded by EnKF:", self.file_loaded_by_enkf)
self.setLayout(layout)
self.typeChanged(field_type.ECLIPSE_RESTART)
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.keywordModel = KeywordModel("")
self.min_std = PathChooser(self, "", "config/ensemble/gen_kw_min_std", True , must_be_set = False)
self.modelWrap(self.min_std, "min_std")
self.template = PathChooser(self, "", "config/ensemble/gen_kw_template", True)
self.modelWrap(self.template, "template")
self.enkf_outfile = PathChooser(self, "", "config/ensemble/gen_kw_enkf_outfile", True, must_be_set=False)
self.modelWrap(self.enkf_outfile, "enkf_outfile")
self.init_files = PathChooser(self, "", "config/ensemble/gen_kw_init_files", True, must_be_set=False)
self.modelWrap(self.init_files, "init_files")
self.parameter_file = PathChooser(self, "", "config/ensemble/gen_kw_parameter_file", True, must_be_set=False)
self.modelWrap(self.parameter_file, "parameter_file")
layout.addRow("Parameter file:" , self.parameter_file)
layout.addRow("Include file:" , self.enkf_outfile)
layout.addRow("Template:" , self.template)
layout.addRow("Minimum std:" , self.min_std)
layout.addRow("Init files:" , self.init_files)
button = QtGui.QPushButton()
button.setText("Reload")
button.setMaximumWidth(70)
self.connect(button, QtCore.SIGNAL('clicked()'), self._reload)
layout.addRow("Reload files:", button)
self.setLayout(layout)
def createWidgets(self, parent):
self.searchableList = SearchableList(parent, list_height=150, list_width=150, ignore_case=True)
self.addWidget(self.searchableList)
self.connect(self.searchableList, QtCore.SIGNAL('currentItemChanged(QListWidgetItem, QListWidgetItem)'),
self.changeParameter)
self.connect(self.searchableList, QtCore.SIGNAL('addItem(list)'), self.addItem)
self.connect(self.searchableList, QtCore.SIGNAL('removeItem(list)'), self.removeItem)
self.run_template_panel = ert_gui.widgets.util.createEmptyPanel()
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.run_template_file = PathChooser(self, "", "config/simulation/run_template_file", show_files=True)
self.run_template_file.initialize = ContentModel.emptyInitializer
self.run_template_file.setter = self.setTemplateFile
self.run_template_file.getter = lambda model: self.run_template.template_file
self.run_template_target = PathChooser(self, "", "config/simulation/run_template_target", show_files=True)
self.run_template_target.initialize = ContentModel.emptyInitializer
self.run_template_target.setter = self.setTargetFile
self.run_template_target.getter = lambda model: self.run_template.target_file
self.run_template_args = StringBox(self, "", "config/simulation/run_template_arguments")
self.run_template_args.initialize = ContentModel.emptyInitializer
self.run_template_args.setter = self.setArguments
self.run_template_args.getter = lambda model: self.run_template.arguments
layout.addRow("Template file:", self.run_template_file)
layout.addRow("Target file:", self.run_template_target)
layout.addRow("Arguments:", self.run_template_args)
layout.addRow(ert_gui.widgets.util.createSpace(20))
self.run_template_panel.setLayout(layout)
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.dataModel = DataModel("")
self.input = ComboChoice(self, enums.gen_data_file_format.INPUT_TYPES, "", "config/ensemble/gen_data_param_init")
self.modelWrap(self.input, "input_format")
self.output = ComboChoice(self, enums.gen_data_file_format.OUTPUT_TYPES, "", "config/ensemble/gen_data_param_output")
self.modelWrap(self.output, "output_format")
self.template_file = PathChooser(self, "", "config/ensemble/gen_data_template_file", True , must_be_set=False)
self.modelWrap(self.template_file, "template_file")
self.template_key = PathChooser(self, "", "config/ensemble/gen_data_template_key", True , must_be_set=False)
self.modelWrap(self.template_key, "template_key")
self.init_file_fmt = PathChooser(self, "", "config/ensemble/gen_data_init_file_fmt", True , must_be_set=False)
self.modelWrap(self.init_file_fmt, "init_file_fmt")
self.file_generated_by_enkf = PathChooser(self, "", "config/ensemble/gen_data_file_generated_by_enkf", True, must_be_set=False)
self.modelWrap(self.file_generated_by_enkf, "enkf_outfile")
self.file_loaded_by_enkf = PathChooser(self, "", "config/ensemble/gen_data_file_loaded_by_enkf", True, must_be_set=False)
self.modelWrap(self.file_loaded_by_enkf, "enkf_infile")
self.min_std = PathChooser(self, "", "config/ensemble/gen_data_min_std", True, must_be_set=False)
self.modelWrap(self.min_std, "min_std")
layout.addRow("Input:", self.input)
layout.addRow("Output:", self.output)
layout.addRow("Template file:", self.template_file)
layout.addRow("Template key:", self.template_key)
layout.addRow("Init files:", self.init_file_fmt)
layout.addRow("Include file:", self.file_generated_by_enkf)
layout.addRow("Min. std.:", self.min_std)
layout.addRow("File loaded by EnKF:", self.file_loaded_by_enkf)
button = QtGui.QPushButton()
button.setText("Reload")
button.setMaximumWidth(70)
self.connect(button, QtCore.SIGNAL('clicked()'), self._reload)
layout.addRow("Reload template:", button)
self.setLayout(layout)
def createObservationsPage(configPanel, parent):
configPanel.startPage("Observations")
r = configPanel.addRow(
ComboChoice(parent, history_source_type.values(), "History source",
"config/observations/history_source"))
def get_history_source(ert):
history_source = ert.enkf.model_config_get_history_source(
ert.model_config)
return history_source_type.resolveValue(history_source)
r.getter = get_history_source
def set_history_source(ert, value):
history_source = history_source_type.resolveName(str(value))
ert.enkf.model_config_get_history_source(ert.model_config,
history_source.value())
r.setter = set_history_source
r = configPanel.addRow(
PathChooser(parent, "Observations config",
"config/observations/obs_config", True))
def get_obs(ert):
obs = ert.enkf.enkf_main_get_obs(ert.main)
return ert.enkf.enkf_obs_get_config_file(obs)
r.getter = get_obs
def set_obs(ert, value):
ert.enkf.enkf_main_load_obs(ert.main, str(value))
r.setter = set_obs
r = configPanel.addRow(
ReloadButton(parent, "Reload Observations",
"config/observations/reload_observation", "Reload"))
r.getter = lambda ert: ert.enkf.enkf_main_reload_obs(ert.main)
configPanel.endPage()
def createWidgets(self, parent):
self.searchableList = SearchableList(parent, list_height=200, list_width=150, ignore_case=True)
self.addWidget(self.searchableList)
self.connect(
self.searchableList,
QtCore.SIGNAL("currentItemChanged(QListWidgetItem, QListWidgetItem)"),
self.changeParameter,
)
self.connect(self.searchableList, QtCore.SIGNAL("addItem(list)"), self.addItem)
self.connect(self.searchableList, QtCore.SIGNAL("removeItem(list)"), self.removeItem)
self.jobPanel = ert_gui.widgets.util.createEmptyPanel()
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.jobpath = PathChooser(self, "", "config/systemenv/install_job_path", show_files=True, must_be_set=True)
self.jobpath.initialize = ContentModel.emptyInitializer
self.jobpath.setter = self.setPath
self.jobpath.getter = lambda model: self.job.path
layout.addRow("Job:", self.jobpath)
layout.addRow(ert_gui.widgets.util.createSpace(20))
self.validationInfo = ValidationInfo(ValidationInfo.EXCLAMATION)
self.validationInfo.setMessage("Pressing edit will create a job that does not exist.")
self.editButton = QtGui.QPushButton(self)
self.editButton.setToolTip("Edit job")
self.editButton.setIcon(ert_gui.widgets.util.resourceIcon("cog"))
self.editButton.setText("Edit")
self.connect(self.editButton, QtCore.SIGNAL("clicked()"), self.editJob)
layout.addRow(ert_gui.widgets.util.centeredWidget(self.editButton))
layout.addRow(ert_gui.widgets.util.centeredWidget(self.validationInfo))
self.jobPanel.setLayout(layout)
def createEclipsePage(configPanel, parent):
configPanel.startPage("Eclipse")
r = configPanel.addRow(PathChooser(parent, "Eclipse Base", "config/eclipse/eclbase", path_format=True))
r.getter = lambda ert : ert.enkf.ecl_config_get_eclbase(ert.ecl_config)
r.setter = lambda ert, value : ert.enkf.enkf_main_set_eclbase(ert.main , str(value))
r = configPanel.addRow(PathChooser(parent, "Data file", "config/eclipse/data_file", show_files=True))
r.getter = lambda ert : ert.enkf.ecl_config_get_data_file(ert.ecl_config)
r.setter = lambda ert, value : ert.enkf.enkf_main_set_data_file(ert.main , str(value))
r = configPanel.addRow(PathChooser(parent, "Grid", "config/eclipse/grid", show_files=True))
r.getter = lambda ert : ert.enkf.ecl_config_get_gridfile(ert.ecl_config)
r.setter = lambda ert, value : ert.enkf.ecl_config_set_grid(ert.ecl_config, str(value))
r = configPanel.addRow(PathChooser(parent, "Schedule file" , "config/eclipse/schedule_file" , show_files = True))
r.getter = lambda ert : ert.enkf.ecl_config_get_schedule_file(ert.ecl_config)
r.setter = lambda ert, value : ert.enkf.ecl_config_set_schedule_file(ert.ecl_config, str(value))
r = configPanel.addRow(PathChooser(parent, "Init section", "config/eclipse/init_section", show_files=True))
r.getter = lambda ert : ert.enkf.ecl_config_get_init_section(ert.ecl_config)
r.setter = lambda ert, value : ert.enkf.ecl_config_set_init_section(ert.ecl_config, str(value))
r = configPanel.addRow(PathChooser(parent, "Refcase", "config/eclipse/refcase", show_files=True))
r.getter = lambda ert : ert.enkf.ecl_config_get_refcase_name(ert.ecl_config)
r.setter = lambda ert, value : ert.enkf.ecl_config_load_refcase(ert.ecl_config, str(value))
r = configPanel.addRow(PathChooser(parent, "Schedule prediction file", "config/eclipse/schedule_prediction_file", show_files=True))
r.getter = lambda ert : ert.enkf.enkf_main_get_schedule_prediction_file(ert.main)
r.setter = lambda ert, value : ert.enkf.enkf_main_set_schedule_prediction_file(ert.main, ert.nonify( value ))
r = configPanel.addRow(KeywordTable(parent, "Data keywords", "config/eclipse/data_kw"))
r.getter = lambda ert : ert.getSubstitutionList(ert.enkf.enkf_main_get_data_kw(ert.main))
def add_data_kw(ert, listOfKeywords):
ert.enkf.enkf_main_clear_data_kw(ert.main)
for keyword in listOfKeywords:
ert.enkf.enkf_main_add_data_kw(ert.main, keyword[0], keyword[1])
r.setter = add_data_kw
configPanel.addSeparator()
internalPanel = ConfigPanel(parent)
internalPanel.startPage("Static keywords")
r = internalPanel.addRow(KeywordList(parent, "", "config/eclipse/add_static_kw"))
r.getter = lambda ert : ert.getStringList(ert.enkf.ecl_config_get_static_kw_list(ert.ecl_config))
def add_static_kw(ert, listOfKeywords):
ert.enkf.ecl_config_clear_static_kw(ert.ecl_config)
for keyword in listOfKeywords:
ert.enkf.ecl_config_add_static_kw(ert.ecl_config, keyword)
r.setter = add_static_kw
internalPanel.endPage()
# todo: add support for fixed length schedule keywords
#internalPanel.startPage("Fixed length schedule keywords")
#
#r = internalPanel.addRow(KeywordList(widget, "", "add_fixed_length_schedule_kw"))
#r.getter = lambda ert : ert.getAttribute("add_fixed_length_schedule_kw")
#r.setter = lambda ert, value : ert.setAttribute("add_fixed_length_schedule_kw", value)
#
#internalPanel.endPage()
configPanel.addRow(internalPanel)
configPanel.endPage()
class DataPanel(QtGui.QFrame):
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.dataModel = DataModel("")
self.input = ComboChoice(self, enums.gen_data_file_format.INPUT_TYPES, "", "config/ensemble/gen_data_param_init")
self.modelWrap(self.input, "input_format")
self.output = ComboChoice(self, enums.gen_data_file_format.OUTPUT_TYPES, "", "config/ensemble/gen_data_param_output")
self.modelWrap(self.output, "output_format")
self.template_file = PathChooser(self, "", "config/ensemble/gen_data_template_file", True , must_be_set=False)
self.modelWrap(self.template_file, "template_file")
self.template_key = PathChooser(self, "", "config/ensemble/gen_data_template_key", True , must_be_set=False)
self.modelWrap(self.template_key, "template_key")
self.init_file_fmt = PathChooser(self, "", "config/ensemble/gen_data_init_file_fmt", True , must_be_set=False)
self.modelWrap(self.init_file_fmt, "init_file_fmt")
self.file_generated_by_enkf = PathChooser(self, "", "config/ensemble/gen_data_file_generated_by_enkf", True, must_be_set=False)
self.modelWrap(self.file_generated_by_enkf, "enkf_outfile")
self.file_loaded_by_enkf = PathChooser(self, "", "config/ensemble/gen_data_file_loaded_by_enkf", True, must_be_set=False)
self.modelWrap(self.file_loaded_by_enkf, "enkf_infile")
self.min_std = PathChooser(self, "", "config/ensemble/gen_data_min_std", True, must_be_set=False)
self.modelWrap(self.min_std, "min_std")
layout.addRow("Input:", self.input)
layout.addRow("Output:", self.output)
layout.addRow("Template file:", self.template_file)
layout.addRow("Template key:", self.template_key)
layout.addRow("Init files:", self.init_file_fmt)
layout.addRow("Include file:", self.file_generated_by_enkf)
layout.addRow("Min. std.:", self.min_std)
layout.addRow("File loaded by EnKF:", self.file_loaded_by_enkf)
button = QtGui.QPushButton()
button.setText("Reload")
button.setMaximumWidth(70)
self.connect(button, QtCore.SIGNAL('clicked()'), self._reload)
layout.addRow("Reload template:", button)
self.setLayout(layout)
def _reload(self):
self.dataModel.emitUpdate()
def modelWrap(self, widget, attribute):
widget.initialize = ert_gui.widgets.helpedwidget.ContentModel.emptyInitializer
widget.setter = lambda model, value: self.dataModel.set(attribute, value)
widget.getter = lambda model: self.dataModel[attribute]
def setDataModel(self, dataModel):
self.dataModel = dataModel
self.input.fetchContent()
self.output.fetchContent()
self.template_file.fetchContent()
self.template_key.fetchContent()
self.init_file_fmt.fetchContent()
self.file_generated_by_enkf.fetchContent()
self.file_loaded_by_enkf.fetchContent()
self.min_std.fetchContent()
class JobsPanel(HelpedWidget):
"""
Widget for adding, removing and editing jobs.
These additional ContentModel functions must be implemented: insert and remove.
The panel expects remove to return True or False based on the success of the removal.
"""
def __init__(self, parent=None):
HelpedWidget.__init__(self, parent, "",
"config/systemenv/install_jobs")
self.job = Job("undefined")
self.createWidgets(parent)
self.emptyPanel = ert_gui.widgets.util.createEmptyPanel()
self.pagesWidget = QtGui.QStackedWidget()
self.pagesWidget.addWidget(self.emptyPanel)
self.pagesWidget.addWidget(self.jobPanel)
self.addWidget(self.pagesWidget)
def createWidgets(self, parent):
self.searchableList = SearchableList(parent,
list_height=200,
list_width=150,
ignore_case=True)
self.addWidget(self.searchableList)
self.connect(
self.searchableList,
QtCore.SIGNAL(
'currentItemChanged(QListWidgetItem, QListWidgetItem)'),
self.changeParameter)
self.connect(self.searchableList, QtCore.SIGNAL('addItem(list)'),
self.addItem)
self.connect(self.searchableList, QtCore.SIGNAL('removeItem(list)'),
self.removeItem)
self.jobPanel = ert_gui.widgets.util.createEmptyPanel()
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.jobpath = PathChooser(self,
"",
"config/systemenv/install_job_path",
show_files=True,
must_be_set=True)
self.jobpath.initialize = ContentModel.emptyInitializer
self.jobpath.setter = self.setPath
self.jobpath.getter = lambda model: self.job.path
layout.addRow("Job:", self.jobpath)
layout.addRow(ert_gui.widgets.util.createSpace(20))
self.validationInfo = ValidationInfo(ValidationInfo.EXCLAMATION)
self.validationInfo.setMessage(
"Pressing edit will create a job that does not exist.")
self.editButton = QtGui.QPushButton(self)
self.editButton.setToolTip("Edit job")
self.editButton.setIcon(ert_gui.widgets.util.resourceIcon("cog"))
self.editButton.setText("Edit")
self.connect(self.editButton, QtCore.SIGNAL('clicked()'), self.editJob)
layout.addRow(ert_gui.widgets.util.centeredWidget(self.editButton))
layout.addRow(ert_gui.widgets.util.centeredWidget(self.validationInfo))
self.jobPanel.setLayout(layout)
def setPath(self, model, path):
self.job.set("path", path)
self.updateContent(self.job)
# if os.path.exists(path):
# self.validationInfo.setMessage("")
# else:
# self.validationInfo.setMessage("The path must exist! Edit to create the job.")
def editJob(self):
if not os.path.exists(Job.path_prefix):
os.mkdir(Job.path_prefix)
ejd = EditJobDialog(self)
ejd.setJob(self.job)
ejd.exec_()
self.jobpath.validatePath()
def fetchContent(self):
"""Retrieves data from the model and inserts it into the widget"""
jobs = self.getFromModel()
for job in jobs:
jobitem = QtGui.QListWidgetItem()
jobitem.setText(job.name)
jobitem.setData(QtCore.Qt.UserRole, job)
jobitem.setToolTip(job.name)
self.searchableList.list.addItem(jobitem)
def setJob(self, job):
self.job = job
self.jobpath.fetchContent()
def changeParameter(self, current, previous):
"""Switch between jobs. Selection from the list"""
if current is None:
self.pagesWidget.setCurrentWidget(self.emptyPanel)
else:
self.pagesWidget.setCurrentWidget(self.jobPanel)
self.setJob(current.data(QtCore.Qt.UserRole).toPyObject())
def addToList(self, list, name):
"""Adds a new job to the list"""
param = QtGui.QListWidgetItem()
param.setText(name)
new_job = Job(name)
param.setData(QtCore.Qt.UserRole, new_job)
list.addItem(param)
list.setCurrentItem(param)
return new_job
def addItem(self, list):
"""Called by the add button to insert a new job"""
uniqueNames = []
for index in range(list.count()):
uniqueNames.append(str(list.item(index).text()))
pd = ValidatedDialog(self, "New job", "Enter name of new job:",
uniqueNames)
if pd.exec_():
new_job = self.addToList(list, pd.getName())
self.updateContent(new_job, operation=self.INSERT)
self.modelEmit('jobListChanged()')
def removeItem(self, list):
"""Called by the remove button to remove a selected job"""
currentRow = list.currentRow()
if currentRow >= 0:
title = "Delete job?"
msg = "Are you sure you want to delete the job?"
btns = QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
doDelete = QtGui.QMessageBox.question(self, title, msg, btns)
if doDelete == QtGui.QMessageBox.Yes:
item = list.currentItem()
job = item.data(QtCore.Qt.UserRole).toPyObject()
success = self.updateContent(job, operation=self.REMOVE)
if success:
list.takeItem(currentRow)
self.modelEmit('jobListChanged()')
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!"
class JobsPanel(HelpedWidget):
"""
Widget for adding, removing and editing jobs.
These additional ContentModel functions must be implemented: insert and remove.
The panel expects remove to return True or False based on the success of the removal.
"""
def __init__(self, parent=None):
HelpedWidget.__init__(self, parent, "", "config/systemenv/install_jobs")
self.job = Job("undefined")
self.createWidgets(parent)
self.emptyPanel = ert_gui.widgets.util.createEmptyPanel()
self.pagesWidget = QtGui.QStackedWidget()
self.pagesWidget.addWidget(self.emptyPanel)
self.pagesWidget.addWidget(self.jobPanel)
self.addWidget(self.pagesWidget)
def createWidgets(self, parent):
self.searchableList = SearchableList(parent, list_height=200, list_width=150, ignore_case=True)
self.addWidget(self.searchableList)
self.connect(
self.searchableList,
QtCore.SIGNAL("currentItemChanged(QListWidgetItem, QListWidgetItem)"),
self.changeParameter,
)
self.connect(self.searchableList, QtCore.SIGNAL("addItem(list)"), self.addItem)
self.connect(self.searchableList, QtCore.SIGNAL("removeItem(list)"), self.removeItem)
self.jobPanel = ert_gui.widgets.util.createEmptyPanel()
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.jobpath = PathChooser(self, "", "config/systemenv/install_job_path", show_files=True, must_be_set=True)
self.jobpath.initialize = ContentModel.emptyInitializer
self.jobpath.setter = self.setPath
self.jobpath.getter = lambda model: self.job.path
layout.addRow("Job:", self.jobpath)
layout.addRow(ert_gui.widgets.util.createSpace(20))
self.validationInfo = ValidationInfo(ValidationInfo.EXCLAMATION)
self.validationInfo.setMessage("Pressing edit will create a job that does not exist.")
self.editButton = QtGui.QPushButton(self)
self.editButton.setToolTip("Edit job")
self.editButton.setIcon(ert_gui.widgets.util.resourceIcon("cog"))
self.editButton.setText("Edit")
self.connect(self.editButton, QtCore.SIGNAL("clicked()"), self.editJob)
layout.addRow(ert_gui.widgets.util.centeredWidget(self.editButton))
layout.addRow(ert_gui.widgets.util.centeredWidget(self.validationInfo))
self.jobPanel.setLayout(layout)
def setPath(self, model, path):
self.job.set("path", path)
self.updateContent(self.job)
# if os.path.exists(path):
# self.validationInfo.setMessage("")
# else:
# self.validationInfo.setMessage("The path must exist! Edit to create the job.")
def editJob(self):
if not os.path.exists(Job.path_prefix):
os.mkdir(Job.path_prefix)
ejd = EditJobDialog(self)
ejd.setJob(self.job)
ejd.exec_()
self.jobpath.validatePath()
def fetchContent(self):
"""Retrieves data from the model and inserts it into the widget"""
jobs = self.getFromModel()
for job in jobs:
jobitem = QtGui.QListWidgetItem()
jobitem.setText(job.name)
jobitem.setData(QtCore.Qt.UserRole, job)
jobitem.setToolTip(job.name)
self.searchableList.list.addItem(jobitem)
def setJob(self, job):
self.job = job
self.jobpath.fetchContent()
def changeParameter(self, current, previous):
"""Switch between jobs. Selection from the list"""
if current is None:
self.pagesWidget.setCurrentWidget(self.emptyPanel)
else:
self.pagesWidget.setCurrentWidget(self.jobPanel)
self.setJob(current.data(QtCore.Qt.UserRole).toPyObject())
def addToList(self, list, name):
"""Adds a new job to the list"""
param = QtGui.QListWidgetItem()
param.setText(name)
new_job = Job(name)
param.setData(QtCore.Qt.UserRole, new_job)
list.addItem(param)
list.setCurrentItem(param)
return new_job
def addItem(self, list):
"""Called by the add button to insert a new job"""
uniqueNames = []
for index in range(list.count()):
uniqueNames.append(str(list.item(index).text()))
pd = ValidatedDialog(self, "New job", "Enter name of new job:", uniqueNames)
if pd.exec_():
new_job = self.addToList(list, pd.getName())
self.updateContent(new_job, operation=self.INSERT)
self.modelEmit("jobListChanged()")
def removeItem(self, list):
"""Called by the remove button to remove a selected job"""
currentRow = list.currentRow()
if currentRow >= 0:
title = "Delete job?"
msg = "Are you sure you want to delete the job?"
btns = QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
doDelete = QtGui.QMessageBox.question(self, title, msg, btns)
if doDelete == QtGui.QMessageBox.Yes:
item = list.currentItem()
job = item.data(QtCore.Qt.UserRole).toPyObject()
success = self.updateContent(job, operation=self.REMOVE)
if success:
list.takeItem(currentRow)
self.modelEmit("jobListChanged()")
class RunTemplatePanel(HelpedWidget):
"""
Widget for adding, removing and editing run templates.
"""
def __init__(self, parent=None):
HelpedWidget.__init__(self, parent, "",
"config/simulation/run_template")
self.run_template = RunTemplate("undefined", "", "", "")
self.createWidgets(parent)
self.emptyPanel = ert_gui.widgets.util.createEmptyPanel()
self.pagesWidget = QtGui.QStackedWidget()
self.pagesWidget.addWidget(self.emptyPanel)
self.pagesWidget.addWidget(self.run_template_panel)
self.addWidget(self.pagesWidget)
self.addHelpButton()
def createWidgets(self, parent):
self.searchableList = SearchableList(parent,
list_height=150,
list_width=150,
ignore_case=True)
self.addWidget(self.searchableList)
self.connect(
self.searchableList,
QtCore.SIGNAL(
'currentItemChanged(QListWidgetItem, QListWidgetItem)'),
self.changeParameter)
self.connect(self.searchableList, QtCore.SIGNAL('addItem(list)'),
self.addItem)
self.connect(self.searchableList, QtCore.SIGNAL('removeItem(list)'),
self.removeItem)
self.run_template_panel = ert_gui.widgets.util.createEmptyPanel()
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.run_template_file = PathChooser(
self, "", "config/simulation/run_template_file", show_files=True)
self.run_template_file.initialize = ContentModel.emptyInitializer
self.run_template_file.setter = self.setTemplateFile
self.run_template_file.getter = lambda model: self.run_template.template_file
self.run_template_target = PathChooser(
self, "", "config/simulation/run_template_target", show_files=True)
self.run_template_target.initialize = ContentModel.emptyInitializer
self.run_template_target.setter = self.setTargetFile
self.run_template_target.getter = lambda model: self.run_template.target_file
self.run_template_args = StringBox(
self, "", "config/simulation/run_template_arguments")
self.run_template_args.initialize = ContentModel.emptyInitializer
self.run_template_args.setter = self.setArguments
self.run_template_args.getter = lambda model: self.run_template.arguments
layout.addRow("Template file:", self.run_template_file)
layout.addRow("Target file:", self.run_template_target)
layout.addRow("Arguments:", self.run_template_args)
layout.addRow(ert_gui.widgets.util.createSpace(20))
self.run_template_panel.setLayout(layout)
def setArguments(self, model, arguments):
self.run_template.setArguments(arguments)
self.runTemplateChanged()
def setTemplateFile(self, model, template_file):
self.run_template.setTemplateFile(template_file)
self.runTemplateChanged()
def setTargetFile(self, model, target_file):
self.run_template.setTargetFile(target_file)
self.runTemplateChanged()
def fetchContent(self):
"""
Retrieves data from the model and inserts it into the widget.
List of tuples: (name, template_file, target_file, arguments)
"""
data = self.getFromModel()
self.searchableList.list.clear()
for item in data:
jobitem = QtGui.QListWidgetItem()
jobitem.setText(item[0])
run_template = RunTemplate(item[0], item[1], item[2], item[3])
jobitem.setData(QtCore.Qt.UserRole, run_template)
jobitem.setToolTip(item[0])
self.searchableList.list.addItem(jobitem)
def setRunTemplate(self, run_template):
"""Set the current visible run template"""
self.run_template = run_template
self.run_template_args.fetchContent()
self.run_template_file.fetchContent()
self.run_template_target.fetchContent()
def changeParameter(self, current, previous):
"""Switch between run templates. Selection from the list"""
if current is None:
self.pagesWidget.setCurrentWidget(self.emptyPanel)
else:
self.pagesWidget.setCurrentWidget(self.run_template_panel)
self.setRunTemplate(current.data(QtCore.Qt.UserRole).toPyObject())
def runTemplateChanged(self):
"""
Called whenever the run template is changed. (adding, removing)
The data submitted to the updateContent() (from ContentModel) is a list of tuples (name, template_file, target_file, arguments)
"""
items = self.searchableList.getItems()
currentRow = self.searchableList.list.currentRow()
run_templates = []
for item in items:
r_t = item.data(QtCore.Qt.UserRole).toPyObject()
run_template_tuple = (r_t.name, r_t.template_file, r_t.target_file,
r_t.arguments)
run_templates.append(run_template_tuple)
self.updateContent(run_templates)
self.fetchContent()
self.searchableList.list.setCurrentRow(currentRow)
def addToList(self, list, name):
"""Adds a new run template to the list"""
param = QtGui.QListWidgetItem()
param.setText(name)
new_job = RunTemplate(name)
param.setData(QtCore.Qt.UserRole, new_job)
list.addItem(param)
list.setCurrentItem(param)
return param
def addItem(self, list):
"""Called by the add button to insert a new run template"""
uniqueNames = []
for index in range(list.count()):
uniqueNames.append(str(list.item(index).text()))
pd = ValidatedDialog(self, "New run template",
"Enter name of new run template:", uniqueNames)
if pd.exec_():
self.addToList(list, pd.getName())
self.runTemplateChanged()
def removeItem(self, list):
"""Called by the remove button to remove a selected job"""
currentRow = list.currentRow()
if currentRow >= 0:
title = "Delete run template?"
msg = "Are you sure you want to delete the run template?"
btns = QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
doDelete = QtGui.QMessageBox.question(self, title, msg, btns)
if doDelete == QtGui.QMessageBox.Yes:
list.takeItem(currentRow)
self.runTemplateChanged()
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.dataModel = DataModel("")
self.input = ComboChoice(self, enums.gen_data_file_format.INPUT_TYPES, "", "config/ensemble/gen_data_param_init")
self.modelWrap(self.input, "input_format")
self.output = ComboChoice(self, enums.gen_data_file_format.OUTPUT_TYPES, "", "config/ensemble/gen_data_param_output")
self.modelWrap(self.output, "output_format")
self.template_file = PathChooser(self, "", "config/ensemble/gen_data_template_file", True , must_be_set=False)
self.modelWrap(self.template_file, "template_file")
self.template_key = PathChooser(self, "", "config/ensemble/gen_data_template_key", True , must_be_set=False)
self.modelWrap(self.template_key, "template_key")
self.init_file_fmt = PathChooser(self, "", "config/ensemble/gen_data_init_file_fmt", True , must_be_set=False)
self.modelWrap(self.init_file_fmt, "init_file_fmt")
self.file_generated_by_enkf = PathChooser(self, "", "config/ensemble/gen_data_file_generated_by_enkf", True, must_be_set=False)
self.modelWrap(self.file_generated_by_enkf, "enkf_outfile")
self.file_loaded_by_enkf = PathChooser(self, "", "config/ensemble/gen_data_file_loaded_by_enkf", True, must_be_set=False)
self.modelWrap(self.file_loaded_by_enkf, "enkf_infile")
self.min_std = PathChooser(self, "", "config/ensemble/gen_data_min_std", True, must_be_set=False)
self.modelWrap(self.min_std, "min_std")
layout.addRow("Input:", self.input)
layout.addRow("Output:", self.output)
layout.addRow("Template file:", self.template_file)
layout.addRow("Template key:", self.template_key)
layout.addRow("Init files:", self.init_file_fmt)
layout.addRow("Include file:", self.file_generated_by_enkf)
layout.addRow("Min. std.:", self.min_std)
layout.addRow("File loaded by EnKF:", self.file_loaded_by_enkf)
button = QtGui.QPushButton()
button.setText("Reload")
button.setMaximumWidth(70)
self.connect(button, QtCore.SIGNAL('clicked()'), self._reload)
layout.addRow("Reload template:", button)
self.setLayout(layout)
class RunTemplatePanel(HelpedWidget):
"""
Widget for adding, removing and editing run templates.
"""
def __init__(self, parent=None):
HelpedWidget.__init__(self, parent, "", "config/simulation/run_template")
self.run_template = RunTemplate("undefined", "", "", "")
self.createWidgets(parent)
self.emptyPanel = ert_gui.widgets.util.createEmptyPanel()
self.pagesWidget = QtGui.QStackedWidget()
self.pagesWidget.addWidget(self.emptyPanel)
self.pagesWidget.addWidget(self.run_template_panel)
self.addWidget(self.pagesWidget)
self.addHelpButton()
def createWidgets(self, parent):
self.searchableList = SearchableList(parent, list_height=150, list_width=150, ignore_case=True)
self.addWidget(self.searchableList)
self.connect(self.searchableList, QtCore.SIGNAL('currentItemChanged(QListWidgetItem, QListWidgetItem)'),
self.changeParameter)
self.connect(self.searchableList, QtCore.SIGNAL('addItem(list)'), self.addItem)
self.connect(self.searchableList, QtCore.SIGNAL('removeItem(list)'), self.removeItem)
self.run_template_panel = ert_gui.widgets.util.createEmptyPanel()
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.run_template_file = PathChooser(self, "", "config/simulation/run_template_file", show_files=True)
self.run_template_file.initialize = ContentModel.emptyInitializer
self.run_template_file.setter = self.setTemplateFile
self.run_template_file.getter = lambda model: self.run_template.template_file
self.run_template_target = PathChooser(self, "", "config/simulation/run_template_target", show_files=True)
self.run_template_target.initialize = ContentModel.emptyInitializer
self.run_template_target.setter = self.setTargetFile
self.run_template_target.getter = lambda model: self.run_template.target_file
self.run_template_args = StringBox(self, "", "config/simulation/run_template_arguments")
self.run_template_args.initialize = ContentModel.emptyInitializer
self.run_template_args.setter = self.setArguments
self.run_template_args.getter = lambda model: self.run_template.arguments
layout.addRow("Template file:", self.run_template_file)
layout.addRow("Target file:", self.run_template_target)
layout.addRow("Arguments:", self.run_template_args)
layout.addRow(ert_gui.widgets.util.createSpace(20))
self.run_template_panel.setLayout(layout)
def setArguments(self, model, arguments):
self.run_template.setArguments(arguments)
self.runTemplateChanged()
def setTemplateFile(self, model, template_file):
self.run_template.setTemplateFile(template_file)
self.runTemplateChanged()
def setTargetFile(self, model, target_file):
self.run_template.setTargetFile(target_file)
self.runTemplateChanged()
def fetchContent(self):
"""
Retrieves data from the model and inserts it into the widget.
List of tuples: (name, template_file, target_file, arguments)
"""
data = self.getFromModel()
self.searchableList.list.clear()
for item in data:
jobitem = QtGui.QListWidgetItem()
jobitem.setText(item[0])
run_template = RunTemplate(item[0], item[1], item[2], item[3])
jobitem.setData(QtCore.Qt.UserRole, run_template)
jobitem.setToolTip(item[0])
self.searchableList.list.addItem(jobitem)
def setRunTemplate(self, run_template):
"""Set the current visible run template"""
self.run_template = run_template
self.run_template_args.fetchContent()
self.run_template_file.fetchContent()
self.run_template_target.fetchContent()
def changeParameter(self, current, previous):
"""Switch between run templates. Selection from the list"""
if current is None:
self.pagesWidget.setCurrentWidget(self.emptyPanel)
else:
self.pagesWidget.setCurrentWidget(self.run_template_panel)
self.setRunTemplate(current.data(QtCore.Qt.UserRole).toPyObject())
def runTemplateChanged(self):
"""
Called whenever the run template is changed. (adding, removing)
The data submitted to the updateContent() (from ContentModel) is a list of tuples (name, template_file, target_file, arguments)
"""
items = self.searchableList.getItems()
currentRow = self.searchableList.list.currentRow()
run_templates = []
for item in items:
r_t = item.data(QtCore.Qt.UserRole).toPyObject()
run_template_tuple = (r_t.name, r_t.template_file, r_t.target_file, r_t.arguments)
run_templates.append(run_template_tuple)
self.updateContent(run_templates)
self.fetchContent()
self.searchableList.list.setCurrentRow(currentRow)
def addToList(self, list, name):
"""Adds a new run template to the list"""
param = QtGui.QListWidgetItem()
param.setText(name)
new_job = RunTemplate(name)
param.setData(QtCore.Qt.UserRole, new_job)
list.addItem(param)
list.setCurrentItem(param)
return param
def addItem(self, list):
"""Called by the add button to insert a new run template"""
uniqueNames = []
for index in range(list.count()):
uniqueNames.append(str(list.item(index).text()))
pd = ValidatedDialog(self, "New run template", "Enter name of new run template:", uniqueNames)
if pd.exec_():
self.addToList(list, pd.getName())
self.runTemplateChanged()
def removeItem(self, list):
"""Called by the remove button to remove a selected job"""
currentRow = list.currentRow()
if currentRow >= 0:
title = "Delete run template?"
msg = "Are you sure you want to delete the run template?"
btns = QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
doDelete = QtGui.QMessageBox.question(self, title, msg, btns)
if doDelete == QtGui.QMessageBox.Yes:
list.takeItem(currentRow)
self.runTemplateChanged()
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!"
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()
class KeywordPanel(QtGui.QFrame):
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.keywordModel = KeywordModel("")
self.min_std = PathChooser(self,
"",
"config/ensemble/gen_kw_min_std",
True,
must_be_set=False)
self.modelWrap(self.min_std, "min_std")
self.template = PathChooser(self, "",
"config/ensemble/gen_kw_template", True)
self.modelWrap(self.template, "template")
self.enkf_outfile = PathChooser(self,
"",
"config/ensemble/gen_kw_enkf_outfile",
True,
must_be_set=False)
self.modelWrap(self.enkf_outfile, "enkf_outfile")
self.init_files = PathChooser(self,
"",
"config/ensemble/gen_kw_init_files",
True,
must_be_set=False)
self.modelWrap(self.init_files, "init_files")
self.parameter_file = PathChooser(
self,
"",
"config/ensemble/gen_kw_parameter_file",
True,
must_be_set=False)
self.modelWrap(self.parameter_file, "parameter_file")
layout.addRow("Parameter file:", self.parameter_file)
layout.addRow("Include file:", self.enkf_outfile)
layout.addRow("Template:", self.template)
layout.addRow("Minimum std:", self.min_std)
layout.addRow("Init files:", self.init_files)
button = QtGui.QPushButton()
button.setText("Reload")
button.setMaximumWidth(70)
self.connect(button, QtCore.SIGNAL('clicked()'), self._reload)
layout.addRow("Reload files:", button)
self.setLayout(layout)
def _reload(self):
self.keywordModel.emitUpdate()
def setKeywordModel(self, keywordModel):
self.keywordModel = keywordModel
self.min_std.fetchContent()
self.template.fetchContent()
self.enkf_outfile.fetchContent()
self.init_files.fetchContent()
self.parameter_file.fetchContent()
def modelWrap(self, widget, attribute):
widget.initialize = ContentModel.emptyInitializer
widget.setter = lambda model, value: self.keywordModel.set(
attribute, value)
widget.getter = lambda model: self.keywordModel[attribute]
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()
class DataPanel(QtGui.QFrame):
def __init__(self, parent):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
layout = QtGui.QFormLayout()
layout.setLabelAlignment(QtCore.Qt.AlignRight)
self.dataModel = DataModel("")
self.input = ComboChoice(self, enums.gen_data_file_format.INPUT_TYPES, "", "config/ensemble/gen_data_param_init")
self.modelWrap(self.input, "input_format")
self.output = ComboChoice(self, enums.gen_data_file_format.OUTPUT_TYPES, "", "config/ensemble/gen_data_param_output")
self.modelWrap(self.output, "output_format")
self.template_file = PathChooser(self, "", "config/ensemble/gen_data_template_file", True , must_be_set=False)
self.modelWrap(self.template_file, "template_file")
self.template_key = PathChooser(self, "", "config/ensemble/gen_data_template_key", True , must_be_set=False)
self.modelWrap(self.template_key, "template_key")
self.init_file_fmt = PathChooser(self, "", "config/ensemble/gen_data_init_file_fmt", True , must_be_set=False)
self.modelWrap(self.init_file_fmt, "init_file_fmt")
self.file_generated_by_enkf = PathChooser(self, "", "config/ensemble/gen_data_file_generated_by_enkf", True, must_be_set=False)
self.modelWrap(self.file_generated_by_enkf, "enkf_outfile")
self.file_loaded_by_enkf = PathChooser(self, "", "config/ensemble/gen_data_file_loaded_by_enkf", True, must_be_set=False)
self.modelWrap(self.file_loaded_by_enkf, "enkf_infile")
self.min_std = PathChooser(self, "", "config/ensemble/gen_data_min_std", True, must_be_set=False)
self.modelWrap(self.min_std, "min_std")
layout.addRow("Input:", self.input)
layout.addRow("Output:", self.output)
layout.addRow("Template file:", self.template_file)
layout.addRow("Template key:", self.template_key)
layout.addRow("Init files:", self.init_file_fmt)
layout.addRow("Include file:", self.file_generated_by_enkf)
layout.addRow("Min. std.:", self.min_std)
layout.addRow("File loaded by EnKF:", self.file_loaded_by_enkf)
button = QtGui.QPushButton()
button.setText("Reload")
button.setMaximumWidth(70)
self.connect(button, QtCore.SIGNAL('clicked()'), self._reload)
layout.addRow("Reload template:", button)
self.setLayout(layout)
def _reload(self):
self.dataModel.emitUpdate()
def modelWrap(self, widget, attribute):
widget.initialize = ert_gui.widgets.helpedwidget.ContentModel.emptyInitializer
widget.setter = lambda model, value: self.dataModel.set(attribute, value)
widget.getter = lambda model: self.dataModel[attribute]
def setDataModel(self, dataModel):
self.dataModel = dataModel
self.input.fetchContent()
self.output.fetchContent()
self.template_file.fetchContent()
self.template_key.fetchContent()
self.init_file_fmt.fetchContent()
self.file_generated_by_enkf.fetchContent()
self.file_loaded_by_enkf.fetchContent()
self.min_std.fetchContent()
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()
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()
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()
