def init(self):
"""
Read the poes and set the .data attribute with the hazard curves
"""
if hasattr(self, '_pmap_by_grp'): # already initialized
return self._pmap_by_grp
if isinstance(self.dstore, str):
self.dstore = hdf5.File(self.dstore, 'r')
else:
self.dstore.open('r') # if not
if self.sids is None:
self.sids = self.dstore['sitecol'].sids
oq = self.dstore['oqparam']
self.imtls = oq.imtls
self.poes = self.poes or oq.poes
self.rlzs_by_grp = self.dstore['full_lt'].get_rlzs_by_grp()
# populate _pmap_by_grp
self._pmap_by_grp = {}
if 'poes' in self.dstore:
# build probability maps restricted to the given sids
ok_sids = set(self.sids)
for grp, dset in self.dstore['poes'].items():
ds = dset['array']
L, G = ds.shape[1:]
pmap = probability_map.ProbabilityMap(L, G)
for idx, sid in enumerate(dset['sids'][()]):
if sid in ok_sids:
pmap[sid] = probability_map.ProbabilityCurve(ds[idx])
self._pmap_by_grp[grp] = pmap
self.nbytes += pmap.nbytes
return self._pmap_by_grp
def get_pcurves(self, sid): # used in classical
"""
:returns: a list of R probability curves with shape L
"""
pmap = self.init()
pcurves = [probability_map.ProbabilityCurve(numpy.zeros((self.L, 1)))
for _ in range(self.num_rlzs)]
try:
pc = pmap[sid]
except KeyError: # no hazard for sid
return pcurves
for g, rlzis in enumerate(self.rlzs_by_g):
c = probability_map.ProbabilityCurve(pc.array[:, [g]])
for rlzi in rlzis:
pcurves[rlzi] |= c
return pcurves
def __init__(self, dstore, sids=None, rlzs_assoc=None):
self.rlzs_assoc = rlzs_assoc or dstore['csm_info'].get_rlzs_assoc()
self.dstore = dstore
self.weights = [rlz.weight for rlz in self.rlzs_assoc.realizations]
self.num_levels = len(self.dstore['oqparam'].imtls.array)
self.sids = sids
self.nbytes = 0
if sids is None:
self.sids = dstore['sitecol'].complete.sids
# populate _pmap_by_grp
self._pmap_by_grp = {}
if 'poes' in self.dstore:
# build probability maps restricted to the given sids
for grp, dset in self.dstore['poes'].items():
sid2idx = {sid: i for i, sid in enumerate(dset.attrs['sids'])}
L, I = dset.shape[1:]
pmap = probability_map.ProbabilityMap(L, I)
for sid in self.sids:
try:
idx = sid2idx[sid]
except KeyError:
continue
else:
pmap[sid] = probability_map.ProbabilityCurve(dset[idx])
self._pmap_by_grp[grp] = pmap
self.nbytes += pmap.nbytes
def init(self):
if hasattr(self, 'data'): # already initialized
return
self.dstore.open() # if not
# populate _pmap_by_grp
self._pmap_by_grp = {}
if 'poes' in self.dstore:
# build probability maps restricted to the given sids
for grp, dset in self.dstore['poes'].items():
sid2idx = {sid: i for i, sid in enumerate(dset.attrs['sids'])}
L, I = dset.shape[1:]
pmap = probability_map.ProbabilityMap(L, I)
for sid in self.sids:
try:
idx = sid2idx[sid]
except KeyError:
continue
else:
pmap[sid] = probability_map.ProbabilityCurve(dset[idx])
self._pmap_by_grp[grp] = pmap
self.nbytes += pmap.nbytes
self.imtls = self.dstore['oqparam'].imtls
self.data = collections.OrderedDict()
try:
hcurves = self.get_hcurves(self.imtls) # shape (R, N)
except IndexError: # no data
return
for sid, hcurve_by_rlz in zip(self.sids, hcurves.T):
self.data[sid] = datadict = {}
for rlzi, hcurve in enumerate(hcurve_by_rlz):
datadict[rlzi] = lst = [None for imt in self.imtls]
for imti, imt in enumerate(self.imtls):
lst[imti] = hcurve[imt] # imls
def get_pmap_by_grp(self, sids=None):
"""
:param sids: an array of site IDs
:returns: a dictionary of probability maps by source group
"""
if self._pmap_by_grp is None: # populate the cache
self._pmap_by_grp = {}
for grp, dset in self.dstore['poes'].items():
sid2idx = {sid: i for i, sid in enumerate(dset.attrs['sids'])}
L, I = dset.shape[1:]
pmap = probability_map.ProbabilityMap(L, I)
for sid in sids:
try:
idx = sid2idx[sid]
except KeyError:
continue
else:
pmap[sid] = probability_map.ProbabilityCurve(dset[idx])
self._pmap_by_grp[grp] = pmap
self.sids = sids # store the sids used in the cache
self.nbytes += pmap.nbytes
else:
# make sure the cache refer to the right sids
assert sids is None or (sids == self.sids).all()
return self._pmap_by_grp
def get_pcurves(self, sid, pmap_by_grp=()): # used in classical
"""
:returns: a list of R probability curves with shape L
"""
if not pmap_by_grp:
pmap_by_grp = self.init()
pcurves = [probability_map.ProbabilityCurve(numpy.zeros((self.L, 1)))
for _ in range(self.num_rlzs)]
for grp, pmap in pmap_by_grp.items():
try:
pc = pmap[sid]
except KeyError: # no hazard for sid
continue
for gsim_idx, rlzis in enumerate(self.rlzs_by_grp[grp]):
c = probability_map.ProbabilityCurve(pc.array[:, [gsim_idx]])
for rlzi in rlzis:
pcurves[rlzi] |= c
return pcurves
def get_pcurve(self, sid): # used in classical
"""
:returns: a ProbabilityCurve of shape L, R
"""
pmap = self.init()
pc0 = probability_map.ProbabilityCurve(
numpy.zeros((self.L, self.num_rlzs)))
try:
pc0.combine(pmap[sid], self.rlzs_by_g)
except KeyError: # no hazard for sid
pass
return pc0
def get_pcurve(self, s, r, g): # used in disaggregation
"""
:param s: site ID
:param r: realization ID
:param g: group ID
:returns: a probability curves with shape L (or None, if missing)
"""
grp = 'grp-%02d' % g
pmap = self.init()[grp]
try:
pc = pmap[s]
except KeyError:
return
L = len(self.imtls.array)
pcurve = probability_map.ProbabilityCurve(numpy.zeros((L, 1)))
for gsim_idx, rlzis in enumerate(self.rlzs_by_grp[grp]):
for rlzi in rlzis:
if rlzi == r:
pcurve |= probability_map.ProbabilityCurve(
pc.array[:, [gsim_idx]])
return pcurve
def get_hazard(self, gsim=None):
"""
:param gsim: ignored
:returns: a probability curve of shape (L, R) for the given site
"""
self.init()
if not self.sids:
# this happens when the poes are all zeros, as in
# classical_risk/case_3 for the first site
return probability_map.ProbabilityCurve(
numpy.zeros((self.L, self.num_rlzs)))
return self.get_pcurve(self.sids[0])
def build_stat_curve(poes, imtls, stat, weights):
"""
Build statistics by taking into account IMT-dependent weights
"""
assert len(poes) == len(weights), (len(poes), len(weights))
L = len(imtls.array)
array = numpy.zeros((L, 1))
if isinstance(weights, list): # IMT-dependent weights
# this is slower since the arrays are shorter
for imt in imtls:
slc = imtls(imt)
ws = [w[imt] for w in weights]
if sum(ws) == 0: # expect no data for this IMT
continue
array[slc] = stat(poes[:, slc], ws)
else:
array = stat(poes, weights)
return probability_map.ProbabilityCurve(array)
def init(self):
"""
Build the probability curves from the underlying dataframes
"""
if self._pmap:
return self._pmap
G = len(self.rlzs_by_g)
with hdf5.File(self.filename) as dstore:
for start, stop in self.slices:
poes_df = dstore.read_df('_poes', slc=slice(start, stop))
for sid, df in poes_df.groupby('sid'):
try:
array = self._pmap[sid].array
except KeyError:
array = numpy.zeros((self.L, G))
self._pmap[sid] = probability_map.ProbabilityCurve(
array)
array[df.lid, df.gid] = df.poe
return self._pmap
def pmap_by_grp(self):
"""
:returns: dictionary "grp-XXX" -> ProbabilityMap instance
"""
if hasattr(self, '_pmap_by_grp'): # already called
return self._pmap_by_grp
# populate _pmap_by_grp
self._pmap_by_grp = {}
if 'poes' in self.dstore:
# build probability maps restricted to the given sids
ok_sids = set(self.sids)
for grp, dset in self.dstore['poes'].items():
ds = dset['array']
L, G = ds.shape[1:]
pmap = probability_map.ProbabilityMap(L, G)
for idx, sid in enumerate(dset['sids'].value):
if sid in ok_sids:
pmap[sid] = probability_map.ProbabilityCurve(ds[idx])
self._pmap_by_grp[grp] = pmap
self.nbytes += pmap.nbytes
return self._pmap_by_grp
def pmap_by_grp(self):
"""
:returns: dictionary "grp-XXX" -> ProbabilityMap instance
"""
if hasattr(self, '_pmap_by_grp'): # already called
return self._pmap_by_grp
# populate _pmap_by_grp
self._pmap_by_grp = {}
if 'poes' in self.dstore:
# build probability maps restricted to the given sids
for grp, dset in self.dstore['poes'].items():
sid2idx = {sid: i for i, sid in enumerate(dset.attrs['sids'])}
L, I = dset.shape[1:]
pmap = probability_map.ProbabilityMap(L, I)
for sid in self.sids:
try:
idx = sid2idx[sid]
except KeyError:
continue
else:
pmap[sid] = probability_map.ProbabilityCurve(dset[idx])
self._pmap_by_grp[grp] = pmap
self.nbytes += pmap.nbytes
return self._pmap_by_grp
