def test_resampling(self):
path = os.path.dirname(os.path.abspath(__file__))
# Read AF
f_af = os.path.join(path, 'data', 'convolution', 'amplification.csv')
df_af = read_csv(f_af, {'ampcode': ampcode_dt, None: numpy.float64},
index='ampcode')
# Read hc
f_hc = os.path.join(path, 'data', 'convolution', 'hazard_curve.csv')
df_hc = pd.read_csv(f_hc, skiprows=1)
# Get imls from the hc
imls = []
pattern = 'poe-(\\d*\\.\\d*)'
for k in df_hc.columns:
m = re.match(pattern, k)
if m:
imls.append(float(m.group(1)))
imtls = DictArray({'PGA': imls})
# Create a list with one ProbabilityCurve instance
poes = numpy.squeeze(df_hc.iloc[0, 3:].to_numpy())
tmp = numpy.expand_dims(poes, 1)
pcurve = ProbabilityCurve(tmp)
soil_levels = numpy.array(list(numpy.geomspace(0.001, 2, 50)))
a = Amplifier(imtls, df_af, soil_levels)
res = a.amplify(b'MQ15', pcurve)
tmp = 'hazard_curve_expected.csv'
fname_expected = os.path.join(path, 'data', 'convolution', tmp)
expected = numpy.loadtxt(fname_expected)
numpy.testing.assert_allclose(numpy.squeeze(res.array), expected)
def amplify(self, ampl_code, pcurve):
"""
:param ampl_code: 2-letter code for the amplification function
:param pcurve: a ProbabilityCurve of shape (L*M, R)
:returns: amplified ProbabilityCurve of shape (A*M, R)
"""
new = [
self.amplify_one(ampl_code, imt, pcurve.array[self.imtls(imt)])
for imt in self.imtls
]
return ProbabilityCurve(numpy.concatenate(new))
def _build_stat_curve(poes, imtls, stat, 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 ProbabilityCurve(array)
def gmvs_to_poe_map(gmvs_by_sid, imtls, invest_time, duration):
"""
Convert a dictionary sid -> gmva into a ProbabilityMap
"""
pmap = ProbabilityMap()
for sid in gmvs_by_sid:
data = []
for imti, imt in enumerate(imtls):
gmvs = get_array(gmvs_by_sid[sid], imti=imti)['gmv']
data.append(
_gmvs_to_haz_curve(gmvs, imtls[imt], invest_time, duration))
# the array underlying the ProbabilityCurve has size (num_levels, 1)
array = numpy.concatenate(data).reshape(-1, 1)
pmap[sid] = ProbabilityCurve(array)
return pmap
def amplify(self, ampl_code, pcurves):
"""
:param ampl_code: 2-letter code for the amplification function
:param pcurves: a list of ProbabilityCurves containing PoEs
:returns: amplified ProbabilityCurves
"""
out = []
for pcurve in pcurves:
lst = []
for imt in self.imtls:
slc = self.imtls(imt)
new = self.amplify_one(ampl_code, imt, pcurve.array[slc])
lst.append(new)
out.append(ProbabilityCurve(numpy.concatenate(lst)))
return out
def calc_hazard_curve(site1, src, gsims, oqparam):
"""
:param site1: site collection with a single site
:param src: a seismic source object
:param gsims: a list of GSIM objects
:param oqparam: an object with attributes .maximum_distance, .imtls
:returns: a ProbabilityCurve object
"""
assert len(site1) == 1, site1
trt = src.tectonic_region_type
cmaker = ContextMaker(trt, gsims, vars(oqparam))
srcfilter = SourceFilter(site1, oqparam.maximum_distance)
pmap, rup_data, calc_times = PmapMaker(cmaker, srcfilter, [src]).make()
if not pmap: # filtered away
zero = numpy.zeros((oqparam.imtls.size, len(gsims)))
return ProbabilityCurve(zero)
return pmap[0] # pcurve with shape (L, G) on site 0
def calc_hazard_curve(site1, src, gsims, oqparam, monitor=Monitor()):
"""
:param site1: site collection with a single site
:param src: a seismic source object
:param gsims: a list of GSIM objects
:param oqparam: an object with attributes .maximum_distance, .imtls
:param monitor: a Monitor instance (optional)
:returns: a ProbabilityCurve object
"""
assert len(site1) == 1, site1
trt = src.tectonic_region_type
cmaker = ContextMaker(trt, gsims, vars(oqparam), monitor)
cmaker.tom = src.temporal_occurrence_model
srcfilter = SourceFilter(site1, oqparam.maximum_distance)
pmap = PmapMaker(cmaker, srcfilter, [src]).make()['pmap']
if not pmap: # filtered away
zero = numpy.zeros((oqparam.imtls.size, len(gsims)))
return ProbabilityCurve(zero)
return pmap[0] # pcurve with shape (L, G) on site 0