def get_rlzs_assoc(self, get_weight=lambda tm: tm.num_ruptures):
"""
Return a RlzsAssoc with fields realizations, gsim_by_trt,
rlz_idx and trt_gsims.
:param get_weight: a function trt_model -> positive number
"""
assoc = RlzsAssoc(self.get_info())
random_seed = self.source_model_lt.seed
num_samples = self.source_model_lt.num_samples
idx = 0
for smodel in self.source_models:
# collect the effective tectonic region types
trts = set(tm.trt for tm in smodel.trt_models if get_weight(tm))
# recompute the GSIM logic tree if needed
if trts != set(smodel.gsim_lt.tectonic_region_types):
before = smodel.gsim_lt.get_num_paths()
smodel.gsim_lt.reduce(trts)
after = smodel.gsim_lt.get_num_paths()
logging.warn(
'Reducing the logic tree of %s from %d to %d '
'realizations', smodel.name, before, after)
if num_samples: # sampling
rnd = random.Random(random_seed + idx)
rlzs = logictree.sample(smodel.gsim_lt, smodel.samples, rnd)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(smodel.gsim_lt)
if rlzs:
idx = assoc._add_realizations(idx, smodel, rlzs, trts)
for trt_model in smodel.trt_models:
trt_model.gsims = smodel.gsim_lt.values[trt_model.trt]
else:
logging.warn('No realizations for %s, %s',
'_'.join(smodel.path), smodel.name)
if assoc.realizations:
if num_samples:
assert len(assoc.realizations) == num_samples
for rlz in assoc.realizations:
rlz.weight = 1. / num_samples
else:
tot_weight = sum(rlz.weight for rlz in assoc.realizations)
if tot_weight == 0:
raise ValueError('All realizations have zero weight??')
elif abs(tot_weight - 1) > 1E-12: # allow for rounding errors
logging.warn('Some source models are not contributing, '
'weights are being rescaled')
for rlz in assoc.realizations:
rlz.weight = rlz.weight / tot_weight
assoc.gsims_by_trt_id = groupby(
assoc.rlzs_assoc, operator.itemgetter(0),
lambda group: sorted(gsim for trt_id, gsim in group))
return assoc
def get_rlzs_assoc(self, get_weight=lambda tm: tm.num_ruptures):
"""
Return a RlzsAssoc with fields realizations, gsim_by_trt,
rlz_idx and trt_gsims.
:param get_weight: a function trt_model -> positive number
"""
assoc = RlzsAssoc(self.get_info())
random_seed = self.source_model_lt.seed
num_samples = self.source_model_lt.num_samples
idx = 0
for smodel in self.source_models:
# collect the effective tectonic region types
trts = set(tm.trt for tm in smodel.trt_models if get_weight(tm))
# recompute the GSIM logic tree if needed
if trts != set(smodel.gsim_lt.tectonic_region_types):
before = smodel.gsim_lt.get_num_paths()
smodel.gsim_lt.reduce(trts)
after = smodel.gsim_lt.get_num_paths()
logging.warn('Reducing the logic tree of %s from %d to %d '
'realizations', smodel.name, before, after)
if num_samples: # sampling
rnd = random.Random(random_seed + idx)
rlzs = logictree.sample(smodel.gsim_lt, smodel.samples, rnd)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(smodel.gsim_lt)
if rlzs:
idx = assoc._add_realizations(idx, smodel, rlzs, trts)
for trt_model in smodel.trt_models:
trt_model.gsims = smodel.gsim_lt.values[trt_model.trt]
else:
logging.warn('No realizations for %s, %s',
'_'.join(smodel.path), smodel.name)
if assoc.realizations:
if num_samples:
assert len(assoc.realizations) == num_samples
for rlz in assoc.realizations:
rlz.weight = 1. / num_samples
else:
tot_weight = sum(rlz.weight for rlz in assoc.realizations)
if tot_weight == 0:
raise ValueError('All realizations have zero weight??')
elif abs(tot_weight - 1) > 1E-12: # allow for rounding errors
logging.warn('Some source models are not contributing, '
'weights are being rescaled')
for rlz in assoc.realizations:
rlz.weight = rlz.weight / tot_weight
assoc.gsims_by_trt_id = groupby(
assoc.rlzs_assoc, operator.itemgetter(0),
lambda group: sorted(valid.gsim(gsim) for trt_id, gsim in group))
return assoc
def get_rlzs_assoc(self, count_ruptures=None):
"""
Return a RlzsAssoc with fields realizations, gsim_by_trt,
rlz_idx and trt_gsims.
:param count_ruptures: a function src_group -> num_ruptures
"""
assoc = RlzsAssoc(self)
random_seed = self.seed
idx = 0
trtset = set(self.gsim_lt.tectonic_region_types)
for i, smodel in enumerate(self.source_models):
# collect the effective tectonic region types and ruptures
trts = set()
for sg in smodel.src_groups:
if count_ruptures:
sg.eff_ruptures = count_ruptures(sg)
if sg.eff_ruptures:
trts.add(sg.trt)
# recompute the GSIM logic tree if needed
if trtset != trts:
before = self.gsim_lt.get_num_paths()
gsim_lt = self.gsim_lt.reduce(trts)
after = gsim_lt.get_num_paths()
if count_ruptures and before > after:
logging.warn(
'Reducing the logic tree of %s from %d to %d '
'realizations', smodel.name, before, after)
else:
gsim_lt = self.gsim_lt
if self.num_samples: # sampling
# the int is needed on Windows to convert numpy.uint32 objects
rnd = random.Random(int(random_seed + idx))
rlzs = logictree.sample(gsim_lt, smodel.samples, rnd)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(gsim_lt)
if rlzs:
indices = numpy.arange(idx, idx + len(rlzs))
idx += len(indices)
assoc._add_realizations(indices, smodel, gsim_lt, rlzs)
elif trts:
logging.warn('No realizations for %s, %s',
'_'.join(smodel.path), smodel.name)
if len(rlzs) > TWO16:
raise ValueError(
'The source model %s has %d realizations, the maximum '
'is %d' % (smodel.name, len(rlzs), TWO16))
# NB: realizations could be filtered away by logic tree reduction
if assoc.realizations:
assoc._init()
return assoc
def get_rlzs_assoc(self, count_ruptures=lambda tm: -1):
"""
Return a RlzsAssoc with fields realizations, gsim_by_trt,
rlz_idx and trt_gsims.
:param count_ruptures: a function trt_model -> num_ruptures
"""
assoc = RlzsAssoc(self)
random_seed = self.seed
num_samples = self.num_samples
idx = 0
for i, smodel in enumerate(self.source_models):
# collect the effective tectonic region types and ruptures
trts = set()
rups = []
for tm in smodel.trt_models:
nr = count_ruptures(tm)
if nr:
rups.append('%r: %d' % (capitalize(tm.trt), nr))
trts.add(tm.trt)
self.eff_ruptures[i] = '{%s}' % cjoin(rups, LENGTH - len('{}'))
# recompute the GSIM logic tree if needed
if trts != set(smodel.gsim_lt.tectonic_region_types):
before = smodel.gsim_lt.get_num_paths()
smodel.gsim_lt.reduce(trts)
after = smodel.gsim_lt.get_num_paths()
logging.warn(
'Reducing the logic tree of %s from %d to %d '
'realizations', smodel.name, before, after)
if num_samples: # sampling
rnd = random.Random(random_seed + idx)
rlzs = logictree.sample(smodel.gsim_lt, smodel.samples, rnd)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(smodel.gsim_lt)
if rlzs:
indices = numpy.arange(idx, idx + len(rlzs))
idx += len(indices)
assoc._add_realizations(indices, smodel, rlzs)
for trt_model in smodel.trt_models:
trt_model.gsims = smodel.gsim_lt.values[trt_model.trt]
else:
logging.warn('No realizations for %s, %s',
'_'.join(smodel.path), smodel.name)
# NB: realizations could be filtered away by logic tree reduction
if assoc.realizations:
assoc._init()
return assoc
def get_rlzs_assoc(self, count_ruptures=lambda tm: -1):
"""
Return a RlzsAssoc with fields realizations, gsim_by_trt,
rlz_idx and trt_gsims.
:param count_ruptures: a function trt_model -> num_ruptures
"""
assoc = RlzsAssoc(self)
random_seed = self.seed
num_samples = self.num_samples
idx = 0
for i, smodel in enumerate(self.source_models):
# collect the effective tectonic region types and ruptures
trts = set()
rups = []
for tm in smodel.trt_models:
nr = count_ruptures(tm)
if nr:
rups.append('%r: %d' % (capitalize(tm.trt), nr))
trts.add(tm.trt)
self.eff_ruptures[i] = '{%s}' % cjoin(rups, LENGTH - len('{}'))
# recompute the GSIM logic tree if needed
if trts != set(smodel.gsim_lt.tectonic_region_types):
before = smodel.gsim_lt.get_num_paths()
smodel.gsim_lt.reduce(trts)
after = smodel.gsim_lt.get_num_paths()
logging.warn('Reducing the logic tree of %s from %d to %d '
'realizations', smodel.name, before, after)
if num_samples: # sampling
rnd = random.Random(random_seed + idx)
rlzs = logictree.sample(smodel.gsim_lt, smodel.samples, rnd)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(smodel.gsim_lt)
if rlzs:
indices = numpy.arange(idx, idx + len(rlzs))
idx += len(indices)
assoc._add_realizations(indices, smodel, rlzs)
for trt_model in smodel.trt_models:
trt_model.gsims = smodel.gsim_lt.values[trt_model.trt]
else:
logging.warn('No realizations for %s, %s',
'_'.join(smodel.path), smodel.name)
# NB: realizations could be filtered away by logic tree reduction
if assoc.realizations:
assoc._init()
return assoc
def get_rlzs_assoc(self, count_ruptures=None):
"""
Return a RlzsAssoc with fields realizations, gsim_by_trt,
rlz_idx and trt_gsims.
:param count_ruptures: a function src_group -> num_ruptures
"""
assoc = RlzsAssoc(self)
random_seed = self.seed
idx = 0
trtset = set(self.gsim_lt.tectonic_region_types)
for i, smodel in enumerate(self.source_models):
# collect the effective tectonic region types and ruptures
trts = set()
for sg in smodel.src_groups:
if count_ruptures:
sg.eff_ruptures = count_ruptures(sg)
if sg.eff_ruptures:
trts.add(sg.trt)
# recompute the GSIM logic tree if needed
if trtset != trts:
before = self.gsim_lt.get_num_paths()
gsim_lt = self.gsim_lt.reduce(trts)
after = gsim_lt.get_num_paths()
if count_ruptures and before > after:
logging.warn('Reducing the logic tree of %s from %d to %d '
'realizations', smodel.name, before, after)
else:
gsim_lt = self.gsim_lt
if self.num_samples: # sampling
# the int is needed on Windows to convert numpy.uint32 objects
rnd = random.Random(int(random_seed + idx))
rlzs = logictree.sample(gsim_lt, smodel.samples, rnd)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(gsim_lt)
if rlzs:
indices = numpy.arange(idx, idx + len(rlzs))
idx += len(indices)
assoc._add_realizations(indices, smodel, gsim_lt, rlzs)
elif trts:
logging.warn('No realizations for %s, %s',
'_'.join(smodel.path), smodel.name)
# NB: realizations could be filtered away by logic tree reduction
if assoc.realizations:
assoc._init()
return assoc
def get_rlzs_assoc(self, count_ruptures=None):
"""
Return a RlzsAssoc with fields realizations, gsim_by_trt,
rlz_idx and trt_gsims.
:param count_ruptures: a function trt_model -> num_ruptures
"""
assoc = RlzsAssoc(self)
random_seed = self.seed
idx = 0
trtset = set(self.gsim_lt.tectonic_region_types)
for i, smodel in enumerate(self.source_models):
# collect the effective tectonic region types and ruptures
trts = set()
for tm in smodel.trt_models:
if count_ruptures:
tm.eff_ruptures = count_ruptures(tm)
if tm.eff_ruptures:
trts.add(tm.trt)
# recompute the GSIM logic tree if needed
if trtset != trts:
before = self.gsim_lt.get_num_paths()
gsim_lt = self.gsim_lt.reduce(trts)
after = gsim_lt.get_num_paths()
if count_ruptures and before > after:
logging.warn(
'Reducing the logic tree of %s from %d to %d '
'realizations', smodel.name, before, after)
else:
gsim_lt = self.gsim_lt
if self.num_samples: # sampling
rnd = random.Random(random_seed + idx)
rlzs = logictree.sample(gsim_lt, smodel.samples, rnd)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(gsim_lt)
if rlzs:
indices = numpy.arange(idx, idx + len(rlzs))
idx += len(indices)
assoc._add_realizations(indices, smodel, gsim_lt, rlzs)
elif trts:
logging.warn('No realizations for %s, %s',
'_'.join(smodel.path), smodel.name)
# NB: realizations could be filtered away by logic tree reduction
if assoc.realizations:
assoc._init()
return assoc
def get_rlzs_assoc(self, get_weight=lambda tm: tm.num_ruptures):
"""
Return a RlzsAssoc with fields realizations, gsim_by_trt,
rlz_idx and trt_gsims.
:param get_weight: a function trt_model -> positive number
"""
assoc = RlzsAssoc(self.info)
random_seed = self.source_model_lt.seed
num_samples = self.source_model_lt.num_samples
idx = 0
for smodel in self.source_models:
# count the number of ruptures per tectonic region type
trts = set()
for trt_model in smodel.trt_models:
if get_weight(trt_model) > 0:
trts.add(trt_model.trt)
# recompute the GSIM logic tree if needed
if trts != set(smodel.gsim_lt.tectonic_region_types):
smodel.gsim_lt.reduce(trts)
if num_samples: # sampling
rnd = random.Random(random_seed + idx)
rlzs = logictree.sample(smodel.gsim_lt, smodel.samples, rnd)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(smodel.gsim_lt)
if rlzs:
idx = assoc._add_realizations(idx, smodel, rlzs)
else:
logging.warn('No realizations for %s, %s',
'_'.join(smodel.path), smodel.name)
if assoc.realizations:
if num_samples:
assert len(assoc.realizations) == num_samples
for rlz in assoc.realizations:
rlz.weight = 1. / num_samples
else:
tot_weight = sum(rlz.weight for rlz in assoc.realizations)
if tot_weight == 0:
raise ValueError('All realizations have zero weight??')
elif abs(tot_weight - 1) > 1E-12: # allow for rounding errors
logging.warn('Some source models are not contributing, '
'weights are being rescaled')
for rlz in assoc.realizations:
rlz.weight = rlz.weight / tot_weight
return assoc
def filter(self, src_filter):
"""
Generate a new CompositeSourceModel by filtering the sources on
the given site collection.
:param sitecol: a SiteCollection instance
:para src_filter: a SourceFilter instance
"""
source_models = []
weight = 0
idx = 0
seed = int(self.source_model_lt.seed) # avoids F32 issues on Windows
for sm in self.source_models:
src_groups = []
for src_group in sm.src_groups:
if self.source_model_lt.num_samples:
rnd = random.Random(seed + idx)
rlzs = logictree.sample(self.gsim_lt, sm.samples, rnd)
idx += len(rlzs)
for i, sg in enumerate(sm.src_groups):
sg.gsims = sorted(set(rlz.value[i] for rlz in rlzs))
else:
for sg in sm.src_groups:
sg.gsims = sorted(self.gsim_lt.values[sg.trt])
sources = []
for src, sites in src_filter(src_group.sources):
sources.append(src)
weight += src.weight
sg = copy.copy(src_group)
sg.sources = sources
src_groups.append(sg)
newsm = logictree.SourceModel(
sm.name, sm.weight, sm.path, src_groups,
sm.num_gsim_paths, sm.ordinal, sm.samples)
source_models.append(newsm)
new = self.__class__(self.gsim_lt, self.source_model_lt, source_models)
new.weight = weight
return new
def _get_rlzs(self, smodel, all_rlzs, seed):
if self.num_samples:
rlzs = logictree.sample(all_rlzs, smodel.samples, seed)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(all_rlzs)
return rlzs
def _get_rlzs(self, smodel, all_rlzs, seed):
if self.num_samples:
rlzs = logictree.sample(all_rlzs, smodel.samples, seed)
else: # full enumeration
rlzs = logictree.get_effective_rlzs(all_rlzs)
return rlzs
