def export_agg_losses(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
dskey = ekey[0]
oq = dstore['oqparam']
aggregate_by = oq.aggregate_by if dskey.startswith('agg_') else []
name, value, rlzs_or_stats = _get_data(dstore, dskey, oq.hazard_stats())
# value has shape (K, R, L)
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
tagcol = dstore['assetcol/tagcol']
aggtags = list(tagcol.get_aggkey(aggregate_by).values())
aggtags.append(('*total*',) * len(aggregate_by))
expvalue = dstore['agg_values'][()] # shape (K+1, L)
tagnames = tuple(aggregate_by)
header = ('loss_type',) + tagnames + (
'loss_value', 'exposed_value', 'loss_ratio')
md = dstore.metadata
md.update(dict(investigation_time=oq.investigation_time,
risk_investigation_time=oq.risk_investigation_time or
oq.investigation_time))
for r, ros in enumerate(rlzs_or_stats):
ros = ros if isinstance(ros, str) else 'rlz-%03d' % ros
rows = []
for (k, l), loss in numpy.ndenumerate(value[:, r]):
if loss: # many tag combinations are missing
evalue = expvalue[k, l]
row = aggtags[k] + (loss, evalue, loss / evalue)
rows.append((oq.loss_names[l],) + row)
dest = dstore.build_fname(name, ros, 'csv')
writer.save(rows, dest, header, comment=md)
return writer.getsaved()
def export_damages_csv(ekey, dstore):
oq = dstore['oqparam']
dmg_dt = build_damage_dt(dstore)
rlzs = dstore['full_lt'].get_realizations()
data = dstore[ekey[0]]
writer = writers.CsvWriter(fmt='%.6E')
assets = get_assets(dstore)
md = dstore.metadata
if oq.investigation_time:
md.update(dict(investigation_time=oq.investigation_time,
risk_investigation_time=oq.risk_investigation_time
or oq.investigation_time))
if ekey[0].endswith('stats'):
rlzs_or_stats = oq.hazard_stats()
else:
rlzs_or_stats = ['rlz-%03d' % r for r in range(len(rlzs))]
name = ekey[0].split('-')[0]
if oq.calculation_mode != 'classical_damage':
name = 'avg_' + name
for i, ros in enumerate(rlzs_or_stats):
if oq.modal_damage_state:
damages = modal_damage_array(data[:, i], dmg_dt)
else:
damages = build_damage_array(data[:, i], dmg_dt)
fname = dstore.build_fname(name, ros, ekey[1])
writer.save(compose_arrays(assets, damages), fname,
comment=md, renamedict=dict(id='asset_id'))
return writer.getsaved()
def export_event_loss_table(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
dest = dstore.build_fname('risk_by_event', '', 'csv')
md = dstore.metadata
if 'scenario' not in oq.calculation_mode:
md.update(dict(investigation_time=oq.investigation_time,
risk_investigation_time=oq.risk_investigation_time
or oq.investigation_time))
events = dstore['events'][()]
K = dstore.get_attr('risk_by_event', 'K', 0)
try:
lstates = dstore.get_attr('risk_by_event', 'limit_states').split()
except KeyError: # ebrisk, no limit states
lstates = []
lnames = numpy.array(oq.loss_types)
df = dstore.read_df('risk_by_event', 'agg_id', dict(agg_id=K))
df['loss_type'] = lnames[df.loss_id.to_numpy()]
del df['loss_id']
if 'variance' in df.columns:
del df['variance']
ren = {'dmg_%d' % i: lstate for i, lstate in enumerate(lstates, 1)}
df.rename(columns=ren, inplace=True)
evs = events[df.event_id.to_numpy()]
if 'scenario' not in oq.calculation_mode:
df['rup_id'] = evs['rup_id']
if 'scenario' not in oq.calculation_mode and 'year' in evs.dtype.names:
df['year'] = evs['year']
df.sort_values(['event_id', 'loss_type'], inplace=True)
writer.save(df, dest, comment=md)
return writer.getsaved()
def export_gmf_data_csv(ekey, dstore):
oq = dstore['oqparam']
imts = list(oq.imtls)
df = dstore.read_df('gmf_data').sort_values(['eid', 'sid'])
ren = {'sid': 'site_id', 'eid': 'event_id'}
for m, imt in enumerate(imts):
ren[f'gmv_{m}'] = 'gmv_' + imt
for imt in oq.get_sec_imts():
ren[imt] = f'sep_{imt}'
df.rename(columns=ren, inplace=True)
event_id = dstore['events']['id']
f = dstore.build_fname('sitemesh', '', 'csv')
arr = dstore['sitecol'][['lon', 'lat']]
sids = numpy.arange(len(arr), dtype=U32)
sites = util.compose_arrays(sids, arr, 'site_id')
writers.write_csv(f, sites, comment=dstore.metadata)
fname = dstore.build_fname('gmf', 'data', 'csv')
writers.CsvWriter(fmt=writers.FIVEDIGITS).save(df,
fname,
comment=dstore.metadata)
if 'sigma_epsilon' in dstore['gmf_data']:
sig_eps_csv = dstore.build_fname('sigma_epsilon', '', 'csv')
sig_eps = dstore['gmf_data/sigma_epsilon'][()]
sig_eps['eid'] = event_id[sig_eps['eid']]
sig_eps.sort(order='eid')
header = list(sig_eps.dtype.names)
header[0] = 'event_id'
writers.write_csv(sig_eps_csv,
sig_eps,
header=header,
comment=dstore.metadata)
return [fname, sig_eps_csv, f]
else:
return [fname, f]
def export_asset_risk_csv(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
path = '%s.%s' % (sanitize(ekey[0]), ekey[1])
fname = dstore.export_path(path)
md = json.loads(extract(dstore, 'exposure_metadata').json)
tostr = {'taxonomy': md['taxonomy']}
for tagname in md['tagnames']:
tostr[tagname] = md[tagname]
tagnames = sorted(set(md['tagnames']) - {'id'})
arr = extract(dstore, 'asset_risk').array
rows = []
lossnames = sorted(name for name in arr.dtype.names if 'loss' in name)
expnames = [name for name in arr.dtype.names if name not in md['tagnames']
and 'loss' not in name and name not in 'lon lat']
colnames = tagnames + ['lon', 'lat'] + expnames + lossnames
# sanity check
assert len(colnames) == len(arr.dtype.names)
for rec in arr:
row = []
for name in colnames:
value = rec[name]
try:
row.append(tostr[name][value])
except KeyError:
row.append(value)
rows.append(row)
writer.save(rows, fname, colnames)
return [fname]
def export_agg_curve_rlzs(ekey, dstore):
oq = dstore['oqparam']
lnames = numpy.array(oq.loss_names)
agg_tags = get_agg_tags(dstore, oq.aggregate_by)
aggvalue = dstore['agg_values'][()] # shape (K+1, L)
md = dstore.metadata
md['risk_investigation_time'] = (
oq.risk_investigation_time or oq.investigation_time)
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
descr = hdf5.get_shape_descr(dstore[ekey[0]].attrs['json'])
name, suffix = ekey[0].split('-')
rlzs_or_stats = descr[suffix[:-1]]
aw = hdf5.ArrayWrapper(dstore[ekey[0]], descr, ('loss_value',))
dataf = aw.to_dframe().set_index(suffix[:-1])
for r, ros in enumerate(rlzs_or_stats):
md['kind'] = f'{name}-' + (
ros if isinstance(ros, str) else 'rlz-%03d' % ros)
try:
df = dataf[dataf.index == ros]
except KeyError:
logging.warning('No data for %s', md['kind'])
continue
dic = {col: df[col].to_numpy() for col in dataf.columns}
dic['loss_type'] = lnames[dic['lti']]
for tagname in oq.aggregate_by:
dic[tagname] = agg_tags[tagname][dic['agg_id']]
dic['loss_ratio'] = dic['loss_value'] / aggvalue[
dic['agg_id'], dic.pop('lti')]
dic['annual_frequency_of_exceedence'] = 1 / dic['return_period']
del dic['agg_id']
dest = dstore.build_fname(md['kind'], '', 'csv')
writer.save(pandas.DataFrame(dic), dest, comment=md)
return writer.getsaved()
def export_avg_losses(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
dskey = ekey[0]
oq = dstore['oqparam']
dt = [(ln, F32) for ln in oq.loss_names]
name, value, rlzs_or_stats = _get_data(dstore, dskey, oq.hazard_stats())
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
assets = get_assets(dstore)
md = dstore.metadata
md.update(
dict(investigation_time=oq.investigation_time,
risk_investigation_time=oq.risk_investigation_time
or oq.investigation_time))
for ros, values in zip(rlzs_or_stats, value.transpose(1, 0, 2)):
dest = dstore.build_fname(name, ros, 'csv')
array = numpy.zeros(len(values), dt)
for li, ln in enumerate(oq.loss_names):
array[ln] = values[:, li]
writer.save(compose_arrays(assets, array),
dest,
comment=md,
renamedict=dict(id='asset_id'))
return writer.getsaved()
def export_agg_risk_csv(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
path = '%s.%s' % (sanitize(ekey[0]), ekey[1])
fname = dstore.export_path(path)
dset = dstore['agg_risk']
writer.save(dset[()], fname, dset.dtype.names)
return [fname]
def export_avg_gmf_csv(ekey, dstore):
oq = dstore['oqparam']
sitecol = dstore['sitecol'].complete
data = dstore['avg_gmf'][:] # shape (2, N, M)
dic = {'site_id': sitecol.sids, 'lon': sitecol.lons, 'lat': sitecol.lats}
for m, imt in enumerate(oq.imtls):
dic['gmv_' + imt] = data[0, :, m]
dic['gsd_' + imt] = data[1, :, m]
fname = dstore.build_fname('avg_gmf', '', 'csv')
writers.CsvWriter(fmt=writers.FIVEDIGITS).save(pandas.DataFrame(dic),
fname,
comment=dstore.metadata)
return [fname]
def export_aggregate_by_csv(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
token, what = ekey[0].split('/', 1)
aw = extract(dstore, 'aggregate/' + what)
fnames = []
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
path = '%s.%s' % (sanitize(ekey[0]), ekey[1])
fname = dstore.export_path(path)
writer.save(aw.to_dframe(), fname)
fnames.append(fname)
return fnames
def export_src_loss_table(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
md = dstore.metadata
md.update(dict(investigation_time=oq.investigation_time,
risk_investigation_time=oq.risk_investigation_time or
oq.investigation_time))
aw = hdf5.ArrayWrapper.from_(dstore['src_loss_table'], 'loss_value')
dest = dstore.build_fname('src_loss_table', '', 'csv')
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
writer.save(aw.to_dframe(), dest, comment=md)
return writer.getsaved()
def export_aggrisk(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
tagnames = oq.aggregate_by
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
tagcol = dstore['assetcol/tagcol']
aggtags = list(tagcol.get_aggkey(tagnames).values())
aggtags.append(('*total*',) * len(tagnames))
agg_values = dstore['agg_values'][()] # shape K+1
md = dstore.metadata
md.update(dict(investigation_time=oq.investigation_time,
risk_investigation_time=oq.risk_investigation_time or
oq.investigation_time))
aggrisk = dstore.read_df('aggrisk')
cols = [col for col in aggrisk.columns
if col not in {'agg_id', 'rlz_id', 'loss_id'}]
csqs = [col for col in cols if not col.startswith('dmg_')]
header = ['loss_type'] + tagnames + ['exposed_value'] + [
'%s_ratio' % csq for csq in csqs]
dest = dstore.build_fname('aggrisk', '', 'csv')
out = general.AccumDict(accum=[])
manyrlzs = hasattr(aggrisk, 'rlz_id') and len(aggrisk.rlz_id.unique()) > 1
for (agg_id, loss_id), df in aggrisk.groupby(['agg_id', 'loss_id']):
n = len(df)
loss_type = oq.loss_types[loss_id]
out['loss_type'].extend([loss_type] * n)
for tagname, tag in zip(tagnames, aggtags[agg_id]):
out[tagname].extend([tag] * n)
if manyrlzs:
out['rlz_id'].extend(df.rlz_id)
for col in cols:
if col in csqs:
aval = scientific.get_agg_value(
col, agg_values, agg_id, loss_type)
out[col + '_value'].extend(df[col])
out[col + '_ratio'].extend(df[col] / aval)
else:
out[col].extend(df[col])
dsdic = {'dmg_0': 'no_damage'}
for s, ls in enumerate(oq.limit_states, 1):
dsdic['dmg_%d' % s] = ls
df = pandas.DataFrame(out).rename(columns=dsdic)
writer.save(df, dest, header, comment=md)
return [dest]
def export_damages_csv(ekey, dstore):
oq = dstore['oqparam']
ebd = oq.calculation_mode == 'event_based_damage'
dmg_dt = build_damage_dt(dstore)
rlzs = dstore['full_lt'].get_realizations()
orig = dstore[ekey[0]][:] # shape (A, R, L, D)
writer = writers.CsvWriter(fmt='%.6E')
assets = get_assets(dstore)
md = dstore.metadata
if oq.investigation_time:
rit = oq.risk_investigation_time or oq.investigation_time
md.update(
dict(investigation_time=oq.investigation_time,
risk_investigation_time=rit))
D = len(oq.limit_states) + 1
R = 1 if oq.collect_rlzs else len(rlzs)
if ekey[0].endswith('stats'):
rlzs_or_stats = oq.hazard_stats()
else:
rlzs_or_stats = ['rlz-%03d' % r for r in range(R)]
name = ekey[0].split('-')[0]
if oq.calculation_mode != 'classical_damage':
name = 'avg_' + name
for i, ros in enumerate(rlzs_or_stats):
if ebd: # export only the consequences from damages-rlzs, i == 0
rate = len(dstore['events']) * oq.time_ratio / len(rlzs)
data = orig[:, i] * rate
A, L, Dc = data.shape
if Dc == D: # no consequences, export nothing
return
csq_dt = build_csq_dt(dstore)
damages = numpy.zeros(A, csq_dt)
for a in range(A):
for li, lt in enumerate(csq_dt.names):
damages[lt][a] = tuple(data[a, li, D:Dc])
fname = dstore.build_fname('avg_risk', ros, ekey[1])
else: # scenario_damage, classical_damage
if oq.modal_damage_state:
damages = modal_damage_array(orig[:, i], dmg_dt)
else:
damages = build_damage_array(orig[:, i], dmg_dt)
fname = dstore.build_fname(name, ros, ekey[1])
writer.save(compose_arrays(assets, damages),
fname,
comment=md,
renamedict=dict(id='asset_id'))
return writer.getsaved()
def export_aggcurves_csv(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
E = len(dstore['events'])
R = len(dstore['weights'])
lossnames = numpy.array(oq.loss_names)
aggtags = get_agg_tags(dstore, oq.aggregate_by)
df = dstore.read_df('aggcurves')
consequences = [
col for col in df.columns if col in scientific.KNOWN_CONSEQUENCES
]
for tagname, tags in aggtags.items():
df[tagname] = tags[df.agg_id]
df['loss_type'] = lossnames[df.loss_id.to_numpy()]
del df['loss_id']
dest = dstore.export_path('%s.%s' % ekey)
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
md = dstore.metadata
md['risk_investigation_time'] = (oq.risk_investigation_time
or oq.investigation_time)
md['num_events'] = E
md['effective_time'] = (oq.investigation_time *
oq.ses_per_logic_tree_path * R)
md['limit_states'] = dstore.get_attr('aggcurves', 'limit_states')
# aggcurves
agg_id = df.pop('agg_id')
agg_values = dstore['agg_values'][:]
edic = general.AccumDict(accum=[])
[loss_type] = df.loss_type.unique()
for cons in consequences:
for col in df.columns:
if col not in scientific.KNOWN_CONSEQUENCES:
edic[col].extend(df[col])
elif col == cons:
edic['conseq_value'].extend(df[col])
edic['conseq_type'].extend([col] * len(df))
aval = scientific.get_agg_value(cons, agg_values, agg_id,
loss_type)
edic['conseq_ratio'].extend(df[col] / aval)
writer.save(pandas.DataFrame(edic), dest, comment=md)
return [dest]
def export_cond_spectra(ekey, dstore):
dset = dstore[ekey[0]] # shape (P, 2, M)
periods = dset.attrs['periods']
imls = dset.attrs['imls']
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
fnames = []
for p, iml in enumerate(imls):
fname = dstore.export_path('conditional-spectrum-%d.csv' % p)
df = pandas.DataFrame(
dict(sa_period=periods,
spectrum_val=dset[p, 0],
spectrum_std=dset[p, 1]))
comment = dstore.metadata.copy()
comment['iml'] = iml
writer.save(df, fname, comment=comment)
fnames.append(fname)
return fnames
def export_bcr_map(ekey, dstore):
oq = dstore['oqparam']
assets = get_assets(dstore)
bcr_data = dstore[ekey[0]]
N, R = bcr_data.shape
if ekey[0].endswith('stats'):
rlzs_or_stats = oq.hazard_stats()
else:
rlzs_or_stats = ['rlz-%03d' % r for r in range(R)]
fnames = []
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
for t, ros in enumerate(rlzs_or_stats):
path = dstore.build_fname('bcr', ros, 'csv')
writer.save(compose_arrays(assets, bcr_data[:, t]), path,
renamedict=dict(id='asset_id'))
fnames.append(path)
return writer.getsaved()
def export_avg_gmf_csv(ekey, dstore):
oq = dstore['oqparam']
sitecol = dstore['sitecol'].complete
if 'custom_site_id' in sitecol.array.dtype.names:
dic = dict(custom_site_id=decode(sitecol.custom_site_id))
else:
dic = dict(site_id=sitecol.sids)
dic['lon'] = sitecol.lons
dic['lat'] = sitecol.lats
data = dstore['avg_gmf'][:] # shape (2, N, M)
for m, imt in enumerate(oq.imtls):
dic['gmv_' + imt] = data[0, :, m]
dic['gsd_' + imt] = data[1, :, m]
fname = dstore.build_fname('avg_gmf', '', 'csv')
writers.CsvWriter(fmt=writers.FIVEDIGITS).save(
pandas.DataFrame(dic), fname, comment=dstore.metadata)
return [fname]
def export_aggcurves_csv(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
E = len(dstore['events'])
R = len(dstore['weights'])
lossnames = numpy.array(oq.loss_types)
aggtags = get_agg_tags(dstore, oq.aggregate_by)
df = dstore.read_df('aggcurves')
consequences = [col for col in df.columns
if col in scientific.KNOWN_CONSEQUENCES]
for tagname, tags in aggtags.items():
df[tagname] = tags[df.agg_id]
dest = dstore.export_path('%s.%s' % ekey)
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
md = dstore.metadata
md['risk_investigation_time'] = (oq.risk_investigation_time or
oq.investigation_time)
md['num_events'] = E
md['effective_time'] = (
oq.investigation_time * oq.ses_per_logic_tree_path * R)
md['limit_states'] = dstore.get_attr('aggcurves', 'limit_states')
# aggcurves
agg_values = dstore['agg_values'][:]
cols = [col for col in df.columns if col not in consequences
and col not in ('agg_id', 'rlz_id', 'loss_id')]
edic = general.AccumDict(accum=[])
manyrlzs = not oq.collect_rlzs and R > 1
for (agg_id, rlz_id, loss_id), d in df.groupby(
['agg_id', 'rlz_id', 'loss_id']):
for col in cols:
edic[col].extend(d[col])
edic['loss_type'].extend([lossnames[loss_id]] * len(d))
if manyrlzs:
edic['rlz_id'].extend([rlz_id] * len(d))
for cons in consequences:
edic[cons + '_value'].extend(d[cons])
aval = scientific.get_agg_value(
cons, agg_values, agg_id, lossnames[loss_id])
edic[cons + '_ratio'].extend(d[cons] / aval)
writer.save(pandas.DataFrame(edic), dest, comment=md)
return [dest]
def export_csv(self, spec, asset_refs, curves_dict):
"""
:param asset_refs: names of the asset
:param curves_dict: a dictionary tag -> loss curves
"""
aval = self.assetcol.arr_value(self.loss_types)
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
ebr = hasattr(self, 'builder')
for key in sorted(curves_dict):
recs = curves_dict[key]
if ebr:
data = [[
'asset_id', 'loss_type', 'loss_value', 'loss_ratio',
'return_period', 'annual_frequency_of_exceedence'
]]
else:
data = [[
'asset_id', 'loss_type', 'loss_value', 'loss_ratio', 'poe'
]]
for li, lt in enumerate(self.loss_types):
if ebr: # event_based_risk
array = recs[:, :, li] # shape (A, P, LI)
periods = self.builder.return_periods
for aref, losses, val in sorted(
zip(asset_refs, array, aval[:, li])):
for period, loss in zip(periods, losses):
data.append((aref, lt, loss, loss / val, period,
1. / period))
else: # classical_risk
array = recs[lt] # shape (A,) loss_curve_dt
for aref, losses, poes, val in sorted(
zip(asset_refs, array['losses'], array['poes'],
aval[:, li])):
for loss, poe in zip(losses, poes):
data.append((aref, lt, loss, loss / val, poe))
dest = self.dstore.build_fname(
'loss_curves', '%s-%s' % (spec, key) if spec else key, 'csv')
com = dict(kind=key,
risk_investigation_time=self.oq.risk_investigation_time
or self.oq.investigation_time)
writer.save(data,
dest,
comment=com,
renamedict=dict(id='asset_id'))
return writer.getsaved()
def export_aggcurves_csv(ekey, dstore):
"""
:param ekey: export key, i.e. a pair (datastore key, fmt)
:param dstore: datastore object
"""
oq = dstore['oqparam']
E = len(dstore['events'])
R = len(dstore['weights'])
lossnames = numpy.array(oq.loss_names)
aggtags = get_agg_tags(dstore, oq.aggregate_by)
df = dstore.read_df('aggcurves')
for tagname, tags in aggtags.items():
df[tagname] = tags[df.agg_id]
df['loss_type'] = lossnames[df.loss_id.to_numpy()]
del df['loss_id']
dest1 = dstore.export_path('%s.%s' % ekey)
dest2 = dstore.export_path('dmgcsq.%s' % ekey[1])
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
md = dstore.metadata
md['risk_investigation_time'] = (oq.risk_investigation_time or
oq.investigation_time)
md['num_events'] = E
md['effective_time'] = (
oq.investigation_time * oq.ses_per_logic_tree_path * R)
md['limit_states'] = dstore.get_attr('aggcurves', 'limit_states')
dmg_states = ['nodamage'] + md['limit_states'].split()
# aggregate damages/consequences
dmgcsq = df[df.return_period == 0].set_index('agg_id') # length K+1
agg_number = dstore['agg_number'][dmgcsq.index.to_numpy()]
dmgs = [col for col in df.columns if col.startswith('dmg_')]
dmg0 = agg_number * E * oq.time_ratio - dmgcsq[dmgs].to_numpy().sum(axis=1)
dmgcsq.insert(0, 'dmg_0', dmg0)
dmgcsq.insert(0, 'number', agg_number)
del dmgcsq['return_period']
writer.save(rename(dmgcsq, dmg_states), dest2, comment=md)
# aggcurves
del df['agg_id']
writer.save(rename(df[df.return_period > 0], dmg_states),
dest1, comment=md)
return [dest1, dest2]
def export_loss_maps_csv(ekey, dstore):
kind = ekey[0].split('-')[1] # rlzs or stats
assets = get_assets(dstore)
value = get_loss_maps(dstore, kind)
oq = dstore['oqparam']
if kind == 'rlzs':
rlzs_or_stats = dstore['full_lt'].get_realizations()
else:
rlzs_or_stats = oq.hazard_stats()
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
md = dstore.metadata
for i, ros in enumerate(rlzs_or_stats):
if hasattr(ros, 'ordinal'): # is a realization
ros = 'rlz-%d' % ros.ordinal
fname = dstore.build_fname('loss_maps', ros, ekey[1])
md.update(
dict(kind=ros, risk_investigation_time=oq.risk_investigation_time
or oq.investigation_time))
writer.save(compose_arrays(assets, value[:, i]), fname, comment=md,
renamedict=dict(id='asset_id'))
return writer.getsaved()
def export_cond_spectra(ekey, dstore):
sitecol = dstore['sitecol']
dset = dstore[ekey[0]] # shape (1, M, N, 2, P)
periods = dset.attrs['periods']
imls = dset.attrs['imls']
writer = writers.CsvWriter(fmt=writers.FIVEDIGITS)
fnames = []
for n in sitecol.sids:
spe = dset[0, :, n, 0] # shape M, P
std = dset[0, :, n, 1] # shape M, P
fname = dstore.export_path('conditional-spectrum-%d.csv' % n)
dic = dict(sa_period=periods)
for p in range(len(imls)):
dic['val%d' % p] = spe[:, p]
dic['std%d' % p] = std[:, p]
df = pandas.DataFrame(dic)
comment = dstore.metadata.copy()
comment['imls'] = list(imls)
comment['site_id'] = n
comment['lon'] = sitecol.lons[n]
comment['lat'] = sitecol.lats[n]
writer.save(df, fname, comment=comment)
fnames.append(fname)
return fnames
