def __init__(self, main_form=None, *args):
QDialog.__init__(self)
self.helper = HelpHandler(self)
if main_form.model == "SWMM":
self.help_topic = "swmm/src/src/mapdimensionsdialog.htm"
elif main_form.model == "EPANET":
self.help_topic = "epanet/src/src/Map_Dime.htm"
self.ui = Ui_frmMapDimensionsDesigner()
self.ui.setupUi(self)
self.session = main_form
self.icon = main_form.windowIcon()
self.map_widget = self.session.map_widget
self.options = None
if args is not None and len(args) > 0:
self.options = args[0]
self.ui.rdoUnitDegrees.toggled.connect(self.changeLinearMapUnit)
self.ui.rdoUnitNone.toggled.connect(self.changeLinearMapUnit)
self.ui.rdoUnitFeet.toggled.connect(self.changeLinearMapUnit)
self.ui.rdoUnitMeters.toggled.connect(self.changeLinearMapUnit)
self.ui.txtLLx.textChanged.connect(
lambda: self.checkCoords(self.ui.txtLLx.text()))
self.ui.txtLLy.textChanged.connect(
lambda: self.checkCoords(self.ui.txtLLy.text()))
self.ui.txtURx.textChanged.connect(
lambda: self.checkCoords(self.ui.txtURx.text()))
self.ui.txtURy.textChanged.connect(
lambda: self.checkCoords(self.ui.txtURy.text()))
self.ui.btnAutoSize.clicked.connect(self.autoSetMapDimensions)
self.ui.buttonBox.accepted.connect(self.setExtent)
self.ui.btnHelp.clicked.connect(self.show_help)
self.setupOptions()
def __init__(self, main_form, title, curve_type, edit_these, new_item):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/curveeditordialog.htm"
self.setupUi(self)
if title:
self.setWindowTitle(title)
self.cboCurveType.clear()
ui.convenience.set_combo_items(core.swmm.curves.CurveType,
self.cboCurveType)
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.btnSave.clicked.connect(self.save_curve_data)
self.btnLoad.clicked.connect(self.load_curve_data)
self.btnHelp.clicked.connect(self.show_help)
self.btnView.clicked.connect(self.btnView_Clicked)
# self.cboCurveType.clicked.connect(self.cboCurveType_currentIndexChanged)
self.cboCurveType.currentIndexChanged.connect(
self.cboCurveType_currentIndexChanged)
# self.set_from(main_form.project) # do after init to set curve type
self._main_form = main_form
self.curve_type = curve_type
self.project = main_form.project
self.section = self.project.curves
self.X = []
self.Y = []
self.new_item = new_item
if new_item:
self.set_from(new_item)
elif edit_these:
if isinstance(edit_these,
list): # edit first transect if given a list
self.set_from(edit_these[0])
else:
self.set_from(edit_these)
def __init__(self, dataset, plot_type, plot_title, window_icon, x_title,
y_title):
"""
Constructor
Args:
dataset: time series data as pandas data frame
"""
QMainWindow.__init__(self)
self.helper = HelpHandler(self)
self.setupUi(self)
self.setWindowIcon(window_icon)
self.actionPrint.setVisible(False)
self.actionSave.setVisible(False)
self.actionCopy.setVisible(False)
self.menuFile.setEnabled(False)
self.menuFile.setVisible(False)
self.menuFile.deleteLater()
self.dataset = dataset
self.plot_title = plot_title
self.x_title = x_title
self.y_title = y_title
if plot_type == 'time':
self.plot_type = 'timeseries'
self.help_topic = "swmm/src/src/timeserieseditordialog.htm"
elif plot_type == 'xy':
self.plot_type = 'xy'
self.help_topic = "swmm/src/src/transecteditordialog.htm"
elif plot_type == 'step':
self.plot_type = 'step'
self.help_topic = '' # TODO
# self.plot = CurvePlot(self.fraPlot, width=6, height=2, dpi=100)
# layout = QVBoxLayout(self.fraPlot)
# layout.setContentsMargins(0, 0, 0, 0)
# layout.addWidget(self.plot)
# self.fraPlot.setLayout(layout)
self.helper = HelpHandler(self)
self.Xunits = {}
self.Yunits = {}
self.Xlabel = ""
self.Ylabel = ""
self.Xunit = ""
self.Yunit = ""
self.TXT_OPEN_CURVE_TITLE = 'Open a Curve'
self.TXT_SAVE_CURVE_TITLE = 'Save Curve As'
self.TXT_CURVE_FILTER = 'Curve files (*.CRV)|*.CRV|All files|*.*'
self.xvals = []
self.yvals = []
self.btnClose.clicked.connect(self.frm_close)
self.btnHelp.clicked.connect(self.get_help)
self.actionOpen.triggered.connect(self.open_datafile)
self.actionCopy.triggered.connect(self.copy_plot)
self.actionSave.triggered.connect(self.save_plot)
self.actionPrint.triggered.connect(self.print_plot)
# self.installEventFilter(self)
self.do_plot()
def __init__(self, main_form):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/viewingastatisticsreport.htm"
self.helper = HelpHandler(self)
self.setupUi(self)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
# self.set_from(parent.project)
self._main_form = main_form
self.stats = None
self.statsResult = None #UStats.TStatsResults()
def __init__(self, main_form, subcatchment_name):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/lidgroupeditor.htm"
self.units = main_form.project.options.flow_units.value
self.setupUi(self)
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.btnAdd.clicked.connect(self.btnAdd_Clicked)
self.btnEdit.clicked.connect(self.btnEdit_Clicked)
self.btnDelete.clicked.connect(self.btnDelete_Clicked)
self._main_form = main_form
# set for first subcatchment for now
self.subcatchment_name = subcatchment_name
self.set_subcatchment(main_form.project, subcatchment_name)
if (main_form.program_settings.value("Geometry/" +
"frmLIDControls_geometry")
and main_form.program_settings.value("Geometry/" +
"frmLIDControls_state")):
self.restoreGeometry(
main_form.program_settings.value("Geometry/" +
"frmLIDControls_geometry",
self.geometry(),
type=QtCore.QByteArray))
self.restoreState(
main_form.program_settings.value("Geometry/" +
"frmLIDControls_state",
self.windowState(),
type=QtCore.QByteArray))
def __init__(self, main_form, calibrate_against, node_id):
QtGui.QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "epanet/src/src/Cali0078.htm"
self.setupUi(self)
# QtCore.QObject.connect(self.cmdOK, QtCore.SIGNAL("clicked()"), self.cmdOK_Clicked)
QtCore.QObject.connect(self.cmdCancel, QtCore.SIGNAL("clicked()"),
self.cmdCancel_Clicked)
# self.set_from(parent.project) # do after init to set control type CONTROLS or RULES
self.setWindowTitle('EPANET Calibration Report - ' + calibrate_against)
self._main_form = main_form
heading = ' Calibration Statistics for ' + calibrate_against + '\n' \
+ '\n' \
+ ' Num Observed Computed Mean RMS' + '\n' \
+ ' Location Obs Mean Mean Error Error' + '\n' \
+ ' ---------------------------------------------------------' + '\n' \
+ ' 11 9 0.64 148.43 147.794 154.996' + '\n' \
+ ' ---------------------------------------------------------' + '\n' \
+ ' Network 9 0.64 148.43 147.794 154.996' + '\n' \
+ '\n' \
+ ' Correlation Between Means: -1.452'
self.txtStatistics.setReadOnly(True)
self.txtStatistics.setText(heading)
# correlation plot tab
correlation_plot = MyPlot(self.widgetPlot, width=6, height=2, dpi=100)
self.setParent(self._main_form)
self.widgetPlot = correlation_plot
# mean comparisons tab
mean_plot = MyPlot(self.widgetMean, width=6, height=2, dpi=100)
self.setParent(self._main_form)
self.widgetMean = mean_plot
def __init__(self, main_form=None):
QMainWindow.__init__(self, main_form)
self.setupUi(self)
self.helper = HelpHandler(self)
if main_form.model == "SWMM":
self.help_topic = "swmm/src/src/settingprogrampreferences.htm"
elif main_form.model == "EPANET":
self.help_topic = "epanet/src/src/setting_.htm"
self.local_subcatch_preferences = {}
self.local_node_preferences = {}
self.local_link_preferences = {}
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self._main_form = main_form
self.set_from(main_form.project)
self.icon = main_form.windowIcon()
self.cboSubcatchment.currentIndexChanged.connect(
self.cboSubcatchment_currentIndexChanged)
self.cboNode.currentIndexChanged.connect(
self.cboNode_currentIndexChanged)
self.cboLink.currentIndexChanged.connect(
self.cboLink_currentIndexChanged)
self.spnSubcatchment.valueChanged.connect(
self.spnSubcatchment_valueChanged)
self.spnNode.valueChanged.connect(self.spnNode_valueChanged)
self.spnLink.valueChanged.connect(self.spnLink_valueChanged)
def __init__(self, session, project):
QMainWindow.__init__(self, session)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/Submitti.htm"
self.setupUi(self)
self.session = session
self.project = project
self.selected_objects = {}
self.model_attributes = {}
self.model_attributes["subcatchment"] = ["Area", "Width", "% Slope", "% Impervious", "% LID Usage"]
self.model_attributes["node"] = ["Invert"]
self.model_attributes["link"] = ["Max. Depth", "Roughness", "% Slope"]
self.model_attributes["lid"] = ["Any LIDs", "Bio-Retention Cell", "Rain Garden", "Green Roof",
"Infiltration Trench", "Permeable Pavement", "Rain Barrel",
"Rooftop Disconnected", "Vegetative Swale"]
self.model_attributes["inflow_node"] = ["Direct Inflow", "DW Inflow", "RDII Inflow", "GW Inflow"]
self.cboFind.currentIndexChanged.connect(self.cboFind_Changed)
self.cboFind.addItem('Find Subcatchments with')
self.cboFind.addItem('Find Nodes with')
self.cboFind.addItem('Find Links with')
self.cboFind.addItem('Find Subcatchments with LID')
self.cboFind.addItem('Find Nodes with Inflow')
self.cboAbove.addItem('Below')
self.cboAbove.addItem('Equal To')
self.cboAbove.addItem('Above')
self.cmdSubmit.clicked.connect(self.cmdSubmit_Clicked)
def __init__(self, main_form, subcatchment_name):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/groundwater_equation_editor.htm"
self._main_form = main_form
self.setupUi(self)
self.subcatchment_name = subcatchment_name
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.set_from(main_form.project)
if (main_form.program_settings.value(
"Geometry/" + "frmGroundwaterEquationDeep_geometry")
and main_form.program_settings.value(
"Geometry/" + "frmGroundwaterEquationDeep_state")):
self.restoreGeometry(
main_form.program_settings.value(
"Geometry/" + "frmGroundwaterEquationDeep_geometry",
self.geometry(),
type=QtCore.QByteArray))
self.restoreState(
main_form.program_settings.value(
"Geometry/" + "frmGroundwaterEquationDeep_state",
self.windowState(),
type=QtCore.QByteArray))
def __init__(self, main_form, edit_these, new_item, title):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/groundwaterfloweditordialog.htm"
self._main_form = main_form
self.project = main_form.project
self.new_item = new_item
self.refresh_column = -1
self.setupUi(self)
self.setWindowTitle(title)
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.backend = PropertyEditorBackend(self.tblGeneric, self.lblNotes,
main_form, edit_these, new_item)
for column in range(0, self.tblGeneric.columnCount()):
# for aquifers, show available aquifers
aquifer_section = main_form.project.find_section("AQUIFERS")
aquifer_list = aquifer_section.value[0:]
combobox = QComboBox()
combobox.addItem('')
selected_index = 0
for value in aquifer_list:
combobox.addItem(value.name)
if edit_these[column].aquifer == value.name:
selected_index = int(combobox.count()) - 1
combobox.setCurrentIndex(selected_index)
self.tblGeneric.setCellWidget(1, column, combobox)
# also set special text plus button cells
self.set_lateral_equation(column)
self.set_deep_equation(column)
self.installEventFilter(self)
def __init__(self, main_form):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/viewing_a_summary_report.htm"
self.setupUi(self)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
# self.set_from(parent.project) # do after init to set control type CONTROLS or RULES
self._main_form = main_form
self.label.setVisible(
False) # since sorting seems buggy, take this off for now
self.tblSummary.setSortingEnabled(False)
self.cboType.currentIndexChanged.connect(
self.cboType_currentIndexChanged)
self.tblSummary.setSortingEnabled(False)
if (main_form.program_settings.value("Geometry/" +
"frmSummaryReport_geometry") and
main_form.program_settings.value("Geometry/" +
"frmSummaryReport_state")):
self.restoreGeometry(
main_form.program_settings.value("Geometry/" +
"frmSummaryReport_geometry",
self.geometry(),
type=QtCore.QByteArray))
self.restoreState(
main_form.program_settings.value("Geometry/" +
"frmSummaryReport_state",
self.windowState(),
type=QtCore.QByteArray))
def __init__(self, session):
self.session = session
QMainWindow.__init__(self, session)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/timeseriesplotdialog.htm"
self.setupUi(self)
self.rbnDate.clicked.connect(self.rbnDate_Clicked)
self.rbnElapsed.clicked.connect(self.rbnDate_Clicked)
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.btnAdd.clicked.connect(self.btnAdd_Clicked)
self.btnRemove.clicked.connect(self.btnRemove_Clicked)
self.btnSave.clicked.connect(self.save_file)
self.btnLoad.clicked.connect(self.load_file)
self.btnScript.clicked.connect(self.save_script)
self.cboStart.currentIndexChanged.connect(
self.cboStart_currentIndexChanged)
self.cboEnd.currentIndexChanged.connect(
self.cboEnd_currentIndexChanged)
self._main_form = session
if (self._main_form.program_settings.value(
"Geometry/" + "frmTimeSeriesPlot_geometry")
and self._main_form.program_settings.value(
"Geometry/" + "frmTimeSeriesPlot_state")):
self.restoreGeometry(
self._main_form.program_settings.value(
"Geometry/" + "frmTimeSeriesPlot_geometry",
self.geometry(),
type=QtCore.QByteArray))
self.restoreState(
self._main_form.program_settings.value(
"Geometry/" + "frmTimeSeriesPlot_state",
self.windowState(),
type=QtCore.QByteArray))
def __init__(self, main_form=None):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/lidusageeditor.htm"
self.units = main_form.project.options.flow_units.value
self.setupUi(self)
self._main_form = main_form
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.cboLIDControl.currentIndexChanged.connect(self.cboLIDControl_currentIndexChanged)
self.spxUnits.valueChanged.connect(self.spxUnits_valueChanged)
self.txtArea.textChanged.connect(self.txtArea_textChanged)
self.cbxFull.stateChanged.connect(self.cbxFull_stateChanged)
self.btnFile.clicked.connect(self.btnFile_clicked)
self.btnClear.clicked.connect(self.btnClear_clicked)
# self.set_from(parent.parent.project)
self.subcatchment_name = ''
self.row_id = -1
self.project = ''
if (main_form.program_settings.value("Geometry/" + "frmLIDUsage_geometry") and
main_form.program_settings.value("Geometry/" + "frmLIDUsage_state")):
self.restoreGeometry(main_form.program_settings.value("Geometry/" + "frmLIDUsage_geometry",
self.geometry(), type=QtCore.QByteArray))
self.restoreState(main_form.program_settings.value("Geometry/" + "frmLIDUsage_state",
self.windowState(), type=QtCore.QByteArray))
def make_editor_from_tree(self, search_for, tree_list):
for tree_item in tree_list:
if search_for == tree_item[
0]: # If we found a matching tree item, return its editor
if len(tree_item) > 0 and tree_item[1] and not (type(
tree_item[1]) is list):
args = [self]
if len(tree_item) > 2:
# We recommend this is a list, but if not, try to treat it as a single argument
if isinstance(tree_item[2],
basestring) or not isinstance(
tree_item[2], list):
args.append(str(tree_item[2]))
else: # tree_item[2] is a list that is not a string
args.extend(tree_item[2])
edit_form = tree_item[1](
*args
) # Create editor with first argument self, other args from tree_item
edit_form.helper = HelpHandler(edit_form)
return edit_form
return None
if len(tree_item) > 0 and type(
tree_item[1]
) is list: # find whether there is a match in this sub-tree
edit_form = self.make_editor_from_tree(search_for,
tree_item[1])
if edit_form:
return edit_form
def __init__(self, main_form, project, output):
QtGui.QMainWindow.__init__(self, main_form)
self.loaded = False
self.helper = HelpHandler(self)
self.help_topic = "epanet/src/src/Crea0079.htm"
self.setupUi(self)
QtCore.QObject.connect(self.cmdOK, QtCore.SIGNAL("clicked()"),
self.cmdOK_Clicked)
QtCore.QObject.connect(self.cmdCancel, QtCore.SIGNAL("clicked()"),
self.cmdCancel_Clicked)
QtCore.QObject.connect(self.listWidget, QtCore.SIGNAL("itemClicked(QListWidgetItem *)"), \
self.listWidget_clicked)
self.project = project
self.output = output
# limit what shows up in the combo box to only those with calibration data
self.comboBox.addItems(
['Demand', 'Head', 'Pressure', 'Quality', 'Flow', 'Velocity'])
self._main_form = main_form
self.listWidget.setSelectionMode(
QtGui.QAbstractItemView.MultiSelection)
#self.listWidget.setItemSelected(self.listWidget.item(0),True)
self.currentECaliType = None
self.selected_nodes = []
self.selected_pipes = []
self.isFlow = None
self.set_from(project)
QtCore.QObject.connect(self.comboBox, QtCore.SIGNAL("currentIndexChanged(int)"), \
self.comboBox_selChanged)
self.loaded = True
def get_editor(self, edit_name):
frm = None
# First handle special cases where forms need more than simply being created
if edit_name == self.tree_quality_Pollutants[0]:
edit_these = []
if self.project and self.project.pollutants:
if not isinstance(self.project.pollutants.value, basestring):
if isinstance(self.project.pollutants.value, list):
edit_these.extend(self.project.pollutants.value)
if len(edit_these) == 0:
new_item = Pollutant()
new_item.name = "NewPollutant"
edit_these.append(new_item)
self.project.pollutants.value = edit_these
frm = frmGenericPropertyEditor(self, edit_these, "SWMM Pollutant Editor")
frm.helper = HelpHandler(frm)
frm.help_topic = "swmm/src/src/pollutanteditordialog.htm"
elif edit_name in [item[0] for item in self.tree_items_using_id]:
# in these cases the click on the tree diagram populates the lower left list, not directly to an editor
return None
# the following items will respond to a click on a conduit form, not the tree diagram
# elif edit_name == tree_links_Conduits[0]:
# frm = frmCrossSection(self)
# the following items will respond to a click on a node form, not the tree diagram
# elif edit_name == "Outfalls" or edit_name == "Dividers" or edit_name == "Storage Units":
# frm = frmInflows(self)
else: # General-purpose case finds most editors from tree information
frm = self.make_editor_from_tree(edit_name, self.tree_top_items)
return frm
def __init__(self, main_form):
QMainWindow.__init__(self, main_form)
self._main_form = main_form
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/scatterplotdialog.htm"
self.setupUi(self)
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.cboStart.currentIndexChanged.connect(
self.cboStart_currentIndexChanged)
self.cboEnd.currentIndexChanged.connect(
self.cboEnd_currentIndexChanged)
self.cboXCat.currentIndexChanged.connect(
self.cboXCat_currentIndexChanged)
self.cboYCat.currentIndexChanged.connect(
self.cboYCat_currentIndexChanged)
if (main_form.program_settings.value("Geometry/" +
"frmScatterPlot_geometry")
and main_form.program_settings.value("Geometry/" +
"frmScatterPlot_state")):
self.restoreGeometry(
main_form.program_settings.value("Geometry/" +
"frmScatterPlot_geometry",
self.geometry(),
type=QtCore.QByteArray))
self.restoreState(
main_form.program_settings.value("Geometry/" +
"frmScatterPlot_state",
self.windowState(),
type=QtCore.QByteArray))
def __init__(self, parent, edit_these, new_item, title, **kwargs):
QtGui.QMainWindow.__init__(self, parent)
self.helper = HelpHandler(self)
option_section = parent.project.find_section('OPTIONS')
if option_section.infiltration=="HORTON" or option_section.infiltration=="MODIFIED_HORTON":
self.help_topic = "swmm/src/src/hortoninfiltrationparameters.htm"
elif option_section.infiltration=="GREEN_AMPT" or option_section.infiltration=="MODIFIED_GREEN_AMPT":
self.help_topic = "swmm/src/src/green_amptinfiltrationparame.htm"
elif option_section.infiltration=="CURVE_NUMBER":
self.help_topic = "swmm/src/src/curvenumberinfiltrationpara.htm"
self.setupUi(self)
self.setWindowTitle(title)
QtCore.QObject.connect(self.cmdOK, QtCore.SIGNAL("clicked()"), self.cmdOK_Clicked)
QtCore.QObject.connect(self.cmdCancel, QtCore.SIGNAL("clicked()"), self.cmdCancel_Clicked)
QtCore.QObject.connect(self.cboInfilModel, QtCore.SIGNAL("currentIndexChanged(int)"),
self.cboInfilModel_currentIndexChanged)
self.defaults = None
if kwargs.has_key("defaults"):
self.defaults = kwargs["defaults"]
enum_val = E_InfilModel.HORTON
if self.defaults is not None:
enum_val = E_InfilModel[self.defaults.properties_sub_values[self.defaults.infil_model_key]]
# self.infil_model = self.qsettings.value(self.default_key, None)
# if self.infil_model is None:
# self.infil_model = HortonInfiltration()
# self.infil_model.set_defaults()
# else:
# enum_val = self.infil_model.model_type()
# if enum_val == E_InfilModel.HORTON or \
# enum_val == E_InfilModel.MODIFIED_HORTON:
# self.infil_model_horton.__dict__.update(self.infil_model.__dict__)
# elif enum_val == E_InfilModel.GREEN_AMPT or \
# enum_val == E_InfilModel.MODIFIED_GREEN_AMPT:
# self.infil_model_ga.__dict__.update(self.infil_model.__dict__)
# elif enum_val == E_InfilModel.CURVE_NUMBER:
# self.infil_model_cn.__dict__.update(self.infil_model.__dict__)
self.cboInfilModel.setEnabled(True)
if self.lblNotes:
self.tblGeneric.currentCellChanged.connect(self.table_currentCellChanged)
self.tblGeneric.itemChanged.connect(self.table_itemChanged)
pass
else:
self.backend = PropertyEditorBackend(self.tblGeneric, self.lblNotes, parent, edit_these, new_item)
#self.lblTop.setText("Infiltration Method: " + parent.project.find_section('OPTIONS').infiltration)
proj_infilmodel = parent.project.find_section('OPTIONS').infiltration
enum_val = E_InfilModel[proj_infilmodel.upper()]
self.cboInfilModel.setEnabled(False)
set_combo_items(type(enum_val), self.cboInfilModel)
set_combo(self.cboInfilModel, enum_val)
self.corner_label = QtGui.QLabel("Property", self.tblGeneric)
self.corner_label.setAlignment(QtCore.Qt.AlignCenter)
self.corner_label.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents)
QtCore.QObject.connect(self.tblGeneric.verticalHeader(),
QtCore.SIGNAL("geometriesChanged()"), self.resizeCorner)
QtCore.QObject.connect(self.tblGeneric.horizontalHeader(),
QtCore.SIGNAL("geometriesChanged()"), self.resizeCorner)
def __init__(self, main_form):
self._main_form = main_form
QtGui.QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/timeseriesplotdialog.htm"
self.setupUi(self)
QtCore.QObject.connect(self.rbnDate, QtCore.SIGNAL("clicked()"),
self.rbnDate_Clicked)
QtCore.QObject.connect(self.rbnElapsed, QtCore.SIGNAL("clicked()"),
self.rbnDate_Clicked)
QtCore.QObject.connect(self.cmdOK, QtCore.SIGNAL("clicked()"),
self.cmdOK_Clicked)
QtCore.QObject.connect(self.cmdCancel, QtCore.SIGNAL("clicked()"),
self.cmdCancel_Clicked)
QtCore.QObject.connect(self.btnAdd, QtCore.SIGNAL("clicked()"),
self.btnAdd_Clicked)
QtCore.QObject.connect(self.btnRemove, QtCore.SIGNAL("clicked()"),
self.btnRemove_Clicked)
QtCore.QObject.connect(self.btnSave, QtCore.SIGNAL("clicked()"),
self.save_file)
QtCore.QObject.connect(self.btnLoad, QtCore.SIGNAL("clicked()"),
self.load_file)
QtCore.QObject.connect(self.btnScript, QtCore.SIGNAL("clicked()"),
self.save_script)
self.cboStart.currentIndexChanged.connect(
self.cboStart_currentIndexChanged)
self.cboEnd.currentIndexChanged.connect(
self.cboEnd_currentIndexChanged)
def __init__(self, main_form):
QtGui.QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "epanet/src/src/Energy_R.htm"
self.setupUi(self)
QtCore.QObject.connect(self.cmdCancel, QtCore.SIGNAL("clicked()"),
self.cmdCancel_Clicked)
QtCore.QObject.connect(self.rbnUtilization, QtCore.SIGNAL("clicked()"),
self.rbnUtilization_Clicked)
QtCore.QObject.connect(self.rbnAverageKw, QtCore.SIGNAL("clicked()"),
self.rbnAverageKw_Clicked)
QtCore.QObject.connect(self.rbnCost, QtCore.SIGNAL("clicked()"),
self.rbnCost_Clicked)
QtCore.QObject.connect(self.rbnEfficiency, QtCore.SIGNAL("clicked()"),
self.rbnEfficiency_Clicked)
QtCore.QObject.connect(self.rbnKwHr, QtCore.SIGNAL("clicked()"),
self.rbnKwHr_Clicked)
QtCore.QObject.connect(self.rbnPeakKw, QtCore.SIGNAL("clicked()"),
self.rbnPeakKw_Clicked)
self._main_form = main_form
self.labels = []
self.utilization_values = []
self.efficiency_values = []
self.kw_values = []
self.average_kw_values = []
self.peak_kw_values = []
self.cost_values = []
def __init__(self, main_form, subcatchment_name):
# purposely not calling frmGenericPropertyEditor.__init__
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/initialbuildupeditor.htm"
self.units = main_form.project.options.flow_units.value
self.setupUi(self)
self.subcatchment_name = subcatchment_name
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.setWindowTitle('SWMM Initial Buildup Editor for Subcatchment ' +
subcatchment_name)
self.lblNotes.setText(
"Enter initial buildup of pollutants on Subcatchment " +
subcatchment_name)
self.tblGeneric.setColumnCount(1)
local_column_list = []
if self.units < 4:
local_column_list.append('Initial Buildup (lbs/ac)')
else:
local_column_list.append('Initial Buildup (kg/ha)')
self.tblGeneric.setHorizontalHeaderLabels(local_column_list)
self.tblGeneric.setColumnWidth(0, 200)
self.local_pollutant_list = []
pollutants_section = main_form.project.find_section("POLLUTANTS")
row_count = 0
for value in pollutants_section.value:
row_count += 1
self.local_pollutant_list.append(value.name)
self.tblGeneric.setRowCount(row_count)
self.tblGeneric.setVerticalHeaderLabels(self.local_pollutant_list)
self.resize(300, 300)
section = main_form.project.find_section("LOADINGS")
loadings_list = section.value[0:]
pollutant_count = -1
for pollutant in self.local_pollutant_list:
pollutant_count += 1
for loading in loadings_list:
if loading.subcatchment_name == subcatchment_name and loading.pollutant_name == pollutant:
led = QLineEdit(str(loading.initial_buildup))
self.tblGeneric.setItem(pollutant_count, 0,
QTableWidgetItem(led.text()))
self._main_form = main_form
if (main_form.program_settings.value("Geometry/" +
"frmInitialBuildup_geometry") and
main_form.program_settings.value("Geometry/" +
"frmInitialBuildup_state")):
self.restoreGeometry(
main_form.program_settings.value("Geometry/" +
"frmInitialBuildup_geometry",
self.geometry(),
type=QtCore.QByteArray))
self.restoreState(
main_form.program_settings.value("Geometry/" +
"frmInitialBuildup_state",
self.windowState(),
type=QtCore.QByteArray))
def __init__(self, main_form=None):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/projectmenu.htm"
self.setupUi(self)
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.set_from(main_form.project)
self._main_form = main_form
def __init__(self, main_form=None):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/projectmenu.htm"
self.setupUi(self)
self._main_form = main_form
self.lstCategory.clicked.connect(self.display_section)
self.lstCategory.currentItemChanged.connect(self.display_section)
self.set_from(main_form.project)
def __init__(self, main_form):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/viewingastatisticsreport.htm"
self.helper = HelpHandler(self)
self.setupUi(self)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
# self.set_from(parent.project)
self._main_form = main_form
self.stats = None
self.statsResult = None #UStats.TStatsResults()
if (main_form.program_settings.value("Geometry/" + "frmStatisticsReport_geometry") and
main_form.program_settings.value("Geometry/" + "frmStatisticsReport_state")):
self.restoreGeometry(main_form.program_settings.value("Geometry/" + "frmStatisticsReport_geometry",
self.geometry(), type=QtCore.QByteArray))
self.restoreState(main_form.program_settings.value("Geometry/" + "frmStatisticsReport_state",
self.windowState(), type=QtCore.QByteArray))
def __init__(self, main_form):
QtGui.QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "epanet/src/src/Energy_R.htm"
self.setupUi(self)
QtCore.QObject.connect(self.cmdCancel, QtCore.SIGNAL("clicked()"),
self.cmdCancel_Clicked)
# self.set_from(parent.project) # do after init to set control type CONTROLS or RULES
self._main_form = main_form
def __init__(self, main_form, subcatchment_name):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/groundwater_equation_editor.htm"
self._main_form = main_form
self.setupUi(self)
self.subcatchment_name = subcatchment_name
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.set_from(main_form.project)
def __init__(self, main_form=None):
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "epanet/src/src/Source_Q.htm"
self.setupUi(self)
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
# self.set_from(parent.project)
self._main_form = main_form
self.node_name = ''
def __init__(self, main_form, node_name):
# purposely not calling frmGenericPropertyEditor.__init__
QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/green_amptinfiltrationparame.htm"
self.setupUi(self)
self.node_name = node_name
self.cmdOK.clicked.connect(self.cmdOK_Clicked)
self.cmdCancel.clicked.connect(self.cmdCancel_Clicked)
self.setWindowTitle('Storage Seepage Editor for Node ' + node_name)
self.section = main_form.project.find_section("STORAGE")
self.storage_nodes_list = self.section.value[0:]
self.tblGeneric.horizontalHeader().hide()
self.tblGeneric.setRowCount(3)
self.tblGeneric.setColumnCount(1)
props = []
props.append('Suction Head')
props.append('Conductivity')
props.append('Initial Deficit')
self.tblGeneric.setVerticalHeaderLabels(props)
found = False
for storage_node in self.storage_nodes_list:
if storage_node.name == node_name:
found = True
led = QLineEdit(str(storage_node.seepage_suction_head))
self.tblGeneric.setItem(-1, 1, QTableWidgetItem(led.text()))
led = QLineEdit(str(storage_node.seepage_hydraulic_conductivity))
self.tblGeneric.setItem(0, 1, QTableWidgetItem(led.text()))
led = QLineEdit(str(storage_node.seepage_initial_moisture_deficit))
self.tblGeneric.setItem(1, 1, QTableWidgetItem(led.text()))
if not found:
led = QLineEdit(str(0))
self.tblGeneric.setItem(-1, 1, QTableWidgetItem(led.text()))
led = QLineEdit(str(1))
self.tblGeneric.setItem(0, 1, QTableWidgetItem(led.text()))
led = QLineEdit(str(2))
self.tblGeneric.setItem(1, 1, QTableWidgetItem(led.text()))
if self.lblNotes:
self.tblGeneric.currentCellChanged.connect(self.table_currentCellChanged)
# ## Soil capillary suction head (in or mm)
# self.seepage_suction_head = '0'
#
# ## Soil saturated hydraulic conductivity (in/hr or mm/hr)
# self.seepage_hydraulic_conductivity = '0'
#
# ## Initial soil moisture deficit (volume of voids / total volume)
# self.seepage_initial_moisture_deficit = '0'
self.resize(280,300)
self._main_form = main_form
def __init__(self, main_form, subcatchment_name):
QtGui.QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/groundwater_equation_editor.htm"
self.setupUi(self)
self.subcatchment_name = subcatchment_name
QtCore.QObject.connect(self.cmdOK, QtCore.SIGNAL("clicked()"),
self.cmdOK_Clicked)
QtCore.QObject.connect(self.cmdCancel, QtCore.SIGNAL("clicked()"),
self.cmdCancel_Clicked)
self.set_from(main_form.project)
def __init__(self, main_form=None):
QtGui.QMainWindow.__init__(self, main_form)
self.helper = HelpHandler(self)
self.help_topic = "epanet/src/src/Demand_E.htm"
self.setupUi(self)
QtCore.QObject.connect(self.cmdOK, QtCore.SIGNAL("clicked()"),
self.cmdOK_Clicked)
QtCore.QObject.connect(self.cmdCancel, QtCore.SIGNAL("clicked()"),
self.cmdCancel_Clicked)
# self.set_from(parent.project)
self._main_form = main_form
self.node_id = ''
def __init__(self, q_application):
frmMain.__init__(self, q_application)
self.model = "EPANET"
self.model_path = '' # Set this only if needed later when running model
self.output = None # Set this when model output is available
self.status_suffix = "_status.txt"
self.status_file_name = '' # Set this when model status is available
self.output_filename = '' # Set this when model output is available
self.project_type = Project # Use the model-specific Project as defined in core.epanet.project
self.project = Project()
self.assembly_path = os.path.dirname(os.path.abspath(__file__))
self.on_load(tree_top_item_list=self.tree_top_items)
HelpHandler.init_class(os.path.join(self.assembly_path, "epanet.qhc"))
self.help_topic = "" # TODO: specify topic to open when Help key is pressed on main form
self.helper = HelpHandler(self)
self.actionStatus_ReportMenu = QtGui.QAction(self)
self.actionStatus_ReportMenu.setObjectName(from_utf8("actionStatus_ReportMenu"))
self.actionStatus_ReportMenu.setText(transl8("frmMain", "Status", None))
self.actionStatus_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Status", None))
self.menuReport.addAction(self.actionStatus_ReportMenu)
QtCore.QObject.connect(self.actionStatus_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_status)
self.actionEnergy_ReportMenu = QtGui.QAction(self)
self.actionEnergy_ReportMenu.setObjectName(from_utf8("actionEnergy_ReportMenu"))
self.actionEnergy_ReportMenu.setText(transl8("frmMain", "Energy", None))
self.actionEnergy_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Energy", None))
self.menuReport.addAction(self.actionEnergy_ReportMenu)
QtCore.QObject.connect(self.actionEnergy_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_energy)
self.actionCalibration_ReportMenu = QtGui.QAction(self)
self.actionCalibration_ReportMenu.setObjectName(from_utf8("actionCalibration_ReportMenu"))
self.actionCalibration_ReportMenu.setText(transl8("frmMain", "Calibration", None))
self.actionCalibration_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Calibration", None))
self.menuReport.addAction(self.actionCalibration_ReportMenu)
QtCore.QObject.connect(self.actionCalibration_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_calibration)
self.actionReaction_ReportMenu = QtGui.QAction(self)
self.actionReaction_ReportMenu.setObjectName(from_utf8("actionReaction_ReportMenu"))
self.actionReaction_ReportMenu.setText(transl8("frmMain", "Reaction", None))
self.actionReaction_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Reaction", None))
self.menuReport.addAction(self.actionReaction_ReportMenu)
QtCore.QObject.connect(self.actionReaction_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_reaction)
self.actionFull_ReportMenu = QtGui.QAction(self)
self.actionFull_ReportMenu.setObjectName(from_utf8("actionFull_ReportMenu"))
self.actionFull_ReportMenu.setText(transl8("frmMain", "Full...", None))
self.actionFull_ReportMenu.setToolTip(transl8("frmMain", "Save full report as text file", None))
self.menuReport.addAction(self.actionFull_ReportMenu)
QtCore.QObject.connect(self.actionFull_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_full)
self.actionGraph_ReportMenu = QtGui.QAction(self)
self.actionGraph_ReportMenu.setObjectName(from_utf8("actionGraph_ReportMenu"))
self.actionGraph_ReportMenu.setText(transl8("frmMain", "Graph...", None))
self.actionGraph_ReportMenu.setToolTip(transl8("frmMain", "Display graph selection options", None))
self.menuReport.addAction(self.actionGraph_ReportMenu)
QtCore.QObject.connect(self.actionGraph_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_graph)
self.actionTable_ReportMenu = QtGui.QAction(self)
self.actionTable_ReportMenu.setObjectName(from_utf8("actionTable_ReportMenu"))
self.actionTable_ReportMenu.setText(transl8("frmMain", "Table...", None))
self.actionTable_ReportMenu.setToolTip(transl8("frmMain", "Display table selection options", None))
self.menuReport.addAction(self.actionTable_ReportMenu)
QtCore.QObject.connect(self.actionTable_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_table)
self.Help_Topics_Menu = QtGui.QAction(self)
self.Help_Topics_Menu.setObjectName(from_utf8("Help_Topics_Menu"))
self.Help_Topics_Menu.setText(transl8("frmMain", "Help Topics", None))
self.Help_Topics_Menu.setToolTip(transl8("frmMain", "Display Help Topics", None))
self.menuHelp.addAction(self.Help_Topics_Menu)
QtCore.QObject.connect(self.Help_Topics_Menu, QtCore.SIGNAL('triggered()'), self.help_topics)
self.Help_About_Menu = QtGui.QAction(self)
self.Help_About_Menu.setObjectName(from_utf8("Help_About_Menu"))
self.Help_About_Menu.setText(transl8("frmMain", "About", None))
self.Help_About_Menu.setToolTip(transl8("frmMain", "About EPANET", None))
self.menuHelp.addAction(self.Help_About_Menu)
QtCore.QObject.connect(self.Help_About_Menu, QtCore.SIGNAL('triggered()'), self.help_about)
class frmMainSWMM(frmMain):
"""Main form for SWMM user interface, based on frmMain which is shared with EPANET."""
# Variables used to populate the tree control
# Each item is a list: label plus either editing form for this section or a child list of tree variables.
# If an editing form takes additional arguments, they follow the editing form as a list.
# Special cases may just have a label and no editing form or children.
# *_items are a lists of items in a section
tree_options_General = ["General", frmGeneralOptions]
tree_options_Dates = ["Dates", frmDates]
tree_options_TimeSteps = ["Time Steps", frmTimeSteps]
tree_options_DynamicWave = ["Dynamic Wave", frmDynamicWave]
tree_options_InterfaceFiles = ["Interface Files", frmInterfaceFiles]
tree_options_Reporting = ["Reporting", frmReportOptions]
tree_options_MapBackdrop = ["Map/Backdrop", frmMapBackdropOptions]
tree_options_items = [
tree_options_General,
tree_options_Dates,
tree_options_TimeSteps,
tree_options_DynamicWave,
tree_options_InterfaceFiles,
tree_options_Reporting,
tree_options_MapBackdrop]
tree_climatology_Temperature = ["Temperature", frmClimatology, ["Temperature"]]
tree_climatology_Evaporation = ["Evaporation", frmClimatology, ["Evaporation"]]
tree_climatology_WindSpeed = ["Wind Speed", frmClimatology, ["Wind Speed"]]
tree_climatology_SnowMelt = ["Snow Melt", frmClimatology, ["Snow Melt"]]
tree_climatology_ArealDepletion = ["Areal Depletion", frmClimatology, ["Areal Depletion"]]
tree_climatology_Adjustment = ["Adjustment", frmClimatology, ["Adjustment"]]
tree_climatology_items = [
tree_climatology_Temperature,
tree_climatology_Evaporation,
tree_climatology_WindSpeed,
tree_climatology_SnowMelt,
tree_climatology_ArealDepletion,
tree_climatology_Adjustment]
tree_hydrology_RainGages = ["Rain Gages", None]
tree_hydrology_Subcatchments = ["Subcatchments", frmSubcatchments]
tree_hydrology_Aquifers = ["Aquifers", frmAquifers]
tree_hydrology_SnowPacks = ["Snow Packs", frmSnowPack]
tree_hydrology_UnitHydrographs = ["Unit Hydrographs", frmUnitHydrograph]
tree_hydrology_LIDControls = ["LID Controls", frmLID]
tree_hydrology_items = [
tree_hydrology_RainGages,
tree_hydrology_Subcatchments,
tree_hydrology_Aquifers,
tree_hydrology_SnowPacks,
tree_hydrology_UnitHydrographs,
tree_hydrology_LIDControls]
tree_nodes_Junctions = ["Junctions", frmJunction]
tree_nodes_Outfalls = ["Outfalls", None, "1"]
tree_nodes_Dividers = ["Dividers", None, "1"]
tree_nodes_StorageUnits = ["Storage Units", None, "1"]
tree_nodes_items = [
tree_nodes_Junctions,
tree_nodes_Outfalls,
tree_nodes_Dividers,
tree_nodes_StorageUnits]
tree_links_Conduits = ["Conduits", frmCrossSection]
tree_links_Pumps = ["Pumps", None]
tree_links_Orifices = ["Orifices", None]
tree_links_Weirs = ["Weirs", None]
tree_links_Outlets = ["Outlets", None]
tree_links_items = [
tree_links_Conduits,
tree_links_Pumps,
tree_links_Orifices,
tree_links_Weirs,
tree_links_Outlets]
tree_hydraulics_Nodes = ["Nodes", tree_nodes_items]
tree_hydraulics_Links = ["Links", tree_links_items]
tree_hydraulics_Transects = ["Transects", frmTransect]
tree_hydraulics_Controls = ["Controls", frmControls]
tree_hydraulics_items = [
tree_hydraulics_Nodes,
tree_hydraulics_Links,
tree_hydraulics_Transects,
tree_hydraulics_Controls]
tree_quality_Pollutants = ["Pollutants", None]
tree_quality_LandUses = ["Land Uses", frmLandUses]
tree_quality_items = [
tree_quality_Pollutants,
tree_quality_LandUses]
tree_curves_ControlCurves = ["Control Curves", frmCurveEditor, ["SWMM Control Curves", "CONTROL"]]
tree_curves_DiversionCurves = ["Diversion Curves", frmCurveEditor, ["SWMM Diversion Curves", "DIVERSION"]]
tree_curves_PumpCurves = ["Pump Curves", frmCurveEditor, ["SWMM Pump Curves", "PUMP"]]
tree_curves_RatingCurves = ["Rating Curves", frmCurveEditor, ["SWMM Rating Curves", "RATING"]]
tree_curves_ShapeCurves = ["Shape Curves", frmCurveEditor, ["SWMM Shape Curves", "SHAPE"]]
tree_curves_StorageCurves = ["Storage Curves", frmCurveEditor, ["SWMM Storage Curves", "STORAGE"]]
tree_curves_TidalCurves = ["Tidal Curves", frmCurveEditor, ["SWMM Tidal Curves", "TIDAL"]]
tree_curves_items = [
tree_curves_ControlCurves,
tree_curves_DiversionCurves,
tree_curves_PumpCurves,
tree_curves_RatingCurves,
tree_curves_ShapeCurves,
tree_curves_StorageCurves,
tree_curves_TidalCurves]
tree_TitleNotes = ["Title/Notes", frmTitle]
tree_Options = ["Options", tree_options_items]
tree_Climatology = ["Climatology", tree_climatology_items]
tree_Hydrology = ["Hydrology", tree_hydrology_items]
tree_Hydraulics = ["Hydraulics", tree_hydraulics_items]
tree_Quality = ["Quality", tree_quality_items]
tree_Curves = ["Curves", tree_curves_items]
tree_TimeSeries = ["Time Series", frmTimeseries]
tree_TimePatterns = ["Time Patterns", frmPatternEditor]
tree_MapLabels = ["Map Labels", None]
tree_top_items = [
tree_TitleNotes,
tree_Options,
tree_Climatology,
tree_Hydrology,
tree_Hydraulics,
tree_Quality,
tree_Curves,
tree_TimeSeries,
tree_TimePatterns,
tree_MapLabels]
tree_items_using_id = (tree_hydrology_LIDControls,
tree_hydrology_UnitHydrographs,
tree_hydrology_SnowPacks,
tree_hydraulics_Transects,
tree_quality_LandUses,
tree_TimeSeries,
tree_TimePatterns,
tree_curves_ControlCurves,
tree_curves_DiversionCurves,
tree_curves_PumpCurves,
tree_curves_RatingCurves,
tree_curves_ShapeCurves,
tree_curves_StorageCurves,
tree_curves_TidalCurves)
def __init__(self, q_application):
frmMain.__init__(self, q_application)
self.model = "SWMM"
self.model_path = '' # Set this only if needed later when running model
self.output = None # Set this when model output is available
self.status_suffix = "_status.txt"
self.status_file_name = '' # Set this when model status is available
self.output_filename = '' # Set this when model output is available
self.project_type = Project # Use the model-specific Project as defined in core.swmm.project
self.project = Project()
self.assembly_path = os.path.dirname(os.path.abspath(__file__))
self.on_load(tree_top_item_list=self.tree_top_items)
HelpHandler.init_class(os.path.join(self.assembly_path, "swmm.qhc"))
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/swmmsmainwindow.htm"
self.actionStatus_ReportMenu = QtGui.QAction(self)
self.actionStatus_ReportMenu.setObjectName(from_utf8("actionStatus_ReportMenu"))
self.actionStatus_ReportMenu.setText(transl8("frmMain", "Status", None))
self.actionStatus_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Status", None))
self.menuReport.addAction(self.actionStatus_ReportMenu)
QtCore.QObject.connect(self.actionStatus_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_status)
self.actionSummary_ReportMenu = QtGui.QAction(self)
self.actionSummary_ReportMenu.setObjectName(from_utf8("actionSummary_ReportMenu"))
self.actionSummary_ReportMenu.setText(transl8("frmMain", "Summary", None))
self.actionSummary_ReportMenu.setToolTip(transl8("frmMain", "Display Results Summary", None))
self.menuReport.addAction(self.actionSummary_ReportMenu)
QtCore.QObject.connect(self.actionSummary_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_summary)
menu = QtGui.QMenu()
submenuGraph = QtGui.QMenu(self.menuReport)
submenuGraph.setTitle("Graph")
self.menuReport.addMenu(submenuGraph)
self.actionGraph_ProfileMenu = QtGui.QAction(self)
self.actionGraph_ProfileMenu.setObjectName(from_utf8("actionGraph_ProfileMenu"))
self.actionGraph_ProfileMenu.setText(transl8("frmMain", "Profile", None))
self.actionGraph_ProfileMenu.setToolTip(transl8("frmMain", "Display Profile Plot", None))
submenuGraph.addAction(self.actionGraph_ProfileMenu)
QtCore.QObject.connect(self.actionGraph_ProfileMenu, QtCore.SIGNAL('triggered()'), self.report_profile)
self.actionGraph_TimeSeriesMenu = QtGui.QAction(self)
self.actionGraph_TimeSeriesMenu.setObjectName(from_utf8("actionGraph_TimeSeriesMenu"))
self.actionGraph_TimeSeriesMenu.setText(transl8("frmMain", "Time Series", None))
self.actionGraph_TimeSeriesMenu.setToolTip(transl8("frmMain", "Display Time Series Plot", None))
submenuGraph.addAction(self.actionGraph_TimeSeriesMenu)
QtCore.QObject.connect(self.actionGraph_TimeSeriesMenu, QtCore.SIGNAL('triggered()'), self.report_timeseries)
self.actionGraph_ScatterMenu = QtGui.QAction(self)
self.actionGraph_ScatterMenu.setObjectName(from_utf8("actionGraph_ScatterMenu"))
self.actionGraph_ScatterMenu.setText(transl8("frmMain", "Scatter", None))
self.actionGraph_ScatterMenu.setToolTip(transl8("frmMain", "Display Scatter Plot", None))
submenuGraph.addAction(self.actionGraph_ScatterMenu)
QtCore.QObject.connect(self.actionGraph_ScatterMenu, QtCore.SIGNAL('triggered()'), self.report_scatter)
self.actionTable_VariableMenu = QtGui.QAction(self)
self.actionTable_VariableMenu.setObjectName(from_utf8("actionTable_VariableMenu"))
self.actionTable_VariableMenu.setText(transl8("frmMain", "Table", None))
self.actionTable_VariableMenu.setToolTip(transl8("frmMain", "Display Table", None))
self.menuReport.addAction(self.actionTable_VariableMenu)
QtCore.QObject.connect(self.actionTable_VariableMenu, QtCore.SIGNAL('triggered()'), self.report_variable)
self.actionStatistics_ReportMenu = QtGui.QAction(self)
self.actionStatistics_ReportMenu.setObjectName(from_utf8("actionStatistics_ReportMenu"))
self.actionStatistics_ReportMenu.setText(transl8("frmMain", "Statistics", None))
self.actionStatistics_ReportMenu.setToolTip(transl8("frmMain", "Display Results Statistics", None))
self.menuReport.addAction(self.actionStatistics_ReportMenu)
QtCore.QObject.connect(self.actionStatistics_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_statistics)
self.Help_Topics_Menu = QtGui.QAction(self)
self.Help_Topics_Menu.setObjectName(from_utf8("Help_Topics_Menu"))
self.Help_Topics_Menu.setText(transl8("frmMain", "Help Topics", None))
self.Help_Topics_Menu.setToolTip(transl8("frmMain", "Display Help Topics", None))
self.menuHelp.addAction(self.Help_Topics_Menu)
QtCore.QObject.connect(self.Help_Topics_Menu, QtCore.SIGNAL('triggered()'), self.help_topics)
self.Help_About_Menu = QtGui.QAction(self)
self.Help_About_Menu.setObjectName(from_utf8("Help_About_Menu"))
self.Help_About_Menu.setText(transl8("frmMain", "About", None))
self.Help_About_Menu.setToolTip(transl8("frmMain", "About SWMM", None))
self.menuHelp.addAction(self.Help_About_Menu)
QtCore.QObject.connect(self.Help_About_Menu, QtCore.SIGNAL('triggered()'), self.help_about)
def get_output(self):
if not self.output:
if os.path.isfile(self.output_filename):
self.output = SMOutputWrapper.OutputObject(self.output_filename)
return self.output
def report_status(self):
print "report_status"
if not os.path.isfile(self.status_file_name):
prefix, extension = os.path.splitext(self.project.file_name)
if os.path.isfile(prefix + self.status_suffix):
self.status_file_name = prefix + self.status_suffix
if os.path.isfile(self.status_file_name):
webbrowser.open_new_tab(self.status_file_name)
else:
QMessageBox.information(None, self.model,
"Model status not found.\n"
"Run the model to generate model status.",
QMessageBox.Ok)
def report_profile(self):
if self.get_output():
self._frmProfilePlot = frmProfilePlot(self)
self._frmProfilePlot.set_from(self.project, self.get_output())
self._frmProfilePlot.show()
else:
QMessageBox.information(None, self.model,
"Model output not found.\n"
"Run the model to generate output.",
QMessageBox.Ok)
def report_timeseries(self):
if self.get_output():
self._frmTimeSeriesPlot = frmTimeSeriesPlot(self)
self._frmTimeSeriesPlot.set_from(self.project, self.get_output())
self._frmTimeSeriesPlot.show()
else:
QMessageBox.information(None, self.model,
"Model output not found.\n"
"Run the model to generate output.",
QMessageBox.Ok)
def report_scatter(self):
if self.get_output():
self._frmScatterPlot = frmScatterPlot(self)
self._frmScatterPlot.set_from(self.project, self.get_output())
self._frmScatterPlot.show()
else:
QMessageBox.information(None, self.model,
"Model output not found.\n"
"Run the model to generate output.",
QMessageBox.Ok)
def report_variable(self):
if self.get_output():
self._frmTableSelection = frmTableSelection(self)
self._frmTableSelection.set_from(self.project, self.get_output())
self._frmTableSelection.show()
else:
QMessageBox.information(None, self.model,
"Model output not found.\n"
"Run the model to generate output.",
QMessageBox.Ok)
def report_statistics(self):
if self.get_output():
self._frmStatisticsReportSelection = frmStatisticsReportSelection(self)
self._frmStatisticsReportSelection.set_from(self.project, self.get_output())
self._frmStatisticsReportSelection.show()
else:
QMessageBox.information(None, self.model,
"Model output not found.\n"
"Run the model to generate output.",
QMessageBox.Ok)
def report_summary(self):
if not os.path.isfile(self.status_file_name):
prefix, extension = os.path.splitext(self.project.file_name)
if os.path.isfile(prefix + self.status_suffix):
self.status_file_name = prefix + self.status_suffix
if os.path.isfile(self.status_file_name):
self._frmSummaryReport = frmSummaryReport(self)
self._frmSummaryReport.set_from(self.project, self.status_file_name)
self._frmSummaryReport.show()
else:
QMessageBox.information(None, self.model,
"Model status not found.\n"
"Run the model to generate model status.",
QMessageBox.Ok)
def calibration_data(self):
self._frmCalibrationData = frmCalibrationData(self)
self._frmCalibrationData.show()
pass
def get_editor(self, edit_name):
frm = None
# First handle special cases where forms need more than simply being created
if edit_name == self.tree_quality_Pollutants[0]:
edit_these = []
if self.project and self.project.pollutants:
if not isinstance(self.project.pollutants.value, basestring):
if isinstance(self.project.pollutants.value, list):
edit_these.extend(self.project.pollutants.value)
if len(edit_these) == 0:
new_item = Pollutant()
new_item.name = "NewPollutant"
edit_these.append(new_item)
self.project.pollutants.value = edit_these
frm = frmGenericPropertyEditor(self, edit_these, "SWMM Pollutant Editor")
frm.helper = HelpHandler(frm)
frm.help_topic = "swmm/src/src/pollutanteditordialog.htm"
elif edit_name in [item[0] for item in self.tree_items_using_id]:
# in these cases the click on the tree diagram populates the lower left list, not directly to an editor
return None
# the following items will respond to a click on a conduit form, not the tree diagram
# elif edit_name == tree_links_Conduits[0]:
# frm = frmCrossSection(self)
# the following items will respond to a click on a node form, not the tree diagram
# elif edit_name == "Outfalls" or edit_name == "Dividers" or edit_name == "Storage Units":
# frm = frmInflows(self)
else: # General-purpose case finds most editors from tree information
frm = self.make_editor_from_tree(edit_name, self.tree_top_items)
return frm
def get_editor_with_selected_item(self, edit_name, selected_item):
frm = None
# First handle special cases where forms need more than simply being created
if edit_name == "Pollutants":
edit_these = []
if self.project and self.project.pollutants:
if not isinstance(self.project.pollutants.value, basestring):
if isinstance(self.project.pollutants.value, list):
for value in self.project.pollutants.value:
if value.name == selected_item:
edit_these.append(value)
frm = frmGenericPropertyEditor(self, edit_these, "SWMM Pollutant Editor")
elif edit_name == "Aquifers":
# do all of these for now, will want to restrict to only selected one
frm = self.make_editor_from_tree(edit_name, self.tree_top_items)
# the following items will respond to a click on a conduit form, not the tree diagram
elif edit_name == "Conduits":
frm = frmCrossSection(self)
# the following items will respond to a click on a node form, not the tree diagram
# elif edit_name == "Outfalls" or edit_name == "Dividers" or edit_name == "Storage Units":
# frm = frmInflows(self)
else: # General-purpose case finds most editors from tree information
frm = self.make_editor_from_tree(edit_name, self.tree_top_items)
frm.set_from(self.project, selected_item)
return frm
def get_object_list(self, category):
ids = []
if category == self.tree_hydrology_Subcatchments[0]:
for i in range(0, len(self.project.subcatchments.value)):
ids.append(self.project.subcatchments.value[i].name)
# elif category.lower() == self.tree_hydrology_RainGages[0]:
# for i in range(0, len(self.project.raingages.value)):
# ids.append(self.project.raingages.value[i].name)
elif category == self.tree_hydrology_Aquifers[0]:
for i in range(0, len(self.project.aquifers.value)):
ids.append(self.project.aquifers.value[i].name)
elif category == self.tree_hydrology_SnowPacks[0]:
for i in range(0, len(self.project.snowpacks.value)):
ids.append(self.project.snowpacks.value[i].name)
elif category == self.tree_hydrology_UnitHydrographs[0]:
for i in range(0, len(self.project.hydrographs.value)):
ids.append(self.project.hydrographs.value[i].group_name)
elif category == self.tree_hydrology_LIDControls[0]:
for i in range(0, len(self.project.lid_controls.value)):
ids.append(self.project.lid_controls.value[i].control_name)
elif category == self.tree_nodes_Junctions[0]:
for i in range(0, len(self.project.junctions.value)):
ids.append(self.project.junctions.value[i].name)
# elif category == self.tree_nodes_Outfalls[0]:
# for i in range(0, len(self.project.outfalls.value)):
# ids.append(self.project.outfalls.value[i].name)
# elif category == self.tree_nodes_Dividers[0]:
# for i in range(0, len(self.project.dividers.value)):
# ids.append(self.project.dividers.value[i].name)
# elif category == self.tree_nodes_StorageUnits[0]:
# for i in range(0, len(self.project.storage.value)):
# ids.append(self.project.storage.value[i].name)
elif category == self.tree_links_Conduits[0]:
for i in range(0, len(self.project.conduits.value)):
ids.append(self.project.conduits.value[i].name)
elif category == self.tree_links_Pumps:
for i in range(0, len(self.project.pumps.value)):
ids.append(self.project.pumps.value[i].name)
# elif category == self.tree_links_Orifices[0]:
# for i in range(0, len(self.project.orifices.value)):
# ids.append(self.project.orifices.value[i].name)
# elif category == self.tree_links_Weirs[0]:
# for i in range(0, len(self.project.weirs.value)):
# ids.append(self.project.weirs.value[i].name)
# elif category == self.tree_links_Outlets[0]:
# for i in range(0, len(self.project.outlets.value)):
# ids.append(self.project.outlets.value[i].name)
elif category == self.tree_hydraulics_Transects[0]:
for i in range(0, len(self.project.transects.value)):
ids.append(self.project.transects.value[i].name)
elif category == self.tree_quality_Pollutants[0]:
for i in range(0, len(self.project.pollutants.value)):
ids.append(self.project.pollutants.value[i].name)
elif category == self.tree_quality_LandUses[0]:
for i in range(0, len(self.project.landuses.value)):
ids.append(self.project.landuses.value[i].land_use_name)
elif category == self.tree_curves_ControlCurves[0]:
for i in range(0, len(self.project.curves.value)):
if self.project.curves.value[i].curve_type == CurveType.CONTROL:
ids.append(self.project.curves.value[i].curve_id)
elif category == self.tree_curves_DiversionCurves[0]:
for i in range(0, len(self.project.curves.value)):
if self.project.curves.value[i].curve_type == CurveType.DIVERSION:
ids.append(self.project.curves.value[i].curve_id)
elif category == self.tree_curves_PumpCurves[0]:
for i in range(0, len(self.project.curves.value)):
curve_type = self.project.curves.value[i].curve_type
if curve_type == CurveType.PUMP1 or curve_type == CurveType.PUMP2 or \
curve_type == CurveType.PUMP3 or curve_type == CurveType.PUMP4:
ids.append(self.project.curves.value[i].curve_id)
elif category == self.tree_curves_RatingCurves[0]:
for i in range(0, len(self.project.curves.value)):
if self.project.curves.value[i].curve_type == CurveType.RATING:
ids.append(self.project.curves.value[i].curve_id)
elif category == self.tree_curves_ShapeCurves[0]:
for i in range(0, len(self.project.curves.value)):
if self.project.curves.value[i].curve_type == CurveType.SHAPE:
ids.append(self.project.curves.value[i].curve_id)
elif category == self.tree_curves_StorageCurves[0]:
for i in range(0, len(self.project.curves.value)):
if self.project.curves.value[i].curve_type == CurveType.STORAGE:
ids.append(self.project.curves.value[i].curve_id)
elif category == self.tree_curves_TidalCurves[0]:
for i in range(0, len(self.project.curves.value)):
if self.project.curves.value[i].curve_type == CurveType.TIDAL:
ids.append(self.project.curves.value[i].curve_id)
elif category == self.tree_TimeSeries[0]:
for i in range(0, len(self.project.timeseries.value)):
ids.append(self.project.timeseries.value[i].name)
elif category == self.tree_TimePatterns[0]:
for i in range(0, len(self.project.patterns.value)):
ids.append(self.project.patterns.value[i].name)
# elif category == self.tree_MapLabels[0]:
# for i in range(0, len(self.project.labels.value)):
# ids.append(self.project.labels.value[i].label_text)
else:
ids = None
return ids
def add_object_clicked(self, section_name):
if section_name == self.tree_hydrology_Subcatchments[0]:
new_item = Subcatchment()
new_item.name = "New"
if len(self.project.subcatchments.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.subcatchments.value = edit_these
else:
self.project.subcatchments.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
# elif section_name == self.tree_hydrology_RainGages[0]:
elif section_name == self.tree_hydrology_Aquifers[0]:
new_item = Aquifer()
new_item.name = "New"
if len(self.project.aquifers.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.aquifers.value = edit_these
else:
self.project.aquifers.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
elif section_name == self.tree_hydrology_SnowPacks[0]:
new_item = SnowPack()
new_item.name = "New"
if len(self.project.snowpacks.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.snowpacks.value = edit_these
else:
self.project.snowpacks.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
elif section_name == self.tree_hydrology_UnitHydrographs[0]:
new_item = UnitHydrograph()
new_item.group_name = "New"
if len(self.project.hydrographs.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.hydrographs.value = edit_these
else:
self.project.hydrographs.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.group_name))
elif section_name == self.tree_hydrology_LIDControls[0]:
new_item = LIDControl()
new_item.control_name = "New"
if len(self.project.lid_controls.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.lid_controls.value = edit_these
else:
self.project.lid_controls.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.control_name))
elif section_name == self.tree_nodes_Junctions[0]:
new_item = Junction()
new_item.name = "New"
if len(self.project.junctions.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.junctions.value = edit_these
else:
self.project.junctions.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
# elif section_name == self.tree_nodes_Outfalls[0]:
# elif section_name == self.tree_nodes_Dividers[0]:
# elif section_name == self.tree_nodes_StorageUnits[0]:
elif section_name == self.tree_links_Conduits[0]:
new_item = Conduit()
new_item.name = "New"
if len(self.project.conduits.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.conduits.value = edit_these
else:
self.project.conduits.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
elif section_name == self.tree_links_Pumps:
new_item = Pump()
new_item.name = "New"
if len(self.project.pumps.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.pumps.value = edit_these
else:
self.project.pumps.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
# elif section_name == self.tree_links_Orifices[0]:
# elif section_name == self.tree_links_Weirs[0]:
# elif section_name == self.tree_links_Outlets[0]:
elif section_name == self.tree_hydraulics_Transects[0]:
new_item = Transect()
new_item.name = "New"
if len(self.project.transects.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.transects.value = edit_these
else:
self.project.transects.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
elif section_name == self.tree_quality_Pollutants[0]:
new_item = Pollutant()
new_item.name = "NewPollutant"
if len(self.project.pollutants.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.pollutants.value = edit_these
else:
self.project.pollutants.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
elif section_name == self.tree_quality_LandUses[0]:
new_item = Landuse()
new_item.land_use_name = "New"
if len(self.project.landuses.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.landuses.value = edit_these
else:
self.project.landuses.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.land_use_name))
elif section_name == self.tree_curves_ControlCurves[0]:
new_item = Curve()
new_item.curve_id = "New"
new_item.curve_type = CurveType.CONTROL
if len(self.project.curves.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.curves.value = edit_these
else:
self.project.curves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.curve_id))
elif section_name == self.tree_curves_DiversionCurves[0]:
new_item = Curve()
new_item.curve_id = "New"
new_item.curve_type = CurveType.DIVERSION
if len(self.project.curves.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.curves.value = edit_these
else:
self.project.curves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.curve_id))
elif section_name == self.tree_curves_PumpCurves[0]:
new_item = Curve()
new_item.curve_id = "New"
new_item.curve_type = CurveType.PUMP1
if len(self.project.curves.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.curves.value = edit_these
else:
self.project.curves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.curve_id))
elif section_name == self.tree_curves_RatingCurves[0]:
new_item = Curve()
new_item.curve_id = "New"
new_item.curve_type = CurveType.RATING
if len(self.project.curves.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.curves.value = edit_these
else:
self.project.curves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.curve_id))
elif section_name == self.tree_curves_ShapeCurves[0]:
new_item = Curve()
new_item.curve_id = "New"
new_item.curve_type = CurveType.SHAPE
if len(self.project.curves.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.curves.value = edit_these
else:
self.project.curves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.curve_id))
elif section_name == self.tree_curves_StorageCurves[0]:
new_item = Curve()
new_item.curve_id = "New"
new_item.curve_type = CurveType.STORAGE
if len(self.project.curves.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.curves.value = edit_these
else:
self.project.curves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.curve_id))
elif section_name == self.tree_curves_TidalCurves[0]:
new_item = Curve()
new_item.curve_id = "New"
new_item.curve_type = CurveType.TIDAL
if len(self.project.curves.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.curves.value = edit_these
else:
self.project.curves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.curve_id))
elif section_name == self.tree_TimeSeries[0]:
new_item = TimeSeries()
new_item.name = "New"
if len(self.project.timeseries.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.timeseries.value = edit_these
else:
self.project.timeseries.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
elif section_name == self.tree_TimePatterns[0]:
new_item = Pattern()
new_item.name = "New"
if len(self.project.patterns.value) == 0:
edit_these = []
edit_these.append(new_item)
self.project.patterns.value = edit_these
else:
self.project.patterns.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.name))
# elif section_name == self.tree_MapLabels[0]:
def delete_object_clicked(self, section_name, item_name):
if section_name == self.tree_hydrology_Subcatchments[0]:
for value in self.project.subcatchments.value:
if value.name == item_name:
self.project.subcatchments.value.remove(value)
# elif section_name == self.tree_hydrology_RainGages[0]:
elif section_name == self.tree_hydrology_Aquifers[0]:
for value in self.project.aquifers.value:
if value.name == item_name:
self.project.aquifers.value.remove(value)
elif section_name == self.tree_hydrology_SnowPacks[0]:
for value in self.project.snowpacks.value:
if value.name == item_name:
self.project.snowpacks.value.remove(value)
elif section_name == self.tree_hydrology_UnitHydrographs[0]:
for value in self.project.hydrographs.value:
if value.group_name == item_name:
self.project.hydrographs.value.remove(value)
elif section_name == self.tree_hydrology_LIDControls[0]:
for value in self.project.lid_controls.value:
if value.control_name == item_name:
self.project.lid_controls.value.remove(value)
elif section_name == self.tree_nodes_Junctions[0]:
for value in self.project.junctions.value:
if value.name == item_name:
self.project.junctions.value.remove(value)
# elif section_name == self.tree_nodes_Outfalls[0]:
# elif section_name == self.tree_nodes_Dividers[0]:
# elif section_name == self.tree_nodes_StorageUnits[0]:
elif section_name == self.tree_links_Conduits[0]:
for value in self.project.conduits.value:
if value.name == item_name:
self.project.conduits.value.remove(value)
elif section_name == self.tree_links_Pumps:
for value in self.project.pumps.value:
if value.name == item_name:
self.project.pumps.value.remove(value)
# elif section_name == self.tree_links_Orifices[0]:
# elif section_name == self.tree_links_Weirs[0]:
# elif section_name == self.tree_links_Outlets[0]:
elif section_name == self.tree_hydraulics_Transects[0]:
for value in self.project.transects.value:
if value.name == item_name:
self.project.transects.value.remove(value)
elif section_name == self.tree_quality_Pollutants[0]:
for value in self.project.pollutants.value:
if value.name == item_name:
self.project.pollutants.value.remove(value)
elif section_name == self.tree_quality_LandUses[0]:
for value in self.project.landuses.value:
if value.land_use_name == item_name:
self.project.landuses.value.remove(value)
elif section_name == self.tree_curves_ControlCurves[0]:
for value in self.project.curves.value:
if value.curve_id == item_name and value.curve_type == CurveType.CONTROL:
self.project.curves.value.remove(value)
elif section_name == self.tree_curves_DiversionCurves[0]:
for value in self.project.curves.value:
if value.curve_id == item_name and value.curve_type == CurveType.DIVERSION:
self.project.curves.value.remove(value)
elif section_name == self.tree_curves_PumpCurves[0]:
for value in self.project.curves.value:
if value.curve_id == item_name and \
(value.curve_type == CurveType.PUMP1 or value.curve_type == CurveType.PUMP2
or value.curve_type == CurveType.PUMP3 or value.curve_type == CurveType.PUMP4):
self.project.curves.value.remove(value)
elif section_name == self.tree_curves_RatingCurves[0]:
for value in self.project.curves.value:
if value.curve_id == item_name and value.curve_type == CurveType.RATING:
self.project.curves.value.remove(value)
elif section_name == self.tree_curves_ShapeCurves[0]:
for value in self.project.curves.value:
if value.curve_id == item_name and value.curve_type == CurveType.SHAPE:
self.project.curves.value.remove(value)
elif section_name == self.tree_curves_StorageCurves[0]:
for value in self.project.curves.value:
if value.curve_id == item_name and value.curve_type == CurveType.STORAGE:
self.project.curves.value.remove(value)
elif section_name == self.tree_curves_TidalCurves[0]:
for value in self.project.curves.value:
if value.curve_id == item_name and value.curve_type == CurveType.TIDAL:
self.project.curves.value.remove(value)
elif section_name == self.tree_TimeSeries[0]:
for value in self.project.timeseries.value:
if value.name == item_name:
self.project.timeseries.value.remove(value)
elif section_name == self.tree_TimePatterns[0]:
for value in self.project.patterns.value:
if value.name == item_name:
self.project.patterns.value.remove(value)
# elif section_name == self.tree_MapLabels[0]:
def run_simulation(self):
self.output = None
# First find input file to run
file_name = ''
use_existing = self.project and self.project.file_name and os.path.exists(self.project.file_name)
if use_existing:
file_name = self.project.file_name
# TODO: save if needed, decide whether to save to temp location as previous version did.
else:
directory = QtCore.QSettings(self.model, "GUI").value("ProjectDir", "")
file_name = QFileDialog.getOpenFileName(self, "Open Project...", directory,
"Inp files (*.inp);;All files (*.*)")
if os.path.exists(file_name):
prefix, extension = os.path.splitext(file_name)
self.status_file_name = prefix + self.status_suffix
self.output_filename = prefix + '.out'
# if not os.path.exists(self.model_path):
# if 'darwin' in sys.platform:
# lib_name = 'libswmm.dylib'
# ext = '.dylib'
# elif 'win' in sys.platform:
# lib_name = 'swmm5_x86.dll'
# ext = '.dll'
#
# if lib_name:
# self.model_path = os.path.join(self.assembly_path, lib_name)
# if not os.path.exists(self.model_path):
# pp = os.path.dirname(os.path.dirname(self.assembly_path))
# self.model_path = os.path.join(pp, "Externals", lib_name)
# if not os.path.exists(self.model_path):
# self.model_path = QFileDialog.getOpenFileName(self,
# 'Locate ' + self.model +' Library',
# '/', '(*{0})'.format(ext))
#
# if os.path.exists(self.model_path):
# try:
# from Externals.swmm5 import pyswmm
# swmm_object = pyswmm(file_name, self.status_file_name, self.output_filename, self.model_path)
# swmm_object.swmmExec()
# print(swmm_object.swmm_getVersion())
# print(swmm_object.swmm_getMassBalErr())
#
# # model_api = pyepanet.ENepanet(file_name, self.status_file_name, self.output_filename, self.model_path)
# # frmRun = frmRunEPANET(model_api, self.project, self)
# # self._forms.append(frmRun)
# # if not use_existing:
# # # Read this project so we can refer to it while running
# # frmRun.progressBar.setVisible(False)
# # frmRun.lblTime.setVisible(False)
# # frmRun.fraTime.setVisible(False)
# # frmRun.fraBottom.setVisible(False)
# # frmRun.showNormal()
# # frmRun.set_status_text("Reading " + file_name)
# #
# # self.project = Project()
# # self.project.read_file(file_name)
# # frmRun.project = self.project
# #
# # frmRun.Execute()
# return
# except Exception as e1:
# print(str(e1) + '\n' + str(traceback.print_exc()))
# QMessageBox.information(None, self.model,
# "Error running model with library:\n {0}\n{1}\n{2}".format(
# self.model_path, str(e1), str(traceback.print_exc())),
# QMessageBox.Ok)
# # finally:
# # try:
# # if model_api and model_api.isOpen():
# # model_api.ENclose()
# # except:
# # pass
# # return
# Could not run with library, try running with executable
args = []
exe_name = "swmm5.exe"
exe_path = os.path.join(self.assembly_path, exe_name)
if not os.path.isfile(exe_path):
pp = os.path.dirname(os.path.dirname(self.assembly_path))
exe_path = os.path.join(pp, "Externals", exe_name)
if not os.path.isfile(exe_path):
pp = os.path.dirname(os.path.dirname(self.assembly_path))
exe_path = os.path.join(pp, "Externals", "swmm", "model", exe_name)
if not os.path.isfile(exe_path):
exe_path = QFileDialog.getOpenFileName(self, 'Locate SWMM Executable', '/', 'exe files (*.exe)')
if os.path.isfile(exe_path):
args.append(file_name)
args.append(self.status_file_name)
args.append(self.output_filename)
# running the Exe
status = StatusMonitor0(exe_path, args, self, model='SWMM')
status.show()
else:
QMessageBox.information(None, self.model, self.model + " input file not found", QMessageBox.Ok)
def help_topics(self):
self.helper.show_help()
def help_about(self):
self._frmAbout = frmAbout(self)
self._frmAbout.show()
pass
class frmMainEPANET(frmMain):
"""Main form for EPANET user interface, based on frmMain which is shared with SWMM."""
# Variables used to populate the tree control
# Each item is a list: label plus either editing form for this section or a child list.
# Special cases may just have a label and no editing form or children.
# *_items are a lists of items in a section
tree_options_Hydraulics = ["Hydraulics", frmHydraulicsOptions]
tree_options_Quality = ["Quality", frmQualityOptions]
tree_options_Reactions = ["Reactions", frmReactionsOptions]
tree_options_Times = ["Times", frmTimesOptions]
tree_options_Energy = ["Energy", frmEnergyOptions]
tree_options_Report = ["Report", frmReportOptions]
tree_options_MapBackdrop = ["Map/Backdrop", frmMapBackdropOptions]
tree_options_items = [tree_options_Hydraulics,
tree_options_Quality,
tree_options_Reactions,
tree_options_Times,
tree_options_Energy,
tree_options_Report,
tree_options_MapBackdrop]
tree_controls_Simple = ["Simple", frmControls, ["EPANET Simple Controls", "CONTROLS"]]
tree_controls_RuleBased = ["Rule-Based", frmControls, ["EPANET Rule-Based Controls", "RULES"]]
tree_controls_items = [tree_controls_Simple,
tree_controls_RuleBased]
tree_TitleNotes = ["Title/Notes", frmTitle]
tree_Options = ["Options", tree_options_items]
tree_Junctions = ["Junctions", None]
tree_Reservoirs = ["Reservoirs", None]
tree_Tanks = ["Tanks", None]
tree_Pipes = ["Pipes", None]
tree_Pumps = ["Pumps", None]
tree_Valves = ["Valves", None]
tree_Labels = ["Labels", None]
tree_Patterns = ["Patterns", frmPatternEditor]
tree_Curves = ["Curves", frmCurveEditor]
tree_Controls = ["Controls", tree_controls_items]
tree_top_items = [tree_TitleNotes,
tree_Options,
tree_Junctions,
tree_Reservoirs,
tree_Tanks,
tree_Pipes,
tree_Pumps,
tree_Valves,
tree_Labels,
tree_Patterns,
tree_Curves,
tree_Controls]
def __init__(self, q_application):
frmMain.__init__(self, q_application)
self.model = "EPANET"
self.model_path = '' # Set this only if needed later when running model
self.output = None # Set this when model output is available
self.status_suffix = "_status.txt"
self.status_file_name = '' # Set this when model status is available
self.output_filename = '' # Set this when model output is available
self.project_type = Project # Use the model-specific Project as defined in core.epanet.project
self.project = Project()
self.assembly_path = os.path.dirname(os.path.abspath(__file__))
self.on_load(tree_top_item_list=self.tree_top_items)
HelpHandler.init_class(os.path.join(self.assembly_path, "epanet.qhc"))
self.help_topic = "" # TODO: specify topic to open when Help key is pressed on main form
self.helper = HelpHandler(self)
self.actionStatus_ReportMenu = QtGui.QAction(self)
self.actionStatus_ReportMenu.setObjectName(from_utf8("actionStatus_ReportMenu"))
self.actionStatus_ReportMenu.setText(transl8("frmMain", "Status", None))
self.actionStatus_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Status", None))
self.menuReport.addAction(self.actionStatus_ReportMenu)
QtCore.QObject.connect(self.actionStatus_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_status)
self.actionEnergy_ReportMenu = QtGui.QAction(self)
self.actionEnergy_ReportMenu.setObjectName(from_utf8("actionEnergy_ReportMenu"))
self.actionEnergy_ReportMenu.setText(transl8("frmMain", "Energy", None))
self.actionEnergy_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Energy", None))
self.menuReport.addAction(self.actionEnergy_ReportMenu)
QtCore.QObject.connect(self.actionEnergy_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_energy)
self.actionCalibration_ReportMenu = QtGui.QAction(self)
self.actionCalibration_ReportMenu.setObjectName(from_utf8("actionCalibration_ReportMenu"))
self.actionCalibration_ReportMenu.setText(transl8("frmMain", "Calibration", None))
self.actionCalibration_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Calibration", None))
self.menuReport.addAction(self.actionCalibration_ReportMenu)
QtCore.QObject.connect(self.actionCalibration_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_calibration)
self.actionReaction_ReportMenu = QtGui.QAction(self)
self.actionReaction_ReportMenu.setObjectName(from_utf8("actionReaction_ReportMenu"))
self.actionReaction_ReportMenu.setText(transl8("frmMain", "Reaction", None))
self.actionReaction_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Reaction", None))
self.menuReport.addAction(self.actionReaction_ReportMenu)
QtCore.QObject.connect(self.actionReaction_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_reaction)
self.actionFull_ReportMenu = QtGui.QAction(self)
self.actionFull_ReportMenu.setObjectName(from_utf8("actionFull_ReportMenu"))
self.actionFull_ReportMenu.setText(transl8("frmMain", "Full...", None))
self.actionFull_ReportMenu.setToolTip(transl8("frmMain", "Save full report as text file", None))
self.menuReport.addAction(self.actionFull_ReportMenu)
QtCore.QObject.connect(self.actionFull_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_full)
self.actionGraph_ReportMenu = QtGui.QAction(self)
self.actionGraph_ReportMenu.setObjectName(from_utf8("actionGraph_ReportMenu"))
self.actionGraph_ReportMenu.setText(transl8("frmMain", "Graph...", None))
self.actionGraph_ReportMenu.setToolTip(transl8("frmMain", "Display graph selection options", None))
self.menuReport.addAction(self.actionGraph_ReportMenu)
QtCore.QObject.connect(self.actionGraph_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_graph)
self.actionTable_ReportMenu = QtGui.QAction(self)
self.actionTable_ReportMenu.setObjectName(from_utf8("actionTable_ReportMenu"))
self.actionTable_ReportMenu.setText(transl8("frmMain", "Table...", None))
self.actionTable_ReportMenu.setToolTip(transl8("frmMain", "Display table selection options", None))
self.menuReport.addAction(self.actionTable_ReportMenu)
QtCore.QObject.connect(self.actionTable_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_table)
self.Help_Topics_Menu = QtGui.QAction(self)
self.Help_Topics_Menu.setObjectName(from_utf8("Help_Topics_Menu"))
self.Help_Topics_Menu.setText(transl8("frmMain", "Help Topics", None))
self.Help_Topics_Menu.setToolTip(transl8("frmMain", "Display Help Topics", None))
self.menuHelp.addAction(self.Help_Topics_Menu)
QtCore.QObject.connect(self.Help_Topics_Menu, QtCore.SIGNAL('triggered()'), self.help_topics)
self.Help_About_Menu = QtGui.QAction(self)
self.Help_About_Menu.setObjectName(from_utf8("Help_About_Menu"))
self.Help_About_Menu.setText(transl8("frmMain", "About", None))
self.Help_About_Menu.setToolTip(transl8("frmMain", "About EPANET", None))
self.menuHelp.addAction(self.Help_About_Menu)
QtCore.QObject.connect(self.Help_About_Menu, QtCore.SIGNAL('triggered()'), self.help_about)
def report_status(self):
print "report_status"
if not os.path.isfile(self.status_file_name):
prefix, extension = os.path.splitext(self.project.file_name)
if os.path.isfile(prefix + self.status_suffix):
self.status_file_name = prefix + self.status_suffix
if os.path.isfile(self.status_file_name):
webbrowser.open_new_tab(self.status_file_name)
else:
QMessageBox.information(None, self.model,
"Model status not found.\n"
"Run the model to generate model status.",
QMessageBox.Ok)
def report_energy(self):
self._frmEnergyReport = frmEnergyReport(self)
self._frmEnergyReport.set_data()
self._frmEnergyReport.show()
pass
def report_calibration(self):
if self.output:
self._frmCalibrationReportOptions = frmCalibrationReportOptions(self, self.project)
self._frmCalibrationReportOptions.show()
else:
QMessageBox.information(None, self.model,
"Model output not found.\n"
"Run the model to generate output.",
QMessageBox.Ok)
def report_reaction(self):
self.reaction_report()
pass
def report_full(self):
if self.output:
directory = os.path.dirname(self.project.file_name)
report_file_name = QtGui.QFileDialog.getSaveFileName(self, "Save Full Report As...", directory, "Text files (*.txt)")
if report_file_name:
try:
reporter = reports.Reports(self.project, self.output)
reporter.write_report(report_file_name)
webbrowser.open_new_tab(report_file_name)
except Exception as e1:
msg = str(e1) + '\n' + str(traceback.print_exc())
print(msg)
QMessageBox.information(None, self.model,
"Error writing report to \n" + report_file_name + '\n' + msg,
QMessageBox.Ok)
else:
QMessageBox.information(None, self.model,
"There is no model output currently open.\n"
"Model output is automatically opened after model is run.",
QMessageBox.Ok)
def report_graph(self):
if self.output:
self._frmGraph = frmGraph(self)
self._frmGraph.set_from(self.project, self.output)
self._frmGraph.show()
else:
QMessageBox.information(None, self.model,
"Model output not found.\n"
"Run the model to generate output.",
QMessageBox.Ok)
def report_table(self):
if self.output:
self._frmTable = frmTable(self)
self._frmTable.set_from(self.project, self.output)
self._frmTable.show()
else:
QMessageBox.information(None, self.model,
"Model output not found.\n"
"Run the model to generate output.",
QMessageBox.Ok)
def reaction_report(self):
# TXT_NO_REACTION = 'No reactions occurred'
# TXT_AVG_RATES = 'Average Reaction Rates (kg/day)'
# ' Reaction Report'
# Find conversion factor to kilograms/day
ucf = 1.0e6/24
quality_options = self.project.options.quality
if 'ug' in str(quality_options.mass_units):
ucf = 1.0e9/24
#
# // Get average reaction rates from output file
# Uoutput.GetReactRates(r);
# procedure GetReactRates(var R: array of Single);
# //-----------------------------------------------
# // Retrieves overall average reaction rates
# // NOTE: The 3 avg. reaction rates + avg. source
# // input rate are stored at end of the
# // binary output file just before the last
# // 3 records.
# //-----------------------------------------------
# begin
# Seek(Fout, FileSize(Fout)-7*RECORDSIZE);
# BlockRead(Fout, R, 4*Sizeof(Single));
# end;
# for i := 0 to 3 do rate[i] := r[i] / ucf;
#
# // Check max. rate to see if any reactions occurred
# maxrate := MaxValue(Slice(rate,3));
# if maxrate = 0 then
# begin
# Chart1.Foot.Text.Add(TXT_NO_REACTION);
# end
#
# // Add each rate category to chart
# else
# begin
# Chart1.Title.Text.Add(TXT_AVG_RATES);
# Add(rate[0],TXT_BULK,clBlue);
# Add(rate[1],TXT_WALL,clRed);
# Add(rate[2],TXT_TANKS,clGreen);
# Active := True;
# Chart1.Foot.Text.Add(Format(FMT_INFLOW,[rate[3]]));
# end;
# end;
import matplotlib.pyplot as plt
# The slices will be ordered and plotted counter-clockwise.
labels = '2.8 Tanks', '0.5 Bulk', '2.1 Wall'
sizes = [52.49, 8.57, 38.93]
colors = ['green', 'blue', 'red']
explode = (0, 0, 0)
plt.figure("Reaction Report")
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
autopct='%1.2f%%', shadow=True, startangle=180)
# Set aspect ratio to be equal so that pie is drawn as a circle.
plt.axis('equal')
plt.suptitle("Average Reaction Rates (kg/day)", fontsize=16)
plt.text(0.9,-0.9,"Inflow Rate = 6")
plt.show()
def calibration_data(self):
self._frmCalibrationData = frmCalibrationData(self)
self._frmCalibrationData.show()
pass
def get_editor(self, edit_name):
frm = None
# First handle special cases where forms need more than simply being created
# the following items will respond to a click on a node form, not the tree diagram
if edit_name == 'Reservoirs' or edit_name == 'Tanks':
# assume we're editing the first node for now
frm = frmSourcesQuality(self)
frm.setWindowTitle('EPANET Source Editor for Node ' + '1')
frm.set_from(self.project, '1')
elif edit_name == 'Junctions':
# assume we're editing the first junction for now
frm = frmDemands(self)
frm.setWindowTitle('EPANET Demands for Junction ' + '1')
frm.set_from(self.project, '1')
elif edit_name == 'Patterns':
return None
elif edit_name == 'Curves':
return None
else: # General-purpose case finds most editors from tree information
frm = self.make_editor_from_tree(edit_name, self.tree_top_items)
return frm
def get_editor_with_selected_item(self, edit_name, selected_item):
frm = None
# the following items will respond to a click on a node form, not the tree diagram
if edit_name == 'Reservoirs' or edit_name == 'Tanks':
# assume we're editing the first node for now
frm = frmSourcesQuality(self)
frm.setWindowTitle('EPANET Source Editor for Node ' + '1')
frm.set_from(self.project, '1')
elif edit_name == 'Junctions':
# assume we're editing the first junction for now
frm = frmDemands(self)
frm.setWindowTitle('EPANET Demands for Junction ' + '1')
frm.set_from(self.project, '1')
else: # General-purpose case finds most editors from tree information
frm = self.make_editor_from_tree(edit_name, self.tree_top_items)
frm.set_from(self.project, selected_item)
return frm
def get_object_list(self, category):
ids = []
if category.lower() == 'junctions':
for i in range(0, len(self.project.junctions.value)):
ids.append(self.project.junctions.value[i].id)
elif category.lower() == 'reservoirs':
for i in range(0, len(self.project.reservoirs.value)):
ids.append(self.project.reservoirs.value[i].id)
elif category.lower() == 'tanks':
for i in range(0, len(self.project.tanks.value)):
ids.append(self.project.tanks.value[i].id)
elif category.lower() == 'pipes':
for i in range(0, len(self.project.pipes.value)):
ids.append(self.project.pipes.value[i].id)
elif category.lower() == 'pumps':
for i in range(0, len(self.project.pumps.value)):
ids.append(self.project.pumps.value[i].id)
elif category.lower() == 'valves':
for i in range(0, len(self.project.valves.value)):
ids.append(self.project.valves.value[i].id)
elif category.lower() == 'labels':
for i in range(0, len(self.project.labels.value)):
ids.append(self.project.labels.value[i].label)
elif category.lower() == 'patterns':
for i in range(0, len(self.project.patterns.value)):
ids.append(self.project.patterns.value[i].pattern_id)
elif category.lower() == 'curves':
for i in range(0, len(self.project.curves.value)):
ids.append(self.project.curves.value[i].curve_id)
else:
ids = None
return ids
def add_object_clicked(self, section_name):
if section_name == "Patterns":
new_item = Pattern()
new_item.pattern_id = "NewPattern"
self.project.patterns.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.pattern_id))
elif section_name == "Curves":
new_item = Curve()
new_item.curve_id = "NewCurve"
self.project.curves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.curve_id))
elif section_name == "Junctions":
new_item = Junction()
new_item.id = "New"
self.project.junctions.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.id))
elif section_name == 'Reservoirs':
new_item = Reservoir()
new_item.id = "New"
self.project.reservoirs.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.id))
elif section_name == 'Tanks':
new_item = Tank()
new_item.id = "New"
self.project.tanks.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.id))
elif section_name == 'Pipes':
new_item = Pipe()
new_item.id = "New"
self.project.pipes.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.id))
elif section_name == 'Pumps':
new_item = Pump()
new_item.id = "New"
self.project.pumps.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.id))
elif section_name == 'Valves':
new_item = Valve()
new_item.id = "New"
self.project.valves.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.id))
elif section_name == 'Labels':
new_item = Label()
new_item.id = "New"
self.project.labels.value.append(new_item)
self.show_edit_window(self.get_editor_with_selected_item(self.tree_section, new_item.id))
def delete_object_clicked(self, section_name, item_name):
if section_name == "Patterns":
for value in self.project.patterns.value:
if value.pattern_id == item_name:
self.project.patterns.value.remove(value)
elif section_name == "Curves":
for value in self.project.curves.value:
if value.curve_id == item_name:
self.project.curves.value.remove(value)
elif section_name == "Junctions":
for value in self.project.junctions.value:
if value.id == item_name:
self.project.junctions.value.remove(value)
elif section_name == 'Reservoirs':
for value in self.project.reservoirs.value:
if value.id == item_name:
self.project.reservoirs.value.remove(value)
elif section_name == 'Tanks':
for value in self.project.tanks.value:
if value.id == item_name:
self.project.tanks.value.remove(value)
elif section_name == 'Pipes':
for value in self.project.pipes.value:
if value.id == item_name:
self.project.pipes.value.remove(value)
elif section_name == 'Pumps':
for value in self.project.pumps.value:
if value.id == item_name:
self.project.pumps.value.remove(value)
elif section_name == 'Valves':
for value in self.project.valves.value:
if value.id == item_name:
self.project.valves.value.remove(value)
elif section_name == 'Labels':
for value in self.project.labels.value:
if value.id == item_name:
self.project.labels.value.remove(value)
def run_simulation(self):
# Find input file to run
file_name = ''
use_existing = self.project and self.project.file_name and os.path.exists(self.project.file_name)
if use_existing:
file_name = self.project.file_name
# TODO: save if needed, decide whether to save to temp location as previous version did.
else:
directory = QtCore.QSettings(self.model, "GUI").value("ProjectDir", "")
file_name = QFileDialog.getOpenFileName(self, "Open Project...", directory,
"Inp files (*.inp);;All files (*.*)")
if os.path.exists(file_name):
if not os.path.exists(self.model_path):
if 'darwin' in sys.platform:
lib_name = 'libepanet.dylib.dylib'
elif 'win' in sys.platform:
lib_name = 'epanet2_amd64.dll'
else: # Linux
lib_name = 'libepanet2_amd64.so'
self.model_path = self.find_external(lib_name)
if os.path.exists(self.model_path):
try:
prefix, extension = os.path.splitext(file_name)
self.status_file_name = prefix + self.status_suffix
self.output_filename = prefix + '.out'
model_api = ENepanet(file_name, self.status_file_name, self.output_filename, self.model_path)
frmRun = frmRunEPANET(model_api, self.project, self)
self._forms.append(frmRun)
if not use_existing:
# Read this project so we can refer to it while running
frmRun.progressBar.setVisible(False)
frmRun.lblTime.setVisible(False)
frmRun.fraTime.setVisible(False)
frmRun.fraBottom.setVisible(False)
frmRun.showNormal()
frmRun.set_status_text("Reading " + file_name)
self.project = Project()
self.project.read_file(file_name)
frmRun.project = self.project
frmRun.Execute()
self.report_status()
self.output = ENOutputWrapper.OutputObject(self.output_filename)
return
except Exception as e1:
print(str(e1) + '\n' + str(traceback.print_exc()))
QMessageBox.information(None, self.model,
"Error running model with library:\n {0}\n{1}\n{2}".format(
self.model_path, str(e1), str(traceback.print_exc())),
QMessageBox.Ok)
finally:
try:
if model_api and model_api.isOpen():
model_api.ENclose()
except:
pass
return
# # Could not run with library, try running with executable
# # Run executable with StatusMonitor0
# args = []
# self.modelenv1 = 'EXE_EPANET'
# program = os.environ[self.modelenv1]
#
# exe_name = "epanet2d.exe"
# exe_path = os.path.join(self.assembly_path, exe_name)
# if not os.path.exists(exe_path):
# pp = os.path.dirname(os.path.dirname(self.assembly_path))
# exe_path = os.path.join(pp, "Externals", exe_name)
# if not os.path.exists(exe_path):
# exe_path = QFileDialog.getOpenFileName(self, 'Locate EPANET Executable', '/',
# 'exe files (*.exe)')
# if os.path.exists(exe_path):
# os.environ[self.modelenv1] = exe_path
# else:
# os.environ[self.modelenv1] = ''
#
# if not os.path.exists(program):
# QMessageBox.information(None, "EPANET", "EPANET Executable not found", QMessageBox.Ok)
# return -1
#
# args.append(file_name)
# args.append(prefix + '.txt')
# args.append(prefix + '.out')
# status = model_utility.StatusMonitor0(program, args, self, model='EPANET')
# status.show()
else:
QMessageBox.information(None, self.model, self.model + " input file not found", QMessageBox.Ok)
def find_external(self, lib_name):
filename = os.path.join(self.assembly_path, lib_name)
if not os.path.exists(filename):
pp = os.path.dirname(os.path.dirname(self.assembly_path))
filename = os.path.join(pp, "Externals", lib_name)
if not os.path.exists(filename):
pp = os.path.dirname(os.path.dirname(self.assembly_path))
filename = os.path.join(pp, "Externals", "epanet", "model", lib_name)
if not os.path.exists(filename):
filename = QFileDialog.getOpenFileName(self,
'Locate ' + self.model + ' Library',
'/', '(*{0})'.format(os.path.splitext(lib_name)[1]))
return filename
def help_topics(self):
self.helper.show_help()
def help_about(self):
self._frmAbout = frmAbout(self)
self._frmAbout.show()
pass
def __init__(self, q_application):
frmMain.__init__(self, q_application)
self.model = "SWMM"
self.model_path = '' # Set this only if needed later when running model
self.output = None # Set this when model output is available
self.status_suffix = "_status.txt"
self.status_file_name = '' # Set this when model status is available
self.output_filename = '' # Set this when model output is available
self.project_type = Project # Use the model-specific Project as defined in core.swmm.project
self.project = Project()
self.assembly_path = os.path.dirname(os.path.abspath(__file__))
self.on_load(tree_top_item_list=self.tree_top_items)
HelpHandler.init_class(os.path.join(self.assembly_path, "swmm.qhc"))
self.helper = HelpHandler(self)
self.help_topic = "swmm/src/src/swmmsmainwindow.htm"
self.actionStatus_ReportMenu = QtGui.QAction(self)
self.actionStatus_ReportMenu.setObjectName(from_utf8("actionStatus_ReportMenu"))
self.actionStatus_ReportMenu.setText(transl8("frmMain", "Status", None))
self.actionStatus_ReportMenu.setToolTip(transl8("frmMain", "Display Simulation Status", None))
self.menuReport.addAction(self.actionStatus_ReportMenu)
QtCore.QObject.connect(self.actionStatus_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_status)
self.actionSummary_ReportMenu = QtGui.QAction(self)
self.actionSummary_ReportMenu.setObjectName(from_utf8("actionSummary_ReportMenu"))
self.actionSummary_ReportMenu.setText(transl8("frmMain", "Summary", None))
self.actionSummary_ReportMenu.setToolTip(transl8("frmMain", "Display Results Summary", None))
self.menuReport.addAction(self.actionSummary_ReportMenu)
QtCore.QObject.connect(self.actionSummary_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_summary)
menu = QtGui.QMenu()
submenuGraph = QtGui.QMenu(self.menuReport)
submenuGraph.setTitle("Graph")
self.menuReport.addMenu(submenuGraph)
self.actionGraph_ProfileMenu = QtGui.QAction(self)
self.actionGraph_ProfileMenu.setObjectName(from_utf8("actionGraph_ProfileMenu"))
self.actionGraph_ProfileMenu.setText(transl8("frmMain", "Profile", None))
self.actionGraph_ProfileMenu.setToolTip(transl8("frmMain", "Display Profile Plot", None))
submenuGraph.addAction(self.actionGraph_ProfileMenu)
QtCore.QObject.connect(self.actionGraph_ProfileMenu, QtCore.SIGNAL('triggered()'), self.report_profile)
self.actionGraph_TimeSeriesMenu = QtGui.QAction(self)
self.actionGraph_TimeSeriesMenu.setObjectName(from_utf8("actionGraph_TimeSeriesMenu"))
self.actionGraph_TimeSeriesMenu.setText(transl8("frmMain", "Time Series", None))
self.actionGraph_TimeSeriesMenu.setToolTip(transl8("frmMain", "Display Time Series Plot", None))
submenuGraph.addAction(self.actionGraph_TimeSeriesMenu)
QtCore.QObject.connect(self.actionGraph_TimeSeriesMenu, QtCore.SIGNAL('triggered()'), self.report_timeseries)
self.actionGraph_ScatterMenu = QtGui.QAction(self)
self.actionGraph_ScatterMenu.setObjectName(from_utf8("actionGraph_ScatterMenu"))
self.actionGraph_ScatterMenu.setText(transl8("frmMain", "Scatter", None))
self.actionGraph_ScatterMenu.setToolTip(transl8("frmMain", "Display Scatter Plot", None))
submenuGraph.addAction(self.actionGraph_ScatterMenu)
QtCore.QObject.connect(self.actionGraph_ScatterMenu, QtCore.SIGNAL('triggered()'), self.report_scatter)
self.actionTable_VariableMenu = QtGui.QAction(self)
self.actionTable_VariableMenu.setObjectName(from_utf8("actionTable_VariableMenu"))
self.actionTable_VariableMenu.setText(transl8("frmMain", "Table", None))
self.actionTable_VariableMenu.setToolTip(transl8("frmMain", "Display Table", None))
self.menuReport.addAction(self.actionTable_VariableMenu)
QtCore.QObject.connect(self.actionTable_VariableMenu, QtCore.SIGNAL('triggered()'), self.report_variable)
self.actionStatistics_ReportMenu = QtGui.QAction(self)
self.actionStatistics_ReportMenu.setObjectName(from_utf8("actionStatistics_ReportMenu"))
self.actionStatistics_ReportMenu.setText(transl8("frmMain", "Statistics", None))
self.actionStatistics_ReportMenu.setToolTip(transl8("frmMain", "Display Results Statistics", None))
self.menuReport.addAction(self.actionStatistics_ReportMenu)
QtCore.QObject.connect(self.actionStatistics_ReportMenu, QtCore.SIGNAL('triggered()'), self.report_statistics)
self.Help_Topics_Menu = QtGui.QAction(self)
self.Help_Topics_Menu.setObjectName(from_utf8("Help_Topics_Menu"))
self.Help_Topics_Menu.setText(transl8("frmMain", "Help Topics", None))
self.Help_Topics_Menu.setToolTip(transl8("frmMain", "Display Help Topics", None))
self.menuHelp.addAction(self.Help_Topics_Menu)
QtCore.QObject.connect(self.Help_Topics_Menu, QtCore.SIGNAL('triggered()'), self.help_topics)
self.Help_About_Menu = QtGui.QAction(self)
self.Help_About_Menu.setObjectName(from_utf8("Help_About_Menu"))
self.Help_About_Menu.setText(transl8("frmMain", "About", None))
self.Help_About_Menu.setToolTip(transl8("frmMain", "About SWMM", None))
self.menuHelp.addAction(self.Help_About_Menu)
QtCore.QObject.connect(self.Help_About_Menu, QtCore.SIGNAL('triggered()'), self.help_about)
