def setUp(self):
# simple logic tree with 3 realizations
# ___/ b11 (w=.2)
# _/ \ b12 (w=.2)
# \____ b02 (w=.6)
self.bs0 = bs0 = lt.BranchSet('abGRAbsolute')
bs0.branches = [
lt.Branch('bs0', 'b01', .4, (4.6, 1.1)),
lt.Branch('bs0', 'b02', .6, (4.4, 0.9))
]
self.bs1 = bs1 = lt.BranchSet('maxMagGRAbsolute')
bs1.branches = [
lt.Branch('bs1', 'b11', .5, 7.0),
lt.Branch('bs1', 'b12', .5, 7.6)
]
bs0.branches[0].bset = bs1
# setup sitecol, srcfilter, gsims, imtls
sitecol = site.SiteCollection(
[site.Site(Point(0, 0), numpy.array([760.]))])
self.srcfilter = calc.filters.SourceFilter(sitecol, {'default': 200})
self.gsims = [valid.gsim('ToroEtAl2002')]
self.imtls = DictArray({'PGA': valid.logscale(.01, 1, 5)})
self.sg = sourceconverter.SourceGroup(ps.tectonic_region_type, [ps])
def __fromh5__(self, array, dic):
self.bsetdict = json.loads(dic['bsetdict'])
self.filename = dic['filename']
self.branches = []
self.shortener = {}
self.values = defaultdict(list)
dirname = os.path.dirname(dic['filename'])
for bsno, branches in enumerate(group_array(array, 'trt').values()):
for brno, branch in enumerate(branches):
branch = fix_bytes(branch)
br_id = branch['branch']
gsim = valid.gsim(branch['uncertainty'], dirname)
for k, v in gsim.kwargs.items():
if k.endswith(('_file', '_table')):
arr = numpy.asarray(dic[os.path.basename(v)][()])
gsim.kwargs[k] = io.BytesIO(bytes(arr))
self.values[branch['trt']].append(gsim)
weight = object.__new__(ImtWeight)
# branch dtype ('trt', 'branch', 'uncertainty', 'weight', ...)
weight.dic = {w: branch[w] for w in array.dtype.names[3:]}
if len(weight.dic) > 1:
gsim.weight = weight
bt = BranchTuple(branch['trt'], br_id, gsim, weight, True)
self.branches.append(bt)
self.shortener[br_id] = keyno(br_id, bsno, brno)
def get_gsims(oqparam):
"""
Return an ordered list of GSIM instances from the gsim name in the
configuration file or from the gsim logic tree file.
:param oqparam:
an :class:`openquake.commonlib.oqvalidation.OqParam` instance
"""
return [valid.gsim(str(rlz)) for rlz in get_gsim_lt(oqparam)]
def test_gsim(self):
class FakeGsim(object):
def __init__(self, arg):
self.arg = arg
def __repr__(self):
return '<FakeGsim(%s)>' % self.arg
valid.GSIM['FakeGsim'] = FakeGsim
try:
gsim = valid.gsim('FakeGsim', arg='0.1')
self.assertEqual(repr(gsim), '<FakeGsim(0.1)>')
finally:
del valid.GSIM['FakeGsim']
def test_gsim(self):
class FakeGsim(object):
def __init__(self, arg):
self.arg = arg
def __repr__(self):
return '<FakeGsim(%s)>' % self.arg
valid.GSIM['FakeGsim'] = FakeGsim
try:
gsim = valid.gsim('FakeGsim', arg='0.1')
self.assertEqual(repr(gsim), '<FakeGsim(0.1)>')
finally:
del valid.GSIM['FakeGsim']
def test_gsim(self):
class FakeGsim(object):
def __init__(self, arg):
self.arg = arg
def __repr__(self):
return '<FakeGsim(%s)>' % self.arg
registry['FakeGsim'] = FakeGsim
try:
gsim = valid.gsim('FakeGsim', arg='0.1')
self.assertEqual(repr(gsim), '<FakeGsim(0.1)>')
self.assertEqual(gsim.minimum_distance, 0)
finally:
del registry['FakeGsim']
def test_make_pmap(self):
trunclevel = 3
imtls = DictArray({'PGA': [0.01]})
gsims = [valid.gsim('AkkarBommer2010')]
ctxs = []
for occ_rate in (.001, .002):
ctx = RuptureContext()
ctx.mag = 5.5
ctx.rake = 90
ctx.occurrence_rate = occ_rate
ctx.sids = numpy.array([0.])
ctx.vs30 = numpy.array([760.])
ctx.rrup = numpy.array([100.])
ctx.rjb = numpy.array([99.])
ctxs.append(ctx)
pmap = make_pmap(ctxs, gsims, imtls, trunclevel, 50.)
numpy.testing.assert_almost_equal(pmap[0].array, 0.066381)
def test_gsim(self):
class FakeGsim(object):
def __init__(self, arg):
self.arg = arg
def init(self):
pass
def __repr__(self):
return '<FakeGsim(%s)>' % self.arg
registry['FakeGsim'] = FakeGsim
try:
gsim = valid.gsim('[FakeGsim]\narg=0.1', '/fake/dir')
self.assertEqual(repr(gsim), '<FakeGsim(0.1)>')
finally:
del registry['FakeGsim']
def test_get_pmap(self):
truncation_level = 3
imtls = DictArray({'PGA': [0.01]})
gsims = [valid.gsim('AkkarBommer2010')]
ctxs = []
for occ_rate in (.001, .002):
ctx = RuptureContext()
ctx.mag = 5.5
ctx.rake = 90
ctx.occurrence_rate = occ_rate
ctx.sids = numpy.array([0.])
ctx.vs30 = numpy.array([760.])
ctx.rrup = numpy.array([100.])
ctx.rjb = numpy.array([99.])
ctxs.append(ctx)
cmaker = ContextMaker(
'TRT', gsims, dict(imtls=imtls, truncation_level=truncation_level))
cmaker.tom = PoissonTOM(time_span=50)
pmap = cmaker.get_pmap(ctxs)
numpy.testing.assert_almost_equal(pmap[0].array, 0.066381)
def __init__(self, **names_vals):
# support legacy names
for name in list(names_vals):
if name == 'quantile_hazard_curves':
names_vals['quantiles'] = names_vals.pop(name)
elif name == 'mean_hazard_curves':
names_vals['mean'] = names_vals.pop(name)
elif name == 'max':
names_vals['max'] = names_vals.pop(name)
super().__init__(**names_vals)
job_ini = self.inputs['job_ini']
if 'calculation_mode' not in names_vals:
raise InvalidFile('Missing calculation_mode in %s' % job_ini)
if 'region_constraint' in names_vals:
if 'region' in names_vals:
raise InvalidFile('You cannot have both region and '
'region_constraint in %s' % job_ini)
logging.warning(
'region_constraint is obsolete, use region instead')
self.region = valid.wkt_polygon(
names_vals.pop('region_constraint'))
self.risk_investigation_time = (self.risk_investigation_time
or self.investigation_time)
if ('intensity_measure_types_and_levels' in names_vals
and 'intensity_measure_types' in names_vals):
logging.warning('Ignoring intensity_measure_types since '
'intensity_measure_types_and_levels is set')
if 'iml_disagg' in names_vals:
self.iml_disagg.pop('default')
# normalize things like SA(0.10) -> SA(0.1)
self.iml_disagg = {
str(from_string(imt)): val
for imt, val in self.iml_disagg.items()
}
self.hazard_imtls = self.iml_disagg
if 'intensity_measure_types_and_levels' in names_vals:
raise InvalidFile(
'Please remove the intensity_measure_types_and_levels '
'from %s: they will be inferred from the iml_disagg '
'dictionary' % job_ini)
elif 'intensity_measure_types_and_levels' in names_vals:
self.hazard_imtls = self.intensity_measure_types_and_levels
delattr(self, 'intensity_measure_types_and_levels')
elif 'intensity_measure_types' in names_vals:
self.hazard_imtls = dict.fromkeys(self.intensity_measure_types)
delattr(self, 'intensity_measure_types')
self._risk_files = get_risk_files(self.inputs)
self.check_source_model()
if self.hazard_precomputed() and self.job_type == 'risk':
self.check_missing('site_model', 'debug')
self.check_missing('gsim_logic_tree', 'debug')
self.check_missing('source_model_logic_tree', 'debug')
# check the gsim_logic_tree
if self.inputs.get('gsim_logic_tree'):
if self.gsim != '[FromFile]':
raise InvalidFile('%s: if `gsim_logic_tree_file` is set, there'
' must be no `gsim` key' % job_ini)
path = os.path.join(self.base_path, self.inputs['gsim_logic_tree'])
gsim_lt = logictree.GsimLogicTree(path, ['*'])
# check the number of branchsets
branchsets = len(gsim_lt._ltnode)
if 'scenario' in self.calculation_mode and branchsets > 1:
raise InvalidFile(
'%s: %s for a scenario calculation must contain a single '
'branchset, found %d!' % (job_ini, path, branchsets))
# check the IMTs vs the GSIMs
self._gsims_by_trt = gsim_lt.values
for gsims in gsim_lt.values.values():
self.check_gsims(gsims)
elif self.gsim is not None:
self.check_gsims([valid.gsim(self.gsim, self.base_path)])
# check inputs
unknown = set(self.inputs) - self.KNOWN_INPUTS
if unknown:
raise ValueError('Unknown key %s_file in %s' %
(unknown.pop(), self.inputs['job_ini']))
# checks for disaggregation
if self.calculation_mode == 'disaggregation':
if not self.poes_disagg and not self.iml_disagg:
raise InvalidFile('poes_disagg or iml_disagg must be set '
'in %(job_ini)s' % self.inputs)
elif self.poes_disagg and self.iml_disagg:
raise InvalidFile(
'%s: iml_disagg and poes_disagg cannot be set '
'at the same time' % job_ini)
for k in ('mag_bin_width', 'distance_bin_width',
'coordinate_bin_width', 'num_epsilon_bins'):
if k not in vars(self):
raise InvalidFile('%s must be set in %s' % (k, job_ini))
# checks for classical_damage
if self.calculation_mode == 'classical_damage':
if self.conditional_loss_poes:
raise InvalidFile('%s: conditional_loss_poes are not defined '
'for classical_damage calculations' %
job_ini)
# checks for event_based_risk
if (self.calculation_mode == 'event_based_risk'
and self.asset_correlation not in (0, 1)):
raise ValueError('asset_correlation != {0, 1} is no longer'
' supported')
# checks for ebrisk
if self.calculation_mode == 'ebrisk':
if self.risk_investigation_time is None:
raise InvalidFile('Please set the risk_investigation_time in'
' %s' % job_ini)
# check for GMFs from file
if (self.inputs.get('gmfs', '').endswith('.csv')
and 'sites' not in self.inputs and self.sites is None):
raise InvalidFile('%s: You forgot sites|sites_csv' % job_ini)
elif self.inputs.get('gmfs', '').endswith('.xml'):
raise InvalidFile('%s: GMFs in XML are not supported anymore' %
job_ini)
# checks for event_based
if 'event_based' in self.calculation_mode:
if self.ses_per_logic_tree_path >= TWO32:
raise ValueError('ses_per_logic_tree_path too big: %d' %
self.ses_per_logic_tree_path)
if self.number_of_logic_tree_samples >= TWO16:
raise ValueError('number_of_logic_tree_samples too big: %d' %
self.number_of_logic_tree_samples)
# check grid + sites
if self.region_grid_spacing and ('sites' in self.inputs or self.sites):
raise ValueError('You are specifying grid and sites at the same '
'time: which one do you want?')
# check for amplification
if 'amplification' in self.inputs and self.imtls:
check_same_levels(self.imtls)
def __init__(self, **names_vals):
if '_job_id' in names_vals:
# assume most attributes already validated
vars(self).update(names_vals)
if 'hazard_calculation_id' in names_vals:
self.hazard_calculation_id = int(
names_vals['hazard_calculation_id'])
if 'maximum_distance' in names_vals:
self.maximum_distance = valid.MagDepDistance.new(
str(names_vals['maximum_distance']))
if 'pointsource_distance' in names_vals:
self.pointsource_distance = valid.MagDepDistance.new(
str(names_vals['pointsource_distance']))
if 'region_constraint' in names_vals:
self.region = valid.wkt_polygon(
names_vals['region_constraint'])
if 'minimum_magnitude' in names_vals:
self.minimum_magnitude = valid.floatdict(
str(names_vals['minimum_magnitude']))
if 'minimum_intensity' in names_vals:
self.minimum_intensity = valid.floatdict(
str(names_vals['minimum_intensity']))
if 'sites' in names_vals:
self.sites = valid.coordinates(names_vals['sites'])
return
# support legacy names
for name in list(names_vals):
if name == 'quantile_hazard_curves':
names_vals['quantiles'] = names_vals.pop(name)
elif name == 'mean_hazard_curves':
names_vals['mean'] = names_vals.pop(name)
elif name == 'max':
names_vals['max'] = names_vals.pop(name)
super().__init__(**names_vals)
if 'job_ini' not in self.inputs:
self.inputs['job_ini'] = '<in-memory>'
job_ini = self.inputs['job_ini']
if 'calculation_mode' not in names_vals:
raise InvalidFile('Missing calculation_mode in %s' % job_ini)
if 'region_constraint' in names_vals:
if 'region' in names_vals:
raise InvalidFile('You cannot have both region and '
'region_constraint in %s' % job_ini)
logging.warning(
'region_constraint is obsolete, use region instead')
self.region = valid.wkt_polygon(
names_vals.pop('region_constraint'))
self.risk_investigation_time = (self.risk_investigation_time
or self.investigation_time)
self.collapse_level = int(self.collapse_level)
if ('intensity_measure_types_and_levels' in names_vals
and 'intensity_measure_types' in names_vals):
logging.warning('Ignoring intensity_measure_types since '
'intensity_measure_types_and_levels is set')
if 'iml_disagg' in names_vals:
self.iml_disagg.pop('default')
# normalize things like SA(0.10) -> SA(0.1)
self.iml_disagg = {
str(from_string(imt)): val
for imt, val in self.iml_disagg.items()
}
self.hazard_imtls = self.iml_disagg
if 'intensity_measure_types_and_levels' in names_vals:
raise InvalidFile(
'Please remove the intensity_measure_types_and_levels '
'from %s: they will be inferred from the iml_disagg '
'dictionary' % job_ini)
elif 'intensity_measure_types_and_levels' in names_vals:
self.hazard_imtls = self.intensity_measure_types_and_levels
delattr(self, 'intensity_measure_types_and_levels')
lens = set(map(len, self.hazard_imtls.values()))
if len(lens) > 1:
dic = {imt: len(ls) for imt, ls in self.hazard_imtls.items()}
raise ValueError(
'Each IMT must have the same number of levels, instead '
'you have %s' % dic)
elif 'intensity_measure_types' in names_vals:
self.hazard_imtls = dict.fromkeys(self.intensity_measure_types)
if 'maximum_intensity' in names_vals:
minint = self.minimum_intensity or {'default': 1E-2}
for imt in self.hazard_imtls:
i1 = calc.filters.getdefault(minint, imt)
i2 = calc.filters.getdefault(self.maximum_intensity, imt)
self.hazard_imtls[imt] = list(valid.logscale(i1, i2, 20))
delattr(self, 'intensity_measure_types')
self._risk_files = get_risk_files(self.inputs)
if self.hazard_precomputed() and self.job_type == 'risk':
self.check_missing('site_model', 'debug')
self.check_missing('gsim_logic_tree', 'debug')
self.check_missing('source_model_logic_tree', 'debug')
# check investigation_time
if (self.investigation_time
and self.calculation_mode.startswith('scenario')):
raise ValueError('%s: there cannot be investigation_time in %s' %
(self.inputs['job_ini'], self.calculation_mode))
# check the gsim_logic_tree
if self.inputs.get('gsim_logic_tree'):
if self.gsim != '[FromFile]':
raise InvalidFile('%s: if `gsim_logic_tree_file` is set, there'
' must be no `gsim` key' % job_ini)
path = os.path.join(self.base_path, self.inputs['gsim_logic_tree'])
gsim_lt = logictree.GsimLogicTree(path, ['*'])
# check the IMTs vs the GSIMs
self._trts = set(gsim_lt.values)
for gsims in gsim_lt.values.values():
self.check_gsims(gsims)
elif self.gsim is not None:
self.check_gsims([valid.gsim(self.gsim, self.base_path)])
# check inputs
unknown = set(self.inputs) - self.KNOWN_INPUTS
if unknown:
raise ValueError('Unknown key %s_file in %s' %
(unknown.pop(), self.inputs['job_ini']))
# checks for disaggregation
if self.calculation_mode == 'disaggregation':
if not self.poes_disagg and self.poes:
self.poes_disagg = self.poes
elif not self.poes and self.poes_disagg:
self.poes = self.poes_disagg
elif self.poes != self.poes_disagg:
raise InvalidFile(
'poes_disagg != poes: %s!=%s in %s' %
(self.poes_disagg, self.poes, self.inputs['job_ini']))
if not self.poes_disagg and not self.iml_disagg:
raise InvalidFile('poes_disagg or iml_disagg must be set '
'in %(job_ini)s' % self.inputs)
elif self.poes_disagg and self.iml_disagg:
raise InvalidFile(
'%s: iml_disagg and poes_disagg cannot be set '
'at the same time' % job_ini)
for k in ('mag_bin_width', 'distance_bin_width',
'coordinate_bin_width', 'num_epsilon_bins'):
if k not in vars(self):
raise InvalidFile('%s must be set in %s' % (k, job_ini))
if self.disagg_outputs and not any('Eps' in out
for out in self.disagg_outputs):
self.num_epsilon_bins = 1
if (self.rlz_index is not None
and self.num_rlzs_disagg is not None):
raise InvalidFile('%s: you cannot set rlzs_index and '
'num_rlzs_disagg at the same time' % job_ini)
# checks for classical_damage
if self.calculation_mode == 'classical_damage':
if self.conditional_loss_poes:
raise InvalidFile('%s: conditional_loss_poes are not defined '
'for classical_damage calculations' %
job_ini)
# checks for event_based_risk
if (self.calculation_mode == 'event_based_risk'
and self.asset_correlation not in (0, 1)):
raise ValueError('asset_correlation != {0, 1} is no longer'
' supported')
# checks for ebrisk
if self.calculation_mode == 'ebrisk':
if self.risk_investigation_time is None:
raise InvalidFile('Please set the risk_investigation_time in'
' %s' % job_ini)
# check for GMFs from file
if (self.inputs.get('gmfs', '').endswith('.csv')
and 'sites' not in self.inputs and self.sites is None):
raise InvalidFile('%s: You forgot sites|sites_csv' % job_ini)
elif self.inputs.get('gmfs', '').endswith('.xml'):
raise InvalidFile('%s: GMFs in XML are not supported anymore' %
job_ini)
# checks for event_based
if 'event_based' in self.calculation_mode:
if self.ses_per_logic_tree_path >= TWO32:
raise ValueError('ses_per_logic_tree_path too big: %d' %
self.ses_per_logic_tree_path)
if self.number_of_logic_tree_samples >= TWO16:
raise ValueError('number_of_logic_tree_samples too big: %d' %
self.number_of_logic_tree_samples)
# check grid + sites
if self.region_grid_spacing and ('sites' in self.inputs or self.sites):
raise ValueError('You are specifying grid and sites at the same '
'time: which one do you want?')
# check for amplification
if ('amplification' in self.inputs and self.imtls
and self.calculation_mode
in ['classical', 'classical_risk', 'disaggregation']):
check_same_levels(self.imtls)
def test_full_instantiation(self):
# test for https://github.com/gem/oq-engine/issues/7363
abr = valid.gsim("AbrahamsonEtAl2014")
self.assertIsNone(abr.region)
def __init__(self, **names_vals):
for name in list(names_vals):
if name == 'quantile_hazard_curves':
names_vals['quantiles'] = names_vals.pop(name)
super().__init__(**names_vals)
job_ini = self.inputs['job_ini']
if 'calculation_mode' not in names_vals:
raise InvalidFile('Missing calculation_mode in %s' % job_ini)
if 'region_constraint' in names_vals:
if 'region' in names_vals:
raise InvalidFile('You cannot have both region and '
'region_constraint in %s' % job_ini)
logging.warning(
'region_constraint is obsolete, use region instead')
self.region = valid.wkt_polygon(
names_vals.pop('region_constraint'))
self.risk_investigation_time = (
self.risk_investigation_time or self.investigation_time)
if ('intensity_measure_types_and_levels' in names_vals and
'intensity_measure_types' in names_vals):
logging.warning('Ignoring intensity_measure_types since '
'intensity_measure_types_and_levels is set')
if 'iml_disagg' in names_vals:
self.iml_disagg.pop('default')
# normalize things like SA(0.10) -> SA(0.1)
self.iml_disagg = {str(from_string(imt)): val
for imt, val in self.iml_disagg.items()}
self.hazard_imtls = self.iml_disagg
if 'intensity_measure_types_and_levels' in names_vals:
raise InvalidFile(
'Please remove the intensity_measure_types_and_levels '
'from %s: they will be inferred from the iml_disagg '
'dictionary' % job_ini)
elif 'intensity_measure_types_and_levels' in names_vals:
self.hazard_imtls = self.intensity_measure_types_and_levels
delattr(self, 'intensity_measure_types_and_levels')
elif 'intensity_measure_types' in names_vals:
self.hazard_imtls = dict.fromkeys(self.intensity_measure_types)
delattr(self, 'intensity_measure_types')
self._risk_files = get_risk_files(self.inputs)
self.check_source_model()
if (self.hazard_calculation_id and
self.calculation_mode == 'ucerf_risk'):
raise ValueError('You cannot use the --hc option with ucerf_risk')
if self.hazard_precomputed() and self.job_type == 'risk':
self.check_missing('site_model', 'debug')
self.check_missing('gsim_logic_tree', 'debug')
self.check_missing('source_model_logic_tree', 'debug')
# check the gsim_logic_tree
if self.inputs.get('gsim_logic_tree'):
if self.gsim != '[FromFile]':
raise InvalidFile('%s: if `gsim_logic_tree_file` is set, there'
' must be no `gsim` key' % job_ini)
path = os.path.join(
self.base_path, self.inputs['gsim_logic_tree'])
gsim_lt = logictree.GsimLogicTree(path, ['*'])
# check the number of branchsets
branchsets = len(gsim_lt._ltnode)
if 'scenario' in self.calculation_mode and branchsets > 1:
raise InvalidFile(
'%s: %s for a scenario calculation must contain a single '
'branchset, found %d!' % (job_ini, path, branchsets))
# check the IMTs vs the GSIMs
self._gsims_by_trt = gsim_lt.values
for gsims in self._gsims_by_trt.values():
self.check_gsims(gsims)
elif self.gsim is not None:
self.check_gsims([valid.gsim(self.gsim)])
# checks for disaggregation
if self.calculation_mode == 'disaggregation':
if not self.poes_disagg and not self.iml_disagg:
raise InvalidFile('poes_disagg or iml_disagg must be set '
'in %(job_ini)s' % self.inputs)
elif self.poes_disagg and self.iml_disagg:
raise InvalidFile(
'%s: iml_disagg and poes_disagg cannot be set '
'at the same time' % job_ini)
for k in ('mag_bin_width', 'distance_bin_width',
'coordinate_bin_width', 'num_epsilon_bins'):
if k not in vars(self):
raise InvalidFile('%s must be set in %s' % (k, job_ini))
# checks for classical_damage
if self.calculation_mode == 'classical_damage':
if self.conditional_loss_poes:
raise InvalidFile(
'%s: conditional_loss_poes are not defined '
'for classical_damage calculations' % job_ini)
# checks for event_based_risk
if (self.calculation_mode == 'event_based_risk' and
self.asset_correlation not in (0, 1)):
raise ValueError('asset_correlation != {0, 1} is no longer'
' supported')
# checks for ebrisk
if self.calculation_mode == 'ebrisk':
pass
# elif self.number_of_logic_tree_samples == 0:
# logging.warning('ebrisk is not meant for full enumeration')
# check for GMFs from file
if (self.inputs.get('gmfs', '').endswith('.csv') and not self.sites and
'sites' not in self.inputs):
raise InvalidFile('%s: You forgot sites|sites_csv' % job_ini)
elif (self.inputs.get('gmfs', '').endswith('.xml') and
'sites' in self.inputs):
raise InvalidFile('%s: You cannot have both sites_csv and '
'gmfs_file' % job_ini)
# checks for event_based
if 'event_based' in self.calculation_mode:
if self.ses_per_logic_tree_path >= TWO32:
raise ValueError('ses_per_logic_tree_path too big: %d' %
self.ses_per_logic_tree_path)
if self.number_of_logic_tree_samples >= TWO16:
raise ValueError('number_of_logic_tree_samples too big: %d' %
self.number_of_logic_tree_samples)
# check grid + sites
if (self.region_grid_spacing and 'site_model' in self.inputs
and 'exposure' in self.inputs):
logging.warning(
'You are specifying a grid, a site model and an exposure at '
'the same time: consider using `oq prepare_site_model`')
def _build_trts_branches(self, tectonic_region_types):
# do the parsing, called at instantiation time to populate .values
trts = []
branches = []
branchids = []
branchsetids = set()
basedir = os.path.dirname(self.filename)
for bsno, blnode in enumerate(self._ltnode):
[branchset] = bsnodes(self.filename, blnode)
if branchset['uncertaintyType'] != 'gmpeModel':
raise InvalidLogicTree(
'%s: only uncertainties of type "gmpeModel" '
'are allowed in gmpe logic tree' % self.filename)
bsid = branchset['branchSetID']
if bsid in branchsetids:
raise InvalidLogicTree('%s: Duplicated branchSetID %s' %
(self.filename, bsid))
else:
branchsetids.add(bsid)
trt = branchset.get('applyToTectonicRegionType')
if trt: # missing in logictree_test.py
self.bsetdict[trt] = bsid
trts.append(trt)
self.bsetdict[trt] = bsid
# NB: '*' is used in scenario calculations to disable filtering
effective = (tectonic_region_types == ['*']
or trt in tectonic_region_types)
weights = []
branch_ids = []
for brno, branch in enumerate(branchset):
weight = ImtWeight(branch, self.filename)
weights.append(weight)
branch_id = branch['branchID']
branch_ids.append(branch_id)
try:
gsim = valid.gsim(branch.uncertaintyModel, basedir)
except Exception as exc:
raise ValueError("%s in file %s" %
(exc, self.filename)) from exc
if gsim in self.values[trt]:
raise InvalidLogicTree('%s: duplicated gsim %s' %
(self.filename, gsim))
if len(weight.dic) > 1:
gsim.weight = weight
self.values[trt].append(gsim)
bt = BranchTuple(branchset['applyToTectonicRegionType'],
branch_id, gsim, weight, effective)
if effective:
branches.append(bt)
self.shortener[branch_id] = keyno(branch_id, bsno, brno,
self.filename)
tot = sum(weights)
assert tot.is_one(), '%s in branch %s' % (tot, branch_id)
if duplicated(branch_ids):
raise InvalidLogicTree(
'There where duplicated branchIDs in %s' % self.filename)
branchids.extend(branch_ids)
if len(trts) > len(set(trts)):
raise InvalidLogicTree(
'%s: Found duplicated applyToTectonicRegionType=%s' %
(self.filename, trts))
dupl = duplicated(branchids)
if dupl:
logging.warning('There are duplicated branchIDs %s in %s', dupl,
self.filename)
branches.sort(key=lambda b: (b.trt, b.id))
# TODO: add an .idx to each GSIM ?
return branches
def test_valid(self):
n = 0
for toml in gsim_aliases.values():
valid.gsim(toml)
n += 1
print('Checked %d valid aliases' % n)
def __init__(self, **names_vals):
super().__init__(**names_vals)
job_ini = self.inputs['job_ini']
if 'calculation_mode' not in names_vals:
raise InvalidFile('Missing calculation_mode in %s' % job_ini)
if 'region_constraint' in names_vals:
if 'region' in names_vals:
raise InvalidFile('You cannot have both region and '
'region_constraint in %s' % job_ini)
logging.warning(
'region_constraint is obsolete, use region instead')
self.region = valid.wkt_polygon(
names_vals.pop('region_constraint'))
self.risk_investigation_time = (
self.risk_investigation_time or self.investigation_time)
if ('intensity_measure_types_and_levels' in names_vals and
'intensity_measure_types' in names_vals):
logging.warning('Ignoring intensity_measure_types since '
'intensity_measure_types_and_levels is set')
if 'iml_disagg' in names_vals:
self.hazard_imtls = self.iml_disagg
if 'intensity_measure_types_and_levels' in names_vals:
raise InvalidFile(
'Please remove the intensity_measure_types_and_levels '
'from %s: they will be inferred from the iml_disagg '
'dictionary' % job_ini)
elif 'intensity_measure_types_and_levels' in names_vals:
self.hazard_imtls = self.intensity_measure_types_and_levels
delattr(self, 'intensity_measure_types_and_levels')
elif 'intensity_measure_types' in names_vals:
self.hazard_imtls = dict.fromkeys(self.intensity_measure_types)
delattr(self, 'intensity_measure_types')
self._file_type, self._risk_files = get_risk_files(self.inputs)
self.check_source_model()
if (self.hazard_calculation_id and
self.calculation_mode == 'ucerf_risk'):
raise ValueError('You cannot use the --hc option with ucerf_risk')
if self.hazard_precomputed() and self.job_type == 'risk':
self.check_missing('site_model', 'debug')
self.check_missing('gsim_logic_tree', 'debug')
self.check_missing('source_model_logic_tree', 'debug')
# check the gsim_logic_tree
if self.inputs.get('gsim_logic_tree'):
if self.gsim != '[FromFile]':
raise InvalidFile('%s: if `gsim_logic_tree_file` is set, there'
' must be no `gsim` key' % job_ini)
path = os.path.join(
self.base_path, self.inputs['gsim_logic_tree'])
gsim_lt = logictree.GsimLogicTree(path, ['*'])
# check the number of branchsets
branchsets = len(gsim_lt._ltnode)
if 'scenario' in self.calculation_mode and branchsets > 1:
raise InvalidFile(
'%s: %s for a scenario calculation must contain a single '
'branchset, found %d!' % (job_ini, path, branchsets))
# check the IMTs vs the GSIMs
self._gsims_by_trt = gsim_lt.values
for gsims in self._gsims_by_trt.values():
self.check_gsims(gsims)
elif self.gsim is not None:
self.check_gsims([valid.gsim(self.gsim)])
# checks for disaggregation
if self.calculation_mode == 'disaggregation':
if not self.poes_disagg and not self.iml_disagg:
raise InvalidFile('poes_disagg or iml_disagg must be set '
'in %(job_ini)s' % self.inputs)
elif self.poes_disagg and self.iml_disagg:
raise InvalidFile(
'%s: iml_disagg and poes_disagg cannot be set '
'at the same time' % job_ini)
for k in ('mag_bin_width', 'distance_bin_width',
'coordinate_bin_width', 'num_epsilon_bins'):
if k not in vars(self):
raise InvalidFile('%s must be set in %s' % (k, job_ini))
# checks for classical_damage
if self.calculation_mode == 'classical_damage':
if self.conditional_loss_poes:
raise InvalidFile(
'%s: conditional_loss_poes are not defined '
'for classical_damage calculations' % job_ini)
# checks for event_based_risk
if (self.calculation_mode == 'event_based_risk' and
self.asset_correlation not in (0, 1)):
raise ValueError('asset_correlation != {0, 1} is no longer'
' supported')
# checks for ebrisk
if self.calculation_mode == 'ebrisk':
if self.insured_losses:
raise ValueError('ebrisk does not support insured losses')
elif self.number_of_logic_tree_samples == 0:
logging.warning('ebrisk is not meant for full enumeration')
# check for GMFs from file
if (self.inputs.get('gmfs', '').endswith('.csv') and not self.sites and
'sites' not in self.inputs):
raise InvalidFile('%s: You forgot sites|sites_csv' % job_ini)
elif (self.inputs.get('gmfs', '').endswith('.xml') and
'sites' in self.inputs):
raise InvalidFile('%s: You cannot have both sites_csv and '
'gmfs_file' % job_ini)
# checks for event_based
if 'event_based' in self.calculation_mode:
if self.ses_per_logic_tree_path >= TWO32:
raise ValueError('ses_per_logic_tree_path too big: %d' %
self.ses_per_logic_tree_path)
if self.number_of_logic_tree_samples >= TWO16:
raise ValueError('number_of_logic_tree_samples too big: %d' %
self.number_of_logic_tree_samples)
# check grid + sites
if (self.region_grid_spacing and 'site_model' in self.inputs
and 'exposure' in self.inputs):
logging.warning(
'You are specifying a grid, a site model and an exposure at '
'the same time: consider using `oq prepare_site_model`')