OrgTJWater/TJWaterServer
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Accept Merge Request #238: (region -> master)

Browse Source 
Merge Request: Support DMA

Created By: @王琼钰
Accepted By: @王琼钰
URL: https://tjwater.coding.net/p/tjwatercloud/d/TJWaterServer/git/merge/238?initial=true
This commit is contained in:
王琼钰
2023-05-14 13:21:28 +08:00
parent 4b72a4855d 58fd285d25
commit b00c870a89
24 changed files with 794 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
api/__init__.py
View File

@@ -142,11 +142,16 @@ from .s32_region_util import get_nodes_in_boundary, get_nodes_in_region, calcula
from .s32_region import get_region_schema, get_region, set_region, add_region, delete_region
from .s32_water_distribution import calculate_demand_to_nodes, calculate_demand_to_region
from .s33_dma_cal import PARTITION_TYPE_RB, PARTITION_TYPE_KWAY
from .s33_dma_cal import calculate_district_metering_area_for_nodes, calculate_district_metering_area_for_region, calculate_district_metering_area_for_network
from .s33_district_metering_area import PARTITION_TYPE_RB, PARTITION_TYPE_KWAY
from .s33_district_metering_area import calculate_district_metering_area
from .s33_dma import get_district_metering_area_schema, get_district_metering_area, set_district_metering_area, add_district_metering_area, delete_district_metering_area
from .s33_dma import get_all_district_metering_area_ids, get_all_district_metering_areas
from .s34_service_area import calculate_service_area
from .s33_dma_gen import generate_district_metering_area, generate_sub_district_metering_area
from .s35_virtual_district import calculate_virtual_district
from .s34_sa import calculate_service_area
from .s35_vd import calculate_virtual_district
from .s36_wda_cal import calculate_demand_to_nodes, calculate_demand_to_region, calculate_demand_to_network

14
api/batch_exe.py
View File

@@ -30,6 +30,8 @@ from .s27_backdrop import set_backdrop
from .s29_scada_device import set_scada_device, add_scada_device, delete_scada_device
from .s30_scada_device_data import set_scada_device_data, add_scada_device_data, delete_scada_device_data
from .s31_scada_element import set_scada_element, add_scada_element, delete_scada_element
from .s32_region import set_region, add_region, delete_region
from .s33_dma import set_district_metering_area, add_district_metering_area, delete_district_metering_area
from .batch_api_cs import rewrite_batch_api
@@ -106,6 +108,10 @@ def _execute_add_command(name: str, cs: ChangeSet) -> ChangeSet:
return add_scada_device_data(name, cs)
elif type == s31_scada_element:
return add_scada_element(name, cs)
elif type == s32_region:
return add_region(name, cs)
elif type == s33_dma:
return add_district_metering_area(name, cs)
return ChangeSet()
@@ -185,6 +191,10 @@ def _execute_update_command(name: str, cs: ChangeSet) -> ChangeSet:
return set_scada_device_data(name, cs)
elif type == s31_scada_element:
return set_scada_element(name, cs)
elif type == s32_region:
return set_region(name, cs)
elif type == s33_dma:
return set_district_metering_area(name, cs)
return ChangeSet()
@@ -262,6 +272,10 @@ def _execute_delete_command(name: str, cs: ChangeSet) -> ChangeSet:
return delete_scada_device_data(name, cs)
elif type == s31_scada_element:
return delete_scada_element(name, cs)
elif type == s32_region:
return delete_region(name, cs)
elif type == s33_dma:
return delete_district_metering_area(name, cs)
return ChangeSet()

230
api/s33_dma.py Normal file
View File

@@ -0,0 +1,230 @@
from .database import *
from .s0_base import is_node
from .s32_region_util import to_postgis_polygon
from .s32_region import get_region
def get_district_metering_area_schema(name: str) -> dict[str, dict[str, Any]]:
return { 'id' : {'type': 'str' , 'optional': False , 'readonly': True },
'boundary' : {'type': 'tuple_list' , 'optional': False , 'readonly': False },
'parent' : {'type': 'str' , 'optional': True , 'readonly': False },
'level' : {'type': 'str' , 'optional': False , 'readonly': True } }
def get_district_metering_area(name: str, id: str) -> dict[str, Any]:
dma = get_region(name, id)
if dma == {}:
return {}
r = try_read(name, f"select * from region_dma where id = '{id}'")
if r == None:
return {}
dma['parent'] = r['parent']
dma['nodes'] = list(eval(r['nodes']))
dma['level'] = 1
if dma['parent'] != None:
parent = dma['parent']
while parent != None:
parent = read(name, f"select parent from region_dma where id = '{parent}'")['parent']
dma['level'] += 1
return dma
# no update for nodes
def _set_district_metering_area(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
new_boundary = cs.operations[0]['boundary']
old_boundary = get_region(name, id)['boundary']
new_parent = cs.operations[0]['parent']
f_new_parent = f"'{new_parent}'" if new_parent != None else 'null'
new_nodes = cs.operations[0]['nodes']
str_new_nodes = str(new_nodes).replace("'", "''")
old = get_district_metering_area(name, id)
old_parent = old['parent']
f_old_parent = f"'{old_parent}'" if old_parent != None else 'null'
old_nodes = old['nodes']
str_old_nodes = str(old_nodes).replace("'", "''")
redo_sql = f"update region set boundary = st_geomfromtext('{to_postgis_polygon(new_boundary)}') where id = '{id}';"
redo_sql += f"update region_dma set parent = {f_new_parent}, nodes = '{str_new_nodes}' where id = '{id}';"
undo_sql = f"update region_dma set parent = {f_old_parent}, nodes = '{str_old_nodes}' where id = '{id}';"
undo_sql += f"update region set boundary = st_geomfromtext('{to_postgis_polygon(old_boundary)}') where id = '{id}';"
redo_cs = g_update_prefix | { 'type': 'district_metering_area', 'id': id, 'boundary': new_boundary, 'parent': new_parent, 'nodes': new_nodes }
undo_cs = g_update_prefix | { 'type': 'district_metering_area', 'id': id, 'boundary': old_boundary, 'parent': old_parent, 'nodes': old_nodes }
return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs])
def set_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
ops = cs.operations
if len(cs.operations) == 0:
return ChangeSet()
op = ops[0]
if 'id' not in op:
return ChangeSet()
dma = get_district_metering_area(name, op['id'])
if dma == {}:
return ChangeSet()
if 'boundary' not in op:
op['boundary'] = dma['boundary']
else:
b = op['boundary']
if len(b) < 4 or b[0] != b[-1]:
return ChangeSet()
if 'parent' not in op:
op['parent'] = dma['parent']
if op['parent'] != None and get_district_metering_area(name, op['parent']) == {}:
return ChangeSet()
if 'nodes' not in op:
op['nodes'] = dma['nodes']
else:
for node in op['nodes']:
if not is_node(name, node):
return ChangeSet()
return execute_command(name, _set_district_metering_area(name, cs))
def _add_district_metering_area(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
boundary = cs.operations[0]['boundary']
parent = cs.operations[0]['parent']
f_parent = f"'{parent}'" if parent != None else 'null'
nodes = cs.operations[0]['nodes']
str_nodes = str(nodes).replace("'", "''")
redo_sql = f"insert into region (id, boundary, r_type) values ('{id}', '{to_postgis_polygon(boundary)}', 'DMA');"
redo_sql += f"insert into region_dma (id, parent, nodes) values ('{id}', {f_parent}, '{str_nodes}');"
undo_sql = f"delete from region_dma where id = '{id}';"
undo_sql += f"delete from region where id = '{id}';"
redo_cs = g_add_prefix | { 'type': 'district_metering_area', 'id': id, 'boundary': boundary, 'parent': parent, 'nodes': nodes }
undo_cs = g_delete_prefix | { 'type': 'district_metering_area', 'id': id }
return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs])
def add_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
ops = cs.operations
if len(cs.operations) == 0:
return ChangeSet()
op = ops[0]
if 'id' not in op:
return ChangeSet()
dma = get_district_metering_area(name, op['id'])
if dma != {}:
return ChangeSet()
if 'boundary' not in op:
return ChangeSet()
else:
b = op['boundary']
if len(b) < 4 or b[0] != b[-1]:
return ChangeSet()
if 'parent' not in op:
op['parent'] = None
if op['parent'] != None and get_district_metering_area(name, op['parent']) == {}:
return ChangeSet()
if 'nodes' not in op:
op['nodes'] = []
else:
for node in op['nodes']:
if not is_node(name, node):
return ChangeSet()
return execute_command(name, _add_district_metering_area(name, cs))
def _delete_district_metering_area(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
dma = get_district_metering_area(name, id)
boundary = dma['boundary']
parent = dma['parent']
f_parent = f"'{parent}'" if parent != None else 'null'
nodes = dma['nodes']
str_nodes = str(nodes).replace("'", "''")
redo_sql = f"delete from region_dma where id = '{id}';"
redo_sql += f"delete from region where id = '{id}';"
undo_sql = f"insert into region (id, boundary, r_type) values ('{id}', '{to_postgis_polygon(boundary)}', 'DMA');"
undo_sql += f"insert into region_dma (id, parent, nodes) values ('{id}', {f_parent}, '{str_nodes}');"
redo_cs = g_delete_prefix | { 'type': 'district_metering_area', 'id': id }
undo_cs = g_add_prefix | { 'type': 'district_metering_area', 'id': id, 'boundary': boundary, 'parent': parent, 'nodes': nodes }
return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs])
def _has_child(name: str, parent: str) -> bool:
return try_read(name, f"select * from region_dma where parent = '{parent}'") != None
def is_descendant_of(name: str, descendant: str, ancestor: str) -> bool:
parent = descendant
while parent != None:
parent = read(name, f"select parent from region_dma where id = '{parent}'")['parent']
if parent == ancestor:
return True
return False
def delete_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
ops = cs.operations
if len(cs.operations) == 0:
return ChangeSet()
op = ops[0]
if 'id' not in op:
return ChangeSet()
dma = get_district_metering_area(name, op['id'])
if dma == {}:
return ChangeSet()
#TODO: cascade ?
if _has_child(name, dma['id']):
return ChangeSet()
return execute_command(name, _delete_district_metering_area(name, cs))
def get_all_district_metering_area_ids(name: str) -> list[str]:
ids = []
for row in read_all(name, f"select id from region_dma"):
ids.append(row['id'])
return ids
def get_all_district_metering_areas(name: str) -> list[dict[str, Any]]:
result = []
for id in get_all_district_metering_area_ids(name):
result.append(get_district_metering_area(name, id))
return result

15
api/s33_district_metering_area.py → api/s33_dma_cal.py
View File

@@ -1,14 +1,17 @@
import ctypes
import os
from .database import *
from .s0_base import get_nodes
from .s32_region_util import get_nodes_in_region, to_postgis_polygon
from .s32_region_util import Topology
from .s32_region import get_region
PARTITION_TYPE_RB = 0
PARTITION_TYPE_KWAY = 1
def calculate_district_metering_area(name: str, nodes: list[str], part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> list[list[str]]:
def calculate_district_metering_area_for_nodes(name: str, nodes: list[str], part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> list[list[str]]:
if part_type != PARTITION_TYPE_RB and part_type != PARTITION_TYPE_KWAY:
return []
if part_count <= 0:
@@ -83,3 +86,13 @@ def calculate_district_metering_area(name: str, nodes: list[str], part_count: in
dmas[c_out_part[i]].append(t_node_list[i])
return dmas
def calculate_district_metering_area_for_region(name: str, region: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> list[list[str]]:
nodes = get_nodes_in_region(name, region)
return calculate_district_metering_area_for_nodes(name, nodes, part_count, part_type)
def calculate_district_metering_area_for_network(name: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> list[list[str]]:
nodes = get_nodes(name)
return calculate_district_metering_area_for_nodes(name, nodes, part_count, part_type)

47
api/s33_dma_gen.py Normal file
View File

@@ -0,0 +1,47 @@
from .s32_region_util import calculate_boundary, inflate_boundary
from .s33_dma_cal import *
from .s33_dma import get_all_district_metering_area_ids, get_all_district_metering_areas, get_district_metering_area, is_descendant_of
from .batch_exe import execute_batch_command
def generate_district_metering_area(name: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> ChangeSet:
cs = ChangeSet()
dmas = get_all_district_metering_areas(name)
max_level = 0
for dma in dmas:
if dma['level'] > max_level:
max_level = dma['level']
while max_level > 0:
for dma in dmas:
if dma['level'] == max_level:
cs.delete({ 'type': 'district_metering_area', 'id': dma['id'] })
max_level -= 1
i = 1
for nodes in calculate_district_metering_area_for_network(name, part_count, part_type):
boundary = calculate_boundary(name, nodes)
boundary = inflate_boundary(name, boundary)
cs.add({ 'type': 'district_metering_area', 'id': f"DMA_1_{i}", 'boundary': boundary, 'parent': None, 'nodes': nodes })
i += 1
return execute_batch_command(name, cs)
def generate_sub_district_metering_area(name: str, dma: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> ChangeSet:
cs = ChangeSet()
for id in get_all_district_metering_area_ids(name):
if is_descendant_of(name, id, dma):
cs.delete({ 'type': 'district_metering_area', 'id': id })
level = get_district_metering_area(name, dma)['level'] + 1
i = 1
for nodes in calculate_district_metering_area_for_region(name, dma, part_count, part_type):
boundary = calculate_boundary(name, nodes)
boundary = inflate_boundary(name, boundary)
cs.add({ 'type': 'district_metering_area', 'id': f"DMA_{level}_{i}", 'boundary': boundary, 'parent': dma, 'nodes': nodes })
i += 1
return execute_batch_command(name, cs)

0
api/s34_service_area.py → api/s34_sa.py
View File

0
api/s35_virtual_district.py → api/s35_vd.py
View File

0
api/s36_wda.py Normal file
View File

7
api/s32_water_distribution.py → api/s36_wda_cal.py
View File

@@ -1,5 +1,5 @@
from .database import ChangeSet
from .s0_base import is_junction
from .s0_base import is_junction, get_nodes
from .s9_demands import get_demand
from .s32_region_util import Topology, get_nodes_in_region
from .batch_exe import execute_batch_command
@@ -43,6 +43,11 @@ def calculate_demand_to_region(name: str, demand: float, region: str) -> dict[st
return calculate_demand_to_nodes(name, demand, nodes)
def calculate_demand_to_network(name: str, demand: float) -> dict[str, float]:
nodes = get_nodes(name)
return calculate_demand_to_nodes(name, demand, nodes)
def distribute_demand_to_nodes(name: str, demand: float, nodes: list[str], type: str = DISTRIBUTION_TYPE_ADD) -> ChangeSet:
if len(nodes) == 0 or demand == 0.0:
return ChangeSet()

2
api/sections.py
View File

@@ -33,6 +33,8 @@ s28_end = 'end'
s29_scada_device = 'scada_device'
s30_scada_device_data = 'scada_device_data'
s31_scada_element = 'scada_element'
s32_region = 'region'
s33_dma = 'district_metering_area'
TITLE = 'TITLE'
JUNCTIONS = 'JUNCTIONS'

1
clean_projects.py
View File

@@ -2,3 +2,4 @@ from tjnetwork import *
if __name__ == '__main__':
clean_project()
delete_project('project')

10
create_template.py
View File

@@ -34,13 +34,21 @@ sql_create = [
"script/sql/create/30.scada_device_data.sql",
"script/sql/create/31.scada_element.sql",
"script/sql/create/32.region.sql",
"script/sql/create/33.dma.sql",
"script/sql/create/34.sa.sql",
"script/sql/create/35.vd.sql",
"script/sql/create/36.wda.sql",
"script/sql/create/extension_data.sql",
"script/sql/create/operation.sql"
]
sql_drop = [
"script/sql/drop/operation.sql",
"script/sql/create/extension_data.sql",
"script/sql/drop/extension_data.sql",
"script/sql/drop/36.wda.sql",
"script/sql/drop/35.vd.sql",
"script/sql/drop/34.sa.sql",
"script/sql/drop/33.dma.sql",
"script/sql/drop/32.region.sql",
"script/sql/drop/31.scada_element.sql",
"script/sql/drop/30.scada_device_data.sql",

3
script/sql/create/32.region.sql
View File

@@ -1,7 +1,10 @@
create type region_type as enum ('NONE', 'DMA', 'SA', 'VD', 'WDA');
create table region
(
id text primary key
, boundary geometry not null unique
, r_type region_type not null default 'NONE'
);
create index region_gist on region using gist(boundary);

6
script/sql/create/33.dma.sql Normal file
View File

@@ -0,0 +1,6 @@
create table region_dma
(
id text primary key references region(id)
, parent text --references region_dma(id)
, nodes text not null
);

7
script/sql/create/34.sa.sql Normal file
View File

@@ -0,0 +1,7 @@
create table region_sa
(
id text primary key references region(id)
, time_index integer not null
, source varchar(32) not null -- references _node(id)
, nodes text not null
);

6
script/sql/create/35.vd.sql Normal file
View File

@@ -0,0 +1,6 @@
create table region_vd
(
id text primary key references region(id)
, center varchar(32) not null -- references _node(id)
, nodes text not null
);

5
script/sql/create/36.wda.sql Normal file
View File

@@ -0,0 +1,5 @@
create table region_wda
(
id text primary key references region(id)
, demand float8 not null default 0.0
);

2
script/sql/drop/32.region.sql
View File

@@ -11,3 +11,5 @@ drop table if exists temp_region;
drop index if exists region_gist;
drop table if exists region;
drop type if exists region_type;

1
script/sql/drop/33.dma.sql Normal file
View File

@@ -0,0 +1 @@
drop table if exists region_dma;

1
script/sql/drop/34.sa.sql Normal file
View File

@@ -0,0 +1 @@
drop table if exists region_sa;

1
script/sql/drop/35.vd.sql Normal file
View File

@@ -0,0 +1 @@
drop table if exists region_vd;

1
script/sql/drop/36.wda.sql Normal file
View File

@@ -0,0 +1 @@
drop table if exists region_wda;

364
test_tjnetwork.py
View File

@@ -5822,47 +5822,15 @@ class TestApi:
self.leave(p)
# 32 water_distribution
def test_calculate_demand_to_nodes(self):
p = 'test_calculate_demand_to_nodes'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
vds = calculate_virtual_district(p, ['107', '139', '267', '211'])['virtual_districts']
result = calculate_demand_to_nodes(p, 100.0, vds[0]['nodes'])
assert result == {'10': 17.357291284684024, '101': 22.112211221122113, '103': 6.466202175773133, '105': 8.232489915658233, '107': 4.180418041804181, '109': 7.260726072607261, '111': 3.862608483070529, '115': 6.466202175773133, '117': 5.738907224055739, '119': 0.892311453367559, '120': 3.9665077618873, '257': 2.9275149737195942, '259': 2.1391027991688056, '261': 2.9275149737195942, '263': 5.469991443588803}
self.leave(p)
def test_calculate_demand_to_region(self):
p = 'test_calculate_demand_to_region'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
vds = calculate_virtual_district(p, ['107', '139', '267', '211'])['virtual_districts']
nodes = vds[0]['nodes']
boundary = calculate_boundary(p, nodes)
boundary = inflate_boundary(p, boundary, 0.1)
add_region(p, ChangeSet({'id': 'r', 'boundary': boundary}))
result = calculate_demand_to_region(p, 100.0, 'r')
assert result == {'10': 17.357291284684024, '101': 22.112211221122113, '103': 6.466202175773133, '105': 8.232489915658233, '107': 4.180418041804181, '109': 7.260726072607261, '111': 3.862608483070529, '115': 6.466202175773133, '117': 5.738907224055739, '119': 0.892311453367559, '120': 3.9665077618873, '257': 2.9275149737195942, '259': 2.1391027991688056, '261': 2.9275149737195942, '263': 5.469991443588803}
self.leave(p)
# 33 district_metering_area
def test_calculate_district_metering_area(self):
p = 'test_calculate_district_metering_area'
def test_calculate_district_metering_area_for_nodes(self):
p = 'test_calculate_district_metering_area_for_nodes'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
dmas = calculate_district_metering_area(p, get_nodes(p), 3)
dmas = calculate_district_metering_area_for_nodes(p, get_nodes(p), 3)
assert len(dmas) == 3
assert dmas[0] == ['173', '184', '185', '199', '2', '201', '203', '205', '206', '207', '208', '209', '211', '213', '215', '217', '219', '225', '229', '231', '237', '239', '241', '243', '247', '249', '251', '253', '255', '273', '275', '50']
assert dmas[1] == ['1', '10', '101', '103', '109', '111', '113', '161', '163', '164', '166', '167', '169', '171', '179', '181', '183', '187', '189', '191', '193', '195', '197', '204', '265', '267', '269', '271', '35', '40', 'Lake']
@@ -5871,6 +5839,289 @@ class TestApi:
self.leave(p)
def test_calculate_district_metering_area_for_region(self):
p = 'test_calculate_district_metering_area_for_region'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
assert get_node_coord(p, '177') == { 'x' : 0.0, 'y' : 0.0 }
add_region(p, ChangeSet({'id': 'r', 'boundary': [(-10000.0, -10000.0), (10000.0, -10000.0), (10000.0, 10000.0), (-10000.0, 10000.0), (-10000.0, -10000.0)]}))
nodes = get_nodes_in_region(p, 'r')
assert len(nodes) == 97
dmas = calculate_district_metering_area_for_region(p, 'r', 3)
assert dmas == [['10', '60', '601', '61', '101', '103', '105', '107', '109', '111', '113', '115', '117', '119', '120', '121', '123', '125', '145', '147', '149', '151', '153', '157', '159', '197', '257', '259', '261', '263', 'River', 'Lake'], ['35', '40', '161', '163', '164', '166', '167', '169', '171', '173', '179', '181', '183', '184', '185', '187', '189', '191', '193', '195', '199', '201', '203', '204', '205', '207', '265', '267', '269', '271', '273', '275', '1', '177'], ['15', '20', '50', '127', '129', '131', '139', '141', '143', '206', '208', '209', '211', '213', '215', '217', '219', '225', '229', '231', '237', '239', '241', '243', '247', '249', '251', '253', '255', '2', '3']]
self.leave(p)
def test_calculate_district_metering_area_for_network(self):
p = 'test_calculate_district_metering_area_for_region'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
dmas = calculate_district_metering_area_for_network(p, 3)
assert len(dmas) == 3
assert dmas[0] == ['173', '184', '185', '199', '2', '201', '203', '205', '206', '207', '208', '209', '211', '213', '215', '217', '219', '225', '229', '231', '237', '239', '241', '243', '247', '249', '251', '253', '255', '273', '275', '50']
assert dmas[1] == ['1', '10', '101', '103', '109', '111', '113', '161', '163', '164', '166', '167', '169', '171', '179', '181', '183', '187', '189', '191', '193', '195', '197', '204', '265', '267', '269', '271', '35', '40', 'Lake']
assert dmas[2] == ['105', '107', '115', '117', '119', '120', '121', '123', '125', '127', '129', '131', '139', '141', '143', '145', '147', '149', '15', '151', '153', '157', '159', '20', '257', '259', '261', '263', '3', '60', '601', '61', 'River']
self.leave(p)
def test_district_metering_area(self):
p = 'test_district_metering_area'
self.enter(p)
dma = get_district_metering_area(p, 'dma')
assert dma == {}
add_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0)]}))
dma = get_district_metering_area(p, 'dma')
assert dma == {}
add_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'parent': '1'}))
dma = get_district_metering_area(p, 'dma')
assert dma == {}
add_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]}))
dma = get_district_metering_area(p, 'dma')
assert dma['id'] == 'dma'
assert dma['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert dma['parent'] == None
assert dma['nodes'] == []
assert dma['level'] == 1
set_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'parent': '1'}))
dma = get_district_metering_area(p, 'dma')
assert dma['id'] == 'dma'
assert dma['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert dma['parent'] == None
assert dma['nodes'] == []
assert dma['level'] == 1
add_district_metering_area(p, ChangeSet({'id': 'd0', 'boundary': [(0.0, 0.0), (1.0, 0.0), (2.0, 2.0), (0.0, 0.0)]}))
set_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'parent': 'd0'}))
dma = get_district_metering_area(p, 'dma')
assert dma['id'] == 'dma'
assert dma['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert dma['parent'] == 'd0'
assert dma['nodes'] == []
assert dma['level'] == 2
set_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'nodes': ['1']}))
dma = get_district_metering_area(p, 'dma')
assert dma['id'] == 'dma'
assert dma['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert dma['parent'] == 'd0'
assert dma['nodes'] == []
assert dma['level'] == 2
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
set_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'nodes': ['j0']}))
dma = get_district_metering_area(p, 'dma')
assert dma['id'] == 'dma'
assert dma['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert dma['parent'] == 'd0'
assert dma['nodes'] == ['j0']
assert dma['level'] == 2
delete_district_metering_area(p, ChangeSet({'id': 'dma'}))
dma = get_district_metering_area(p, 'dma')
assert dma == {}
add_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'parent': 'd0', 'nodes': ['j0']}))
dma = get_district_metering_area(p, 'dma')
assert dma['id'] == 'dma'
assert dma['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert dma['parent'] == 'd0'
assert dma['nodes'] == ['j0']
assert dma['level'] == 2
delete_district_metering_area(p, ChangeSet({'id': 'd0'}))
dma = get_district_metering_area(p, 'd0')
assert dma != {}
delete_district_metering_area(p, ChangeSet({'id': 'dma'}))
dma = get_district_metering_area(p, 'dma')
assert dma == {}
delete_district_metering_area(p, ChangeSet({'id': 'd0'}))
dma = get_district_metering_area(p, 'd0')
assert dma == {}
self.leave(p)
def test_district_metering_area_op(self):
p = 'test_district_metering_area_op'
self.enter(p)
cs = add_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0)]})).operations
assert len(cs) == 0
cs = add_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'parent': '1'})).operations
assert len(cs) == 0
cs = add_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]})).operations[0]
assert cs['operation'] == API_ADD
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == None
assert cs['nodes'] == []
cs = execute_undo(p).operations[0]
assert cs['operation'] == API_DELETE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
cs = execute_redo(p).operations[0]
assert cs['operation'] == API_ADD
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == None
assert cs['nodes'] == []
cs = set_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'parent': '1'})).operations
assert len(cs) == 0
add_district_metering_area(p, ChangeSet({'id': 'd0', 'boundary': [(0.0, 0.0), (1.0, 0.0), (2.0, 2.0), (0.0, 0.0)]}))
cs = set_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'parent': 'd0'})).operations[0]
assert cs['operation'] == API_UPDATE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == 'd0'
assert cs['nodes'] == []
cs = execute_undo(p).operations[0]
assert cs['operation'] == API_UPDATE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == None
assert cs['nodes'] == []
cs = execute_redo(p).operations[0]
assert cs['operation'] == API_UPDATE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == 'd0'
assert cs['nodes'] == []
cs = set_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'nodes': ['1']})).operations
assert len(cs) == 0
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
cs = set_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'nodes': ['j0']})).operations[0]
assert cs['operation'] == API_UPDATE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == 'd0'
assert cs['nodes'] == ['j0']
cs = execute_undo(p).operations[0]
assert cs['operation'] == API_UPDATE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == 'd0'
assert cs['nodes'] == []
cs = execute_redo(p).operations[0]
assert cs['operation'] == API_UPDATE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == 'd0'
assert cs['nodes'] == ['j0']
cs = delete_district_metering_area(p, ChangeSet({'id': 'xxx'})).operations
assert len(cs) == 0
cs = delete_district_metering_area(p, ChangeSet({'id': 'dma'})).operations[0]
assert cs['operation'] == API_DELETE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
cs = execute_undo(p).operations[0]
assert cs['operation'] == API_ADD
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == 'd0'
assert cs['nodes'] == ['j0']
cs = execute_redo(p).operations[0]
assert cs['operation'] == API_DELETE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
cs = add_district_metering_area(p, ChangeSet({'id': 'dma', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)], 'parent': 'd0', 'nodes': ['j0']})).operations[0]
assert cs['operation'] == API_ADD
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
assert cs['parent'] == 'd0'
assert cs['nodes'] == ['j0']
cs = delete_district_metering_area(p, ChangeSet({'id': 'd0'})).operations
assert len(cs) == 0
cs = delete_district_metering_area(p, ChangeSet({'id': 'dma'})).operations[0]
assert cs['operation'] == API_DELETE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'dma'
cs = delete_district_metering_area(p, ChangeSet({'id': 'dma'})).operations
assert len(cs) == 0
cs = delete_district_metering_area(p, ChangeSet({'id': 'd0'})).operations[0]
assert cs['operation'] == API_DELETE
assert cs['type'] == 'district_metering_area'
assert cs['id'] == 'd0'
self.leave(p)
def test_district_metering_area_gen(self):
p = 'test_district_metering_area_gen'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
cs = generate_district_metering_area(p, 3).operations
assert len(cs) == 3
dmas = get_all_district_metering_area_ids(p)
assert len(dmas) == 3
cs = generate_district_metering_area(p, 3).operations
assert len(cs) == 6
dmas = get_all_district_metering_area_ids(p)
assert len(dmas) == 3
cs = generate_sub_district_metering_area(p, 'DMA_1_1', 2).operations
assert len(cs) == 2
dmas = get_all_district_metering_area_ids(p)
assert len(dmas) == 5
cs = generate_district_metering_area(p, 3).operations
assert len(cs) == 8
dmas = get_all_district_metering_area_ids(p)
assert len(dmas) == 3
self.leave(p)
# 34 service_area
@@ -5919,5 +6170,48 @@ class TestApi:
self.leave(p)
# 36 water_distribution
def test_calculate_demand_to_nodes(self):
p = 'test_calculate_demand_to_nodes'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
vds = calculate_virtual_district(p, ['107', '139', '267', '211'])['virtual_districts']
result = calculate_demand_to_nodes(p, 100.0, vds[0]['nodes'])
assert result == {'10': 17.357291284684024, '101': 22.112211221122113, '103': 6.466202175773133, '105': 8.232489915658233, '107': 4.180418041804181, '109': 7.260726072607261, '111': 3.862608483070529, '115': 6.466202175773133, '117': 5.738907224055739, '119': 0.892311453367559, '120': 3.9665077618873, '257': 2.9275149737195942, '259': 2.1391027991688056, '261': 2.9275149737195942, '263': 5.469991443588803}
self.leave(p)
def test_calculate_demand_to_region(self):
p = 'test_calculate_demand_to_region'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
vds = calculate_virtual_district(p, ['107', '139', '267', '211'])['virtual_districts']
nodes = vds[0]['nodes']
boundary = calculate_boundary(p, nodes)
boundary = inflate_boundary(p, boundary, 0.1)
add_region(p, ChangeSet({'id': 'r', 'boundary': boundary}))
result = calculate_demand_to_region(p, 100.0, 'r')
assert result == {'10': 17.357291284684024, '101': 22.112211221122113, '103': 6.466202175773133, '105': 8.232489915658233, '107': 4.180418041804181, '109': 7.260726072607261, '111': 3.862608483070529, '115': 6.466202175773133, '117': 5.738907224055739, '119': 0.892311453367559, '120': 3.9665077618873, '257': 2.9275149737195942, '259': 2.1391027991688056, '261': 2.9275149737195942, '263': 5.469991443588803}
self.leave(p)
def test_calculate_demand_to_network(self):
p = 'test_calculate_demand_to_network'
read_inp(p, f'./inp/net3.inp', '3')
open_project(p)
result = calculate_demand_to_network(p, 100.0)
assert result == {'10': 3.2923444181778216, '101': 4.194261304565972, '103': 1.226514223391597, '105': 1.561545046227298, '107': 0.7929449232512782, '109': 1.3772201298574833, '111': 1.7690554866687873, '113': 1.2381069854274345, '115': 1.6902247048250931, '117': 1.088560355165132, '119': 1.9174428407275061, '120': 1.2276734995951808, '121': 1.502421959844527, '123': 10.897196313687157, '125': 2.0240962514572103, '127': 1.141887060529984, '129': 2.3486935884606575, '131': 1.5024219598445272, '139': 1.1129051554403906, '141': 1.6137124753885663, '143': 0.7071584841860814, '145': 1.3238934244926313, '147': 0.7141141414075839, '149': 0.44052495736182123, '15': 0.38256114718263423, '151': 1.3099821100496263, '153': 1.328530529306966, '157': 1.1569576511765725, '159': 1.1384092319192327, '161': 1.0966752885902182, '163': 0.41270232847581145, '164': 0.14838735405871872, '166': 0.11360906795120652, '167': 0.01391131444300488, '169': 0.5949405476791755, '171': 0.48225890069083593, '173': 0.9390137249028294, '179': 0.32459733700344723, '181': 0.06723801980785693, '183': 0.4799403482836684, '184': 1.0734665789944717, '185': 0.4486167052628357, '187': 0.732639375140852, '189': 0.8638926269106031, '191': 0.9807476682318441, '193': 0.8601829430591352, '195': 0.6167349403065497, '197': 0.9135096484239872, '199': 1.2415848140381855, '20': 0.20496003279360525, '201': 0.2434480027525854, '203': 0.02782262888600976, '204': 0.33037053249729426, '205': 1.4780771595692686, '206': 0.22258103108807809, '207': 0.7141141414075839, '208': 0.3234380607998635, '209': 0.48573672930158707, '211': 0.9923404302676815, '213': 1.7331179243576913, '215': 1.378379406061067, '217': 1.2218771185772621, '219': 0.47530324346933345, '225': 0.3616941755181269, '229': 1.1476834415479027, '231': 0.4544362718048261, '237': 0.7836707136226083, '239': 0.22605885969882933, '241': 0.6213720451208846, '243': 0.5100815295768456, '247': 0.42777291912240006, '249': 0.4382064049546538, '251': 0.5912308638277075, '253': 0.2550407647884228, '255': 1.0468264118361172, '257': 0.5552933015166115, '259': 0.405746671254309, '261': 0.5552933015166115, '263': 1.0375522022074473, '265': 0.7813521612154408, '267': 0.9227838580526571, '269': 0.5986502315306435, '271': 0.535585606055688, '273': 0.8346788665802929, '275': 0.9181467532383222, '35': 0.00695565722150244, '40': 0.2988614052838882, '50': 0.23741976649394997, '60': 0.28564565656303353, '601': 0.00046371048143349603, '61': 10.549645307852751}
self.leave(p)
if __name__ == '__main__':
pytest.main()

108
tjnetwork.py
View File

@@ -826,7 +826,7 @@ def set_option_v3(name: str, cs: ChangeSet) -> ChangeSet:
# coord 24.[COORDINATES]
############################################################
def get_node_coord(name: str, node_id: str) -> dict[str, float] | None:
def get_node_coord(name: str, node_id: str) -> dict[str, float]:
return api.get_node_coord(name, node_id)
@@ -984,9 +984,13 @@ def get_all_scada_elements(name: str) -> list[dict[str, Any]]:
# general_region 32
############################################################
# pure geometry function, test point is in polygon
def get_nodes_in_boundary(name: str, boundary: list[tuple[float, float]]) -> list[str]:
return api.get_nodes_in_boundary(name, boundary)
# if region is general or wda => get_nodes_in_boundary
# if region is dma, sa or vd => get stored nodes in table
# TODO: more test
def get_nodes_in_region(name: str, region_id: str) -> list[str]:
return api.get_nodes_in_region(name, region_id)
@@ -1002,12 +1006,6 @@ def inflate_boundary(name: str, boundary: list[tuple[float, float]], delta: floa
def inflate_region(name: str, region_id: str, delta: float = 0.5) -> list[tuple[float, float]]:
return api.inflate_region(name, region_id, delta)
def calculate_demand_to_nodes(name: str, demand: float, nodes: list[str]) -> dict[str, float]:
return api.calculate_demand_to_nodes(name, demand, nodes)
def calculate_demand_to_region(name: str, demand: float, region: str) -> dict[str, float]:
return api.calculate_demand_to_region(name, demand, region)
def get_region_schema(name: str) -> dict[str, dict[str, Any]]:
return api.get_region_schema(name)
@@ -1029,8 +1027,41 @@ def delete_region(name: str, cs: ChangeSet) -> ChangeSet:
# district_metering_area 33
############################################################
def calculate_district_metering_area(name: str, nodes: list[str], part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> list[list[str]]:
return api.calculate_district_metering_area(name, nodes, part_count, part_type)
def calculate_district_metering_area_for_nodes(name: str, nodes: list[str], part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> list[list[str]]:
return api.calculate_district_metering_area_for_nodes(name, nodes, part_count, part_type)
def calculate_district_metering_area_for_region(name: str, region: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> list[list[str]]:
return api.calculate_district_metering_area_for_region(name, region, part_count, part_type)
def calculate_district_metering_area_for_network(name: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> list[list[str]]:
return api.calculate_district_metering_area_for_network(name, part_count, part_type)
def get_district_metering_area_schema(name: str) -> dict[str, dict[str, Any]]:
return api.get_district_metering_area_schema(name)
def get_district_metering_area(name: str, id: str) -> dict[str, Any]:
return api.get_district_metering_area(name, id)
def set_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
return api.set_district_metering_area(name, cs)
def add_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_district_metering_area(name, cs)
def delete_district_metering_area(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_district_metering_area(name, cs)
def get_all_district_metering_area_ids(name: str) -> list[str]:
return api.get_all_district_metering_area_ids(name)
def get_all_district_metering_areas(name: str) -> list[dict[str, Any]]:
return api.get_all_district_metering_areas(name)
def generate_district_metering_area(name: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> ChangeSet:
return api.generate_district_metering_area(name, part_count, part_type)
def generate_sub_district_metering_area(name: str, dma: str, part_count: int = 1, part_type: int = PARTITION_TYPE_RB) -> ChangeSet:
return api.generate_sub_district_metering_area(name, dma, part_count, part_type)
############################################################
@@ -1040,6 +1071,27 @@ def calculate_district_metering_area(name: str, nodes: list[str], part_count: in
def calculate_service_area(name: str, time_index: int = 0) -> dict[str, Any]:
return api.calculate_service_area(name, time_index)
def get_service_area_schema(name: str) -> dict[str, dict[str, Any]]:
return {}
def get_service_area(name: str, id: str) -> dict[str, Any]:
return {}
def set_service_area(name: str, cs: ChangeSet) -> ChangeSet:
return ChangeSet()
def add_service_area(name: str, cs: ChangeSet) -> ChangeSet:
return ChangeSet()
def delete_service_area(name: str, cs: ChangeSet) -> ChangeSet:
return ChangeSet()
def get_all_service_areas(name: str) -> list[dict[str, Any]]:
return []
def generate_service_area(name: str) -> ChangeSet:
return ChangeSet()
############################################################
# virtual_district 35
@@ -1047,3 +1099,41 @@ def calculate_service_area(name: str, time_index: int = 0) -> dict[str, Any]:
def calculate_virtual_district(name: str, centers: list[str]) -> dict[str, list[Any]]:
return api.calculate_virtual_district(name, centers)
def get_virtual_district_schema(name: str) -> dict[str, dict[str, Any]]:
return {}
def get_virtual_district(name: str, id: str) -> dict[str, Any]:
return {}
def set_virtual_district(name: str, cs: ChangeSet) -> ChangeSet:
return ChangeSet()
def add_virtual_district(name: str, cs: ChangeSet) -> ChangeSet:
return ChangeSet()
def delete_virtual_district(name: str, cs: ChangeSet) -> ChangeSet:
return ChangeSet()
def get_all_virtual_district(name: str) -> list[dict[str, Any]]:
return []
def generate_virtual_district(name: str, centers: list[str]) -> ChangeSet:
return ChangeSet()
############################################################
# water_distribution_area 36
############################################################
def calculate_demand_to_nodes(name: str, demand: float, nodes: list[str]) -> dict[str, float]:
return api.calculate_demand_to_nodes(name, demand, nodes)
# if region is general or wda => get_nodes_in_boundary
# if region is dma, sa or vd => get stored nodes in table
# TODO: more test
def calculate_demand_to_region(name: str, demand: float, region: str) -> dict[str, float]:
return api.calculate_demand_to_region(name, demand, region)
def calculate_demand_to_network(name: str, demand: float) -> dict[str, float]:
return api.calculate_demand_to_network(name, demand)