spertl
/
QGIS-IBP-Kanalplanung
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
main
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '38d8a0aec7'
${ noResults }
QGIS-IBP-Kanalplanung/upload/KanalTools.py

782 lines
38 KiB
Python
Raw Blame History

import ezdxf
import pandas as pd
import numpy as np
import networkx as nx
import math
import scipy
import sqlite3
import subprocess
TEIGHA_PATH = "C:/Daten/nc/Ingenieurbüro/20 Projekte/Kanalplanung/Teigha File Converter 4.3.2/TeighaFileConverter.exe"
"""
Funktionsweise der Kanal_Tools:
Daten mit QGIS aufbereiten
ibp_calc()
ibp_calc_netz()
ibp_calc_hydraulik()
"""
inp_file = 'D:/Daten/nc/Ingenieurbüro/20 Projekte/Kanalplanung/kanalplanung.gpkg'
md = QgsProviderRegistry.instance().providerMetadata("ogr")
gpkg_con = md.createConnection( inp_file, {})
def ibp_all():
ibp_calc()
ibp_calc_netz()
ibp_hydraulik()
## Funktion um einen globalen Layer-Filter zu setzen
def ibp_filter(filter):
#alle Layer
gpkg_con.executeSql("UPDATE projekt SET aktiv = 0;")
#for i in self.iface.mapCanvas().layers():
# idx = i.fields().indexFromName('ibpprj')
# if idx >= 0:
# i.setSubsetString("ibpprj LIKE '%"+self.act.currentText()+"%'")
text, ok = QInputDialog().getText(self, "QInputDialog().getText()","User name:", QLineEdit.Normal)
#for row in QgsProject.instance().mapLayers().values():
# #if row.name() in ["haltung", "schacht", "rw_einzugsgebiete"]:
# if re.search(r".*kanalplanung.gpkg\|layername=(haltung|schacht|rw_einzugsgebiete).*", row.source()):
# if re.search(r".*kanalplanung.gpkg\|layername=(haltung_sp)", row.source()):
# row.setSubsetString("")
# elif filter != "":
# row.setSubsetString(""""ibpprj" = '{0}'""".format(filter))
# gpkg_con.executeSql("UPDATE projekt SET aktiv = 1 WHERE nr='{}';".format(filter))
# else:
# row.setSubsetString("")
def ibp_calc():
query = """UPDATE haltung SET
zul_sch_fid = (SELECT s.fid FROM schacht s WHERE distance(geomfromgpb(s.geom),startpoint(geomfromgpb(haltung.geom))) < 0.05 LIMIT 1),
abl_sch_fid = (SELECT s.fid FROM schacht s WHERE distance(geomfromgpb(s.geom),endpoint(geomfromgpb(haltung.geom))) < 0.05 LIMIT 1);"""
res = gpkg_con.executeSql(query)
query = """UPDATE sw_fallrohre SET
(du, dn, anmerkung, kurz) = (SELECT du, dn, anmerkung, kurz FROM config_gegenstaende where config_gegenstaende.gegenstand = sw_fallrohre.gegenstand);"""
res = gpkg_con.executeSql(query)
query = """UPDATE schacht SET
(ezg_direkt_A, ezg_direkt_Aum, ezg_direkt_Aus) = (SELECT sum(rw_ezg.A), sum(rw_ezg.Aum),sum(rw_ezg.Aus) FROM rw_einzugsgebiete rw_ezg WHERE rw_ezg.schacht_fid = schacht.fid),
(sw_du_sum) = (SELECT sum(swf.du) FROM sw_fallrohre swf WHERE swf.schacht_fid = schacht.fid),
sh = IIF(sh_fix > 0, sh_fix, (SELECT min(sh) FROM (
SELECT haltung.zul_sh as sh FROM haltung WHERE haltung.zul_sch_fid = schacht.fid and haltung.zul_sh > 0
UNION
SELECT haltung.abl_sh as sh FROM haltung WHERE haltung.abl_sch_fid = schacht.fid and haltung.abl_sh > 0)));"""
res = gpkg_con.executeSql(query)
query = """UPDATE schacht SET
ezg_direkt_psi_m = ezg_direkt_Aum/ezg_direkt_A,
ezg_direkt_psi_s = ezg_direkt_Aus/ezg_direkt_A;"""
res = gpkg_con.executeSql(query)
query = """DROP TABLE IF EXISTS haltung_sp;"""
res = gpkg_con.executeSql(query)
query = """CREATE TABLE haltung_sp AS
SELECT
s1z.name, s1a.name,
s2z.name, s2a.name,
a.zul_sch_fid, a.abl_sch_fid,
b.zul_sch_fid, b.abl_sch_fid,
ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)) geometry,
AsText(ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom))) txt,
ifnull(ST_InterpolatePoint(ST_AddMeasure(geomfromgpb(a.geom),0, 1),ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)))*a.c_laenge,0) d1,
ifnull(a.zul_sh - a.c_laenge / (ST_InterpolatePoint(ST_AddMeasure(geomfromgpb(a.geom),0, 1),ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)))*a.c_laenge) * a.gefaelle / 1000,0) h1,
ifnull(ST_InterpolatePoint(ST_AddMeasure(geomfromgpb(b.geom),0, 1),ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)))*b.c_laenge,0) d2,
ifnull(b.zul_sh - b.c_laenge / (ST_InterpolatePoint(ST_AddMeasure(geomfromgpb(b.geom),0, 1),ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)))*b.c_laenge) * b.gefaelle / 1000,0) h2,
a.di di1, b.di, b.art
FROM
haltung a, haltung b
LEFT JOIN schacht s1z on a.zul_sch_fid = s1z.fid
LEFT JOIN schacht s1a on a.abl_sch_fid = s1a.fid
LEFT JOIN schacht s2z on b.zul_sch_fid = s1z.fid
LEFT JOIN schacht s2a on b.abl_sch_fid = s1z.fid
WHERE
geometry not NULL and
GeometryType(ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom))) = "POINT"
and round(d1,2) > 0 and d1 < a.c_laenge;"""
res = gpkg_con.executeSql(query)
query = """DROP TABLE IF EXISTS haltung_calc_graph;"""
res = gpkg_con.executeSql(query)
query = """CREATE TABLE haltung_calc_graph AS
WITH RECURSIVE graph(n,sn_fid,en_fid,du_sum,sw_k,Qpump,Qc, Aus, Aum) AS (
SELECT
h.fid, h.zul_sch_fid, h.abl_sch_fid,
schc.sw_du_sum, schc.sw_k, schc.Qpump, schc.Qc,
schc.ezg_direkt_Aus, schc.ezg_direkt_Aum
FROM haltung h
LEFT join schacht schc on h.zul_sch_fid = schc.fid
UNION
SELECT
n, h.zul_sch_fid, h.abl_sch_fid,
schc.sw_du_sum, schc.sw_k, schc.Qpump, schc.Qc,
schc.ezg_direkt_Aus, schc.ezg_direkt_Aum
FROM graph
LEFT JOIN haltung h on h.abl_sch_fid = graph.sn_fid
LEFT JOIN schacht schc on h.zul_sch_fid = schc.fid
)
SELECT n fid,sn_fid zul_sch_fid,en_fid abl_sch_fid,
sum(du_sum) du_sum,max(sw_k) sw_k,sum(Qpump) Qpump,sum(Qc) Qc, sum(Aus) Aus, sum(Aum) Aum
FROM graph
WHERE sn_fid IS NOT NULL and en_fid IS NOT NULL GROUP BY n;"""
res = gpkg_con.executeSql(query)
query = """UPDATE haltung SET
(du_sum, Qww, Qpump, Qc, Aus, Aum) =
(SELECT
ifnull(g.du_sum,0),
ifnull(g.sw_k*sqrt(g.du_sum),0),
ifnull(g.Qpump,0),
ifnull(g.Qc,0),
ifnull(g.Aus,0),
ifnull(g.Aum,0)
FROM haltung_calc_graph g WHERE g.fid = haltung.fid),
(sw_k, bem_regen) = (SELECT sw_k, rohr_bem_regen FROM projekt WHERE projekt.nr = haltung.ibpprj),
c_laenge = GLength(geomfromgpb(geom))
;"""
res = gpkg_con.executeSql(query)
query = """UPDATE haltung SET
Qsw = ifnull(sw_k * sqrt(du_sum)+Qpump+Qc, 0),
Qrr = ifnull(Aus*bem_regen/10000,0 ),
zul_fuellg = IIF(haltung.art = 'SW', IIF(haltung.Qpump = 0, 0.5, 0.7), IIF(haltung.art='RW',0.9,NULL) );"""
res = gpkg_con.executeSql(query)
query = """UPDATE haltung SET
Qtot = Qsw + Qrr;"""
res = gpkg_con.executeSql(query)
query = """UPDATE schacht SET
(ezg_total_Aus, ezg_total_Aum) = (SELECT sum(haltung.Aus), sum(haltung.Aum) FROM haltung WHERE haltung.abl_sch_fid = schacht.fid);"""
res = gpkg_con.executeSql(query)
## Funktion um einen Schnitt zu erstellen
# Ausgangsdaten-Tabelle: haltung, haltung_sp, schacht, sw_fallrohre
# Ergebnis-Tablle: haltung_calc_hydraulik
def ibp_schnitt(schnitte_filename, hor, fok, schnitte_masstab, schnitte, ibpprj):
mx,my = schnitte_masstab
graph = nx.DiGraph()
query = """SELECT
ifnull(zul_sch_fid,0) zul_sch_fid,
ifnull(abl_sch_fid,0) abl_sch_fid,
s1.name zul_sch,
s2.name abl_sch
FROM haltung
join schacht s1 on s1.fid = haltung.zul_sch_fid
join schacht s2 on s2.fid = haltung.abl_sch_fid
WHERE haltung.ibpprj = '{}'""".format(ibpprj)
res = gpkg_con.executeSql(query)
translate_fid = {}
for row in res:
if row[0] is not NULL and row[1] is not NULL:
graph.add_edge(row[0], row[1])
translate_fid[row[2]] = row[0]
translate_fid[row[3]] = row[1]
# ZEICHNE SCHNITT
s_doc = ezdxf.readfile("C:/tmp/schnitte_temp.dxf") # Vorlagendatei
s_msp = s_doc.modelspace()
pos = {}
for schn in schnitte:
[source_nam, target_nam, basis] = schn
source = translate_fid[source_nam]
target = translate_fid[target_nam]
[bx,by] = basis
if bx == 0:
pos[by] = 0
elif bx < 10:
bx = pos[by]
print("Von: ",source_nam," Nach: ",target_nam,)
path = nx.shortest_path(graph, source=source, target=target)
print(path)
###########################################
# Lade Leitungen und Querungen für den aktuellen Schnitt
###########################################
ltg = []
quer = []
for i in range(len(path)-1):
query = """SELECT
ifnull(c_laenge,0) c_laenge,
ifnull(zul_sh,0) zul_sh,
ifnull(abl_sh,0) abl_sh,
mat,
ifnull(di,0) di,
ifnull(gefaelle,0) gefaelle,
art
FROM haltung WHERE zul_sch_fid='{}' and abl_sch_fid='{}'""".format(path[i],path[i+1])
res = gpkg_con.executeSql(query)
ltg.append({'dist': res[0][0],
'sh_a': res[0][1],
'sh_e': res[0][2],
'mat_dim': res[0][3],
'di': res[0][4],
'gef': res[0][5],
'art': res[0][6],
'zu': path[i],
'ab': path[i+1]})
query = "SELECT d1, di, h2, art FROM haltung_sp WHERE zul_sch_fid='{}' and abl_sch_fid='{}'".format(path[i],path[i+1])
res = gpkg_con.executeSql(query)
for j in res:
print(j)
quer.append({'dist': float(j[0]),
'dn': j[1],
'sh': float(j[2]),
'art': j[3],
'zu1': path[i],
'ab1': path[i+1]})
###########################################
# Lade Punkte für den aktellen Schnitt
###########################################
#ws = wb.sheets['Punkte']
pkt = []
for i in range(len(path)):
query = "SELECT name, dh, sh, symbol, schacht_dn, art FROM schacht WHERE fid='{}'".format(path[i])
res = gpkg_con.executeSql(query)
res[0] = [0 if x == NULL else x for x in res[0]]
pkt.append({'name': res[0][0],
'dh': res[0][1],
'sh': res[0][2],
'symb': res[0][3],
'dn': res[0][4],
'art': res[0][5],
'fid': path[i]})
###########################################
# Lade die Fallrohre für den aktuellen Schnitt
###########################################
fr_dat = []
fr_dat = pd.DataFrame()
# Wähle die Fallrohre, die für den aktuellen Schnitt notwendig sind aus
for i in range(len(path)):
query = "SELECT swf.schacht_fid, swf.kurz, swf.geschoss FROM sw_fallrohre swf WHERE swf.schacht_fid='{}'".format(path[i])
res = gpkg_con.executeSql(query)
for i in res:
print(i)
# ALTE VERSION
#fr_dat = fr_dat.append({'schacht_fid': i[0],
# 'objekt': i[1],
# 'geschoss': i[2]
# }, ignore_index=True)
new_row = [{'schacht_fid': i[0], 'objekt': i[1], 'geschoss': i[2]}]
fr_dat = pd.concat([fr_dat, pd.DataFrame(new_row)], ignore_index=True)
if len(fr_dat) > 0:
# y-Verschiebung nach oben pro Geschoss (benötigt) - Werte 1 bis Anzahl der Geschosse
df3 = pd.DataFrame()
query = "SELECT swf.geschoss FROM sw_fallrohre swf JOIN schacht s ON swf.schacht_fid = s.fid WHERE s.ibpprj='{}'".format(ibpprj)
res = gpkg_con.executeSql(query)
for i in res:
# ALTE VERSION
# df3 = df3.append({'geschoss': i[0]}, ignore_index=True)
new_row = [{'geschoss': i[0]}]
df3 = pd.concat([df3, pd.DataFrame(new_row)], ignore_index=True)
#for r in range(8,200):
# df3 = df3.append({'geschoss': ws.range((r,6)).value}, ignore_index=True)
# x-Verschiebung nach rechts (nicht benötigt, da durch Fallrohrposition vorgegeben)
fr_dat['x'] = 0
df3 = df3[['geschoss']].drop_duplicates().dropna()
df3['y'] = df3['geschoss'].astype(str).str[:2].astype(int)-10
fr_dat = fr_dat.merge(df3, on='geschoss', how='left')
# Symbole je Fallrohr ordnen
conditions = [(fr_dat['objekt'] == 'BW'),(fr_dat['objekt'] == 'DU'),
(fr_dat['objekt'] == 'WB'),(fr_dat['objekt'] == 'WC'),
(fr_dat['objekt'] == 'GM'),(fr_dat['objekt'] == 'SP'),(fr_dat['objekt'] == 'WM')]
choices = list(range(7,0,-1))
fr_dat['order'] = np.select(conditions, choices, default=0)
# Symbol-Nummer und maximale Symbolanzahl je Zeile ermitteln
fr_dat['elem_nr'] = fr_dat.sort_values("order").groupby(['geschoss','schacht_fid']).cumcount()+1
fr_dat['elem_nr_max'] = fr_dat.groupby(['geschoss','schacht_fid'])['geschoss'].transform('size')
# Breite je Symbol zuweisen
choices = [11,5,4,4,4,4,4] #alte Breiten
choices = [i/4 for i in choices]
fr_dat['width'] = np.select(conditions, choices, default=0)
# Breiten aufsummieren
fr_dat['width_csum'] = fr_dat.sort_values("order").groupby(['geschoss','schacht_fid'])['width'].cumsum()-fr_dat['width']
fr_dat['x1'] = fr_dat.x-fr_dat.width_csum
fr_dat['y1'] = 5*mx + fr_dat.y*20*mx
#5 = Basisabstand von FOK // 20 = Geschosshöhe jeweils in mm
fr_dat['symbol'] = "IBP_EW_"+fr_dat['objekt']+"_SCHN"
###########################################
# zeichne den Schnitt
###########################################
# Angaben in Millimeter
band = {}
band['hoehe'] = 8*mx
band['titel_breite'] = 70*mx
# Einheit = Millimeter * mx
# my nur für Höhenanpassung oberhalb des Horizontes notwendig!!
titelfelder = ['Station', 'Geländehöhe', 'Schachtsohle', 'Leitungsohle', 'Deckelhöhe', 'Länge', 'Gefälle', 'Material / DN', 'Punkt']
titelfelder_einhei = ['m', 'mNN','mNN','mNN','mNN','m','%.','','']
x_hor = bx+band['titel_breite'] # Starpunkt Zeichnung
y_hor = by+len(titelfelder)*band['hoehe'] #OK Bänder
###########################################
# Titelfelder Bänder
###########################################
titelfelder_line_dxfatt = {'layer': "##IBP_Schnitt_Fett"}
titelfelder_text_dxfatt = {'style': 'IBP_Norm', 'height': 5.0*mx, 'layer': "##IBP_Schnitt_Text_50", 'width': 0.7}
s_msp.add_line((bx,by), (bx+band['titel_breite'], by+0), dxfattribs=titelfelder_line_dxfatt)
for i, v in enumerate(titelfelder, 1):
s_msp.add_line((bx+0, by+i*band['hoehe']), (bx+band['titel_breite'], by+i*band['hoehe']), dxfattribs=titelfelder_line_dxfatt)
y_txt = (i)*band['hoehe']-band['hoehe']/2
s_msp.add_text(v+":", dxfattribs=titelfelder_text_dxfatt).set_pos((bx+5*mx, by+y_txt), align='MIDDLE_LEFT')
if titelfelder_einhei[i-1] != '':
s_msp.add_text("["+titelfelder_einhei[i-1]+"]", dxfattribs=titelfelder_text_dxfatt).set_pos((bx+band['titel_breite']-15*mx, by+y_txt), align='MIDDLE_RIGHT')
s_msp.add_line((bx, by), (bx, by+i*band['hoehe']), dxfattribs=titelfelder_line_dxfatt)
s_msp.add_line((bx+band['titel_breite']-10*mx, by), (bx+band['titel_breite']-10*mx, by+i*band['hoehe']), dxfattribs=titelfelder_line_dxfatt)
s_msp.add_text("Horizont: {:.2f}mNN".format(hor), dxfattribs=titelfelder_text_dxfatt
).set_pos((bx+band['titel_breite']-10*mx, y_hor), align='BOTTOM_RIGHT')
###########################################
# Inhalte Bänder
###########################################
# Bänder anlegen:
laeng = 0
laen = [0]
band_beschr_dxfattrib = {'style': 'IBP_Norm', 'height': 2.5*mx, 'layer': "##IBP_Schnitt_Text_25", 'width': 0.7}
band_beschr90_dxfattrib = {'style': 'IBP_Norm', 'height': 2.0*mx, 'layer': "##IBP_Schnitt_Text_20", 'width': 0.7, 'rotation': 90}
band_schnr_dxfattrib = {'style': 'IBP_Norm', 'height': 3.5*mx, 'layer': "##IBP_Schnitt_Text_35", 'width': 0.7}
band_linie_fein_dxfattrib = {'layer': "##IBP_Schnitt_Fein"}
band_linie_fett_dxfattrib = {'layer': "##IBP_Schnitt_Fett"}
# Leitungsdaten:
# Vertikale Linie an der Basis
s_msp.add_line((x_hor,by),(x_hor,y_hor), dxfattribs=band_linie_fein_dxfattrib)
for i in ltg:
xp = x_hor+laeng+i['dist']/2
# Schreibe Länge in Band
zl = 6 # Zeilennummer
s_msp.add_text("{:.2f}".format(i['dist']), dxfattribs=band_beschr_dxfattrib).set_pos((xp, by+(zl-.5)*band['hoehe']), align='MIDDLE_CENTER')
# Schreibe Gef in Band
zl = 7 # Zeilennummer
s_msp.add_text("{:.2f}".format(i['gef']), dxfattribs=band_beschr_dxfattrib).set_pos((xp, by+(zl-.5)*band['hoehe']), align='MIDDLE_CENTER')
# Schreibe Material / Dim in Band
zl = 8 # Zeilennummer
s_msp.add_text(i['mat_dim'], dxfattribs=band_beschr_dxfattrib).set_pos((xp, by+(zl-.5)*band['hoehe']), align='MIDDLE_CENTER')
laeng = laeng + i['dist']
laen.append(laeng)
s_msp.add_line((x_hor+laeng,by),(x_hor+laeng,y_hor), dxfattribs=band_linie_fein_dxfattrib)
# Schreibe Sohlhöhen in Band
zl = 4 # Zeilennummer
s_msp.add_text("{:.2f}".format(i['sh_a']), dxfattribs=band_beschr90_dxfattrib).set_pos((x_hor+laeng-i['dist']+1*mx, by+(zl-0.9)*band['hoehe']), align='TOP_LEFT')
s_msp.add_text("{:.2f}".format(i['sh_e']), dxfattribs=band_beschr90_dxfattrib).set_pos((x_hor+laeng-1*mx, by+(zl-0.9)*band['hoehe']), align='BOTTOM_LEFT')
# Horizontale Einfassungen der Bänder
s_msp.add_line((x_hor, by), (x_hor+laeng+20*mx, by), dxfattribs=band_linie_fett_dxfattrib)
for i, v in enumerate(titelfelder, 1):
s_msp.add_line((x_hor, by+i*band['hoehe']), (x_hor+laeng+20*mx, by+i*band['hoehe']), dxfattribs=band_linie_fett_dxfattrib)
# Vertikale Einfassung der Bänder hinten
s_msp.add_line((x_hor+laeng+20*mx, by), (x_hor+laeng+20*mx, by+i*band['hoehe']), dxfattribs=band_linie_fett_dxfattrib)
# Punktdaten
for i, j in enumerate(pkt):
# Schreibe Name in Band
zl = 9 # Zeilennummer
s_msp.add_text(j['name'], dxfattribs=band_schnr_dxfattrib
).set_pos((x_hor+laen[i]+1*mx, by+(zl-.5)*band['hoehe']), align='MIDDLE_LEFT')
# Schreibe DH in Band
zl = 5 # Zeilennummer
s_msp.add_text("{:.2f}".format(j['dh']), dxfattribs=band_beschr90_dxfattrib
).set_pos((x_hor+laen[i]+1*mx, by+(zl-.9)*band['hoehe']), align='TOP_LEFT')
# Schreibe SH in Band
zl = 3 # Zeilennummer
s_msp.add_text("{:.2f}".format(j['sh']), dxfattribs=band_beschr90_dxfattrib
).set_pos((x_hor+laen[i]+1*mx, by+(zl-.9)*band['hoehe']), align='TOP_LEFT')
# Schreibe Station in Band
zl = 1 # Zeilennummer
s_msp.add_text("{:.2f}".format(laen[i]), dxfattribs=band_beschr90_dxfattrib
).set_pos((x_hor+laen[i]+1*mx, by+(zl-.9)*band['hoehe']), align='TOP_LEFT')
pos[by] = x_hor+laeng+20*mx+20*mx
###########################################
# Zeichne Schnitt-Grafik
###########################################
ueho = mx/my # Überhöhungsfaktor
graf_linie_ltg = {}
graf_linie_ltg['SW'] = {'layer': "##IBP_Schnitt_Leitung_SW"}
graf_linie_ltg['RW'] = {'layer': "##IBP_Schnitt_Leitung_RW"}
graf_linie_ltg['MW'] = {'layer': "##IBP_Schnitt_Leitung_MW"}
graf_linie_ltg['Bestand SW'] = {'layer': "##IBP_Schnitt_Leitung_Best_SW"}
graf_linie_ltg['Bestand RW'] = {'layer': "##IBP_Schnitt_Leitung_Best_RW"}
graf_linie_ltg['Bestand MW'] = {'layer': "##IBP_Schnitt_Leitung_Best_MW"}
graf_linie_schacht = {'layer': "##IBP_Schnitt_Schacht"}
graf_linie_geb = {'layer': "##IBP_Schnitt_Gebaeude"}
graf_symb_ew = {'xscale': 1, 'yscale': 1, 'rotation': 0, 'layer': 'KANAL-SW_Planung_Schnitt_Sym'}
# zeichne Leitungen
for i,j in enumerate(ltg):
s_msp.add_line( (x_hor+laen[i], y_hor+(j['sh_a']-hor)*ueho),
(x_hor+laen[i+1], y_hor+(j['sh_e']-hor)*ueho),
dxfattribs=graf_linie_ltg[j['art']])
s_msp.add_line(( x_hor+laen[i], y_hor+(j['sh_a']-hor+j['di']/1000)*ueho), (x_hor+laen[i+1],y_hor+(j['sh_e']-hor+j['di']/1000)*ueho),
dxfattribs=graf_linie_ltg[j['art']])
print(quer)
for k in quer:
if j['zu'] == k['zu1'] and j['ab'] == k['ab1']:
s_msp.add_circle((x_hor+laen[i]+k['dist'], y_hor+(k['sh']-hor+k['dn']/2/1000)*ueho), #@ToDo bei Überhöhung eigentlich Ellipse!!!!
k['dn']/2/1000, dxfattribs=graf_linie_ltg[k['art']])
#s_msp.add_ellipse
# Zeichne Punkte
for i,j in enumerate(pkt):
x_a = x_hor+laen[i] #Aktuelle X-Position
#vertikale Linie
s_msp.add_line((x_a, y_hor),(x_a,y_hor+(max(j['dh'],j['sh'])-hor)*ueho),
dxfattribs=band_linie_fein_dxfattrib)
sh_e = ltg[i-1]['sh_a'] if i > 0 else j['sh']
dh = j['dh'] if j['dh'] > 0 else j['sh']
s_msp.add_line((x_a-j['dn']/2/1000, y_hor+(min(dh,j['sh'])-hor)*ueho),
(x_a-j['dn']/2/1000, y_hor+((max(dh,j['sh'],sh_e)-hor)*ueho)),
dxfattribs=graf_linie_schacht)
s_msp.add_line((x_a+j['dn']/2/1000, y_hor+(min(dh,j['sh'])-hor)*ueho),
(x_a+j['dn']/2/1000, y_hor+(max(dh,j['sh'],sh_e)-hor)*ueho),
dxfattribs=graf_linie_schacht)
s_msp.add_line((x_a-j['dn']/2/1000, y_hor+(min(dh,j['sh'])-hor)*ueho),
(x_a+j['dn']/2/1000, y_hor+(min(dh,j['sh'])-hor)*ueho),
dxfattribs=graf_linie_schacht)
s_msp.add_line((x_a-j['dn']/2/1000, y_hor+(max(dh,j['sh'],sh_e)-hor)*ueho),
(x_a+j['dn']/2/1000, y_hor+(max(dh,j['sh'],sh_e)-hor)*ueho),
dxfattribs=graf_linie_schacht)
# Wenn Fallrohr dann EW-Gegenstände zeichnen
if j['symb'] == "Fallrohr":
abst = 2.5*mx*ueho #45° gewinkelte Linie
#Zeichne Fallrohre:
xp = x_a-j['dn']/2/1000
yp = y_hor+(j['sh']-hor)*ueho
points = [(xp,yp),(xp-abst,yp+abst),(xp-abst,yp+50*mx*ueho)]
s_msp.add_lwpolyline(points, dxfattribs=graf_linie_ltg[j["art"]])
xp = x_a+j['dn']/2/1000
points = [(xp,yp),(xp-abst,yp+abst),(xp-abst,yp+50*mx*ueho)]
s_msp.add_lwpolyline(points, dxfattribs=graf_linie_ltg[j["art"]])
#Zeichne Gegenstände mit Leitung
for index, row in fr_dat.iterrows():
xp = x_a + row['x1'] - abst - 8*mx #8*mx = Abstand von der Fallleitung
yp = y_hor + (fok-hor + row['y1'])*ueho
if row['schacht_fid'] == j['fid']:
s_msp.add_blockref(row['symbol'], [xp,yp], dxfattribs=graf_symb_ew)
#Leitung horizontal und Geschosslinie
if(row['elem_nr'] == row['elem_nr_max']):
# Leitung
x2 = x_a + row['x'] - 2*abst # Abzgl. 2x 45° Schräge
points = [(xp,yp), (x2,yp), (x2+abst,yp-abst)]
s_msp.add_lwpolyline(points, dxfattribs=graf_linie_ltg["SW"])
# Gebäudelinie
yp = y_hor + ((fok-hor)*10*my + 20*row['y']*mx)*ueho
s_msp.add_line((xp-5*abst,yp),(x2+5*abst,yp), dxfattribs=graf_linie_geb)
###########################################
# Layout-Rahmen
###########################################
s_msp.add_line( (bx-10*mx ,by-10*mx), (pos[by]-10*mx ,by-10*mx),
dxfattribs={'layer': "##IBP_nicht_drucken"})
s_doc.saveas(schnitte_filename)
ibp_dxf_to_dwg(schnitte_filename.split("/")[-1],schnitte_filename.replace(schnitte_filename.split("/")[-1],""))
#ibp_dxf_to_dwg(schnitte_filename.split("/")[-1])
def reduce_list(input_list: list) -> list:
"""
Entfernung der Teilstücke welche in den vorangegangenen Pfaden schon beeinhaltet sind
:param input_list: Liste mit Listen welche alle Pfade beinhaltet
:return: Reduzierte Liste, Teilstücke wurden entfernt
"""
output_list = []
seen_values = set()
for group in sorted(input_list,key=len)[::-1]:
if not set(group).issubset(seen_values):
output_list.append(group)
seen_values.update(group)
return output_list
def ibp_calc_netz():
#-- Bestimme Schachtanschlüsse und Länge
gpkg_con.executeSql("""UPDATE haltung SET
zul_sch_fid = (SELECT fid FROM schacht s WHERE distance(geomfromgpb(s.geom), startpoint(geomfromgpb(haltung.geom))) < 0.1 LIMIT 1),
abl_sch_fid = (SELECT fid FROM schacht s WHERE distance(geomfromgpb(s.geom), endpoint(geomfromgpb(haltung.geom))) < 0.1 LIMIT 1);""")
#-- Reset zu Beginn
gpkg_con.executeSql("UPDATE schacht SET sh = 0;")
gpkg_con.executeSql("UPDATE haltung SET zul_sh = 0, abl_sh = 0, c_laenge = ST_Length(geomfromgpb(geom)), gefaelle = gefaelle_vorg;")
#-- Setze fixierte Sohlhöhen
gpkg_con.executeSql("UPDATE schacht SET sh = sh_fix WHERE sh_fix > 0;")
#-- Setze fixierte Schachthöhen auf Haltungen
gpkg_con.executeSql("""UPDATE haltung SET
zul_sh = (SELECT sh_fix FROM schacht WHERE schacht.fid = haltung.zul_sch_fid)
WHERE haltung.zul_sch_fid IN (SELECT schacht.fid FROM schacht WHERE schacht.sh_fix > 0);""")
gpkg_con.executeSql("""UPDATE haltung SET
abl_sh = (SELECT sh_fix FROM schacht WHERE schacht.fid = haltung.abl_sch_fid)
WHERE haltung.abl_sch_fid in (SELECT schacht.fid FROM schacht WHERE schacht.sh_fix > 0);""")
gpkg_con.executeSql("UPDATE haltung SET zul_sh = zul_sh_fix WHERE zul_sh_fix > 0;")
gpkg_con.executeSql("UPDATE haltung SET abl_sh = abl_sh_fix WHERE abl_sh_fix > 0;")
graph = nx.DiGraph()
cols = ["zul_sch_fid", "abl_sch_fid"]
query = "SELECT "+",".join(cols)+" FROM haltung"
res = gpkg_con.executeSql(query)
dat = [dict(zip(cols, row)) for row in res]
#print(dat)
for row in dat:
graph.add_edge(row["zul_sch_fid"], row["abl_sch_fid"])
cols = ["schacht_bezug", "zul_sch_fid", "abl_sch_fid"]
query = "SELECT "+",".join(cols)+" FROM haltung WHERE (schacht_bezug > 0) and (zul_sh = 0 or abl_sh = 0 or zul_sh is null or abl_sh is null) ORDER BY schacht_bezug"
res = gpkg_con.executeSql(query)
dat = [dict(zip(cols, row)) for row in res]
#print(dat)
"""
Nachfolgender Code ist ggf. in eine Schleife zu packen,
Wenn eine Abhängigkeit sich erst löst wenn andere Berechnungen fertig gestellt sind.
Ggf. muss auch die initial-Abfrage noch leicht modifiziert werden
"""
paths = []
for i in dat:
source_fid = i['schacht_bezug']
target_fid = i['zul_sch_fid']
#print(source_fid, target_fid)
try:
path = nx.shortest_path(graph, source=source_fid, target=target_fid)
path.append(i['abl_sch_fid'])
path.insert(0,1)
#print("oben", path, source_fid, target_fid)
paths.append(path)
except nx.NetworkXNoPath:
try:
path = nx.shortest_path(graph, source=target_fid, target=source_fid)
path = path[::-1]
path.insert(0,-1)
#print("unten", path, source_fid, target_fid)
paths.append(path)
except nx.NetworkXNoPath:
print("no path", source_fid, target_fid)
except:
print("error", source_fid, target_fid, i)
break
cnt = 0
cnt_query = "SELECT COUNT(*) FROM haltung WHERE abl_sh = 0 or zul_sh = 0"
while cnt != gpkg_con.executeSql(cnt_query)[0][0]:
cnt = gpkg_con.executeSql(cnt_query)[0][0]
for path in paths:
direction = path[0]
path = path[1:]
## von Oben nach unten:
if direction == 1:
for i in range(len(path)-1):
query = """UPDATE haltung SET
abl_sh = zul_sh-gefaelle/1000*c_laenge
WHERE zul_sch_fid={0} and abl_sch_fid={1} and zul_sh > 0;""".format(path[i],path[i+1])
res = gpkg_con.executeSql(query)
if i < len(path)-2: ## ggf. anpassen
query = """UPDATE haltung SET
zul_sh = (SELECT abl_sh FROM haltung WHERE zul_sch_fid={0} and abl_sch_fid={1} and abl_sh > 0)
WHERE zul_sch_fid ={1} and abl_sch_fid = {2};""".format(path[i],path[i+1],path[i+2])
#print(query)
res = gpkg_con.executeSql(query)
## von unten nach oben:
elif direction == -1:
for i in range(len(path)-1):
query = """UPDATE haltung SET
zul_sh = abl_sh+gefaelle/1000*c_laenge
WHERE abl_sch_fid={0} and zul_sch_fid={1} and abl_sh > 0;""".format(path[i],path[i+1])
res = gpkg_con.executeSql(query)
#if path[i] == 198 and path[i+1] == 184:
# print(query)
if i < len(path)-2: ## ggf. anpassen
query = """UPDATE haltung SET
abl_sh = (SELECT zul_sh FROM haltung WHERE abl_sch_fid={0} and zul_sch_fid={1} and zul_sh > 0)
WHERE abl_sch_fid ={1} and zul_sch_fid = {2};""".format(path[i],path[i+1],path[i+2])
res = gpkg_con.executeSql(query)
gpkg_con.executeSql("""UPDATE haltung SET
zul_sh = (SELECT sh+stichmas FROM schacht WHERE schacht.fid = haltung.zul_sch_fid)
WHERE
haltung.zul_sh = 0 or haltung.zul_sh IS NULL;""")
gpkg_con.executeSql("""UPDATE haltung SET
abl_sh = (SELECT sh+stichmas FROM schacht WHERE schacht.fid = haltung.abl_sch_fid)
WHERE
haltung.abl_sh = 0 or haltung.abl_sh IS NULL;""")
gpkg_con.executeSql("""UPDATE schacht SET
sh = IIF(sh_fix > 0, sh_fix, (SELECT min(ber_sh) FROM
(
SELECT abl_sh ber_sh FROM haltung WHERE abl_sch_fid = schacht.fid and abl_sh > 0
UNION
SELECT zul_sh ber_sh FROM haltung WHERE zul_sch_fid = schacht.fid and zul_sh > 0
) WHERE ber_sh > 0)-stichmas);""")
gpkg_con.executeSql("""UPDATE haltung SET
gefaelle = (zul_sh - abl_sh)/c_laenge*1000 WHERE zul_sh > 0 and abl_sh > 0""")
gpkg_con.executeSql("""UPDATE haltung SET
gefaelle = NULL WHERE zul_sh = 0 or abl_sh = 0 or zul_sh is null or abl_sh is null""")
################################################################################################################################################
################################################################################################################################################
# Berechnet die Hydraulik der Leitungen
# Ausgangsdaten-Tabelle: haltung
# Ergebnis-Tablle: haltung_calc_hydraulik
def ibp_hydraulik(ibpprj = ""):
con = sqlite3.connect(inp_file)
query = "PRAGMA table_info(haltung)"
col = gpkg_con.executeSql(query)
coln = []
for i in col:
coln.append(i[1])
coln = ['fid','di','gefaelle','Qtot','ibpprj']
query = 'SELECT '+",".join(coln)+' FROM haltung WHERE 0<'+" and 0 < ".join(coln)+' '
#query = 'SELECT '+",".join(coln)+' FROM haltung WHERE ibpprj = "{0}"'.format(ibpprj)
res = gpkg_con.executeSql(query)
df = pd.DataFrame(res, columns = coln)
df['Av']=(df['di']/1000)**2/4*np.pi
nu = 0.00000131
g = 9.81
kb = 0.50
df = df.dropna()
df['vv'] = -2*np.log10(2.51*nu/(4*df['di']/4000*np.sqrt(8*g*df['di']/4000*df['gefaelle']/1000))+kb/(1000*(14.84*df['di']/4000)))*np.sqrt(8*g*df['di']/4000*df['gefaelle']/1000)
df['Qv'] = df['Av']*df['vv']*1000
df['ausl'] = df['Qtot']/df['Qv']
def ber_ht(df,ht):
di_m = df['di']/1000
r_m = di_m/2
nu = 0.00000131
g = 9.81
kb = 0.50
#Kreissegment:
# Quelle Wikipedia: https://de.wikipedia.org/wiki/Kreissegment
# At = r_m**2*np.arccos(1-ht/r_m)-(r_m-ht)*np.sqrt(2*r_m*ht-ht**2)
At = (df['di']/1000)**2/8*((4*np.arcsin(np.emath.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.emath.sqrt(ht/(df['di']/1000))))))
#Iu = 0.5*di_m*(4*np.arcsin(np.sqrt(ht/di_m)))
Iu = 0.5*df['di']/1000*(4*np.arcsin(np.emath.sqrt(ht/(df['di']/1000))))
#Iu = Iu.fillna(0)
rhy = At/Iu
#vt = -2*np.log10(2.51*nu/(4*rhy*np.sqrt(8*g*rhy*df['gefaelle']/1000))+kb/(1000*14.84*rhy))*np.sqrt(8*g*rhy*df['gefaelle']/1000)
vt = -2*np.log10(2.51*nu/(4*rhy*np.emath.sqrt(8*g*rhy*df['gefaelle']/1000))+kb/(1000*(14.84*rhy)))*np.emath.sqrt(8*g*rhy*df['gefaelle']/1000)
#vt = vt.fillna(0)
Qt=At*vt*1000
return Qt
df['ht'] = np.ones(len(df['ausl']))
#func = lambda ht : df['Qtot'] - (((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))*(-2*np.log10(2.51*nu/(4*(((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))/(0.5*df['di']/1000*(4*np.arcsin(np.sqrt(ht/(df['di']/1000))))))*np.sqrt(8*g*(((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))/(0.5*df['di']/1000*(4*np.arcsin(np.sqrt(ht/(df['di']/1000))))))*df['gefaelle']/1000))+kb/(1000*(14.84*(((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))/(0.5*df['di']/1000*(4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))))*np.sqrt(8*g*(((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))/(0.5*df['di']/1000*(4*np.arcsin(np.sqrt(ht/(df['di']/1000))))))*df['gefaelle']/1000))*1000)
for index, row in df.iterrows():
if row['Qtot'] < 0.01:
df['ht'][index] = 0
else:
func = lambda ht : row['Qtot'] - ber_ht(row,ht)
erg = scipy.optimize.fsolve(func, 0.001, full_output=True)
if erg[2] > 1:
erg = scipy.optimize.fsolve(func, 0.01, full_output=True)
if erg[2] > 1:
print(index, " ", row['fid'], " ", erg)
df['ht'][index] = erg[0]
#df['ht'] = scipy.optimize.fsolve(func, np.ones(len(df['ausl']))*0.1)
df['h/d'] = df['ht']/df['di']*1000
df['At'] = (df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(df['ht']/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(df['ht']/(df['di']/1000))))))
df['Iu'] = 0.5*df['di']/1000*(4*np.arcsin(np.sqrt(df['ht']/(df['di']/1000))))
df['rhy'] = df['At']/df['Iu']
df['vt'] = -2*np.log10(2.51*nu/(4*df['rhy']*np.sqrt(8*g*df['rhy']*df['gefaelle']/1000))+kb/(1000*(14.84*df['rhy'])))*np.sqrt(8*g*df['rhy']*df['gefaelle']/1000)
df['Qt'] = df['At']*df['vt']*1000
df['tau'] = 1000*g*df['rhy']*df['gefaelle']/1000
df.to_sql('haltung_calc_hydraulik',con,if_exists='replace')
Reference in New Issue View Git Blame Copy Permalink