def setup_hebesatz(self):
'''
assessment rate parameters
'''
if self.hebesatz_params:
self.hebesatz_params.close()
layout = self.ui.grundsteuer_hebesatz_param_group.layout()
clear_layout(layout)
self.hebesatz_params = Params(
layout, help_file='einnahmen_grundsteuer_hebesatz.txt')
self.hebesatz_params.hebesatz = Param(
self.grst_settings.Hebesatz_GrStB,
SpinBox(maximum=999, step=10),
label='Hebesatz GrSt B Projektgemeinde',
unit='v.H.')
def save():
self.changed.emit()
self.grst_settings.Hebesatz_GrStB = \
self.hebesatz_params.hebesatz.value
self.grst_settings.save()
self.hebesatz_params.show(title='Hebesatz bearbeiten')
self.hebesatz_params.changed.connect(save)
def setup_line_params(self):
'''
set up the parameters to edit the lengths of the line measures
'''
layout = self.ui.mengen_params_group.layout()
clear_layout(layout)
if len(self.line_elements) == 0:
self.init_lines()
self.line_params = Params(
layout, help_file='infrastruktur_linienelemente.txt')
for element in self.line_elements:
param = Param(int(element.length), Slider(maximum=10000),
label=element.Netzelement, unit='m')
self.line_params.add(
param, name=f'netzelement_{element.IDNetzelement}')
def save():
for element in self.line_elements:
param = self.line_params[f'netzelement_{element.IDNetzelement}']
element.length = param.value
element.save()
self.line_params.show(title=self.ui.mengen_params_group.title())
self.line_params.changed.connect(save)
last_row = self.line_params.layout.children()[-1]
button = QPushButton()
button.setText('aus Zeichnung übernehmen')
last_row.insertWidget(0, button)
button.clicked.connect(self.apply_drawing)
def setup_weights(self):
'''
set up the parameters to weight the transfer nodes
'''
self.set_status()
if self.weight_params:
self.weight_params.close()
layout = self.ui.weights_group.layout()
clear_layout(layout)
self.weight_params = Params(parent=layout,
button_label='Gewichtungen verändern',
help_file='verkehr_gewichtungen.txt')
dependency = SumDependency(100)
for node in self.transfer_nodes:
perc = round(node.weight)
param = Param(perc,
Slider(maximum=100, lockable=True),
label=node.name,
unit='%')
self.weight_params.add(param, name=node.name)
dependency.add(param)
def save():
for node in self.transfer_nodes:
node.weight = self.weight_params[node.name].value
node.save()
self.traffic_load.table.truncate()
self.canvas.refreshAllLayers()
self.set_status()
self.weight_params.changed.connect(save)
self.weight_params.show()
def setup_params(self):
if self.params:
self.params.close()
layout = self.ui.gewerbesteuer_hebesatz_param_group.layout()
clear_layout(layout)
self.params = Params(layout,
help_file='einnahmen_gewerbesteuer_hebesätze.txt')
self.params.add(Title('Hebesätze', bold=False))
for gemeinde in sorted(self.gemeinden, key=lambda x: x.GEN):
spinbox = SpinBox(minimum=0, maximum=999, step=1)
param = Param(gemeinde.Hebesatz_GewSt,
spinbox,
label=f' - {gemeinde.GEN}',
unit='v.H.')
self.params.add(param, name=gemeinde.AGS)
def save():
self.changed.emit()
for gemeinde in self.gemeinden:
param = self.params[gemeinde.AGS]
gemeinde.Hebesatz_GewSt = param.value
gemeinde.save()
self.params.show(title='Hebesätze Gewerbesteuer bearbeiten',
scrollable=True)
self.params.changed.connect(save)
def setup_rohmiete(self):
'''
gross rent parameters
'''
tou = self.areas.values('nutzungsart')
if self.grst_settings.is_new_bundesland \
or not Nutzungsart.WOHNEN.value in tou:
self.ui.grundsteuer_rohmiete_param_group.setVisible(False)
return
self.ui.grundsteuer_rohmiete_param_group.setVisible(True)
if self.rohmiete_params:
self.rohmiete_params.close()
layout = self.ui.grundsteuer_rohmiete_param_group.layout()
clear_layout(layout)
self.rohmiete_params = Params(
layout, help_file='einnahmen_grundsteuer_rohmieten.txt')
self.rohmiete_params.add(
Title('Rohmiete 1964 in Euro pro Monat', bold=False))
self.rohmiete_params.efh = Param(self.grst_settings.EFH_Rohmiete / 100,
DoubleSpinBox(minimum=0.3,
maximum=5,
step=0.05),
label=f' - Einfamilienhaus',
unit='€/m²')
self.rohmiete_params.dhh = Param(self.grst_settings.DHH_Rohmiete / 100,
DoubleSpinBox(minimum=0.3,
maximum=5,
step=0.05),
label=f' - Doppelhaus',
unit='€/m²')
self.rohmiete_params.rhw = Param(self.grst_settings.RHW_Rohmiete / 100,
DoubleSpinBox(minimum=0.3,
maximum=5,
step=0.05),
label=f' - Reihenhaus',
unit='€/m²')
self.rohmiete_params.mfh = Param(self.grst_settings.MFH_Rohmiete / 100,
DoubleSpinBox(minimum=0.3,
maximum=5,
step=0.05),
label=f' - Mehrfamilienhaus',
unit='€/m²')
def save():
self.changed.emit()
self.grst_settings.EFH_Rohmiete = round(
self.rohmiete_params.efh.value * 100)
self.grst_settings.DHH_Rohmiete = round(
self.rohmiete_params.dhh.value * 100)
self.grst_settings.RHW_Rohmiete = round(
self.rohmiete_params.rhw.value * 100)
self.grst_settings.MFH_Rohmiete = round(
self.rohmiete_params.mfh.value * 100)
self.grst_settings.save()
self.rohmiete_params.show(title='Rohmieten bearbeiten')
self.rohmiete_params.changed.connect(save)
def close(self):
'''
close rendered parameters
'''
if self.dialog:
clear_layout(self.dialog.layout)
del(self.dialog)
clear_layout(self.layout)
def setup_kostenaufteilung(self, net_id):
'''
set up parameters to edit shares for a specific type of infrastructure
'''
self.net_id = net_id
ui_group = self.ui.kostenaufteilung_params_group
net_name = self.netzelemente.filter(IDNetz=net_id)[0].Netz
ui_group.setTitle(net_name)
layout = ui_group.layout()
clear_layout(layout)
self.params = Params(
layout, help_file='infrastruktur_kostenaufteilung.txt')
field_names = ['Anteil_GSB', 'Anteil_GEM', 'Anteil_ALL']
labels = ['Kostenanteil der Grunstücksbesitzer/innen',
'Kostenanteil der Gemeinde',
'Netznutzer/innen und Tarifkundschaft']
def preset_changed(c, p):
preset = c.get_data()
if not preset:
return
for field_name in field_names:
param = self.params.get(f'{p.Kostenphase}_{field_name}')
param.input.value = preset[field_name]
for i, phase in enumerate(self.kostenphasen):
dependency = SumDependency(100)
self.params.add(Title(phase.Kostenphase))
feature = self.kostenaufteilung.get(
IDKostenphase=phase.IDKostenphase, IDNetz=net_id)
preset_combo, options = self.create_presets(
net_id, phase.IDKostenphase)
param = Param(0, preset_combo, label='Vorschlagswerte')
param.hide_in_overview = True
self.params.add(param, name=f'{phase.Kostenphase}_presets')
for j, field_name in enumerate(field_names):
label = labels[j]
slider = Slider(maximum=100, lockable=True)
param = Param(feature[field_name], slider,
label=label, unit='%')
self.params.add(
param, name=f'{phase.Kostenphase}_{field_name}')
dependency.add(param)
slider.changed.connect(
lambda b,
c=preset_combo, o=options: c.set_value(o[0]))
if i != len(self.kostenphasen) - 1:
self.params.add(Seperator(margin=0))
preset_combo.changed.connect(
lambda b, c=preset_combo, p=phase: preset_changed(c, p))
self.params.show(title='Kostenaufteilung festlegen')
self.params.changed.connect(lambda: self.save(net_id))
def setup_bauvolumen(self):
'''
construction volume parameters
'''
tou = self.areas.values('nutzungsart')
if not (Nutzungsart.GEWERBE.value in tou
or Nutzungsart.EINZELHANDEL.value in tou):
self.ui.grundsteuer_bauvolumen_param_group.setVisible(False)
# set to 0 as a precaution to not put some old values into
# the calculation
self.grst_settings.Bueroflaeche = 0
self.grst_settings.Verkaufsraeume = 0
self.grst_settings.save()
return
self.ui.grundsteuer_bauvolumen_param_group.setVisible(True)
if self.bauvolumen_params:
self.bauvolumen_params.close()
layout = self.ui.grundsteuer_bauvolumen_param_group.layout()
clear_layout(layout)
self.bauvolumen_params = Params(
layout, help_file='einnahmen_grundsteuer_bauvolumen.txt')
self.bauvolumen_params.add(
Title(
'Gewerbe / Einzelhandel: Voraussichtliches '
'Bauvolumen\n(Brutto-Grundfläche, BGF)',
bold=False))
self.bauvolumen_params.bueroflaeche = Param(
self.grst_settings.Bueroflaeche,
SpinBox(minimum=0, maximum=99999, step=10),
label=f' - Bürofläche',
unit='m²')
self.bauvolumen_params.verkaufsraeume = Param(
self.grst_settings.Verkaufsraeume,
SpinBox(minimum=0, maximum=99999, step=10),
label=f' - Hallen und Verkaufsräume',
unit='m²')
def save():
self.changed.emit()
self.grst_settings.Bueroflaeche = \
self.bauvolumen_params.bueroflaeche.value
self.grst_settings.Verkaufsraeume = \
self.bauvolumen_params.verkaufsraeume.value
self.grst_settings.save()
self.bauvolumen_params.show(
title='Voraussichtliches Bauvolumen bearbeiten')
self.bauvolumen_params.changed.connect(save)
def setup_params(self):
'''
set up the parameters for editing the mean residential area per
appartment and the net share of residential building land in the active
area
'''
anteil = self.wohnbauland_anteile.get(id_teilflaeche=self.area.id)
value = anteil.nettoflaeche if anteil else 85
clear_layout(self.layout)
self.params = Params(
self.layout,
help_file='flaecheninanspruchnahme_wohnbauland_wohnflaeche.txt'
)
self.params.add(Title('Anteil Nettowohnbauland'))
self.params.nettoflaeche = Param(
int(value), Slider(maximum=100),
label='Anteil des Nettowohnbaulandes (= Summe aller\n'
'Wohnbaugrundstücke) an der Gesamtfläche der\n'
'ausgewählten Teilfläche',
unit='%'
)
self.params.add(Seperator())
self.params.add(Title('Durchschnittliche Wohnfläche je Wohnung'))
for bt in self.gebaeudetypen_base.features():
param_name = bt.param_we
feature = self.wohnflaeche.get(id_gebaeudetyp=bt.id,
id_teilflaeche=self.area.id)
# default value on first time
value = bt.Wohnfl_m2_pro_WE if not feature \
else feature.mean_wohnflaeche
self.params.add(Param(
value, Slider(maximum=200),
label=f'... in {bt.display_name}', unit='m²'),
name=param_name
)
self.params.changed.connect(self.save)
self.params.show(
title='Annahmen für Wohnungsdichte und Wohnflächendichte')
self.save()
def setup_type(self):
'''
set up basic parameters (name, type of use)
'''
layout = self.ui.parameter_group.layout()
clear_layout(layout)
self.params = Params(layout,
help_file='definitionen_flaechen.txt', )
self.params.name = Param(self.area.name, LineEdit(width=300),
label='Name')
self.params.add(Seperator(margin=0))
ha = round(self.area.geom.area()) / 10000
self.area.area = ha
self.params.area = Param(ha, label='Größe', unit='ha')
self.params.typ = Param(
self.types[self.area.nutzungsart][0],
ComboBox([t[0] for t in self.types], width=300),
label='Nutzungsart'
)
# user changed type of use
def type_changed():
name = self.params.name.value
type_labels = [t[0] for t in self.types]
tou_id = type_labels.index(self.params.typ.value)
self.area.nutzungsart = tou_id
tou_label = self.types[tou_id][0]
self.ui.area_combo.setItemText(
self.ui.area_combo.currentIndex(),
f'{name} ({tou_label})'
)
self.area.name = name
self.area.save()
# update connector names
connector = self.connectors.get(id_teilflaeche=self.area.id)
connector.name_teilflaeche = self.area.name
connector.save()
if self.typ:
self.typ.clear(self.area)
self.setup_type_params()
self.canvas.refreshAllLayers()
Traffic.reset()
self.params.changed.connect(type_changed)
self.params.show(title='Teilfläche definieren')
def setup_type_params(self):
'''
set up detailled parameters depending on current type of use
'''
tou_label = self.types[self.area.nutzungsart][0]
title = f'Maß der baulichen Nutzung ({tou_label})'
self.ui.type_parameter_group.setTitle(title)
clear_layout(self.ui.type_parameter_group.layout())
if self.typ:
self.typ.close()
self.typ = self.types[self.area.nutzungsart][1]
if self.typ is None:
self.ui.type_parameter_group.setVisible(False)
return
self.ui.type_parameter_group.setVisible(True)
self.typ.setup_params(self.area)
self.typ.params.changed.connect(lambda: self.canvas.refreshAllLayers())
def setup_ways(self):
'''
set up paramaters to set ways
'''
if self.ways_params:
self.ways_params.close()
if len(self.ways) == 0:
self.calculate_ways()
layout = self.ui.ways_group.layout()
clear_layout(layout)
self.ways_params = Params(parent=layout,
button_label='Annahmen verändern',
help_file='verkehr_wege.txt')
for i, way in enumerate(self.ways):
name = Nutzungsart(way.nutzungsart).name.capitalize()
self.ways_params.add(Title(name, fontsize=8))
self.ways_params[f'{name}_gesamt'] = Param(
way.wege_gesamt,
SpinBox(),
label='Gesamtanzahl der Wege pro Werktag (Hin- und Rückwege)')
self.ways_params[f'{name}_miv'] = Param(
way.miv_anteil,
SpinBox(maximum=100),
label='Anteil der von Pkw-Fahrenden gefahrenen Wegen',
unit='%')
if i != len(self.ways) - 1:
self.ways_params.add(Seperator(margin=0))
def save():
for way in self.ways:
name = Nutzungsart(way.nutzungsart).name.capitalize()
way.miv_anteil = self.ways_params[f'{name}_miv'].value
way.wege_gesamt = self.ways_params[f'{name}_gesamt'].value
way.save()
self.traffic_load.table.truncate()
self.canvas.refreshAllLayers()
self.set_status()
self.ways_params.changed.connect(save)
self.ways_params.show()
def setup_params(self):
'''
set up the parameter for setting the percentages of ground cover in
status quo and the scenario
'''
self.params_nullfall = Params(
self.ui.param_nullfall_tab.layout(),
help_file='oekologie_bodenbedeckung_nullfall.txt')
self.params_planfall = Params(
self.ui.param_planfall_tab.layout(),
help_file='oekologie_bodenbedeckung_planfall.txt')
clear_layout(self.ui.param_nullfall_tab.layout())
clear_layout(self.ui.param_planfall_tab.layout())
def apply_nf():
self.apply_drawing(False)
def apply_pf():
self.apply_drawing(True)
for params, prefix in [(self.params_nullfall, 'nullfall'),
(self.params_planfall, 'planfall')]:
planfall = prefix == 'planfall'
dependency = SumDependency(100)
for bb_typ in self.bb_types.features():
bb_id = bb_typ.IDBodenbedeckung
feature = self.anteile.get(IDBodenbedeckung=bb_id,
planfall=planfall)
value = feature.anteil if feature else 0
slider = Slider(maximum=100, width=200, lockable=True)
param = Param(int(value), slider, label=bb_typ.name, unit='%')
dependency.add(param)
params.add(param, name=f'{prefix}_{bb_id}')
params.changed.connect(lambda p=prefix: self.save(p))
params.show(title='Flächenanteile der Bodenbedeckung für die '
f'Analyse: {prefix.capitalize()}')
last_row = params.layout.children()[-1]
button = QPushButton()
button.setText('aus Zeichnung übernehmen')
last_row.insertWidget(0, button)
# workaround: lambda with argument didn't seem to work here (weird)
#button.clicked.connect(lambda p=planfall: self.apply_drawing(p))
func = apply_pf if planfall else apply_nf
button.clicked.connect(func)
def setup_node_params(self, node):
'''
set up the parameters of a single transfer node
'''
if self.node_params:
self.node_params.close()
layout = self.ui.transfer_node_parameter_group.layout()
clear_layout(layout)
if not node:
self.ui.transfer_node_parameter_group.setVisible(False)
return
self.ui.transfer_node_parameter_group.setVisible(True)
#self.ui.transfer_node_parameter_group.setTitle(node.name)
self.node_params = Params(layout, help_file='verkehr_knoten.txt')
self.node_params.name = Param(node.name,
LineEdit(width=300),
label='Name')
def save():
node.name = self.node_params.name.value
#self.ui.transfer_node_parameter_group.setTitle(node.name)
node.save()
self.canvas.refreshAllLayers()
# lazy way to update the combo box
self.fill_node_combo(select=node)
self.setup_weights()
self.node_params.show(title='Herkunfts-/Zielpunkt bearbeiten')
self.node_params.changed.connect(save)
last_row = self.node_params.layout.children()[-1]
button = QPushButton()
icon_path = 'iconset_mob/20190619_iconset_mob_delete_1.png'
icon = QIcon(os.path.join(self.project.settings.IMAGE_PATH, icon_path))
button.setText('Punkt entfernen')
button.setIcon(icon)
button.setToolTip(
'<p><span style=" font-weight:600;">'
'Herkunfts-/Zielpunkt entfernen</span>'
'</p><p>Löscht den aktuell gewählten Herkunfts-/Zielpunkt. '
'<br/>Dieser Schritt kann nicht rückgängig gemacht werden. </p>')
last_row.insertWidget(0, button)
button.clicked.connect(lambda: self.remove_node(node))
def setup_sachwert(self):
'''
asset value parameters
'''
tou = self.areas.values('nutzungsart')
if not self.grst_settings.is_new_bundesland\
or not Nutzungsart.WOHNEN.value in tou:
self.ui.grundsteuer_sachwert_param_group.setVisible(False)
return
if self.sachwert_params:
self.sachwert_params.close()
self.ui.grundsteuer_sachwert_param_group.setVisible(True)
layout = self.ui.grundsteuer_sachwert_param_group.layout()
clear_layout(layout)
self.sachwert_params = Params(
layout, help_file='einnahmen_grundsteuer_sachwertverfahren.txt')
self.sachwert_params.add(Title('Sachwertverfahren', bold=False))
self.sachwert_params.bodenwert = Param(
self.grst_settings.Bodenwert_SWV / 100,
DoubleSpinBox(minimum=0.3, maximum=5, step=0.05),
label=f' - Bodenwert 1935 pro m²',
unit='€/m²')
self.sachwert_params.flaeche = Param(
self.grst_settings.qm_Grundstueck_pro_WE_EFH,
SpinBox(minimum=300, maximum=2000, step=1),
label=f' - mittl. Größe Einfamilienhausgrundstücke',
unit='m²')
def save():
self.changed.emit()
self.grst_settings.Bodenwert_SWV = round(
self.sachwert_params.bodenwert.value * 100)
self.grst_settings.qm_Grundstueck_pro_WE_EFH = \
self.sachwert_params.flaeche.value
self.grst_settings.save()
self.sachwert_params.show(title='Sachwertverfahren bearbeiten')
self.sachwert_params.changed.connect(save)
def setup_net_element(self, net_element_id):
'''
set up parameters to edit the costs per element and phase
'''
self.net_element_id = net_element_id
ui_group = self.ui.kostenkennwerte_params_group
net_element_name = self.netzelemente.get(
IDNetzelement=net_element_id).Netzelement
ui_group.setTitle(net_element_name)
layout = ui_group.layout()
clear_layout(layout)
net_element = self.kostenkennwerte.get(IDNetzelement=net_element_id)
self.params = Params(
layout, help_file='infrastruktur_kostenkennwerte.txt')
self.params.euro_EH = Param(
net_element.Euro_EH, DoubleSpinBox(),
unit='€', label='Kosten der erstmaligen Herstellung \n'
'pro laufenden Meter'
)
self.params.euro_BU = Param(
net_element.Cent_BU / 100, DoubleSpinBox(),
unit='€', label='Jährliche Kosten für Betrieb und Unterhaltung \n'
'pro laufenden Meter und Jahr'
)
self.params.euro_EN = Param(
net_element.Euro_EN, DoubleSpinBox(),
unit='€', label='Kosten der Erneuerung \n'
'pro laufenden Meter und Erneuerungszyklus'
)
self.params.lebensdauer = Param(
net_element.Lebensdauer, SpinBox(minimum=1, maximum=1000),
label='Lebensdauer: Jahre zwischen den Erneuerungszyklen',
unit='Jahr(e)'
)
self.params.show()
self.params.changed.connect(lambda: self.save(net_element_id))
def setup_params(self, center):
'''
set up the parameters to edit the given center
'''
if self.params:
self.params.close()
layout = self.ui.center_parameter_group.layout()
clear_layout(layout)
if not center:
self.ui.center_parameter_group.setVisible(False)
return
self.ui.center_parameter_group.setVisible(True)
self.params = Params(layout,
help_file='standortkonkurrenz_zentren.txt')
self.params.name = Param(center.name,
LineEdit(width=300),
label='Name')
def save():
center.name = self.params.name.value
center.save()
self.canvas.refreshAllLayers()
# lazy way to update the combo box
self.fill_combo(select=center)
self.params.show(title='Zentrum bearbeiten')
self.params.changed.connect(save)
last_row = self.params.layout.children()[-1]
button = QPushButton()
icon_path = 'iconset_mob/20190619_iconset_mob_delete_1.png'
icon = QIcon(os.path.join(self.project.settings.IMAGE_PATH, icon_path))
button.setText('Zentrum entfernen')
button.setIcon(icon)
button.setToolTip(
'<p><span style=" font-weight:600;">Zentrum entfernen</span>'
'</p><p>Löscht das gewählte Zentrum. </p>')
last_row.insertWidget(0, button)
button.clicked.connect(lambda: self.remove_center(center))
def setup_params(self, area):
'''
set the parameters according to the data of the given area
'''
self.area = area
clear_layout(self.layout)
self.params = Params(self.layout,
help_file='definitionen_einzelhandel.txt')
self.params.add(Title('Verkaufsfläche'))
for sortiment in self.sortimente_base.features():
feature = self.verkaufsflaechen.get(id_sortiment=sortiment.id,
id_teilflaeche=self.area.id)
value = feature.verkaufsflaeche_qm if feature else 0
self.params.add(Param(
value,
Slider(maximum=20000),
label=f'{sortiment.Name_Sortiment_ProjektCheck}', unit='m²'),
name=sortiment.param_vfl
)
self.params.changed.connect(self.save)
self.params.show(
title='Einzelhandel: Bezugszeitraum und Maß der baulichen Nutzung')
def setup_point_params(self, point: 'Feature'):
'''
set up the parameters in the UI to edit the given point measure
'''
if self.point_params:
self.point_params.close()
ui_group = self.ui.point_parameter_group
layout = ui_group.layout()
clear_layout(layout)
if not point:
return
self.point_params = Params(
layout, help_file='infrastruktur_punktmassnahme.txt')
self.point_params.bezeichnung = Param(
point.bezeichnung, LineEdit(width=300),
label='Bezeichnung')
punktelemente = list(self.netzelemente.filter(Typ='Punkt'))
type_names = [p.Netzelement for p in punktelemente]
typ = self.netzelemente.get(IDNetzelement=point.IDNetzelement)
type_combo = ComboBox( ['nicht gesetzt'] + type_names,
data=[None] + list(punktelemente), width=300)
self.point_params.typ = Param(
typ.Netzelement if typ else 'nicht gesetzt', type_combo,
label='Erschließungsnetz'
)
self.point_params.add(Seperator(margin=0))
self.point_params.euro_EH = Param(
point.Euro_EH, DoubleSpinBox(),
unit='€', label='Kosten der erstmaligen Herstellung'
)
self.point_params.euro_BU = Param(
point.Cent_BU / 100, DoubleSpinBox(),
unit='€', label='Jährliche Kosten für Betrieb und Unterhaltung'
)
self.point_params.euro_EN = Param(
point.Euro_EN, DoubleSpinBox(),
unit='€', label='Erneuerungskosten nach Ablauf der Lebensdauer'
)
self.point_params.lebensdauer = Param(
point.Lebensdauer, SpinBox(minimum=1, maximum=1000),
label='Technische oder wirtschaftliche \n'
'Lebensdauer bis zur Erneuerung',
unit='Jahr(e)'
)
def save():
point.bezeichnung = self.point_params.bezeichnung.value
typ = type_combo.get_data()
point.IDNetzelement = typ.IDNetzelement if typ else 0
point.IDNetz = typ.IDNetz if typ else 0
point.Lebensdauer = self.point_params.lebensdauer.value
point.Euro_EH = self.point_params.euro_EH.value
point.Euro_EN = self.point_params.euro_EN.value
point.Cent_BU = self.point_params.euro_BU.value * 100
point.save()
# lazy way to update the combo box
self.fill_points_combo(select=point)
self.point_params.show()
self.point_params.changed.connect(save)
last_row = self.point_params.layout.children()[-1]
button = QPushButton()
icon_path = 'iconset_mob/20190619_iconset_mob_delete_1.png'
icon = QIcon(os.path.join(self.project.settings.IMAGE_PATH, icon_path))
button.setText('Maßnahme entfernen')
button.setIcon(icon)
button.setToolTip(
'<p><span style=" font-weight:600;">Maßnahme entfernen</span>'
'</p><p>Löscht die aktuell gewählte Maßnahme. '
'<br/>Dieser Schritt kann nicht rückgängig gemacht werden. </p>')
last_row.insertWidget(0, button)
button.clicked.connect(self.remove_point)
def setup_params(self, area):
'''
set the parameters according to the data of the given area
'''
self.area = area
clear_layout(self.layout)
self.params = Params(self.layout,
help_file='definitionen_wohnen.txt')
self.params.add(Title('Bezugszeitraum'))
self.params.beginn_nutzung = Param(
area.beginn_nutzung, SpinBox(minimum=2000, maximum=2100),
label='Beginn des Bezuges', repr_format='%d'
)
self.params.aufsiedlungsdauer = Param(
area.aufsiedlungsdauer, SpinBox(minimum=1, maximum=100),
label='Dauer des Bezuges', unit='Jahr(e)')
self.params.add(Seperator())
self.params.add(Title('Anzahl Wohneinheiten nach Gebäudetypen'))
# load the building presets to select from
preset_names, idx = np.unique(self.df_presets['Gebietstyp'].values,
return_index=True)
idx.sort()
preset_names = self.df_presets['Gebietstyp'].values[idx]
options = ['Gebietstyp wählen'] + list(preset_names)
self.preset_combo = ComboBox(options)
self.preset_combo.input.model().item(0).setEnabled(False)
param = Param(0, self.preset_combo, label='Vorschlagswerte')
param.hide_in_overview = True
self.params.add(param, name='gebietstyp')
self.params.add(
QSpacerItem(0, 3, QSizePolicy.Fixed, QSizePolicy.Minimum))
# preset is selected
def preset_changed(gebietstyp):
presets = self.df_presets[self.df_presets['Gebietstyp']==gebietstyp]
for idx, preset in presets.iterrows():
id_bt = preset['IDGebaeudetyp']
bt = self.gebaeudetypen_base.get(id=id_bt)
param = self.params.get(bt.param_we)
param.input.value = self.area.area * preset['WE_pro_Hektar']
self.preset_combo.changed.connect(preset_changed)
for bt in self.gebaeudetypen_base:
param_name = bt.param_we
feature = self.wohneinheiten.get(id_gebaeudetyp=bt.id,
id_teilflaeche=self.area.id)
value = feature.we if feature else 0
slider = Slider(maximum=2000)
self.params.add(Param(
value, slider,
label=f'... in {bt.display_name}'),
name=param_name
)
slider.changed.connect(
lambda: self.preset_combo.set_value(options[0]))
self.params.add(Seperator())
self.params.add(Title('Mittlere Anzahl Bewohner pro Wohneinheit\n'
'(3 Jahre nach Bezug)'))
for bt in self.gebaeudetypen_base:
param_name = bt.param_ew_je_we
feature = self.wohneinheiten.get(id_gebaeudetyp=bt.id,
id_teilflaeche=self.area.id)
# set to default if no feature yet
value = feature.ew_je_we if feature else bt.default_ew_je_we
self.params.add(Param(
value, DoubleSpinBox(step=0.1, maximum=50),
label=f'... in {bt.display_name}'),
name=param_name
)
self.params.add(Seperator())
self.params.add(Title('Anteil der Bewohner unter 18 Jahre'))
# load the age presets to select from
for bt in self.gebaeudetypen_base:
param_name = bt.param_anteil_u18
feature = self.wohneinheiten.get(id_gebaeudetyp=bt.id,
id_teilflaeche=self.area.id)
# set to default if no feature yet
value = feature.anteil_u18 if feature else bt.default_anteil_u18
self.params.add(Param(
value, Slider(maximum=60), unit='%',
label=f'... in {bt.display_name}'),
name=param_name
)
self.params.changed.connect(self.save)
self.params.show(
title='Wohnen: Bezugszeitraum, Maß der baulichen Nutzung, '
'Haushaltsstrukturen')
def setup_params(self, area):
'''
set the parameters according to the data of the given area
'''
self.area = area
clear_layout(self.layout)
self.params = Params(self.layout,
help_file='definitionen_gewerbe.txt')
self.params.add(Title('Bezugszeitraum'))
self.params.beginn_nutzung = Param(
area.beginn_nutzung, SpinBox(minimum=2000, maximum=2100),
label='Beginn des Bezuges', repr_format='%d'
)
self.params.aufsiedlungsdauer = Param(
area.aufsiedlungsdauer, SpinBox(minimum=1, maximum=100),
label='Dauer des Bezuges (Jahre, 1 = Bezug wird noch\n'
'im Jahr des Bezugsbeginns abgeschlossen)', unit='Jahr(e)'
)
self.params.add(Seperator(margin=10))
self.params.add(
Title('Voraussichtlicher Anteil der Branchen an der Nettofläche'))
preset_names = self.df_industry_types_base[
'Name_Gewerbegebietstyp'].values
preset_ids = self.df_industry_types_base['IDGewerbegebietstyp'].values
options = ['Gebietstyp wählen'] + list(preset_names)
self.preset_combo = ComboBox(options, [-1] + list(preset_ids))
self.preset_combo.input.model().item(0).setEnabled(False)
param = Param(0, self.preset_combo, label='Vorschlagswerte')
param.hide_in_overview = True
self.params.add(param, name='gebietstyp')
# break grid layout
self.params.add(
QSpacerItem(0, 3, QSizePolicy.Fixed, QSizePolicy.Minimum))
def values_changed():
if self.auto_check.value:
n_jobs = self.estimate_jobs()
self.ap_slider.set_value(n_jobs)
def slider_changed():
self.preset_combo.set_value(options[0])
values_changed()
def preset_changed():
self.set_industry_presets(self.preset_combo.input.currentData())
values_changed()
self.preset_combo.changed.connect(preset_changed)
dependency = SumDependency(100)
for branche in self.branchen:
feature = self.gewerbeanteile.get(
id_branche=branche.id,
id_teilflaeche=self.area.id
)
value = feature.anteil_definition if feature else 0
slider = Slider(maximum=100, width=200, lockable=True)
param = Param(
value, slider, label=f'{branche.Name_Branche_ProjektCheck}',
unit='%'
)
slider.changed.connect(slider_changed)
dependency.add(param)
self.params.add(param, name=branche.param_gewerbenutzung)
self.params.add(Seperator())
self.params.add(Title('Voraussichtliche Anzahl an Arbeitsplätzen'))
self.auto_check = Checkbox()
self.params.auto_check = Param(
bool(self.area.ap_ist_geschaetzt), self.auto_check,
label='Automatische Schätzung'
)
self.ap_slider = Slider(maximum=10000)
self.params.arbeitsplaetze_insgesamt = Param(
self.area.ap_gesamt, self.ap_slider,
label='Zahl der Arbeitsplätze\n'
'nach Vollbezug (Summe über alle Branchen)'
)
def toggle_auto_check():
# disable input for manual setting of jobs
# when auto check is enabled
read_only = self.auto_check.value
for _input in [self.ap_slider.slider, self.ap_slider.spinbox]:
_input.setAttribute(Qt.WA_TransparentForMouseEvents, read_only)
_input.setFocusPolicy(Qt.NoFocus if read_only
else Qt.StrongFocus)
_input.update()
values_changed()
self.auto_check.changed.connect(toggle_auto_check)
toggle_auto_check()
# set to default preset if assignment is new
if len(self.gewerbeanteile) == 0:
self.set_industry_presets(self.DEFAULT_INDUSTRY_ID)
ap_gesamt = self.estimate_jobs()
self.params.arbeitsplaetze_insgesamt.value = ap_gesamt
self.save()
self.params.changed.connect(self.save)
self.params.show(
title='Gewerbe: Bezugszeitraum und Maß der baulichen Nutzung')
def setup_params(self):
'''
set up migration settings for each muncipality in study area
'''
if self.params:
self.params.close()
self.ui.svb_parameter_group.setVisible(True)
layout = self.ui.svb_parameter_group.layout()
clear_layout(layout)
if len(self.wanderung) == 0:
self.ui.svb_parameter_group.setVisible(False)
return
self.ui.svb_parameter_group.setVisible(True)
self.params = Params(layout,
help_file='einnahmen_beschaeftigte_wanderung.txt')
self.df_wanderung = self.wanderung.to_pandas()
randsummen = self.project.basedata.get_table('Wanderung_Randsummen',
'Einnahmen').features()
factor_inner = randsummen.get(IDWanderungstyp=1).Anteil_Gewerbe
factor_outer = randsummen.get(IDWanderungstyp=2).Anteil_Gewerbe
factor_neu = randsummen.get(IDWanderungstyp=3).Anteil_Gewerbe
project_ags = self.project_frame.ags
project_gem = self.gemeinden.get(AGS=project_ags)
wanderung = self.wanderung.get(AGS=project_ags)
sum_ap = sum(x or 0 for x in self.areas.values('ap_gesamt'))
# ToDo: this is exactly the same as in EinwohnerMigration
def update_salden(ags_changed):
param = self.params[ags_changed]
fixed = param.is_locked
saldo = param.input.value
idx = self.df_wanderung['AGS'] == ags_changed
if fixed:
fixed_fortzug = self.df_wanderung[np.invert(idx)
& self.df_wanderung['fixed']
== True]['fortzug'].sum()
# the rest of "fortzüge" that can be applied to this row
min_value = fixed_fortzug - (sum_ap * factor_inner)
saldo = max(saldo, min_value)
zuzug = self.df_wanderung[idx]['zuzug'].values[0]
self.df_wanderung.loc[idx, 'fortzug'] = zuzug - saldo
self.df_wanderung.loc[idx, 'fixed'] = fixed
self.df_wanderung.loc[idx, 'saldo'] = saldo
self.df_wanderung = MigrationCalculation.calculate_saldi(
self.df_wanderung, factor_inner, project_ags)
for gemeinde_ags in self.df_wanderung['AGS'].values:
param = self.params[gemeinde_ags]
row = self.df_wanderung[self.df_wanderung['AGS'] ==
gemeinde_ags]
param.input.blockSignals(True)
param.input.value = row['saldo'].values[0]
param.input.blockSignals(False)
self.params.add(Title('Standortgemeinde des Projekts', bold=False))
spinbox = DoubleSpinBox(minimum=0,
maximum=1000,
step=1,
lockable=True,
locked=wanderung.fixed,
reversed_lock=True)
project_saldo = Param(wanderung.saldo,
spinbox,
repr_format='%+.2f',
label=f' - {project_gem.GEN}',
unit='SvB')
self.params.add(project_saldo, name=project_ags)
spinbox.changed.connect(lambda o: update_salden(project_ags))
spinbox.locked.connect(lambda o: update_salden(project_ags))
self.params.add(
Param(factor_neu * sum_ap,
label='davon neu geschaffene Arbeitsplätze'))
self.params.add(Seperator())
self.params.add(Title('Region um Standortgemeinde', bold=False))
for gemeinde in sorted(self.gemeinden, key=lambda x: x.GEN):
ags = gemeinde.AGS
if ags == project_ags:
continue
wanderung = self.wanderung.get(AGS=ags)
if not wanderung:
continue
spinbox = DoubleSpinBox(minimum=-1000,
maximum=0,
step=1,
lockable=True,
locked=wanderung.fixed,
reversed_lock=True)
param = Param(wanderung.saldo,
spinbox,
label=f' - {gemeinde.GEN}',
unit='SvB')
self.params.add(param, name=ags)
spinbox.changed.connect(lambda o, a=ags: update_salden(a))
spinbox.locked.connect(lambda o, a=ags: update_salden(a))
self.params.add(Seperator())
self.params.add(
Param(-factor_outer * sum_ap,
label='Restliches Bundesgebiet / Ausland',
unit='SvB'))
def save():
self.wanderung.update_pandas(self.df_wanderung)
self.canvas.refreshAllLayers()
self.params.show(title='Geschätzte Salden (Beschäftigte) bearbeiten',
scrollable=True)
self.params.changed.connect(save)
def setup_params(self, market):
'''
set up the parameters to edit the given scenario market
'''
# ToDo: that's mostly the same as in EditNullfallMarkets,
# might be merged
if self.params:
self.params.close()
layout = self.param_group.layout()
clear_layout(layout)
if not market:
self.param_group.setVisible(False)
return
self.param_group.setVisible(True)
self.params = Params(
layout, help_file='standortkonkurrenz_geplante_maerkte.txt')
self.params.name = Param(market.name,
LineEdit(width=300),
label='Name')
self.params.add(Seperator(margin=0))
# 'nicht aufgeführt' (kette 0) is first, rest alphabetical order
ketten = sorted(self.ketten,
key=lambda k: k.name.lower()
if k.name != 'nicht aufgeführt' else '')
chain_ids = [typ.id_kette for typ in ketten]
chain_labels = [kette.name for kette in ketten]
chain_combo = ComboBox(chain_labels, data=chain_ids, width=300)
value = self.ketten.get(id_kette=market.id_kette).name
self.params.kette = Param(value, chain_combo, label='Anbieter')
type_ids = [typ.id_betriebstyp for typ in self.typen]
type_labels = [self.detailed_type_label(i) for i in type_ids if i > 0]
type_combo = ComboBox(type_labels, data=type_ids, width=300)
self.params.typ = Param(self.detailed_type_label(
market.id_betriebstyp_planfall),
type_combo,
label='Neue Märkte',
value_label=market.betriebstyp_planfall)
def save():
market.name = self.params.name.value
id_bt = type_combo.get_data()
bt = self.typen.get(id_betriebstyp=id_bt).name
market.id_betriebstyp_planfall = id_bt
market.betriebstyp_planfall = bt
market.id_kette = chain_combo.get_data()
market.kette = self.ketten.get(id_kette=market.id_kette).name
vkfl = self.market_tool.betriebstyp_to_vkfl(
market.id_betriebstyp_planfall, market.id_kette)
market.vkfl_planfall = vkfl
market.save()
self.canvas.refreshAllLayers()
# lazy way to update the combo box
self.fill_combo(select=market)
self.changed.emit()
self.params.show(title='Neuen Markt im Planfall bearbeiten')
self.params.changed.connect(save)
# markets on project areas can not be deleted
if market.id_teilflaeche < 0:
last_row = self.params.layout.children()[-1]
button = QPushButton()
icon_path = 'iconset_mob/20190619_iconset_mob_delete_1.png'
icon = QIcon(
os.path.join(self.project.settings.IMAGE_PATH, icon_path))
button.setText('Markt entfernen')
button.setIcon(icon)
button.setToolTip(
'<p><span style=" font-weight:600;">Markt entfernen</span>'
'</p><p>Löscht den aktuell gewählten Markt. '
'<br/>Dieser Schritt kann nicht rückgängig gemacht '
'werden. </p>')
last_row.insertWidget(0, button)
button.clicked.connect(lambda: self.remove_market(market))
def setup_params(self, market):
'''
set up the parameters to change attributes of the given status quo
market in the scenario
'''
if self.params:
self.params.close()
layout = self.param_group.layout()
clear_layout(layout)
if not market:
self.param_group.setVisible(False)
return
self.param_group.setVisible(True)
self.params = Params(
layout, help_file='standortkonkurrenz_veraenderte_maerkte.txt')
self.params.name = Param(market.name, label='Name')
self.params.add(Seperator(margin=0))
self.params.kette = Param(market.kette, label='Anbieter')
self.params.nullfall = Param(
market.betriebstyp_nullfall,
label='Betriebstyp im Nullfall',
)
closed_label = 'Markt geschlossen'
type_ids = [typ.id_betriebstyp for typ in self.typen]
type_labels = []
for tid in type_ids:
type_labels.append(closed_label if tid ==
0 else self.detailed_type_label(tid))
type_combo = ComboBox(type_labels, data=type_ids, width=300)
typ = market.id_betriebstyp_planfall
self.params.planfall = Param(
closed_label if typ == 0 else self.detailed_type_label(typ),
type_combo,
label='Betriebstyp im Planfall',
value_label=closed_label
if typ == 0 else market.betriebstyp_planfall)
close_check = Checkbox()
self.params.gets_closed = Param(typ == 0,
close_check,
label='Markt im Planfall schließen')
self.params.gets_closed.hide_in_overview = True
def closed_toggled(checked):
if checked:
type_combo.set_value(closed_label)
close_check.changed.connect(closed_toggled)
def type_changed(value):
close_check.set_value(value == closed_label)
type_combo.changed.connect(type_changed)
def save():
id_bt = type_combo.get_data()
bt = self.typen.get(id_betriebstyp=id_bt).name
market.id_betriebstyp_planfall = id_bt
market.betriebstyp_planfall = bt
vkfl = self.market_tool.betriebstyp_to_vkfl(
market.id_betriebstyp_planfall, market.id_kette)
market.vkfl_planfall = vkfl
market.save()
self.canvas.refreshAllLayers()
# lazy way to update the combo box
self.fill_combo(select=market)
self.changed.emit()
self.params.show(title='Markt im Planfall verändern')
self.params.changed.connect(save)
