def _write_meta(self):# {{{
j=Json()
report = OrderedDict()
report['worker'] = self.host_name
report['sim_id'] = self.sim_id
report['scenario_id'] = self.vars['conf']['scenario_id']
report['project_id'] = self.vars['conf']['project_id']
report['path_to_project'] = '/home/aamks_users/'+self.working_dir.split('workers')[0]
report['fire_origin'] = self.vars['conf']['FIRE_ORIGIN']
report['highlight_geom'] = None
report['psql'] = dict()
report['psql']['fed'] = dict()
report['psql']['rset'] = dict()
report['psql']['runtime'] = int(time.time() - self.start_time)
report['psql']['cross_building_results'] = self.cross_building_results
for i in self.floors:
report['psql']['fed'][i.floor] = i.fed
report['psql']['rset'][i.floor] = int(i.rset)
for num_floor in range(len(self.floors)):
report['animation'] = "{}_{}_{}_anim.zip".format(self.vars['conf']['project_id'], self.vars['conf']['scenario_id'], self.sim_id)
report['floor'] = num_floor
self.meta_file = "meta_{}.json".format(self.sim_id)
j.write(report, self.meta_file)
self.wlogger.info('Metadata prepared successfully')
def _navmesh_vis(self, floor, navmesh_paths, colors): # {{{
j = Json()
z = j.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
for cc, path in enumerate(navmesh_paths):
for i, p in enumerate(path):
try:
z[floor]['lines'].append({
"xy": (path[i][0], path[i][1]),
"x1": path[i + 1][0],
"y1": path[i + 1][1],
"strokeColor": colors[cc],
"strokeWidth": 2,
"opacity": 0.7
})
except:
pass
j.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
class CFASTimporter():
def __init__(self): # {{{
self.json = Json()
self.conf = self.json.read("{}/conf.json".format(
os.environ['AAMKS_PROJECT']))
if self.conf['fire_model'] == 'FDS':
return
self.s = Sqlite("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
self.raw_geometry = self.json.read("{}/cad.json".format(
os.environ['AAMKS_PROJECT']))
self.geomsMap = self.json.read("{}/inc.json".format(
os.environ['AAMKS_PATH']))['aamksGeomsMap']
self.doors_width = 32
self.walls_width = 4
self._geometry2sqlite()
self._enhancements()
self._init_dd_geoms()
self._towers_slices()
self._floors_meta()
self._world_meta()
self._aamks_geom_into_polygons()
self._make_id2compa_name()
self._find_intersections_within_floor()
self._get_faces()
self._hvents_per_room()
self._find_intersections_between_floors()
self._vvents_per_room()
self._add_names_to_vents_from_to()
self._recalculate_vents_from_to()
self._calculate_sills()
self._terminal_doors()
self._auto_detectors_and_sprinklers()
self._assert_faces_ok()
self._assert_room_has_door()
self._debug()
# }}}
def _floors_meta(self): # {{{
'''
Floor dimensions are needed here and there.
for z_absolute high towers are not taken under account, we want the natural floor's zdim
for z_relative high towers are not taken under account, we want the natural floor's zdim
'''
self.floors_meta = OrderedDict()
self._world3d = dict()
self._world3d['minx'] = 9999999
self._world3d['maxx'] = -9999999
self._world3d['miny'] = 9999999
self._world3d['maxy'] = -9999999
prev_maxz = 0
for floor in self.floors:
ty = 0
tx = 0
minx = self.s.query(
"SELECT min(x0) AS minx FROM aamks_geom WHERE floor=?",
(floor, ))[0]['minx']
maxx = self.s.query(
"SELECT max(x1) AS maxx FROM aamks_geom WHERE floor=?",
(floor, ))[0]['maxx']
miny = self.s.query(
"SELECT min(y0) AS miny FROM aamks_geom WHERE floor=?",
(floor, ))[0]['miny']
maxy = self.s.query(
"SELECT max(y1) AS maxy FROM aamks_geom WHERE floor=?",
(floor, ))[0]['maxy']
minz_abs = self.s.query(
"SELECT min(z0) AS minz FROM aamks_geom WHERE type_sec NOT IN('STAI','HALL') AND floor=?",
(floor, ))[0]['minz']
maxz_abs = self.s.query(
"SELECT max(z1) AS maxz FROM aamks_geom WHERE type_sec NOT IN('STAI','HALL') AND floor=?",
(floor, ))[0]['maxz']
zdim = maxz_abs - prev_maxz
prev_maxz = maxz_abs
xdim = maxx - minx
ydim = maxy - miny
center = (minx + int(xdim / 2), miny + int(ydim / 2), minz_abs)
self.floors_meta[floor] = OrderedDict([('name', floor),
('xdim', xdim),
('ydim', ydim),
('center', center),
('minx', minx),
('miny', miny),
('maxx', maxx),
('maxy', maxy),
('minz_abs', minz_abs),
('maxz_abs', maxz_abs),
('zdim', zdim), ('ty', ty),
('tx', tx)])
self._world3d['minx'] = min(self._world3d['minx'], minx)
self._world3d['maxx'] = max(self._world3d['maxx'], maxx)
self._world3d['miny'] = min(self._world3d['miny'], miny)
self._world3d['maxy'] = max(self._world3d['maxy'], maxy)
self.s.query("CREATE TABLE floors_meta(json)")
self.s.query('INSERT INTO floors_meta VALUES (?)',
(json.dumps(self.floors_meta), ))
# }}}
def _world_meta(self): # {{{
self.s.query("CREATE TABLE world_meta(json)")
self.world_meta = {}
self.world_meta['world3d'] = self._world3d
self.world_meta['walls_width'] = self.walls_width
self.world_meta['doors_width'] = self.doors_width
if len(self.floors_meta) > 1:
self.world_meta['multifloor_building'] = 1
else:
self.world_meta['multifloor_building'] = 0
self.s.query('INSERT INTO world_meta(json) VALUES (?)',
(json.dumps(self.world_meta), ))
# }}}
def _geometry2sqlite(self): # {{{
'''
Parse geometry and place geoms in sqlite. The lowest floor is always 0.
The self.raw_geometry example for floor("0"):
"0": [
"ROOM": [
[ [ 3.0 , 4.8 , 0.0 ] , [ 4.8 , 6.5 , 3.0 ] ] ,
[ [ 3.0 , 6.5 , 0.0 ] , [ 6.8 , 7.4 , 3.0 ] ]
]
]
Some columns in db are left empty for now.
Sqlite's aamks_geom table must use two unique ids
a) 'name' for visualisation and
b) 'global_type_id' for cfast enumeration.
'''
data = []
for floor, gg in self.raw_geometry.items():
for k, arr in gg.items():
if k in ('UNDERLAY'):
continue
for v in arr:
rr = {
'x0': int(v[0][0]),
'y0': int(v[0][1]),
'x1': int(v[1][0]),
'y1': int(v[1][1]),
'z0': int(v[0][2]),
'z1': int(v[1][2])
}
points = ((rr['x0'], rr['y0']), (rr['x1'], rr['y0']),
(rr['x1'], rr['y1']), (rr['x0'], rr['y1']),
(rr['x0'], rr['y0']))
width = rr['x1'] - rr['x0']
depth = rr['y1'] - rr['y0']
height = rr['z1'] - rr['z0']
attrs = self._prepare_attrs(v[2])
record = self._prepare_geom_record(k, rr, points, width,
depth, height, floor,
attrs)
if record != False:
data.append(record)
self.s.query(
"CREATE TABLE aamks_geom(name,floor,global_type_id,hvent_room_seq,vvent_room_seq,type_pri,type_sec,type_tri,x0,y0,z0,width,depth,height,cfast_width,sill,face,face_offset,vent_from,vent_to,material_ceiling,material_floor,material_wall,heat_detectors,smoke_detectors,sprinklers,is_vertical,vent_from_name,vent_to_name, how_much_open, room_area, x1, y1, z1, center_x, center_y, center_z, fire_model_ignore, mvent_throughput, exit_type, room_enter, terminal_door, points)"
)
self.s.executemany(
'INSERT INTO aamks_geom VALUES ({})'.format(','.join(
'?' * len(data[0]))), data)
#dd(self.s.dump())
#}}}
def _prepare_attrs(self, attrs): # {{{
aa = {"mvent_throughput": None, "exit_type": None, "room_enter": None}
for k, v in attrs.items():
aa[k] = v
return aa
# }}}
def _prepare_geom_record(self, k, rect, points, width, depth, height,
floor, attrs): # {{{
''' Format a record for sqlite. Hvents get fixed width self.doors_width cm '''
# OBST
if k in ('OBST', ):
type_pri = 'OBST'
type_tri = ''
# EVACUEE
elif k in ('EVACUEE', ):
type_pri = 'EVACUEE'
type_tri = ''
# FIRE
elif k in ('FIRE', ):
type_pri = 'FIRE'
type_tri = ''
# MVENT
elif k in ('MVENT', ):
type_pri = 'MVENT'
type_tri = ''
# VVENT
elif k in ('VVENT', ):
type_pri = 'VVENT'
height = 10
type_tri = ''
# COMPA
elif k in ('ROOM', 'COR', 'HALL', 'STAI'):
type_pri = 'COMPA'
type_tri = ''
# HVENT
elif k in ('DOOR', 'DCLOSER', 'DELECTR', 'HOLE', 'WIN'):
width = max(width, self.doors_width)
depth = max(depth, self.doors_width)
type_pri = 'HVENT'
if k in ('DOOR', 'DCLOSER', 'DELECTR', 'HOLE'):
type_tri = 'DOOR'
elif k in ('WIN'):
type_tri = 'WIN'
global_type_id = attrs['idx']
name = '{}{}'.format(self.geomsMap[k], global_type_id)
#self.s.query("CREATE TABLE aamks_geom(name , floor , global_type_id , hvent_room_seq , vvent_room_seq , type_pri , type_sec , type_tri , x0 , y0 , z0 , width , depth , height , cfast_width , sill , face , face_offset , vent_from , vent_to , material_ceiling , material_floor , material_wall , heat_detectors , smoke_detectors , sprinklers , is_vertical , vent_from_name , vent_to_name , how_much_open , room_area , x1 , y1 , z1 , center_x , center_y , center_z , fire_model_ignore , mvent_throughput , exit_type , room_enter , terminal_door , points)")
return (name, floor, global_type_id, None, None, type_pri, k, type_tri,
rect['x0'], rect['y0'], rect['z0'], width, depth, height, None,
None, None, None, None, None,
self.conf['material_ceiling']['type'],
self.conf['material_floor']['type'],
self.conf['material_wall']['type'], 0, 0, 0, None, None, None,
None, None, None, None, None, None, None, None, 0,
attrs['mvent_throughput'], attrs['exit_type'],
attrs['room_enter'], None, json.dumps(points))
# }}}
def _enhancements(self): # {{{
'''
Is HVENT vertical or horizontal? Apart from what is width and height
for geometry, HVENTS have their cfast_width always along the wall
Doors and Holes will be later interescted with parallel walls
(obstacles). We inspect is_vertical and make the doors just enough
smaller to avoid perpendicular intersections.
Since obstacles are generated to right/top direction, we need to
address the overlapping coming from left/bottom. So we make doors
shorter at x0 and y0, but not at x1 and y1. At the end our door=90cm
are now 86cm.
'''
self.outside_compa = self.s.query(
"SELECT count(*) FROM aamks_geom WHERE type_pri='COMPA'"
)[0]['count(*)'] + 1
self.floors = [
z['floor'] for z in self.s.query(
"SELECT DISTINCT floor FROM aamks_geom ORDER BY floor")
]
self.all_doors = [
z['name'] for z in self.s.query(
"SELECT name FROM aamks_geom WHERE type_tri='DOOR' ORDER BY name"
)
]
self.s.query(
"UPDATE aamks_geom SET is_vertical=0, cfast_width=width WHERE type_pri='HVENT' AND width > depth"
)
self.s.query(
"UPDATE aamks_geom SET is_vertical=1, cfast_width=depth WHERE type_pri='HVENT' AND width < depth"
)
self.s.query(
"UPDATE aamks_geom SET room_area=width*depth WHERE type_pri='COMPA'"
)
self.s.query(
"UPDATE aamks_geom SET x1=x0+width, y1=y0+depth, z1=z0+height, center_x=x0+width/2, center_y=y0+depth/2, center_z=z0+height/2"
)
self.s.query(
"UPDATE aamks_geom SET y0=y0+?, depth=depth-? WHERE type_tri='DOOR' AND is_vertical=1",
(self.walls_width, self.walls_width))
self.s.query(
"UPDATE aamks_geom SET x0=x0+?, width=width-? WHERE type_tri='DOOR' AND is_vertical=0",
(self.walls_width, self.walls_width))
# }}}
def _init_dd_geoms(self): # {{{
'''
dd_geoms are some optional extra rectangles, points, lines and
circles that are written to on top of our geoms. Useful for developing
and debugging features. Must come early, because visualization depends
on it.
Procedure:
z=self.json.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
z["0"]['rectangles'].append( { "xy": (0 , 0) , "width": 200 , "depth": 200 , "strokeColor": "#fff" , "strokeWidth": 2 , "fillColor": "#f80" , "opacity": 0.7 } )
z["0"]['circles'].append({ "xy": (i['center_x'], i['center_y']),"radius": 200, "fillColor": "#fff" , "opacity": 0.3 } )
self.json.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
'''
z = dict()
for floor in self.floors:
z[floor] = dict()
z[floor]['rectangles'] = []
z[floor]['lines'] = []
z[floor]['circles'] = []
z[floor]['texts'] = []
z[floor]['rectangles'] = []
#for i in self.s.query("SELECT * FROM aamks_geom WHERE type_tri='DOOR' AND floor=?", (floor,)):
# z[floor]['circles'].append({ "xy": (i['center_x'] , i['center_y']) , "radius": 90 , "fillColor": "#fff" , "opacity": 0.05 } )
# Example usage anywhere inside aamks:
# z=self.json.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# z["0"]['rectangles'].append( { "xy": (1000 , 1000) , "width": 200 , "depth": 300 , "strokeColor": "#fff" , "strokeWidth": 2 , "fillColor": "#f80" , "opacity": 0.7 } )
# z["0"]['rectangles'].append( { "xy": (0 , 0) , "width": 200 , "depth": 200 , "strokeColor": "#fff" , "strokeWidth": 2 , "fillColor": "#f80" , "opacity": 0.7 } )
# z["0"]['lines'].append( { "xy": (2000 , 200) , "x1": 3400 , "y1": 500 , "strokeColor": "#fff" , "strokeWidth": 2 , "opacity": 0.7 } )
# z["0"]['texts'].append( { "xy": (1000 , 1000) , "content": "(1000x1000)" , "fontSize": 400 , "fillColor":"#06f" , "opacity":0.7 } )
# self.json.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# Vis(None, 'image', 'dd_geoms example')
self.json.write(z,
'{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# }}}
def _make_id2compa_name(self): # {{{
'''
Create a map of ids to names for COMPAS, e.g. _id2compa_name[4]='ROOM_1_4'
This map is stored to sqlite because path.py needs it.
Still true after mesh travelling?
'''
self._id2compa_name = OrderedDict()
for v in self.s.query(
"select name,global_type_id from aamks_geom where type_pri='COMPA' ORDER BY global_type_id"
):
self._id2compa_name[v['global_type_id']] = v['name']
self._id2compa_name[self.outside_compa] = 'outside'
# }}}
def _add_names_to_vents_from_to(self): # {{{
'''
Vents from/to use indices, but names will be simpler for AAMKS and for
debugging. Hvents/Vvents lower_id/higher_id are already taken care of
in _find_intersections_between_floors()
'''
query = []
for v in self.s.query(
"select vent_from,vent_to,name from aamks_geom where type_pri IN('HVENT', 'VVENT')"
):
query.append((self._id2compa_name[v['vent_from']],
self._id2compa_name[v['vent_to']], v['name']))
self.s.executemany(
'UPDATE aamks_geom SET vent_from_name=?, vent_to_name=? WHERE name=?',
query)
# }}}
def _recalculate_vents_from_to(self): # {{{
'''
CFAST requires that towers slices are mapped back to the original cuboids
'''
update = []
for hi, lo in self.towers_parents.items():
z = self.s.query(
"SELECT name,vent_from FROM aamks_geom WHERE type_pri='HVENT' AND vent_from=? OR vent_to=? ORDER BY name",
(hi, hi))
for i in z:
update.append(
(min(lo, i['vent_from']), max(lo,
i['vent_from']), i['name']))
self.s.executemany(
"UPDATE aamks_geom SET vent_from=?, vent_to=? WHERE name=?",
update)
# }}}
def _calculate_sills(self): # {{{
'''
Sill is the distance relative to the floor. Say there's a HVENT H
between rooms A and B. Say A and B may have variate z0 (floor elevations).
We find 'hvent_from' and then we use it's z0. This z0 is the needed
'relative 0' for the calcuation.
'''
update = []
for v in self.s.query(
"SELECT global_type_id, z0, vent_from FROM aamks_geom WHERE type_pri='HVENT' ORDER BY name"
):
floor_baseline = self.s.query(
"SELECT z0 FROM aamks_geom WHERE global_type_id=? AND type_pri='COMPA'",
(v['vent_from'], ))[0]['z0']
update.append((v['z0'] - floor_baseline, v['global_type_id']))
self.s.executemany(
"UPDATE aamks_geom SET sill=? WHERE type_pri='HVENT' AND global_type_id=?",
update)
# }}}
def _terminal_doors(self): # {{{
'''
Doors that lead to outside or lead to staircases are terminal
'''
terminal_rooms = self.s.query(
"SELECT global_type_id FROM aamks_geom WHERE type_sec='STAI'")
update = []
for i in terminal_rooms:
z = self.s.query(
"SELECT name,exit_type FROM aamks_geom WHERE type_pri='HVENT' AND (vent_from=? OR vent_to=? OR vent_to_name='outside')",
(i['global_type_id'], i['global_type_id']))
for ii in z:
update.append((ii['exit_type'], ii['name']))
self.s.executemany(
"UPDATE aamks_geom SET terminal_door=? WHERE name=?", update)
#dd(self.s.query("SELECT name,terminal_door,vent_from_name,vent_to_name from aamks_geom order by name"))
# }}}
def _auto_detectors_and_sprinklers(self): # {{{
if len(''.join([str(i)
for i in self.conf['heat_detectors'].values()])) > 0:
self.s.query(
"UPDATE aamks_geom set heat_detectors = 1 WHERE type_pri='COMPA'"
)
if len(''.join([str(i)
for i in self.conf['smoke_detectors'].values()])) > 0:
self.s.query(
"UPDATE aamks_geom set smoke_detectors = 1 WHERE type_pri='COMPA'"
)
if len(''.join([str(i)
for i in self.conf['sprinklers'].values()])) > 0:
self.s.query(
"UPDATE aamks_geom set sprinklers = 1 WHERE type_pri='COMPA'")
# }}}
# INTERSECTIONS
def _aamks_geom_into_polygons(self): # {{{
''' aamks_geom into shapely polygons for intersections '''
self.aamks_polies = OrderedDict()
self.aamks_polies['COMPA'] = OrderedDict()
self.aamks_polies['HVENT'] = OrderedDict()
self.aamks_polies['VVENT'] = OrderedDict()
self.aamks_polies['MVENT'] = OrderedDict()
for floor in self.floors:
for elem in self.aamks_polies.keys():
self.aamks_polies[elem][floor] = OrderedDict()
for v in self.s.query(
"SELECT * FROM aamks_geom WHERE type_pri NOT IN('OBST', 'EVACUEE', 'FIRE') AND floor=?",
(floor, )):
self.aamks_polies[v['type_pri']][floor][
v['global_type_id']] = box(v['x0'], v['y0'],
v['x0'] + v['width'],
v['y0'] + v['depth'])
# }}}
def _get_faces(self): # {{{
'''
Cfast faces and offsets calculation. HVENTS have self.doors_width, so
we only consider intersection.length > self.doors_width. Faces are
properties of the doors. They are calculated in respect to the room of
lower id. The orientation of faces in each room:
3
+-------+
4 | | 2
+-------+
1
'''
for floor in self.floors:
for i in self.s.query(
"SELECT vent_from as compa_id, global_type_id as vent_id FROM aamks_geom WHERE type_pri='HVENT' AND floor=?",
(floor, )):
hvent_poly = self.aamks_polies['HVENT'][floor][i['vent_id']]
compa_poly = self.aamks_polies['COMPA'][floor][i['compa_id']]
compa = [(round(x), round(y))
for x, y in compa_poly.exterior.coords]
lines = OrderedDict()
lines[2] = LineString([compa[0], compa[1]])
lines[3] = LineString([compa[1], compa[2]])
lines[4] = LineString([compa[2], compa[3]])
lines[1] = LineString([compa[3], compa[0]])
for key, line in lines.items():
if hvent_poly.intersection(line).length > self.doors_width:
pt = list(zip(*line.xy))[0]
face = key
offset = hvent_poly.distance(Point(pt))
self.s.query(
"UPDATE aamks_geom SET face=?, face_offset=? WHERE global_type_id=? AND type_pri='HVENT'",
(face, offset, i['vent_id']))
# }}}
def _hvents_per_room(self): # {{{
'''
If there are more than one vent in a room Cfast needs them enumerated.
'''
i = 0
j = 0
update = []
for v in self.s.query(
"SELECT name,vent_from,vent_to FROM aamks_geom WHERE type_pri='HVENT' ORDER BY vent_from,vent_to"
):
if v['vent_from'] != i:
i = v['vent_from']
j = 0
j += 1
update.append((j, v['name']))
self.s.executemany(
'UPDATE aamks_geom SET hvent_room_seq=? WHERE name=?', (update))
# }}}
def _vvents_per_room(self): # {{{
'''
If there are more than one vent in a room Cfast needs them enumerated.
'''
i = 0
j = 0
update = []
for v in self.s.query(
"SELECT name,vent_from,vent_to FROM aamks_geom WHERE type_pri='VVENT' ORDER BY vent_from,vent_to"
):
if v['vent_from'] != i:
i = v['vent_from']
j = 0
j += 1
update.append((j, v['name']))
self.s.executemany(
'UPDATE aamks_geom SET vvent_room_seq=? WHERE name=?', (update))
# }}}
def _find_intersections_within_floor(self): # {{{
'''
Find intersections (hvents vs compas). This is how we know which doors
belong to which compas. We expect that HVENT intersects either:
a) room_from, room_to (two rectangles)
b) room_from, outside (one rectangle)
If the door originates at the very beginning of the room, then it also
has a tiny intersection with some third rectangle which we filter out
with:
intersection.length > 100 (intersection perimeter, 100 is arbitrary)
self.aamks_polies is a dict of floors:
COMPA: OrderedDict([(1, OrderedDict([(42, <shapely.geometry.polygon.Polygon object at 0x2b2206282e48>), (43, <shapely.geometry.polygon.Polygon object at 0x2b2206282eb8>), (44, <shapely.geometry.polygon.Polygon object at 0x2b2206282f28>)))]) ...
HVENT: OrderedDict([(1, OrderedDict([(21, <shapely.geometry.polygon.Polygon object at 0x2b2206282fd0>), (22, <shapely.geometry.polygon.Polygon object at 0x2b2206293048>)))]) ...
VVENT: OrderedDict([(1, OrderedDict([(1, <shapely.geometry.polygon.Polygon object at 0x2b2206298550>)]))])
We aim at having vc_intersections (Vent_x_Compa intersections) dict of vents. Each vent collects two compas:
1: [48, 29]
2: [49, 29]
3: [11 ] -> [11, 99(Outside)]
v=sorted(v) asserts that we go from lower_vent_id to higher_vent_id
Also, we need to make sure room A and room B do intersect if there is door from A to B.
'''
update = []
for floor, vents_dict in self.aamks_polies['HVENT'].items():
all_hvents = [
z['global_type_id'] for z in self.s.query(
"SELECT global_type_id FROM aamks_geom WHERE type_pri='HVENT' AND floor=? ORDER BY name",
floor)
]
vc_intersections = {key: [] for key in all_hvents}
for vent_id, vent_poly in vents_dict.items():
for compa_id, compa_poly in self.aamks_polies['COMPA'][
floor].items():
if vent_poly.intersection(compa_poly).length > 100:
vc_intersections[vent_id].append(compa_id)
for vent_id, v in vc_intersections.items():
v = sorted(v)
if len(v) == 2 and self.aamks_polies['COMPA'][floor][
v[0]].intersects(
self.aamks_polies['COMPA'][floor][v[1]]) == False:
self.make_vis("Space between compas", vent_id)
if len(v) == 1:
v.append(self.outside_compa)
if len(v) > 2:
self.make_vis(
'Door intersects no rooms or more than 2 rooms.',
vent_id)
update.append((v[0], v[1], vent_id))
self.s.executemany(
"UPDATE aamks_geom SET vent_from=?, vent_to=? where global_type_id=? and type_pri='HVENT'",
update)
# }}}
def _find_intersections_between_floors(self): # {{{
'''
Similar to _find_intersections_within_floor() This time we are looking for a
vvent (at floor n) which intersects a compa at it's floor (floor n)
and a compa above (floor n+1) We will iterate over two_floors, which
can contain: a) the set of compas from (floor n) and (floor n+1) b)
the set of compas from (floor n) only if it is the top most floor --
outside_compa will come into play
As opposed to _find_intersections_between_floors() vents go from higher to lower:
"UPDATE aamks_geom SET vent_to=?, vent_from=?"
intersection.length > 100 (intersection perimeter, 100 is arbitrary)
'''
update = []
for floor, vents_dict in self.aamks_polies['VVENT'].items():
all_vvents = [
z['global_type_id'] for z in self.s.query(
"SELECT global_type_id FROM aamks_geom WHERE type_pri='VVENT' AND floor=? ORDER BY name",
floor)
]
vc_intersections = {key: [] for key in all_vvents}
for vent_id, vent_poly in vents_dict.items():
try:
two_floors = self.aamks_polies['COMPA'][
floor] + self.aamks_polies['COMPA'][floor + 1]
except:
two_floors = self.aamks_polies['COMPA'][floor]
for compa_id, compa_poly in two_floors.items():
if vent_poly.intersection(compa_poly).length > 100:
vc_intersections[vent_id].append(compa_id)
for vent_id, v in vc_intersections.items():
v = sorted(v)
if len(v) == 1:
v.append(self.outside_compa)
if len(v) > 2:
self.make_vis(
'Vent intersects no rooms or more than 2 rooms.',
vent_id)
update.append((v[0], v[1], vent_id))
self.s.executemany(
"UPDATE aamks_geom SET vent_to=?, vent_from=? where global_type_id=? and type_pri='VVENT'",
update)
# }}}
def _towers_slices(self): # {{{
'''
This is for evacuation only and cannot interfere with fire models
(fire_model_ignore=1). Most STAI(RCASES) or HALL(S) are drawn on floor
0, but they are tall and need to cross other floors (towers). Say we
have floor bottoms at 0, 3, 6, 9, 12 metres and STAI's top is at 9
metres - the STAI belongs to floors 0, 1, 2. We INSERT (x,y) STAI
slices on proper floors. The slices are enumerated from 100000.
'''
towers = {}
for w in self.s.query(
"SELECT name,z0 as tower_z0,height+z0 as tower_z1,floor,height,type_sec FROM aamks_geom WHERE type_sec in ('STAI','HALL')"
):
floor_max_z = self.s.query(
"SELECT max(z1) FROM aamks_geom WHERE type_sec NOT IN('STAI','HALL') AND floor=?",
(w['floor'], ))[0]['max(z1)']
if w['tower_z1'] >= floor_max_z + 200:
towers[w['name']] = []
current_floor = w['floor']
for floor in self.floors:
for v in self.s.query(
"SELECT min(z0) FROM aamks_geom WHERE type_pri='COMPA' AND floor=?",
(floor, )):
if v['min(z0)'] < w['tower_z1'] and v['min(z0)'] >= w[
'tower_z0']:
towers[w['name']].append(floor)
towers[w['name']].remove(current_floor)
self.towers_parents = {}
high_global_type_id = 1000001
for orig_name, floors in towers.items():
orig_record = self.s.query(
"SELECT global_type_id,type_pri,type_sec,type_tri,x0,y0,width,depth,x1,y1,room_area,room_enter,points,1 as fire_model_ignore, terminal_door FROM aamks_geom WHERE name=?",
(orig_name, ))[0]
parent_id = orig_record['global_type_id']
kk = list(orig_record.keys())
kk.append('floor')
kk.append('name')
for flo in floors:
self.towers_parents[high_global_type_id] = parent_id
orig_record['global_type_id'] = high_global_type_id
vv = list(orig_record.values())
vv.append(flo)
vv.append("{}.{}".format(orig_name, flo))
self.s.query(
"INSERT INTO aamks_geom ({}) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
.format(",".join(kk)), tuple(vv))
high_global_type_id += 1
# }}}
# ASSERTIONS
def _assert_faces_ok(self): # {{{
''' Are all hvents' faces fine? '''
for v in self.s.query(
"SELECT * FROM aamks_geom WHERE type_tri='DOOR' ORDER BY vent_from,vent_to"
):
assert v['face_offset'] is not None, self.make_vis(
'Problem with cfast face calculation.', v['global_type_id'])
# }}}
def _assert_room_has_door(self): # {{{
# TODO: MUST ENABLE!
return
''' Each room must have at least one type_tri DOOR. '''
doors_intersect_room_ids = []
for i in self.s.query(
"SELECT vent_from,vent_to FROM aamks_geom WHERE type_tri='DOOR'"
):
doors_intersect_room_ids.append(i['vent_from'])
doors_intersect_room_ids.append(i['vent_to'])
all_interected_room = set(doors_intersect_room_ids)
for i in self.s.query(
"SELECT name,floor,global_type_id FROM aamks_geom WHERE type_pri='COMPA'"
):
if i['global_type_id'] not in all_interected_room:
self.make_vis('Room without door (see Animator)',
i['global_type_id'], 'COMPA')
# }}}
def make_vis(self, title, faulty_id='', type_pri='HVENT'): # {{{
'''
This method is for visualizing both errors and just how things look.
If faulty_id comes non-empty then we are signaling an error.
'''
if faulty_id != '':
r = self.s.query(
"SELECT name,floor FROM aamks_geom WHERE type_pri=? AND global_type_id=?",
(type_pri, faulty_id))[0]
fatal = "Fatal: {}: {}".format(r['name'], title)
Vis({
'highlight_geom': r['name'],
'anim': None,
'title': "<div id=python_msg>{}</div>".format(fatal),
'srv': 1
})
print(fatal)
sys.exit()
else:
Vis({
'highlight_geom': None,
'anim': None,
'title': title,
'srv': 1
})
# }}}
def _debug(self): # {{{
#dd(os.environ['AAMKS_PROJECT'])
#self.s.dumpall()
#self.s.dump_geoms()
#dd(self.s.query("select * from aamks_geom"))
#dd(self.s.query("select * from world2d"))
#exit()
#self.s.dump()
pass
class ResultsCollector():
def __init__(self, host, meta_file, sim_id): # {{{
'''
1. aamksrun makes gearman pass these jobs to workers:
/usr/local/aamks/tests/worker.py
2. Worker calls gearman server aOut function
3. This file implements gearman's aOut function:
* download results.json with configuration to workers/123/report_123.json
* download animation.zip to workers/123/anim.zip
'''
self.host = host
self.meta_file = meta_file
self.sim_id = sim_id
self.meta = None
self.json = Json()
self._fetch_meta()
self._animation()
self.psql_report()
# }}}
def _fetch_meta(self): # {{{
SendMessage("self.meta copied")
try:
Popen([
"scp", "{}:{}".format(self.host, self.meta_file),
self.meta_file
]).wait()
except Exception as e:
SendMessage(e)
else:
pass
self.meta = self.json.read(self.meta_file)
# }}}
def _fire_origin_coords(self, sim_id): # {{{
room = self.meta['fire_origin']
self.s = Sqlite("{}/aamks.sqlite".format(
self.meta['path_to_project']))
z = self.s.query(
"SELECT center_x, center_y FROM aamks_geom WHERE name=?",
(room, ))[0]
return (z['center_x'], z['center_y'])
# }}}
def _animation(self): # {{{
source = self.host + ':' + self.meta[
'path_to_project'] + 'workers/' + str(
self.meta['sim_id']) + '/' + self.meta['animation']
dest = self.meta['path_to_project'] + 'workers/' + str(
self.meta['sim_id']) + '/' + self.meta['animation']
Popen(["scp", source, dest])
self.jsonOut = OrderedDict()
self.jsonOut['sort_id'] = int(sim_id)
self.jsonOut['title'] = "sim{}, f{}".format(
self.meta['sim_id'], self.meta['floor'])
self.jsonOut['floor'] = self.meta['floor']
self.jsonOut['fire_origin'] = self._fire_origin_coords(
self.meta['sim_id'])
self.jsonOut['highlight_geom'] = None
self.jsonOut['anim'] = "{}/{}".format(self.meta['sim_id'],
self.meta['animation'])
anims_master = "{}/workers/vis/anims.json".format(
self.meta['path_to_project'])
try:
z = self.json.read(anims_master)
except:
z = []
z.append(self.jsonOut)
self.json.write(z, anims_master)
# }}}
def psql_report(self):
p = Psql()
fed = json.dumps(self.meta['psql']['fed'])
rset = json.dumps(self.meta['psql']['rset'])
p.query(
"UPDATE simulations SET fed = '{}', wcbe='{}', run_time = {}, dcbe_time = {}, min_vis_compa = {}, max_temp = {}, host = '{}', min_hgt_compa = {}, min_vis_cor = {}, min_hgt_cor = {} WHERE project=%s AND iteration=%s"
.format(
fed, rset, self.meta['psql']['runtime'],
self.meta['psql']['cross_building_results']['dcbe'],
self.meta['psql']['cross_building_results']
['min_vis_compa'], self.meta['psql']
['cross_building_results']['max_temp_compa'],
self.meta['worker'], self.meta['psql']
['cross_building_results']['min_hgt_compa'],
self.meta['psql']['cross_building_results']['min_vis_cor'],
self.meta['psql']['cross_building_results']
['min_hgt_cor']),
(self.meta['project_id'], self.meta['sim_id']))
class CfastMcarlo():
def __init__(self): # {{{
''' Generate montecarlo cfast.in. Log what was drawn to psql. '''
self.s = Sqlite("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
self.p = Psql()
self.json = Json()
self.conf = self.json.read("{}/conf.json".format(
os.environ['AAMKS_PROJECT']))
self._psql_collector = OrderedDict()
si = SimIterations(self.conf['project_id'],
self.conf['number_of_simulations'])
for self._sim_id in range(*si.get()):
seed(self._sim_id)
self._new_psql_log()
self._make_cfast()
self._write()
# }}}
# DISTRIBUTIONS / DRAWS
def _draw_outdoor_temp(self): # {{{
outdoor_temp = round(
normal(self.conf['outdoor_temperature']['mean'],
self.conf['outdoor_temperature']['sd']), 2)
self._psql_log_variable('outdoort', outdoor_temp)
return outdoor_temp
# }}}
def _draw_fire(self): # {{{
'''
FIRE_ORIGIN is passed via fire_origin.json to evac.in
TODO: we should have a better way of passing FIRE_ORIGIN, psql perhaps?
'''
origin_in_room = binomial(1, self.conf['fire_starts_in_a_room'])
self.all_corridors_and_halls = [
z['name'] for z in self.s.query(
"SELECT name FROM aamks_geom WHERE type_pri='COMPA' and type_sec in('COR','HALL') ORDER BY name"
)
]
self.all_rooms = [
z['name'] for z in self.s.query(
"SELECT name FROM aamks_geom WHERE type_sec='ROOM' ORDER BY name"
)
]
if origin_in_room == 1 or len(self.all_corridors_and_halls) == 0:
chosen = str(choice(self.all_rooms))
self._psql_log_variable('fireorig', 'room')
self._psql_log_variable('fireorigname', chosen)
else:
chosen = str(choice(self.all_corridors_and_halls))
self._psql_log_variable('fireorig', 'non_room')
self._psql_log_variable('fireorigname', chosen)
self.conf['ROOM_OF_FIRE_ORIGIN'] = chosen
compa = self.s.query(
"SELECT * FROM aamks_geom WHERE name=? and type_pri='COMPA'",
(chosen, ))[0]
self.json.write(
chosen, "{}/workers/{}/fire_origin.json".format(
os.environ['AAMKS_PROJECT'], self._sim_id))
x = round(compa['width'] / (2.0 * 100), 2)
y = round(compa['depth'] / (2.0 * 100), 2)
z = round(compa['height'] / 100.0 * (1 - math.log10(uniform(1, 10))),
2)
collect = ('FIRE', compa['global_type_id'], x, y, z, 1, 'TIME', '0',
'0', '0', '0', 'medium')
return (','.join(str(i) for i in collect))
# }}}
def _draw_fire_properties(self, intervals): # {{{
i = OrderedDict()
i['coyield'] = round(uniform(0.01, 0.043), 3)
i['sootyield'] = round(uniform(0.11, 0.17), 3)
i['trace'] = 0
i['q_star'] = round(uniform(0.5, 2), 3)
i['heigh'] = 0
i['radfrac'] = round(gamma(124.48, 0.00217), 3)
i['heatcom'] = round(uniform(16400000, 27000000), 1)
for k, v in i.items():
self._psql_log_variable(k, v)
result = OrderedDict()
result['sootyield'] = 'SOOT,{}'.format(','.join([str(i['sootyield'])] *
intervals))
result['coyield'] = 'CO,{}'.format(','.join([str(i['coyield'])] *
intervals))
result['trace'] = 'TRACE,{}'.format(','.join([str(i['trace'])] *
intervals))
result['q_star'] = i['q_star']
result['heigh'] = 'HEIGH,{}'.format(','.join([str(i['heigh'])] *
intervals))
result['radfrac'] = str(i['radfrac'])
result['heatcom'] = str(i['heatcom'])
return result
# }}}
def _draw_fire_development(self): # {{{
'''
Generate the fire. Alpha t square on the left, then constant in the
middle, then fading on the right. At the end read hrrs at given times.
'''
hrrpua = self.conf['hrrpua']
hrr_alpha = self.conf['hrr_alpha']
#'TODO:' HRR_PEAK is calculated as if each room was 10 m2, by HRRPUA times 10. It should be better addressed, by choosing room area and vent characteristics
hrr_peak = int(
triangular(hrrpua['min'], hrrpua['mode'], hrrpua['max']) * 10000)
alpha = int(
triangular(hrr_alpha['min'], hrr_alpha['mode'], hrr_alpha['max']) *
1000)
self._psql_log_variable('hrrpeak', hrr_peak / 1000)
self._psql_log_variable('alpha', alpha / 1000.0)
# left
t_up_to_hrr_peak = int((hrr_peak / alpha)**0.5)
interval = int(round(t_up_to_hrr_peak / 10))
times0 = list(range(0, t_up_to_hrr_peak,
interval)) + [t_up_to_hrr_peak]
hrrs0 = [int((alpha * t**2)) for t in times0]
# middle
t_up_to_starts_dropping = 15 * 60
times1 = [t_up_to_starts_dropping]
hrrs1 = [hrr_peak]
# right
t_up_to_drops_to_zero = t_up_to_starts_dropping + t_up_to_hrr_peak
interval = int(
round((t_up_to_drops_to_zero - t_up_to_starts_dropping) / 10))
times2 = list(
range(t_up_to_starts_dropping, t_up_to_drops_to_zero,
interval)) + [t_up_to_drops_to_zero]
hrrs2 = [int((alpha * (t - t_up_to_drops_to_zero)**2)) for t in times2]
times = list(times0 + times1 + times2)
hrrs = list(hrrs0 + hrrs1 + hrrs2)
return (times, hrrs)
# }}}
def _draw_window_opening(self, outdoor_temp): # {{{
'''
Windows are open / close based on outside temperatures but even
still, there's a distribution of users willing to open/close the
windows. Windows can be full-open (1), quarter-open (0.25) or closed
(0).
'''
draw_value = uniform(0, 1)
for i in self.conf['windows']:
if outdoor_temp > i['min'] and outdoor_temp <= i['max']:
if draw_value < i['full']:
how_much_open = 1
elif draw_value < i['full'] + i['quarter']:
how_much_open = 0.25
else:
how_much_open = 0
self._psql_log_variable('w', how_much_open)
return how_much_open
# }}}
def _draw_door_and_hole_opening(self, Type): # {{{
'''
Door may be open or closed, but Hole is always open and we don't need
to log that.
'''
vents = self.conf['vents_open']
if Type == 'HOLE':
how_much_open = 1
else:
how_much_open = binomial(1, vents[Type])
self._psql_log_variable(Type.lower(), how_much_open)
return how_much_open
# }}}
def _draw_heat_detectors_triggers(self): # {{{
mean = self.conf['heat_detectors']['temp_mean']
sd = self.conf['heat_detectors']['temp_sd']
zero_or_one = binomial(1, self.conf['heat_detectors']['not_broken'])
chosen = round(normal(mean, sd), 2) * zero_or_one
self._psql_log_variable('heat_detectors', chosen)
return str(chosen)
# }}}
def _draw_smoke_detectors_triggers(self): # {{{
mean = self.conf['smoke_detectors']['temp_mean']
sd = self.conf['smoke_detectors']['temp_sd']
zero_or_one = binomial(1, self.conf['smoke_detectors']['not_broken'])
chosen = round(normal(mean, sd), 2) * zero_or_one
self._psql_log_variable('smoke_detectors', chosen)
return str(chosen)
# }}}
def _draw_sprinklers_triggers(self): # {{{
mean = self.conf['sprinklers']['temp_mean']
sd = self.conf['sprinklers']['temp_sd']
zero_or_one = binomial(1, self.conf['sprinklers']['not_broken'])
chosen = round(normal(mean, sd), 2) * zero_or_one
self._psql_log_variable('sprinklers', chosen)
return str(chosen)
# }}}
def _psql_log_variable(self, attr, val): #{{{
self._psql_collector[self._sim_id][attr].append(val)
# }}}
# CFAST SECTIONS
def _make_cfast(self): # {{{
''' Compose cfast.in sections '''
outdoor_temp = self._draw_outdoor_temp()
txt = (
self._section_preamble(outdoor_temp),
self._section_matl(),
self._section_compa(),
self._section_halls_onez(),
self._section_windows(outdoor_temp),
self._section_doors_and_holes(),
self._section_vvent(),
self._section_mvent(),
self._section_fire(),
self._section_heat_detectors(),
self._section_smoke_detectors(),
self._section_sprinklers(),
)
with open(
"{}/workers/{}/cfast.in".format(os.environ['AAMKS_PROJECT'],
self._sim_id), "w") as output:
output.write("\n".join(filter(None, txt)))
# }}}
def _section_preamble(self, outdoor_temp): # {{{
'''
We use 600 as time, since Cfast will be killed by aamks.
'''
txt = (
'VERSN,7,{}_{}'.format('SIM', self.conf['project_id']),
'TIMES,600,-120,10,10',
'EAMB,{},101300,0'.format(273 + outdoor_temp),
'TAMB,293.15,101300,0,50',
'DTCHECK,1.E-9,100',
'',
)
return "\n".join(txt)
# }}}
def _section_matl(self): # {{{
txt = (
'!! MATL,name,param1,param2,param3,param4,param5,param6',
'MATL,concrete,1.7,840,2500,0.4,0.9,concrete',
'MATL,gypsum,0.3,1000,1000,0.02,0.85,gipsum',
'MATL,glass,0.8,840,2500,0.013,0.9,glass',
'MATL,block,0.3,840,800,0.03,0.85,floor',
'MATL,brick,0.3,840,800,0.03,0.85,brick',
'',
)
return "\n".join(txt)
# }}}
def _section_compa(self): # {{{
txt = [
'!! COMPA,name,width,depth,height,x,y,z,matl_ceiling,matl_floor,matl_wall'
]
for v in self.s.query(
"SELECT * from aamks_geom WHERE type_pri='COMPA'"):
collect = []
collect.append('COMPA') # COMPA
collect.append(v['name']) # NAME
collect.append(round(v['width'] / 100.0, 2)) # WIDTH
collect.append(round(v['depth'] / 100.0, 2)) # DEPTH
collect.append(round(v['height'] / 100.0, 2)) # INTERNAL_HEIGHT
collect.append(round(v['x0'] / 100.0, 2)) # ABSOLUTE_X_POSITION
collect.append(round(v['y0'] / 100.0, 2)) # ABSOLUTE_Y_POSITION
collect.append(round(v['z0'] / 100.0, 2)) # ABSOLUTE_Z_POSITION
collect.append(v['material_ceiling']) # CEILING_MATERIAL_NAME
collect.append(v['material_floor']) # FLOOR_MATERIAL_NAME
collect.append(v['material_wall']) # WALL_MATERIAL_NAME
txt.append(','.join(str(i) for i in collect))
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_halls_onez(self): # {{{
txt = ['!! ONEZ,id']
for v in self.s.query(
"SELECT * from aamks_geom WHERE type_sec in ('STAI', 'COR') order by type_sec"
):
collect = []
if v['type_sec'] == 'COR':
collect.append('HALL')
else:
collect.append('ONEZ')
collect.append(v['global_type_id'])
txt.append(','.join(str(i) for i in collect))
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_windows(self, outdoor_temp): # {{{
''' Randomize how windows are opened/closed. '''
txt = ['!! WINDOWS, from,to,id,width,soffit,sill,offset,face,open']
windows_setup = []
for v in self.s.query(
"SELECT * FROM aamks_geom WHERE type_tri='WIN' ORDER BY vent_from,vent_to"
):
collect = []
collect.append('HVENT') # HVENT
collect.append(v['vent_from']) # COMPARTMENT1
collect.append(v['vent_to']) # COMPARTMENT2
collect.append(v['hvent_room_seq']) # HVENT_NUMBER
collect.append(round(v['cfast_width'] / 100.0, 2)) # WIDTH
collect.append(round(
(v['sill'] + v['height']) / 100.0, 2
)) # SOFFIT (height of the top of the hvent relative to the floor)
collect.append(round(v['sill'] / 100.0, 2)) # SILL
collect.append(round(v['face_offset'] / 100.0,
2)) # COMPARTMENT1_OFFSET
collect.append(v['face']) # FACE
how_much_open = self._draw_window_opening(outdoor_temp)
windows_setup.append((how_much_open, v['name']))
collect.append(how_much_open)
txt.append(','.join(str(i) for i in collect))
self.s.executemany(
'UPDATE aamks_geom SET how_much_open=? WHERE name=?',
windows_setup)
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_doors_and_holes(self): # {{{
''' Randomize how doors are opened/close. '''
txt = ['!! DOORS, from,to,id,width,soffit,sill,offset,face,open']
hvents_setup = []
for v in self.s.query(
"SELECT * FROM aamks_geom WHERE type_tri='DOOR' ORDER BY vent_from,vent_to"
):
collect = []
collect.append('HVENT') # HVENT
collect.append(v['vent_from']) # COMPARTMENT1
collect.append(v['vent_to']) # COMPARTMENT2
collect.append(v['hvent_room_seq']) # VENT_NUMBER
collect.append(round(v['cfast_width'] / 100.0, 2)) # WIDTH
collect.append(round(
(v['sill'] + v['height']) / 100.0, 2
)) # SOFFIT (height of the top of the hvent relative to the floor)
collect.append(round(v['sill'] / 100.0, 2)) # SILL
collect.append(round(v['face_offset'] / 100.0,
2)) # COMPARTMENT1_OFFSET
collect.append(v['face']) # FACE
how_much_open = self._draw_door_and_hole_opening(
v['type_sec']) # HOLE_CLOSE
hvents_setup.append((how_much_open, v['name']))
collect.append(how_much_open)
txt.append(','.join(str(i) for i in collect))
self.s.executemany(
'UPDATE aamks_geom SET how_much_open=? WHERE name=?', hvents_setup)
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_vvent(self): # {{{
# VVENT AREA, SHAPE, INITIAL_FRACTION
txt = [
'!! VVENT,top,bottom,id,area,shape,rel_type,criterion,target,i_time, i_frac, f_time, f_frac, offset_x, offset_y'
]
for v in self.s.query(
"SELECT distinct v.room_area, v.type_sec, v.vent_from, v.vent_to, v.vvent_room_seq, v.width, v.depth, (v.x0 - c.x0) + 0.5*v.width as x0, (v.y0 - c.y0) + 0.5*v.depth as y0 FROM aamks_geom v JOIN aamks_geom c on v.vent_to_name = c.name WHERE v.type_pri='VVENT' AND c.type_pri = 'COMPA' ORDER BY v.vent_from,v.vent_to"
):
collect = []
collect.append('VVENT') # VVENT AREA, SHAPE, INITIAL_FRACTION
collect.append(v['vent_from']) # COMPARTMENT1
collect.append(v['vent_to']) # COMPARTMENT2
collect.append(v['vvent_room_seq']) # VENT_NUMBER
# TODO: we have it calcuated, right? collect.append(v['room_area']) # AREA OF THE ROOM, feb.2018: previously: round((v['width']*v['depth'])/1e4, 2)
collect.append(
round((v['width'] * v['depth']) / 1e4, 2)
) # AREA OF THE ROOM, feb.2018: previously: round((v['width']*v['depth'])/1e4, 2)
collect.append(2) # Type of dumper 1 - round, 2 - squere
collect.append('TIME') # Type of realease
collect.append('') # empty for time release
collect.append('') # empty for time release
collect.append(60) # start work on time
collect.append(0) # intial state before triggering
collect.append(120) # end work on time
#collect.append(1) # end state with probability of working
collect.append(self._draw_door_and_hole_opening(
v['type_sec'])) # end state with probability of working
collect.append(round(v['x0'] / 100, 2)) # Offset_x
collect.append(round(v['y0'] / 100, 2)) # Offset_y
txt.append(','.join(str(i) for i in collect))
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_mvent(self): # {{{
# VVENT AREA, SHAPE, INITIAL_FRACTION
txt = [
'!!VVENT,first_comp,second_comp,id,orientation1,height_in,area_in,orientation2,height_out,area_out,flowm3/s,press_l,press_u,release,nix,nix,initial_time,initial_fraction,final_time,final_fraction'
]
collect = []
#collect.append('MVENT,28,35,1,V,2.3,0.48,H,3,0.48,1.7,200,300,TIME,,,60,0,70,1,1,1')
#collect.append('MVENT,28,35,2,V,2.3,0.48,H,3,0.48,1.7,200,300,TIME,,,60,0,70,1,2.5,1')
#collect.append('MVENT,35,28,3,V,2.3,0.48,H,3,0.48,1.7,200,300,TIME,,,60,0,70,1,10,1')
#collect.append('MVENT,35,28,4,V,2.3,0.48,H,3,0.48,1.7,200,300,TIME,,,60,0,70,1,11,1')
#collect.append('MVENT,30,35,1,V,2.3,0.48,H,3,0.48,1.7,200,300,TIME,,,60,0,70,1,1,1')
#collect.append('MVENT,31,35,2,V,2.3,0.48,H,3,0.48,1.7,200,300,TIME,,,60,0,70,1,1,1')
#collect.append('MVENT,35,30,3,V,2.3,0.48,H,3,0.48,1.7,200,300,TIME,,,60,0,70,1,1,4')
#collect.append('MVENT,35,31,4,V,2.3,0.48,H,3,0.48,1.7,200,300,TIME,,,60,0,70,1,2,1')
txt.append('\n'.join(str(i) for i in collect))
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_heat_detectors(self): # {{{
txt = [
'!! DETECTORS,type,compa,temp,width,depth,height,rti,supress,density'
]
for v in self.s.query(
"SELECT * from aamks_geom WHERE type_pri='COMPA' AND heat_detectors=1"
):
temp = self._draw_heat_detectors_triggers(
) # ACTIVATION_TEMPERATURE,
if temp == '0.0':
collect = []
else:
collect = []
collect.append('DETECT') # DETECT,
collect.append('HEAT') # TYPE: HEAT,SMOKE,SPRINKLER
collect.append(v['global_type_id']) # COMPARTMENT,
collect.append(temp) # ACTIVATION_TEMPERATURE,
collect.append(round(v['width'] / (2.0 * 100), 2)) # WIDTH
collect.append(round(v['depth'] / (2.0 * 100), 2)) # DEPTH
collect.append(round(v['height'] / 100.0, 2)) # HEIGHT
collect.append(80) # RTI,
collect.append(0) # SUPPRESSION,
collect.append(7E-05) # SPRAY_DENSITY
txt.append(','.join(str(i) for i in collect))
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_smoke_detectors(self): # {{{
txt = [
'!! DETECTORS,type,compa,temp,width,depth,height,rti,supress,density'
]
for v in self.s.query(
"SELECT * from aamks_geom WHERE type_pri='COMPA' AND smoke_detectors=1"
):
temp = self._draw_smoke_detectors_triggers(
) # ACTIVATION_TEMPERATURE,
if temp == '0.0':
collect = []
else:
collect = []
collect.append('DETECT') # DETECT,
collect.append('SMOKE') # TYPE: HEAT,SMOKE,SPRINKLER
collect.append(v['global_type_id']) # COMPARTMENT,
collect.append(temp) # ACTIVATION_TEMPERATURE,
collect.append(round(v['width'] / (2.0 * 100), 2)) # WIDTH
collect.append(round(v['depth'] / (2.0 * 100), 2)) # DEPTH
collect.append(round(v['height'] / 100.0, 2)) # HEIGHT
collect.append(80) # RTI,
collect.append(0) # SUPPRESSION,
collect.append(7E-05) # SPRAY_DENSITY
txt.append(','.join(str(i) for i in collect))
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_sprinklers(self): # {{{
txt = [
'!! SPRINKLERS,type,compa,temp,width,depth,height,rti,supress,density'
]
for v in self.s.query(
"SELECT * from aamks_geom WHERE type_pri='COMPA' and sprinklers=1"
):
temp = self._draw_sprinklers_triggers() # ACTIVATION_TEMPERATURE,
if temp == '0.0':
collect = []
else:
collect = []
collect.append('DETECT') # DETECT,
collect.append('SPRINKLER') # TYPE: HEAT,SMOKE,SPRINKLER
collect.append(v['global_type_id']) # COMPARTMENT,
collect.append(temp) # ACTIVATION_TEMPERATURE,
collect.append(round(v['width'] / (2.0 * 100), 2)) # WIDTH
collect.append(round(v['depth'] / (2.0 * 100), 2)) # DEPTH
collect.append(round(v['height'] / 100.0, 2)) # HEIGHT
collect.append(50) # RTI,
collect.append(1) # SUPPRESSION,
collect.append(7E-05) # SPRAY_DENSITY
txt.append(','.join(str(i) for i in collect))
return "\n".join(txt) + "\n" if len(txt) > 1 else ""
# }}}
def _section_fire(self): # {{{
times, hrrs = self._draw_fire_development()
fire_properties = self._draw_fire_properties(len(times))
area = (
((npa(hrrs) / 1000) /
(fire_properties['q_star'] * 1.204 * 1.005 * 293 * sqrt(9.81)))
**(2 / 5)) + 0.0001
txt = (
'!! FIRE,compa,x,y,z,fire_number,ignition_type,ignition_criterion,ignition_target,?,?,name',
self._draw_fire(),
'',
'!! CHEMI,?,?,?,?',
'CHEMI,1,1.8,0.3,0.05,0,0.283,{}'.format(
fire_properties['heatcom']),
'',
'TIME,' + ','.join(str(i) for i in times),
'HRR,' + ','.join(str(round(i, 3)) for i in hrrs),
fire_properties['sootyield'],
fire_properties['coyield'],
fire_properties['trace'],
'AREA,' + ','.join(str(i) for i in area),
fire_properties['heigh'],
)
return "\n".join(txt) + "\n"
# }}}
def _new_psql_log(self): #{{{
''' Init the collector for storing montecarlo cfast setup. Variables will be registered later one at a time. '''
self._psql_collector[self._sim_id] = OrderedDict([
('fireorig', []),
('fireorigname', []),
('heat_detectors', []),
('smoke_detectors', []),
('hrrpeak', []),
('sootyield', []),
('coyield', []),
('alpha', []),
('trace', []),
('area', []),
('q_star', []),
('heigh', []),
('w', []),
('outdoort', []),
('c', []),
('d', []),
('sprinklers', []),
('heatcom', []),
('e', []),
('vnt', []),
('radfrac', []),
])
#}}}
def _write(self): #{{{
'''
Write cfast variables to postgres. Both column names and the values for
psql come from trusted source, so there should be no security issues
with just joining dict data (non-parametrized query).
'''
pairs = []
for k, v in self._psql_collector[self._sim_id].items():
pairs.append("{}='{}'".format(k, ','.join(str(x) for x in v)))
data = ', '.join(pairs)
self.p.query(
"UPDATE simulations SET {} WHERE project=%s AND iteration=%s".
format(data), (self.conf['project_id'], self._sim_id))
class OnInit():
def __init__(self): # {{{
''' Stuff that happens at the beggining of the project '''
if len(sys.argv) > 1:
os.environ["AAMKS_PROJECT"] = sys.argv[1]
self.json = Json()
self.conf = self.json.read("{}/conf.json".format(
os.environ['AAMKS_PROJECT']))
self.project_id = self.conf['project_id']
self.scenario_id = self.conf['scenario_id']
self.p = Psql()
self._clear_srv_anims()
self._clear_sqlite()
self._setup_simulations()
# }}}
def _clear_srv_anims(self): # {{{
'''
Need to detect and remove obsolete srv animations. Server always
overwrites anims.json and we need to prevent the dumplicates in
Animator right menu entries.
We try: because there may be no anims.json just yet.
TODO: it is possible we could just remove this file and remove all
server animations. But would it hurt workers animations?
'''
try:
anims = self.json.read("{}/workers/anims.json".format(
os.environ['AAMKS_PROJECT']))
new_anims = []
for a in anims:
if a['srv'] != 1:
new_anims.append(a)
self.json.write(
new_anims,
"{}/workers/anims.json".format(os.environ['AAMKS_PROJECT']))
except:
pass
# }}}
def _clear_sqlite(self): # {{{
try:
os.remove("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
except:
pass
# }}}
def _create_iterations_sequence(self): # {{{
'''
For a given project we may run simulation 0 to 999. Then we may wish to
run 100 simulations more and have them numbered here: from=1000 to=1099
These from and to numbers are unique for the project and are used as
rand seeds in later aamks modules. This is similar, but distinct from
SimIterations() - we are creating the sequence, and the later reads the
sequence from/to. Remember that range(1,4) returns 1,2,3; hence SELECT
max(iteration)+1
'''
how_many = self.conf['number_of_simulations']
r = []
try:
# If the project already exists in simulations table (e.g. adding 100 simulations to existing 1000); try: fails on addition on int+None.
r.append(
self.p.query(
'SELECT max(iteration)+1 FROM simulations WHERE project=%s AND scenario_id=%s',
(self.project_id, self.scenario_id))[0][0])
r.append(r[0] + how_many)
except:
# If a new project
r = [1, how_many + 1]
return r
# }}}
def _setup_simulations(self): # {{{
''' Simulation dir maps to id from psql's simulations table'''
workers_dir = "{}/workers".format(os.environ['AAMKS_PROJECT'])
os.makedirs(workers_dir, exist_ok=True)
irange = self._create_iterations_sequence()
for i in range(*irange):
sim_dir = "{}/{}".format(workers_dir, i)
os.makedirs(sim_dir, exist_ok=True)
self.p.query(
"INSERT INTO simulations(iteration,project,scenario_id) VALUES(%s,%s,%s)",
(i, self.project_id, self.scenario_id))
class Geom():
def __init__(self): # {{{
self.json = Json()
self.s = Sqlite("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
self.raw_geometry = self.json.read("{}/cad.json".format(
os.environ['AAMKS_PROJECT']))
self.conf = self.json.read("{}/conf.json".format(
os.environ['AAMKS_PROJECT']))
self._doors_width = 32
self._wall_width = 4
self._make_elem_counter()
self._geometry2sqlite()
self._enhancements()
self._init_dd_geoms()
self._make_fake_wells()
self._floors_details()
self._aamks_geom_into_polygons()
self._make_id2compa_name()
self._find_intersections_within_floor()
self._get_faces()
self._hvents_per_room()
self._find_intersections_between_floors()
self._vvents_per_room()
self._add_names_to_vents_from_to()
self._calculate_sills()
self._auto_detectors_and_sprinklers()
self._create_obstacles()
self.make_vis('Create obstacles')
self._navmesh()
self._assert_faces_ok()
self._assert_room_has_door()
#self.s.dumpall()
# }}}
def _floors_details(self): # {{{
'''
Floor dimensions are needed here and there, therefore we store it in
sqlite. Canvas size is 1600 x 800 in css.css. Calculate how to scale
the whole floor to fit the canvas. Minima don't have to be at (0,0) in
autocad, therefore we also need to translate the drawing for the
canvas.
'''
values = OrderedDict()
for floor in self.floors:
minx = self.s.query(
"SELECT min(x0) AS minx FROM aamks_geom WHERE floor=?",
(floor, ))[0]['minx']
miny = self.s.query(
"SELECT min(y0) AS miny FROM aamks_geom WHERE floor=?",
(floor, ))[0]['miny']
maxx = self.s.query(
"SELECT max(x1) AS maxx FROM aamks_geom WHERE floor=?",
(floor, ))[0]['maxx']
maxy = self.s.query(
"SELECT max(y1) AS maxy FROM aamks_geom WHERE floor=?",
(floor, ))[0]['maxy']
z0 = self.s.query("SELECT z0 FROM aamks_geom WHERE floor=?",
(floor, ))[0]['z0']
width = maxx - minx
height = maxy - miny
center = (minx + int(width / 2), miny + int(height / 2), z0)
animation_scale = round(min(1600 / width, 800 / height) * 0.95,
2) # 0.95 is canvas padding
animation_translate = [
int(maxx - 0.5 * width),
int(maxy - 0.5 * height)
]
values[floor] = OrderedDict([('width', width), ('height', height),
('z', z0), ('center', center),
('minx', minx), ('miny', miny),
('maxx', maxx), ('maxy', maxy),
('animation_scale', animation_scale),
('animation_translate',
animation_translate)])
self.s.query("CREATE TABLE floors(json)")
self.s.query('INSERT INTO floors VALUES (?)', (json.dumps(values), ))
# }}}
def _geometry2sqlite(self): # {{{
'''
Parse geometry and place geoms in sqlite. The lowest floor is always 0.
The self.raw_geometry example for floor("0"):
"0": [
"ROOM": [
[ [ 3.0 , 4.8 , 0.0 ] , [ 4.8 , 6.5 , 3.0 ] ] ,
[ [ 3.0 , 6.5 , 0.0 ] , [ 6.8 , 7.4 , 3.0 ] ]
]
]
Each geom entity will be classified as DOOR, WINDOW, ROOM etc, and will
get a unique name via elem_counter. Some columns in db are left empty
for now.
Sqlite's aamks_geom table must use two unique ids a) 'name' for
visualisation and b) 'global_type_id' for cfast enumeration.
'''
data = []
for floor, gg in self.raw_geometry.items():
for k, arr in gg.items():
for v in arr:
p0 = [int(i) for i in v[0]]
p1 = [int(i) for i in v[1]]
width = p1[0] - p0[0]
depth = p1[1] - p0[1]
height = p1[2] - p0[2]
record = self._prepare_geom_record(k, [p0, p1], width,
depth, height, floor)
if record != False:
data.append(record)
self.s.query(
"CREATE TABLE aamks_geom(name,floor,global_type_id,hvent_room_seq,vvent_room_seq,type_pri,type_sec,type_tri,x0,y0,z0,width,depth,height,cfast_width,sill,face,face_offset,vent_from,vent_to,material_ceiling,material_floor,material_wall,heat_detectors,smoke_detectors,sprinklers,is_vertical,vent_from_name,vent_to_name, how_much_open, room_area, x1, y1, z1, center_x, center_y, center_z, fire_model_ignore)"
)
self.s.executemany(
'INSERT INTO aamks_geom VALUES ({})'.format(','.join(
'?' * len(data[0]))), data)
#dd(self.s.dump())
#}}}
def _prepare_geom_record(self, k, v, width, depth, height, floor): # {{{
''' Format a record for sqlite. Hvents get fixed width self._doors_width cm '''
# OBST
if k in ('OBST', ):
type_pri = 'OBST'
type_tri = ''
# EVACUEE
elif k in ('EVACUEE', ):
type_pri = 'EE'
type_tri = ''
# MVENT
elif k in ('MVENT', ):
type_pri = 'MVENT'
type_tri = ''
# VVENT
elif k in ('VVENT', ):
type_pri = 'VVENT'
height = 10
type_tri = ''
# COMPA
elif k in ('ROOM', 'COR', 'HALL', 'STAI'):
type_pri = 'COMPA'
type_tri = ''
# HVENT
elif k in ('D', 'C', 'E', 'HOLE', 'W'):
width = max(width, self._doors_width)
depth = max(depth, self._doors_width)
type_pri = 'HVENT'
if k in ('D', 'C', 'E', 'HOLE'):
type_tri = 'DOOR'
elif k in ('W'):
type_tri = 'WIN'
self._elem_counter[type_pri] += 1
global_type_id = self._elem_counter[type_pri]
name = '{}_{}'.format(k[0], global_type_id)
#data.append('name' , 'floor' , 'global_type_id' , 'hvent_room_seq' , 'vvent_room_seq' , 'type_pri' , 'type_sec' , 'type_tri' , 'x0' , 'y0' , 'z0' , 'width' , 'depth' , 'height' , 'cfast_width' , 'sill' , 'face' , 'face_offset' , 'vent_from' , 'vent_to' , material_ceiling , material_floor , material_wall , 'heat_detectors' , 'smoke_detectors' , 'sprinklers' , 'is_vertical' , 'vent_from_name' , 'vent_to_name' , 'how_much_open' , 'room_area' , 'x1' , 'y1' , 'z1' , 'center_x' , 'center_y' , 'center_z' , 'fire_model_ignore')
return (name, floor, global_type_id, None, None, type_pri, k, type_tri,
v[0][0], v[0][1], v[0][2], width, depth, height, None, None,
None, None, None, None, self.conf['material_ceiling']['type'],
self.conf['material_floor']['type'],
self.conf['material_wall']['type'], 0, 0, 0, None, None, None,
None, None, None, None, None, None, None, None, 0)
# }}}
def _enhancements(self): # {{{
'''
Is HVENT vertical or horizontal? Apart from what is width and height
for geometry, HVENTS have their cfast_width always along the wall
Doors and Holes will be later interescted with parallel walls
(obstacles). We inspect is_vertical and make the doors just enough
smaller to avoid perpendicular intersections.
Since obstacles are generated to right/top direction, we need to
address the overlapping coming from left/bottom. So we make doors
shorter at x0 and y0, but not at x1 and y1. At the end our door=90cm
are now 86cm.
'''
self.outside_compa = self.s.query(
"SELECT count(*) FROM aamks_geom WHERE type_pri='COMPA'"
)[0]['count(*)'] + 1
self.floors = [
z['floor'] for z in self.s.query(
"SELECT DISTINCT floor FROM aamks_geom ORDER BY floor")
]
self.all_doors = [
z['name'] for z in self.s.query(
"SELECT name FROM aamks_geom WHERE type_tri='DOOR' ORDER BY name"
)
]
self.s.query(
"UPDATE aamks_geom SET is_vertical=0, cfast_width=width WHERE type_pri='HVENT' AND width > depth"
)
self.s.query(
"UPDATE aamks_geom SET is_vertical=1, cfast_width=depth WHERE type_pri='HVENT' AND width < depth"
)
self.s.query(
"UPDATE aamks_geom SET room_area=round(width*depth/10000,2) WHERE type_pri='COMPA'"
)
self.s.query(
"UPDATE aamks_geom SET x1=x0+width, y1=y0+depth, z1=z0+height, center_x=x0+width/2, center_y=y0+depth/2, center_z=z0+height/2"
)
self.s.query(
"UPDATE aamks_geom SET y0=y0+?, depth=depth-? WHERE type_tri='DOOR' AND is_vertical=1",
(self._wall_width, self._wall_width))
self.s.query(
"UPDATE aamks_geom SET x0=x0+?, width=width-? WHERE type_tri='DOOR' AND is_vertical=0",
(self._wall_width, self._wall_width))
# }}}
def _init_dd_geoms(self): # {{{
'''
dd_geoms are some optional extra rectangles, points, lines and
circles that are written to on top of our geoms. Useful for developing
and debugging features. Must come early, because visualization depends
on it.
Procedure:
* z=self.json.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
* z["0"]['circles'].append({ "xy": (i['center_x'], i['center_y']),"radius": 200, "fillColor": "#fff" , "opacity": 0.3 } )
* z["0"]['circles'].append({ "xy": (i['center_x'], i['center_y']),"radius": 200, "fillColor": "#fff" , "opacity": 0.3 } )
* self.json.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
'''
z = dict()
for floor in self.floors:
z[floor] = dict()
z[floor]['rectangles'] = []
z[floor]['lines'] = []
z[floor]['circles'] = []
z[floor]['texts'] = []
z[floor]['rectangles'] = []
for i in self.s.query(
"SELECT * FROM aamks_geom WHERE type_tri='DOOR' AND floor=?",
(floor, )):
z[floor]['circles'].append({
"xy": (i['center_x'], i['center_y']),
"radius": 90,
"fillColor": "#fff",
"opacity": 0.05
})
# Example usage anywhere inside aamks:
# z=self.json.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# z["0"]['rectangles'].append( { "xy": (1000 , 1000) , "width": 200 , "depth": 300 , "strokeColor": "#fff" , "strokeWidth": 2 , "fillColor": "#f80" , "opacity": 0.7 } )
# z["0"]['rectangles'].append( { "xy": (0 , 0) , "width": 200 , "depth": 200 , "strokeColor": "#fff" , "strokeWidth": 2 , "fillColor": "#f80" , "opacity": 0.7 } )
# z["0"]['lines'].append( { "xy": (2000 , 200) , "x1": 3400 , "y1": 500 , "strokeColor": "#fff" , "strokeWidth": 2 , "opacity": 0.7 } )
# z["0"]['texts'].append( { "xy": (1000 , 1000) , "content": "(1000x1000)" , "fontSize": 400 , "fillColor":"#06f" , "opacity":0.7 } )
# self.json.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# Vis(None, 'image', 'dd_geoms example')
self.json.write(z,
'{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# }}}
def _make_fake_wells(self): # {{{
'''
TODO: are we using this?
This is for evacuation only and cannot interfere with fire models
(fire_model_ignore=1). Most STAI(RCASES) or HALL(S) are drawn on floor
0, but they are tall and need to cross other floors. We call them
WELLs. Say we have floor bottoms at 0, 3, 6, 9, 12 metres and WELL's
top is at 9 metres - the WELL belongs to floors 0, 1, 2. We INSERT fake
(x,y) WELL slices on proper floors in order to calculate vent_from /
vent_to properly.
'''
return
add_wells = {}
for w in self.s.query(
"SELECT floor,global_type_id,height FROM aamks_geom WHERE type_sec in ('STAI','HALL')"
):
add_wells[(w['floor'], w['global_type_id'])] = []
current_floor = w['floor']
for floor in self.floors:
for v in self.s.query(
"SELECT min(z0) FROM aamks_geom WHERE type_pri='COMPA' AND floor=?",
(floor, )):
if v['min(z0)'] < w['height']:
add_wells[(w['floor'],
w['global_type_id'])].append(floor)
add_wells[(w['floor'], w['global_type_id'])].remove(current_floor)
for w, floors in add_wells.items():
row = self.s.query(
"SELECT * FROM aamks_geom WHERE type_pri='COMPA' AND global_type_id=?",
(w[1], ))[0]
for floor in floors:
row['fire_model_ignore'] = 1
row['floor'] = floor
self.s.query(
'INSERT INTO aamks_geom VALUES ({})'.format(','.join(
'?' * len(row.keys()))), list(row.values()))
# }}}
def _make_id2compa_name(self): # {{{
'''
Create a map of ids to names for COMPAS, e.g. _id2compa_name[4]='ROOM_1_4'
This map is stored to sqlite because path.py needs it.
Still true after mesh travelling?
'''
self._id2compa_name = OrderedDict()
for v in self.s.query(
"select name,global_type_id from aamks_geom where type_pri='COMPA' ORDER BY global_type_id"
):
self._id2compa_name[v['global_type_id']] = v['name']
self._id2compa_name[self.outside_compa] = 'outside'
# }}}
def _add_names_to_vents_from_to(self): # {{{
'''
Vents from/to use indices, but names will be simpler for AAMKS and for
debugging. Hvents/Vvents lower_id/higher_id are already taken care of
in _find_intersections_between_floors()
'''
query = []
for v in self.s.query(
"select vent_from,vent_to,name from aamks_geom where type_pri IN('HVENT', 'VVENT')"
):
query.append((self._id2compa_name[v['vent_from']],
self._id2compa_name[v['vent_to']], v['name']))
self.s.executemany(
'UPDATE aamks_geom SET vent_from_name=?, vent_to_name=? WHERE name=?',
query)
# }}}
def _calculate_sills(self): # {{{
'''
Sill is the distance relative to the floor. Say there's a HVENT H
between rooms A and B. Say A and B have variate z0 (floor elevations).
How do we calculate the height of the sill? The CFAST.in solution is
simple: We find 'hvent_from' for H and then we use it's z0. This z0 is
the needed 'relative 0' for the calcuation.
'''
update = []
for v in self.s.query(
"SELECT global_type_id, z0, vent_from FROM aamks_geom WHERE type_pri='HVENT' ORDER BY name"
):
floor_baseline = self.s.query(
"SELECT z0 FROM aamks_geom WHERE global_type_id=? AND type_pri='COMPA'",
(v['vent_from'], ))[0]['z0']
update.append((v['z0'] - floor_baseline, v['global_type_id']))
self.s.executemany(
"UPDATE aamks_geom SET sill=? WHERE type_pri='HVENT' AND global_type_id=?",
update)
# }}}
def _auto_detectors_and_sprinklers(self): # {{{
if len(''.join([str(i)
for i in self.conf['heat_detectors'].values()])) > 0:
self.s.query(
"UPDATE aamks_geom set heat_detectors = 1 WHERE type_pri='COMPA'"
)
if len(''.join([str(i)
for i in self.conf['smoke_detectors'].values()])) > 0:
self.s.query(
"UPDATE aamks_geom set smoke_detectors = 1 WHERE type_pri='COMPA'"
)
if len(''.join([str(i)
for i in self.conf['sprinklers'].values()])) > 0:
self.s.query(
"UPDATE aamks_geom set sprinklers = 1 WHERE type_pri='COMPA'")
# }}}
def _make_elem_counter(self): # {{{
'''
Geom primary types are enumerated globally for the building in sqlite.
Each of the types has separate numbering starting from 1. ROOM_2_8
refers to the eight compartment in the building which happens to exist
on floor 2.
'''
self._elem_counter = {}
for i in ('COMPA', 'HVENT', 'VVENT', 'OBST', 'EE', 'MVENT'):
self._elem_counter[i] = 0
# }}}
# INTERSECTIONS
def _aamks_geom_into_polygons(self): # {{{
''' aamks_geom into shapely polygons for intersections '''
self.aamks_polies = OrderedDict()
self.aamks_polies['COMPA'] = OrderedDict()
self.aamks_polies['HVENT'] = OrderedDict()
self.aamks_polies['VVENT'] = OrderedDict()
self.aamks_polies['MVENT'] = OrderedDict()
for floor in self.floors:
for elem in self.aamks_polies.keys():
self.aamks_polies[elem][floor] = OrderedDict()
for v in self.s.query(
"SELECT * FROM aamks_geom WHERE type_pri NOT IN('OBST', 'EE') AND floor=?",
(floor, )):
self.aamks_polies[v['type_pri']][floor][
v['global_type_id']] = box(v['x0'], v['y0'],
v['x0'] + v['width'],
v['y0'] + v['depth'])
# }}}
def _get_faces(self): # {{{
'''
Cfast faces and offsets calculation. HVENTS have self._doors_width, so
we only consider intersection.length > self._doors_width Faces are
properties of doors. They are calculated in respect to the room of
lower id. The orientation of faces in each room:
3
+-------+
4 | | 2
+-------+
1
'''
for floor in self.floors:
for i in self.s.query(
"SELECT vent_from as compa_id, global_type_id as vent_id FROM aamks_geom WHERE type_pri='HVENT' AND floor=?",
(floor, )):
hvent_poly = self.aamks_polies['HVENT'][floor][i['vent_id']]
compa_poly = self.aamks_polies['COMPA'][floor][i['compa_id']]
compa = [(round(x), round(y))
for x, y in compa_poly.exterior.coords]
lines = OrderedDict()
lines[2] = LineString([compa[0], compa[1]])
lines[3] = LineString([compa[1], compa[2]])
lines[4] = LineString([compa[2], compa[3]])
lines[1] = LineString([compa[3], compa[0]])
for key, line in lines.items():
if hvent_poly.intersection(
line).length > self._doors_width:
pt = list(zip(*line.xy))[0]
face = key
offset = hvent_poly.distance(Point(pt))
self.s.query(
"UPDATE aamks_geom SET face=?, face_offset=? WHERE global_type_id=? AND type_pri='HVENT'",
(face, offset, i['vent_id']))
# }}}
def _hvents_per_room(self): # {{{
'''
If there are more than one vent in a room Cfast needs them enumerated.
'''
i = 0
j = 0
update = []
for v in self.s.query(
"SELECT name,vent_from,vent_to FROM aamks_geom WHERE type_pri='HVENT' ORDER BY vent_from,vent_to"
):
if v['vent_from'] != i:
i = v['vent_from']
j = 0
j += 1
update.append((j, v['name']))
self.s.executemany(
'UPDATE aamks_geom SET hvent_room_seq=? WHERE name=?', (update))
# }}}
def _vvents_per_room(self): # {{{
'''
If there are more than one vent in a room Cfast needs them enumerated.
'''
i = 0
j = 0
update = []
for v in self.s.query(
"SELECT name,vent_from,vent_to FROM aamks_geom WHERE type_pri='VVENT' ORDER BY vent_from,vent_to"
):
if v['vent_from'] != i:
i = v['vent_from']
j = 0
j += 1
update.append((j, v['name']))
self.s.executemany(
'UPDATE aamks_geom SET vvent_room_seq=? WHERE name=?', (update))
# }}}
def _find_intersections_within_floor(self): # {{{
'''
Find intersections (hvents vs compas). This is how we know which doors
belong to which compas. We expect that HVENT intersects either:
a) room_from, room_to (two rectangles)
b) room_from, outside (one rectangle)
If the door originates at the very beginning of the room, then it also
has a tiny intersection with some third rectangle which we filter out
with:
intersection.length > 100 (intersection perimeter, 100 is arbitrary)
self.aamks_polies is a dict of floors:
COMPA: OrderedDict([(1, OrderedDict([(42, <shapely.geometry.polygon.Polygon object at 0x2b2206282e48>), (43, <shapely.geometry.polygon.Polygon object at 0x2b2206282eb8>), (44, <shapely.geometry.polygon.Polygon object at 0x2b2206282f28>)))]) ...
HVENT: OrderedDict([(1, OrderedDict([(21, <shapely.geometry.polygon.Polygon object at 0x2b2206282fd0>), (22, <shapely.geometry.polygon.Polygon object at 0x2b2206293048>)))]) ...
VVENT: OrderedDict([(1, OrderedDict([(1, <shapely.geometry.polygon.Polygon object at 0x2b2206298550>)]))])
We aim at having vc_intersections (Vent_x_Compa intersections) dict of vents. Each vent collects two compas:
1: [48, 29]
2: [49, 29]
3: [11 ] -> [11, 99(Outside)]
v=sorted(v) asserts that we go from lower_vent_id to higher_vent_id
Also, we need to make sure room A and room B do intersect if there is door from A to B.
'''
update = []
for floor, vents_dict in self.aamks_polies['HVENT'].items():
all_hvents = [
z['global_type_id'] for z in self.s.query(
"SELECT global_type_id FROM aamks_geom WHERE type_pri='HVENT' AND floor=? ORDER BY name",
floor)
]
vc_intersections = {key: [] for key in all_hvents}
for vent_id, vent_poly in vents_dict.items():
for compa_id, compa_poly in self.aamks_polies['COMPA'][
floor].items():
if vent_poly.intersection(compa_poly).length > 100:
vc_intersections[vent_id].append(compa_id)
for vent_id, v in vc_intersections.items():
v = sorted(v)
if len(v) == 2 and self.aamks_polies['COMPA'][floor][
v[0]].intersects(
self.aamks_polies['COMPA'][floor][v[1]]) == False:
self.make_vis("Space between compas".format(floor),
vent_id)
if len(v) == 1:
v.append(self.outside_compa)
if len(v) > 2:
self.make_vis(
'Door intersects no rooms or more than 2 rooms.',
vent_id)
update.append((v[0], v[1], vent_id))
self.s.executemany(
"UPDATE aamks_geom SET vent_from=?, vent_to=? where global_type_id=? and type_pri='HVENT'",
update)
# }}}
def _find_intersections_between_floors(self): # {{{
'''
Similar to _find_intersections_within_floor() This time we are looking for a
vvent (at floor n) which intersects a compa at it's floor (floor n)
and a compa above (floor n+1) We will iterate over two_floors, which
can contain: a) the set of compas from (floor n) and (floor n+1) b)
the set of compas from (floor n) only if it is the top most floor --
outside_compa will come into play
As opposed to _find_intersections_between_floors() vents go from higher to lower:
"UPDATE aamks_geom SET vent_to=?, vent_from=?"
intersection.length > 100 (intersection perimeter, 100 is arbitrary)
'''
update = []
for floor, vents_dict in self.aamks_polies['VVENT'].items():
all_vvents = [
z['global_type_id'] for z in self.s.query(
"SELECT global_type_id FROM aamks_geom WHERE type_pri='VVENT' AND floor=? ORDER BY name",
floor)
]
vc_intersections = {key: [] for key in all_vvents}
for vent_id, vent_poly in vents_dict.items():
try:
two_floors = self.aamks_polies['COMPA'][
floor] + self.aamks_polies['COMPA'][floor + 1]
except:
two_floors = self.aamks_polies['COMPA'][floor]
for compa_id, compa_poly in two_floors.items():
if vent_poly.intersection(compa_poly).length > 100:
vc_intersections[vent_id].append(compa_id)
for vent_id, v in vc_intersections.items():
v = sorted(v)
if len(v) == 1:
v.append(self.outside_compa)
if len(v) > 2:
self.make_vis(
'Vent intersects no rooms or more than 2 rooms.',
vent_id)
update.append((v[0], v[1], vent_id))
self.s.executemany(
"UPDATE aamks_geom SET vent_to=?, vent_from=? where global_type_id=? and type_pri='VVENT'",
update)
# }}}
# OBSTACLES
def _create_obstacles(self): # {{{
'''
Geometry may contain obstacles to model machines, FDS walls, bookcases,
etc. Obstacles are not visible in CFAST, since they don't belong to
aamks_geom table.
'''
data = OrderedDict()
data['points'] = OrderedDict()
data['named'] = OrderedDict()
floors_meta = json.loads(
self.s.query("SELECT json FROM floors")[0]['json'])
for floor, gg in self.raw_geometry.items():
data['points'][floor] = []
data['named'][floor] = []
boxen = []
# TODO: once cad.json uses 'OBST': [], there's no need to try.
try:
for v in gg['OBST']:
boxen.append(
box(int(v[0][0]), int(v[0][1]), int(v[1][0]),
int(v[1][1])))
except:
pass
boxen += self._rooms_into_boxen(floor)
data['named'][floor] = self._boxen_into_rectangles(boxen)
for i in boxen:
data['points'][floor].append([(int(x), int(y),
floors_meta[floor]['z'])
for x, y in i.exterior.coords])
self.s.query("CREATE TABLE obstacles(json)")
self.s.query("INSERT INTO obstacles VALUES (?)", (json.dumps(data), ))
#}}}
def _rooms_into_boxen(self, floor): # {{{
'''
For a roomX we create a roomX_ghost, we move it by self._wall_width,
which must match the width of hvents. Then we create walls via logical
operations. Finally doors cut the openings in walls.
'''
walls = []
for i in self.s.query(
"SELECT * FROM aamks_geom WHERE floor=? AND type_pri='COMPA' ORDER BY name",
(floor, )):
walls.append((i['x0'] + self._wall_width, i['y0'],
i['x0'] + i['width'], i['y0'] + self._wall_width))
walls.append((i['x0'] + i['width'], i['y0'],
i['x0'] + i['width'] + self._wall_width,
i['y0'] + i['depth'] + self._wall_width))
walls.append((i['x0'] + self._wall_width, i['y0'] + i['depth'],
i['x0'] + i['width'],
i['y0'] + i['depth'] + self._wall_width))
walls.append((i['x0'], i['y0'], i['x0'] + self._wall_width,
i['y0'] + i['depth'] + self._wall_width))
walls_polygons = ([
box(ii[0], ii[1], ii[2], ii[3]) for ii in set(walls)
])
doors_polygons = []
for i in self.s.query(
"SELECT * FROM aamks_geom WHERE floor=? AND type_tri='DOOR' ORDER BY name",
(floor, )):
doors_polygons.append(
box(i['x0'], i['y0'], i['x0'] + i['width'],
i['y0'] + i['depth']))
boxen = []
for wall in walls_polygons:
for door in doors_polygons:
wall = wall.difference(door)
if isinstance(wall, MultiPolygon):
for i in polygonize(wall):
boxen.append(i)
elif isinstance(wall, Polygon):
boxen.append(wall)
return boxen
# }}}
def _boxen_into_rectangles(self, boxen): # {{{
'''
Transform shapely boxen into rectangles for paperjs visualization:
[(x0,y0,width,height)]
'''
rectangles = []
for i in boxen:
m = i.bounds
coords = OrderedDict()
coords["x0"] = int(m[0])
coords["y0"] = int(m[1])
coords["width"] = int(m[2] - m[0])
coords["depth"] = int(m[3] - m[1])
rectangles.append(coords)
return rectangles
# }}}
# NAVMESH
def _navmesh(self): # {{{
'''
1. Create obj file from aamks geometries.
2. Build navmesh with golang, obj is input
3. Query navmesh with python
'''
self.nav = OrderedDict()
z = self.s.query("SELECT json FROM obstacles")
for floor, faces in json.loads(z[0]['json'])['points'].items():
self._obj_num = 0
obj = ''
for face in faces:
obj += self._obj_elem(face, 99)
for face in self._obj_platform(floor):
obj += self._obj_elem(face, 0)
with open("{}/{}.obj".format(os.environ['AAMKS_PROJECT'], floor),
"w") as f:
f.write(obj)
self.nav[floor] = Navmesh()
self.nav[floor].build(obj, os.environ['AAMKS_PROJECT'], floor)
self._navmesh_test(floor)
Vis({
'highlight_geom': None,
'anim': None,
'title': 'Navmesh test',
'srv': 1
})
# }}}
def _obj_platform(self, floor): # {{{
z = self.s.query(
"SELECT x0,y0,x1,y1 FROM aamks_geom WHERE type_pri='COMPA' AND floor=?",
(floor, ))
platforms = []
for i in z:
platforms.append([(i['x1'], i['y1']), (i['x1'], i['y0']),
(i['x0'], i['y0']), (i['x0'], i['y1'])])
return platforms
# }}}
def _obj_elem(self, face, z): # {{{
elem = ''
elem += "o Face{}\n".format(self._obj_num)
for verts in face[:4]:
elem += "v {}\n".format(" ".join(
[str(i / 100) for i in [verts[0], z, verts[1]]]))
elem += "f {}\n\n".format(" ".join(
[str(4 * self._obj_num + i) + "//1" for i in [1, 2, 3, 4]]))
self._obj_num += 1
return elem
# }}}
def _navmesh_test(self, floor): # {{{
colors = ["#fff", "#f80", "#f00", "#8f0", "#08f", "#f0f"]
navmesh_paths = []
for x in range(6):
src_dest = []
for i in self.s.query(
"SELECT * FROM aamks_geom WHERE type_pri='COMPA' AND floor=? ORDER BY RANDOM() LIMIT 2",
(floor, )):
src_dest.append([
round(uniform(i['x0'], i['x1'])),
round(uniform(i['y0'], i['y1']))
])
z = self.json.read('{}/dd_geoms.json'.format(
os.environ['AAMKS_PROJECT']))
z[floor]['circles'].append({
"xy": (src_dest[0]),
"radius": 20,
"fillColor": colors[x],
"opacity": 1
})
z[floor]['circles'].append({
"xy": (src_dest[1]),
"radius": 20,
"fillColor": colors[x],
"opacity": 1
})
self.json.write(
z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
navmesh_paths.append(self.nav[floor].query(src_dest, floor))
self._navmesh_vis(floor, navmesh_paths, colors)
# }}}
def _navmesh_vis(self, floor, navmesh_paths, colors): # {{{
j = Json()
z = j.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
for cc, path in enumerate(navmesh_paths):
for i, p in enumerate(path):
try:
z[floor]['lines'].append({
"xy": (path[i][0], path[i][1]),
"x1": path[i + 1][0],
"y1": path[i + 1][1],
"strokeColor": colors[cc],
"strokeWidth": 2,
"opacity": 0.7
})
except:
pass
j.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# }}}
# ASSERTIONS
def _assert_faces_ok(self): # {{{
''' Are all hvents' faces fine? '''
for v in self.s.query(
"SELECT * FROM aamks_geom WHERE type_tri='DOOR' ORDER BY vent_from,vent_to"
):
assert v['face_offset'] is not None, self.make_vis(
'Problem with cfast face calculation.', v['global_type_id'])
# }}}
def _assert_room_has_door(self): # {{{
''' Each room must have at least one type_tri DOOR. '''
doors_intersect_room_ids = []
for i in self.s.query(
"SELECT vent_from,vent_to FROM aamks_geom WHERE type_tri='DOOR'"
):
doors_intersect_room_ids.append(i['vent_from'])
doors_intersect_room_ids.append(i['vent_to'])
all_interected_room = set(doors_intersect_room_ids)
for i in self.s.query(
"SELECT name,floor,global_type_id FROM aamks_geom WHERE type_pri='COMPA'"
):
if i['global_type_id'] not in all_interected_room:
self.make_vis('Room without door (see Animator)',
i['global_type_id'], 'COMPA')
# }}}
def make_vis(self, title, faulty_id='', type_pri='HVENT'): # {{{
'''
This method is for visualizing both errors and just how things look.
If faulty_id comes non-empty then we are signaling an error.
'''
if faulty_id != '':
r = self.s.query(
"SELECT name,floor FROM aamks_geom WHERE type_pri=? AND global_type_id=?",
(type_pri, faulty_id))[0]
fatal = "Fatal: {}: {}".format(r['name'], title)
Vis({
'highlight_geom': r['name'],
'anim': None,
'title': "<div id=python_msg>{}</div>".format(fatal),
'srv': 1
})
print(fatal)
sys.exit()
else:
Vis({
'highlight_geom': None,
'anim': None,
'title': title,
'srv': 1
})
class EvacMcarlo():
def __init__(self):# {{{
''' Generate montecarlo evac.conf. '''
self.json=Json()
self.conf=self.json.read("{}/conf.json".format(os.environ['AAMKS_PROJECT']))
self.s=Sqlite("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
self.evacuee_radius=self.json.read('{}/inc.json'.format(os.environ['AAMKS_PATH']))['evacueeRadius']
self.floors=[z['floor'] for z in self.s.query("SELECT DISTINCT floor FROM aamks_geom ORDER BY floor")]
self._project_name=os.path.basename(os.environ['AAMKS_PROJECT'])
si=SimIterations(self.conf['project_id'], self.conf['scenario_id'], self.conf['number_of_simulations'])
sim_ids=range(*si.get())
for self._sim_id in sim_ids:
seed(self._sim_id)
self._fire_obstacle()
self._static_evac_conf()
self._dispatch_evacuees()
self._make_evac_conf()
self._evacuees_static_animator()
# }}}
def _static_evac_conf(self):# {{{
'''
AAMKS_PROJECT must be propagated to worker environment.
'''
self._evac_conf=self.conf
self._evac_conf['AAMKS_PROJECT']=os.environ['AAMKS_PROJECT']
self._evac_conf['SIM_ID']=self._sim_id
self._evac_conf['SERVER']=os.environ['AAMKS_SERVER']
self._evac_conf['FIRE_ORIGIN']=self.s.query("SELECT name FROM fire_origin WHERE sim_id=?", (self._sim_id,))[0]['name']
# }}}
def _fire_obstacle(self):# {{{
'''
Fire Obstacle prevents humans to walk right through the fire. Currently
we build the rectangle xx * yy around x,y. Perhaps this size could be
some function of fire properties.
'''
xx=150
yy=150
z=self.s.query("SELECT * FROM fire_origin")
i=z[0]
points=[ [i['x']-xx, i['y']-yy, 0], [i['x']+xx, i['y']-yy, 0], [i['x']+xx, i['y']+yy, 0], [i['x']-xx, i['y']+yy, 0], [i['x']-xx, i['y']-yy, 0] ]
obstacles=self.json.readdb("obstacles")
obstacles['fire']={ i['floor']: points }
self.s.query("UPDATE obstacles SET json=?", (json.dumps(obstacles),))
# }}}
def _make_pre_evacuation(self,room,type_sec):# {{{
'''
An evacuee pre_evacuates from either ordinary room or from the room of
fire origin; type_sec is for future development.
'''
if room != self._evac_conf['FIRE_ORIGIN']:
pe=self.conf['pre_evac']
else:
pe=self.conf['pre_evac_fire_origin']
return round(lognorm(s=1, loc=pe['mean'], scale=pe['sd']).rvs(), 2)
# }}}
def _get_density(self,name,type_sec,floor):# {{{
'''
Special selectors from distributions.json
First we try to return ROOM_1_2, then ROOM_FLOOR_1, then ROOM
Concentration comes as m^2, but aamks uses 100 * 100 cm^2
'''
z=self.conf['evacuees_concentration']
for i in [name, "{}_FLOOR_{}".format(type_sec,floor), type_sec]:
if i in z.keys():
return z[i] * 100 * 100
raise Exception("Cannot determine the density for {}".format(name))
# }}}
def _evac_rooms(self,floor): # {{{
'''
* probabilistic: probabilistic rooms
* manual: manually asigned evacuees
'''
rooms={}
probabilistic_rooms={}
for i in self.s.query("SELECT points, name, type_sec FROM aamks_geom WHERE type_pri='COMPA' AND floor=? ORDER BY global_type_id", (floor,)):
i['points']=json.loads(i['points'])
probabilistic_rooms[i['name']]=i
manual_rooms={}
for i in self.s.query("SELECT name, x0, y0 FROM aamks_geom WHERE type_pri='EVACUEE' AND floor=?", (floor,)):
q=(floor,i['x0'], i['y0'], i['x0'], i['y0'])
x=self.s.query("SELECT name,type_sec FROM aamks_geom WHERE type_pri='COMPA' AND floor=? AND x0<=? AND y0<=? AND x1>=? AND y1>=?", q)[0]
if not x['name'] in manual_rooms:
manual_rooms[x['name']]={'type_sec': x['type_sec'], 'positions': [] }
del probabilistic_rooms[x['name']]
manual_rooms[x['name']]['positions'].append((i['x0'], i['y0'], x['name']))
rooms['probabilistic']=probabilistic_rooms
rooms['manual']=manual_rooms
return rooms
# }}}
def _dispatch_evacuees(self):# {{{
'''
We dispatch the evacuees across the building according to the density
distribution.
'''
self.dispatched_evacuees=OrderedDict()
self.pre_evacuation=OrderedDict()
self._make_floor_obstacles()
for floor in self.floors:
self.pre_evacuation[floor] = list()
positions = []
evac_rooms=self._evac_rooms(floor)
for name,r in evac_rooms['probabilistic'].items():
density=self._get_density(r['name'],r['type_sec'],floor)
room_positions=self._dispatch_inside_polygons(density,r['points'], floor, name)
positions += room_positions
for i in room_positions:
self.pre_evacuation[floor].append(self._make_pre_evacuation(r['name'], r['type_sec']))
for name,r in evac_rooms['manual'].items():
positions += r['positions']
for i in r['positions']:
self.pre_evacuation[floor].append(self._make_pre_evacuation(name, r['type_sec']))
self.dispatched_evacuees[floor] = positions
# }}}
def _make_floor_obstacles(self):# {{{
self._floor_obstacles={}
for floor in self.floors:
obsts=[]
for x in self.json.readdb("obstacles")['obstacles'][floor]:
obsts.append([(o[0],o[1]) for o in x])
try:
obsts.append(self.json.readdb("obstacles")['fire'][floor])
except:
pass
self._floor_obstacles[floor]=unary_union([ Polygon(i) for i in obsts ])
# }}}
def _dispatch_inside_polygons(self,density,points,floor,name):# {{{
exterior=Polygon(points)
exterior_minus_obsts=exterior.difference(self._floor_obstacles[floor])
walkable=exterior_minus_obsts.buffer(- self.evacuee_radius - 10 )
bbox=list(walkable.bounds)
target=int(walkable.area / density)
positions=[]
while len(positions) < target:
x=uniform(bbox[0], bbox[2])
y=uniform(bbox[1], bbox[3])
if walkable.intersects(Point(x,y)):
positions.append((int(x),int(y), name))
return positions
# }}}
def _make_evac_conf(self):# {{{
''' Write data to sim_id/evac.json. '''
self._evac_conf['FLOORS_DATA']=OrderedDict()
for floor in self.floors:
self._evac_conf['FLOORS_DATA'][floor]=OrderedDict()
self._evac_conf['FLOORS_DATA'][floor]['NUM_OF_EVACUEES']=len(self.dispatched_evacuees[floor])
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES']=OrderedDict()
z=self.s.query("SELECT z0 FROM aamks_geom WHERE floor=?", (floor,))[0]['z0']
for i,pos in enumerate(self.dispatched_evacuees[floor]):
e_id='f{}'.format(i)
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id]=OrderedDict()
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id]['ORIGIN'] = (pos[0], pos[1])
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id]['COMPA'] = (pos[2])
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id]['PRE_EVACUATION'] = self.pre_evacuation[floor][i]
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id]['ALPHA_V'] = round(normal(self.conf['evacuees_alpha_v']['mean'] , self.conf['evacuees_alpha_v']['sd']) , 2)
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id]['BETA_V'] = round(normal(self.conf['evacuees_beta_v']['mean'] , self.conf['evacuees_beta_v']['sd']) , 2)
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id]['H_SPEED'] = round(normal(self.conf['evacuees_max_h_speed']['mean'] , self.conf['evacuees_max_h_speed']['sd']) , 2)
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id]['V_SPEED'] = round(normal(self.conf['evacuees_max_v_speed']['mean'] , self.conf['evacuees_max_v_speed']['sd']) , 2)
self.json.write(self._evac_conf, "{}/workers/{}/evac.json".format(os.environ['AAMKS_PROJECT'],self._sim_id))
# }}}
def _evacuees_static_animator(self):# {{{
'''
For the animator. We just pick a single, newest sim_id and display
evacuees init positions. Animator can use it when there are no worker
provided animations (moving evacuees for specific sim_id).
'''
m={}
for floor in self.floors:
m[floor]=self.dispatched_evacuees[floor]
self.s.query('INSERT INTO dispatched_evacuees VALUES (?)', (json.dumps(m),))
class CfastPartition():
def __init__(self, verbose=0): # {{{
'''
Divide space into cells for smoke conditions queries asked by evacuees.
A cell may be a square or a rectangle. First divide space into squares
of self._square_side. Iterate over squares and if any square is crossed by an
obstacle divide this square further into rectangles.
In the final structure of partition.json we encode each cell.
Each cell is sorted by x, which allows quick bisections.
* In each cell we always encode the first sub-cell - the square itself.
(2000, 2449): OrderedDict([('x', (2000,)), ('y', (2449,))])
* Then we can add more sub-cells (rectangles).
(1600, 2449): OrderedDict([('x', (1600, 1600, 1842, 1842)), ('y', (2449, 2541, 2449, 2541))])
Partition will be later used for filling the cells with smoke
conditions. Finally we get a tool for quick altering of the state of an
evacuee at x,y.
'''
self._square_side=300
self.s=Sqlite("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
try:
self.s.query("DROP TABLE cell2compa")
self.s.query("DROP TABLE query_vertices")
except:
pass
self.s.query("CREATE TABLE cell2compa(json)")
self.s.query("CREATE TABLE query_vertices(json)")
self.json=Json()
self._cell2compa=OrderedDict()
self._save=OrderedDict()
floors=json.loads(self.s.query("SELECT * FROM floors")[0]['json'])
for floor in floors.keys():
self._init_space(floor)
self._intersect_space()
self._optimize(floor)
self._make_cell2compa(floor)
if(verbose==1):
self._plot_space(floor) # debug
if(verbose==1):
Vis(None, 'image', 'partition') # debug
self._dbsave()
# }}}
def _init_space(self,floor):# {{{
''' Divide floor into squares. Prepare empty rectangles placeholders. '''
floors=json.loads(self.s.query("SELECT * FROM floors")[0]['json'])
fdims=floors[floor]
self.squares=OrderedDict()
self.rectangles=OrderedDict()
self.lines=[]
for i in self.s.query("SELECT * FROM aamks_geom WHERE type_pri='COMPA' AND floor=? ORDER BY x0,y0", (floor,)):
self.lines.append(LineString([ Point(i['x0'],i['y0']), Point(i['x0'], i['y1'])] ))
self.lines.append(LineString([ Point(i['x0'],i['y0']), Point(i['x1'], i['y0'])] ))
self.lines.append(LineString([ Point(i['x1'],i['y1']), Point(i['x0'], i['y1'])] ))
self.lines.append(LineString([ Point(i['x1'],i['y1']), Point(i['x1'], i['y0'])] ))
x=int(fdims['width']/self._square_side)+1
y=int(fdims['height']/self._square_side)+1
for v in range(y):
for i in range(x):
x_=fdims['minx']+self._square_side*i
y_=fdims['miny']+self._square_side*v
xy=(x_, y_)
self.squares[xy]=box(x_, y_, x_+self._square_side, y_+self._square_side)
self.rectangles[xy]=[]
# }}}
def _candidate_intersection(self,id_,points):# {{{
'''
So there's an intersection "points" of the square and the walls of the
room. We get 2 points in this call. Should we create a rectangle of any
of these points? The rectangle is defined by it's (minX,minY) vertex.
We only accept the points that belong to the square but don't lie on
the maxX (right) and maxY (top) edges.
'''
right_limit=id_[0]+self._square_side
top_limit=id_[1]+self._square_side
for pt in list(zip(points.xy[0], points.xy[1])):
if right_limit != pt[0] and top_limit != pt[1]:
self.rectangles[id_].append((int(pt[0]), int(pt[1])))
# }}}
def _optimize(self, floor):# {{{
'''
* self.squares (collection of shapely boxen) is not needed anymore
* self.rectangles must have duplicates removed and must be sorted by x
* xy_vectors must be of the form: [ [x0,x1,x2,x3], [y0,y1,y2,y3] ].
self._query_vertices are of the form:
square : optimized rectangles
(1000 , -1000): OrderedDict([('x' , (1000 , 1100)) , ('y' , (-1000 , -1000))])
(1400 , -1000): OrderedDict([('x' , (1400 , 1500)) , ('y' , (-1000 , -1000))])
(1800 , -1000): OrderedDict([('x' , (1800 , )) , ('y' , (-1000 , ))])
(2200 , -1000): OrderedDict([('x' , (2200 , )) , ('y' , (-1000 , ))])
'''
del(self.squares)
for id_,rects in self.rectangles.items():
rects.append(id_)
self.rectangles[id_]=list(sorted(set(rects)))
self._query_vertices=OrderedDict()
for id_,v in self.rectangles.items():
self._query_vertices[id_]=OrderedDict()
xy_vectors=list(zip(*self.rectangles[id_]))
try:
self._query_vertices[id_]['x']=xy_vectors[0]
self._query_vertices[id_]['y']=xy_vectors[1]
except:
self._query_vertices[id_]['x']=()
self._query_vertices[id_]['y']=()
self._save[floor]=OrderedDict()
self._save[floor]['square_side']=self._square_side
self._save[floor]['query_vertices']=OrderedDict()
for k,v in self._query_vertices.items():
cell_str="{}x{}".format(k[0], k[1])
self._save[floor]['query_vertices'][cell_str]=v
# }}}
def _intersect_space(self):# {{{
'''
We want to further partition the square into rectangles based on obstacles.
'''
for line in self.lines:
for id_,square in self.squares.items():
if square.intersects(line):
points=square.intersection(line)
if points.length>0:
self._candidate_intersection(id_,points)
# }}}
def _plot_space(self,floor):# {{{
'''
Plots the partition on top of the rooms.
'''
z=self.json.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
radius=5
a=self._square_side
for k,v in self.rectangles.items():
z[floor]['rectangles'].append( { "xy": k, "width": a , "depth": a , "strokeColor": "#f80" , "strokeWidth": 2 , "opacity": 0.2 } )
z[floor]['circles'].append( { "xy": k, "radius": radius , "fillColor": "#fff", "opacity": 0.3 } )
z[floor]['texts'].append( { "xy": k, "content": k, "fontSize": 5, "fillColor":"#f0f", "opacity":0.7 })
for mm in v:
z[floor]['circles'].append( { "xy": mm, "radius": radius, "fillColor": "#fff", "opacity": 0.3 } )
z[floor]['texts'].append( { "xy": mm, "content": mm, "fontSize": 5, "fillColor":"#f0f", "opacity":0.7 })
self.json.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# }}}
def _make_cell2compa_record(self,cell,floor):# {{{
cell_str="{}x{}".format(cell[0], cell[1])
try:
self._cell2compa[floor][cell_str]=self.s.query("SELECT name from aamks_geom WHERE floor=? AND type_pri='COMPA' AND ?>=x0 AND ?>=y0 AND ?<x1 AND ?<y1", (floor, cell[0], cell[1], cell[0], cell[1]))[0]['name']
except:
pass
# }}}
def _make_cell2compa(self,floor):#{{{
self._cell2compa[floor]=OrderedDict()
for k,v in self._query_vertices.items():
self._make_cell2compa_record(k,floor)
for pt in list(zip(v['x'], v['y'])):
self._make_cell2compa_record(pt,floor)
#}}}
def _dbsave(self):# {{{
self.s.query('INSERT INTO cell2compa VALUES (?)' , (json.dumps(self._cell2compa),))
self.s.query('INSERT INTO query_vertices VALUES (?)' , (json.dumps(self._save),))
class Navmesh:
def __init__(self): # {{{
'''
installer/navmesh_installer.sh installs all the dependencies.
* navmesh build from the obj geometry file
thanks to https://github.com/arl/go-detour !
* navmesh query
thanks to https://github.com/layzerar/recastlib/ !
============================================
This is how we are supposed to be called:
nav=Navmesh()
nav.build(floor)
nav.query([(1300,600), (3100,1800)])
or if you want to block r1 and r2 and have the navmeshes named
navs=dict()
navs[('r1','r2')]=Navmesh()
navs[('r1','r2')].build(floor,('r1','r2'))
navs[('r1','r2')].query([(1300,600), (3100,1800)])
'''
self.json = Json()
self.s = Sqlite("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
self.navmesh = OrderedDict()
# }}}
def _bricked_wall(self, floor, bypass_rooms=[]): # {{{
'''
For navmesh we may wish to turn some doors into bricks.
'''
bricked_wall = []
if len(bypass_rooms) > 0:
floors_meta = json.loads(
self.s.query("SELECT json FROM floors_meta")[0]['json'])
elevation = floors_meta[floor]['minz_abs']
where = " WHERE "
where += " vent_from_name=" + " OR vent_from_name=".join(
["'{}'".format(i) for i in bypass_rooms])
where += " OR vent_to_name=" + " OR vent_to_name=".join(
["'{}'".format(i) for i in bypass_rooms])
bypass_doors = self.s.query(
"SELECT name,x0,y0,x1,y1 FROM aamks_geom {}".format(where))
for i in bypass_doors:
bricked_wall.append([[i['x0'], i['y0'], elevation],
[i['x1'], i['y0'], elevation],
[i['x1'], i['y1'], elevation],
[i['x0'], i['y1'], elevation],
[i['x0'], i['y0'], elevation]])
bricked_wall += self.json.readdb("obstacles")['obstacles'][floor]
try:
bricked_wall.append(self.json.readdb("obstacles")['fire'][floor])
except:
pass
return bricked_wall
# }}}
def _obj_platform(self, floor): # {{{
z = self.s.query(
"SELECT x0,y0,x1,y1 FROM aamks_geom WHERE type_pri='COMPA' AND floor=?",
(floor, ))
platforms = []
for i in z:
platforms.append([(i['x1'], i['y1']), (i['x1'], i['y0']),
(i['x0'], i['y0']), (i['x0'], i['y1'])])
return platforms
# }}}
def _obj_elem(self, face, z): # {{{
elem = ''
elem += "o Face{}\n".format(self._obj_num)
for verts in face[:4]:
elem += "v {}\n".format(" ".join(
[str(i / 100) for i in [verts[0], z, verts[1]]]))
elem += "f {}\n\n".format(" ".join(
[str(4 * self._obj_num + i) + "//1" for i in [1, 2, 3, 4]]))
self._obj_num += 1
return elem
# }}}
def _obj_make(self, floor, bypass_rooms): # {{{
'''
1. Create obj file from aamks geometries.
2. Build navmesh with golang, obj is input
3. Query navmesh with python
4. bypass_rooms are the rooms excluded from navigation
99 is the z-dim in cm
'''
z = self._bricked_wall(floor, bypass_rooms)
obj = ''
self._obj_num = 0
for face in z:
obj += self._obj_elem(face, 99)
for face in self._obj_platform(floor):
obj += self._obj_elem(face, 0)
path = "{}/{}.obj".format(os.environ['AAMKS_PROJECT'], self.nav_name)
with open(path, "w") as f:
f.write(obj)
return path
# }}}
def _navmesh_vis(self, navmesh_paths, colors): # {{{
j = Json()
z = j.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
for cc, path in enumerate(navmesh_paths):
for i, p in enumerate(path):
try:
z[self.floor]['lines'].append({
"xy": (path[i][0], path[i][1]),
"x1":
path[i + 1][0],
"y1":
path[i + 1][1],
"strokeColor":
colors[cc],
"strokeWidth":
14,
"opacity":
0.5
})
except:
pass
j.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# }}}
def _chunks(self, l, n): # {{{
"""Yield successive n-sized chunks from l."""
for i in range(0, len(l), n):
yield l[i:i + n]
# }}}
def _get_name(self, floor, bypass_rooms=[]): # {{{
brooms = ''
if len(bypass_rooms) > 0:
brooms = "-" + "-".join(bypass_rooms)
self.nav_name = "{}{}.nav".format(floor, brooms)
# }}}
def test(self): # {{{
agents_pairs = 6
colors = [
"#f80", "#f00", "#8f0", "#08f", "#f0f", "#f8f", "#0ff", "#ff0"
]
navmesh_paths = []
z = self.json.read('{}/dd_geoms.json'.format(
os.environ['AAMKS_PROJECT']))
evacuees = self.s.query(
"SELECT x0,y0 FROM aamks_geom WHERE type_pri='EVACUEE' AND floor=? ORDER BY global_type_id LIMIT ?",
(self.floor, agents_pairs * 2))
for x, i in enumerate(self._chunks(evacuees, 2)):
p0 = (i[0]['x0'], i[0]['y0'])
p1 = (i[1]['x0'], i[1]['y0'])
z[self.floor]['circles'].append({
"xy": p0,
"radius": 30,
"fillColor": colors[x],
"opacity": 1
})
z[self.floor]['circles'].append({
"xy": p1,
"radius": 30,
"fillColor": colors[x],
"opacity": 1
})
navmesh_paths.append(self.query((p0, p1), 300))
self.json.write(z,
'{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
self._navmesh_vis(navmesh_paths, colors)
Vis({
'highlight_geom': None,
'anim': None,
'title': 'Nav {} test'.format(self.nav_name),
'srv': 1
})
# }}}
def build(self, floor, bypass_rooms=[]): # {{{
self.floor = floor
self.bypass_rooms = bypass_rooms
self._get_name(floor, bypass_rooms)
file_obj = self._obj_make(floor, bypass_rooms)
file_nav = "{}/{}".format(os.environ['AAMKS_PROJECT'], self.nav_name)
file_conf = "{}/recast.yml".format(os.environ['AAMKS_PROJECT'])
with open(file_conf, "w") as f:
f.write('''\
cellsize: 0.10
cellheight: 0.2
agentheight: 2
agentradius: 0.30
agentmaxclimb: 0.1
agentmaxslope: 45
regionminsize: 8
regionmergesize: 20
edgemaxlen: 12
edgemaxerror: 1.3
vertsperpoly: 6
detailsampledist: 6
detailsamplemaxerror: 1
partitiontype: 1
tilesize: 0
''')
subprocess.call(
"rm -rf {}; recast --config {} --input {} build {} 1>/dev/null 2>/dev/null"
.format(file_nav, file_conf, file_obj, file_nav),
shell=True)
try:
self.NAV = dt.dtLoadSampleTileMesh(file_nav)
except:
raise SystemExit("Navmesh: cannot create {}".format(file_nav))
# }}}
def query(self, q, maxStraightPath=16): # {{{
'''
./Detour/Include/DetourNavMeshQuery.h: maxStraightPath: The maximum number of points the straight path arrays can hold. [Limit: > 0]
We set maxStraightPath to a default low value which stops calculations early
If one needs to get the full path to the destination one must call us with any high value, e.g. 999999999
'''
filtr = dt.dtQueryFilter()
query = dt.dtNavMeshQuery()
status = query.init(self.NAV, 2048)
if dt.dtStatusFailed(status):
return "err", -1, status
polyPickExt = dt.dtVec3(2.0, 4.0, 2.0)
startPos = dt.dtVec3(q[0][0] / 100, 1, q[0][1] / 100)
endPos = dt.dtVec3(q[1][0] / 100, 1, q[1][1] / 100)
status, out = query.findNearestPoly(startPos, polyPickExt, filtr)
if dt.dtStatusFailed(status):
return "err", -2, status
startRef = out["nearestRef"]
_startPt = out["nearestPt"]
status, out = query.findNearestPoly(endPos, polyPickExt, filtr)
if dt.dtStatusFailed(status):
return "err", -3, status
endRef = out["nearestRef"]
_endPt = out["nearestPt"]
status, out = query.findPath(startRef, endRef, startPos, endPos, filtr,
maxStraightPath)
if dt.dtStatusFailed(status):
return "err", -4, status
pathRefs = out["path"]
status, fixEndPos = query.closestPointOnPoly(pathRefs[-1], endPos)
if dt.dtStatusFailed(status):
return "err", -5, status
status, out = query.findStraightPath(startPos, fixEndPos, pathRefs,
maxStraightPath, 0)
if dt.dtStatusFailed(status):
return "err", -6, status
straightPath = out["straightPath"]
straightPathFlags = out["straightPathFlags"]
straightPathRefs = out["straightPathRefs"]
path = []
for i in straightPath:
path.append((i[0] * 100, i[2] * 100))
if path[0] == "err":
return None
else:
return path
# }}}
def closest_terminal(self, p0, exit_type): # {{{
'''
The shortest polyline defines the closest exit from the floor.
dist < 10 test asserts the polyline has min 2 distinct points.
exit_type: primary | secondary | any
'''
if exit_type in ['primary', 'secondary']:
r = self.s.query(
"SELECT name,center_x,center_y FROM aamks_geom WHERE terminal_door=? AND floor=?",
(exit_type, self.floor))
else:
r = self.s.query(
"SELECT name,center_x,center_y FROM aamks_geom WHERE terminal_door IS NOT NULL AND floor=?",
(self.floor, ))
m = {}
closest = {'len': 999999999, 'name': None, 'x': None, 'y': None}
for i in r:
if abs(i['center_x'] - p0[0]) < 10 and abs(i['center_y'] -
p0[1]) < 10:
closest = {
'name': i['name'],
'x': i['center_x'],
'y': i['center_y'],
'len': 0
}
return closest
ll = LineString(
self.query((p0, (i['center_x'], i['center_y'])), 300)).length
if ll < closest['len']:
closest = {
'name': i['name'],
'x': i['center_x'],
'y': i['center_y'],
'len': int(ll)
}
return closest
# }}}
def closest_room_escape(self, p0, room): # {{{
'''
Evacuee finds himself in a room with smoke and needs to leave urgently
'''
r = self.s.query(
"SELECT name,center_x,center_y FROM aamks_geom WHERE (vent_from_name=? OR vent_to_name=?) AND floor=?",
(room, room, self.floor))
m = {}
closest = {'len': 999999999, 'name': None, 'x': None, 'y': None}
for i in r:
if abs(i['center_x'] - p0[0]) < 10 and abs(i['center_y'] -
p0[1]) < 10:
closest = {
'name': i['name'],
'x': i['center_x'],
'y': i['center_y'],
'len': 0
}
return closest
ll = sqrt((i['center_x'] - p0[0])**2 + (i['center_y'] - p0[1])**2)
if ll < closest['len']:
closest = {
'name': i['name'],
'x': i['center_x'],
'y': i['center_y'],
'len': int(ll)
}
return closest
class FDSimporter():
def __init__(self): # {{{
self.json = Json()
self.conf = self.json.read("{}/conf.json".format(
os.environ['AAMKS_PROJECT']))
if self.conf['fire_model'] == 'CFAST':
return
self.s = Sqlite("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
self.cadfds = self.json.read("{}/cadfds.json".format(
os.environ['AAMKS_PROJECT']))
self.doors_width = 32
self.walls_width = 4
self._geometry2sqlite()
self.geomsMap = self.json.read("{}/inc.json".format(
os.environ['AAMKS_PATH']))['aamksGeomsMap']
self._floors_meta()
self._world_meta()
self._fire_origin()
self._init_dd_geoms()
self._debug()
# }}}
def _floors_meta(self): # {{{
'''
Floor dimensions are needed here and there.
for z_absolute high towers are not taken under account, we want the natural floor's zdim
for z_relative high towers are not taken under account, we want the natural floor's zdim
'''
self.floors = [
z['floor'] for z in self.s.query(
"SELECT DISTINCT floor FROM aamks_geom ORDER BY floor")
]
self.floors_meta = OrderedDict()
self._world3d = dict()
self._world3d['minx'] = 9999999
self._world3d['maxx'] = -9999999
self._world3d['miny'] = 9999999
self._world3d['maxy'] = -9999999
prev_maxz = 0
for floor in self.floors:
ty = 0
tx = 0
minx = self.s.query(
"SELECT min(x0) AS minx FROM aamks_geom WHERE floor=?",
(floor, ))[0]['minx']
maxx = self.s.query(
"SELECT max(x1) AS maxx FROM aamks_geom WHERE floor=?",
(floor, ))[0]['maxx']
miny = self.s.query(
"SELECT min(y0) AS miny FROM aamks_geom WHERE floor=?",
(floor, ))[0]['miny']
maxy = self.s.query(
"SELECT max(y1) AS maxy FROM aamks_geom WHERE floor=?",
(floor, ))[0]['maxy']
minz_abs = self.s.query(
"SELECT min(z0) AS minz FROM aamks_geom WHERE type_sec NOT IN('STAI','HALL') AND floor=?",
(floor, ))[0]['minz']
maxz_abs = self.s.query(
"SELECT max(z1) AS maxz FROM aamks_geom WHERE type_sec NOT IN('STAI','HALL') AND floor=?",
(floor, ))[0]['maxz']
zdim = maxz_abs - prev_maxz
prev_maxz = maxz_abs
xdim = maxx - minx
ydim = maxy - miny
center = (minx + int(xdim / 2), miny + int(ydim / 2), minz_abs)
self.floors_meta[floor] = OrderedDict([('name', floor),
('xdim', xdim),
('ydim', ydim),
('center', center),
('minx', minx),
('miny', miny),
('maxx', maxx),
('maxy', maxy),
('minz_abs', minz_abs),
('maxz_abs', maxz_abs),
('zdim', zdim), ('ty', ty),
('tx', tx)])
self._world3d['minx'] = min(self._world3d['minx'], minx)
self._world3d['maxx'] = max(self._world3d['maxx'], maxx)
self._world3d['miny'] = min(self._world3d['miny'], miny)
self._world3d['maxy'] = max(self._world3d['maxy'], maxy)
self.s.query("CREATE TABLE floors_meta(json)")
self.s.query('INSERT INTO floors_meta VALUES (?)',
(json.dumps(self.floors_meta), ))
# }}}
def _world_meta(self): # {{{
self.s.query("CREATE TABLE world_meta(json)")
self.world_meta = {}
self.world_meta['world3d'] = self._world3d
self.world_meta['walls_width'] = self.walls_width
self.world_meta['doors_width'] = self.doors_width
if len(self.floors_meta) > 1:
self.world_meta['multifloor_building'] = 1
else:
self.world_meta['multifloor_building'] = 0
self.s.query('INSERT INTO world_meta(json) VALUES (?)',
(json.dumps(self.world_meta), ))
# }}}
def _geometry2sqlite(self): # {{{
data = []
for floor, gg in self.cadfds.items():
for k, arr in gg.items():
if k in ('META'):
continue
for v in arr:
zz = list(zip(*v['points']))
bbox = [
int(min(zz[0])),
int(min(zz[1])),
int(max(zz[0])),
int(max(zz[1]))
]
attrs = self._prepare_attrs(v)
record = self._prepare_geom_record(k, v, bbox, floor,
attrs, gg['META'])
if record != False:
data.append(record)
self.s.query(
"CREATE TABLE aamks_geom(name,floor,type_pri,type_sec,type_tri,x0,y0,z0,x1,y1,z1,global_type_id,exit_type, room_enter, terminal_door, points)"
)
self.s.executemany(
'INSERT INTO aamks_geom VALUES ({})'.format(','.join(
'?' * len(data[0]))), data)
#}}}
def _prepare_attrs(self, v): # {{{
aa = {"exit_type": None, "room_enter": None}
if 'attribs' in v:
for kk, vv in v['attribs'].items():
aa[kk] = vv
return aa
# }}}
def _prepare_geom_record(self, k, v, bbox, floor, attrs, meta): # {{{
''' Format a record for sqlite. Hvents get fixed width self.doors_width cm '''
# OBST
if k in ('OBST', ):
if len(v['points']) > 5:
print(
"You need to split obstacles having more than 5 vertices")
exit()
type_pri = 'OBST'
type_tri = ''
# EVACUEE
elif k in ('EVACUEE', ):
type_pri = 'EVACUEE'
type_tri = ''
# FIRE
elif k in ('FIRE', ):
type_pri = 'FIRE'
type_tri = ''
# MVENT
elif k in ('MVENT', ):
type_pri = 'MVENT'
type_tri = ''
# VVENT
elif k in ('VVENT', ):
type_pri = 'VVENT'
height = 10
type_tri = ''
# COMPA
elif k in ('ROOM', 'COR', 'HALL', 'STAI'):
type_pri = 'COMPA'
type_tri = ''
# HVENT
elif k in ('DOOR', 'DCLOSER', 'DELECTR', 'HOLE', 'WIN'):
type_pri = 'HVENT'
if k in ('DOOR', 'DCLOSER', 'DELECTR', 'HOLE'):
type_tri = 'DOOR'
elif k in ('WIN'):
type_tri = 'WIN'
if 'name' not in v:
v['name'] = ''
#self.s.query("CREATE TABLE aamks_geom(name , floor , type_pri , type_sec , type_tri , x0 , y0 , z0 , x1 , y1 , z1 , global_type_id , exit_type , room_enter , terminal_door , points)")
return (v['name'], floor, type_pri, k, type_tri, bbox[0], bbox[1],
meta['z0'], bbox[2], bbox[3], meta['z1'], None,
attrs['exit_type'], attrs['room_enter'], attrs['exit_type'],
json.dumps(v['points']))
# }}}
def _fire_origin(self): # {{{
si = SimIterations(self.conf['project_id'], self.conf['scenario_id'],
self.conf['number_of_simulations'])
self.s.query(
"CREATE TABLE fire_origin(name,is_room,x,y,z,floor,sim_id)")
for sim_id in range(*si.get()):
seed(sim_id)
r = self.s.query(
"SELECT * FROM aamks_geom WHERE type_pri='FIRE'")[0]
fire_origin = [
'fire', 1, r['x0'], r['y0'], r['z0'], r['floor'], sim_id
]
self.s.query(
'INSERT INTO fire_origin VALUES (? , ? , ? , ? , ? , ? , ?)',
fire_origin)
# }}}
def _init_dd_geoms(self): # {{{
'''
dd_geoms are some optional extra rectangles, points, lines and
circles that are written to on top of our geoms. Useful for developing
and debugging features. Must come early, because visualization depends
on it.
Procedure:
z=self.json.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
z["0"]['rectangles'].append( { "xy": (0 , 0) , "width": 200 , "depth": 200 , "strokeColor": "#fff" , "strokeWidth": 2 , "fillColor": "#f80" , "opacity": 0.7 } )
z["0"]['circles'].append({ "xy": (i['center_x'], i['center_y']),"radius": 200, "fillColor": "#fff" , "opacity": 0.3 } )
self.json.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
'''
z = dict()
for floor in self.floors:
z[floor] = dict()
z[floor]['rectangles'] = []
z[floor]['lines'] = []
z[floor]['circles'] = []
z[floor]['texts'] = []
z[floor]['rectangles'] = []
#for i in self.s.query("SELECT * FROM aamks_geom WHERE type_tri='DOOR' AND floor=?", (floor,)):
# z[floor]['circles'].append({ "xy": (i['center_x'] , i['center_y']) , "radius": 90 , "fillColor": "#fff" , "opacity": 0.05 } )
# Example usage anywhere inside aamks:
# z=self.json.read('{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# z["0"]['rectangles'].append( { "xy": (1000 , 1000) , "width": 200 , "depth": 300 , "strokeColor": "#fff" , "strokeWidth": 2 , "fillColor": "#f80" , "opacity": 0.7 } )
# z["0"]['rectangles'].append( { "xy": (0 , 0) , "width": 200 , "depth": 200 , "strokeColor": "#fff" , "strokeWidth": 2 , "fillColor": "#f80" , "opacity": 0.7 } )
# z["0"]['lines'].append( { "xy": (2000 , 200) , "x1": 3400 , "y1": 500 , "strokeColor": "#fff" , "strokeWidth": 2 , "opacity": 0.7 } )
# z["0"]['texts'].append( { "xy": (1000 , 1000) , "content": "(1000x1000)" , "fontSize": 400 , "fillColor":"#06f" , "opacity":0.7 } )
# self.json.write(z, '{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# Vis(None, 'image', 'dd_geoms example')
self.json.write(z,
'{}/dd_geoms.json'.format(os.environ['AAMKS_PROJECT']))
# }}}
def _debug(self): # {{{
#dd(os.environ['AAMKS_PROJECT'])
#self.s.dumpall()
#self.s.dump_geoms()
#dd(self.s.query("select * from aamks_geom"))
#dd(self.s.query("select * from world2d"))
#exit()
#self.s.dump()
pass
class EvacMcarlo():
def __init__(self): # {{{
''' Generate montecarlo evac.conf. '''
self.s = Sqlite("{}/aamks.sqlite".format(os.environ['AAMKS_PROJECT']))
self.json = Json()
self.conf = self.json.read("{}/conf.json".format(
os.environ['AAMKS_PROJECT']))
self.floors = [
z['floor'] for z in self.s.query(
"SELECT DISTINCT floor FROM aamks_geom ORDER BY floor")
]
self._project_name = os.path.basename(os.environ['AAMKS_PROJECT'])
si = SimIterations(self.conf['project_id'],
self.conf['number_of_simulations'])
for self._sim_id in range(*si.get()):
seed(self._sim_id)
self._static_evac_conf()
self._dispatch_evacuees()
self._make_evac_conf()
# }}}
def _static_evac_conf(self): # {{{
'''
AAMKS_PROJECT must be propagated to worker environment.
'''
fire_origin_file = "{}/workers/{}/fire_origin.json".format(
os.environ['AAMKS_PROJECT'], self._sim_id)
self._evac_conf = self.conf
self._evac_conf['AAMKS_PROJECT'] = os.environ['AAMKS_PROJECT']
self._evac_conf['SIM_ID'] = self._sim_id
self._evac_conf['SERVER'] = os.environ['AAMKS_SERVER']
self._evac_conf['FIRE_ORIGIN'] = self.json.read(fire_origin_file)
os.remove(fire_origin_file)
# }}}
def _make_pre_evacuation(self, room, type_sec): # {{{
'''
An evacuee pre_evacuates from either ordinary room or from the room of
fire origin; type_sec is for future development.
'''
if room != self._evac_conf['FIRE_ORIGIN']:
pe = self.conf['pre_evac_fire_origin']
else:
pe = self.conf['pre_evac']
return round(lognorm(s=1, loc=pe['mean'], scale=pe['sd']).rvs(), 2)
# }}}
def _get_density(self, name, type_sec, floor): # {{{
''' Special selectors from distributions.json
First we try to return ROOM_1_2, then ROOM_FLOOR_1, then ROOM
'''
z = self.conf['evacuees_concentration']
for i in [name, "{}_FLOOR_{}".format(type_sec, floor), type_sec]:
if i in z.keys():
return z[i]
raise Exception("Cannot determine the density for {}".format(name))
# }}}
def _dispatch_evacuees(self): # {{{
'''
We dispatch the evacuees across the building according to the density
distribution.
'''
self.dispatched_evacuees = OrderedDict()
self.pre_evacuation = OrderedDict()
for floor in self.floors:
self.pre_evacuation[floor] = list()
positions = []
rooms = self.s.query(
"SELECT x0, x1, y0, y1, name, type_sec, room_area FROM aamks_geom WHERE type_pri='COMPA' AND floor=?",
(floor, ))
for r in rooms:
density = self._get_density(r['name'], r['type_sec'], floor)
x = uniform(r['x0'] + 50, r['x1'] - 50,
int(r['room_area'] / density))
y = uniform(r['y0'] + 50, r['y1'] - 50,
int(r['room_area'] / density))
positions += list(zip(x, y))
for i in x:
self.pre_evacuation[floor].append(
self._make_pre_evacuation(r['name'], r['type_sec']))
self.dispatched_evacuees[floor] = [
list([int(i) for i in l]) for l in positions
]
# }}}
def _make_evac_conf(self): # {{{
''' Write data to sim_id/evac.json. '''
self._evac_conf['FLOORS_DATA'] = OrderedDict()
for floor in self.floors:
self._evac_conf['FLOORS_DATA'][floor] = OrderedDict()
self._evac_conf['FLOORS_DATA'][floor]['NUM_OF_EVACUEES'] = len(
self.dispatched_evacuees[floor])
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'] = OrderedDict()
z = self.s.query("SELECT z0 FROM aamks_geom WHERE floor=?",
(floor, ))[0]['z0']
for i, pos in enumerate(self.dispatched_evacuees[floor]):
e_id = 'E{}'.format(i)
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][
e_id] = OrderedDict()
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id][
'ORIGIN'] = (pos[0], pos[1])
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id][
'PRE_EVACUATION'] = self.pre_evacuation[floor][i]
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id][
'ALPHA_V'] = round(
normal(self.conf['evacuees_alpha_v']['mean'],
self.conf['evacuees_alpha_v']['sd']), 2)
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id][
'BETA_V'] = round(
normal(self.conf['evacuees_beta_v']['mean'],
self.conf['evacuees_beta_v']['sd']), 2)
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id][
'H_SPEED'] = round(
normal(self.conf['evacuees_max_h_speed']['mean'],
self.conf['evacuees_max_h_speed']['sd']), 2)
self._evac_conf['FLOORS_DATA'][floor]['EVACUEES'][e_id][
'V_SPEED'] = round(
normal(self.conf['evacuees_max_v_speed']['mean'],
self.conf['evacuees_max_v_speed']['sd']), 2)
self.json.write(
self._evac_conf,
"{}/workers/{}/evac.json".format(os.environ['AAMKS_PROJECT'],
self._sim_id))
