def _store_em(self):
[ism] = models.inputs4job(self.job.id, input_type="exposure")
em = models.ExposureModel(owner=ism.owner,
input=ism,
name="AAA",
category="single_asset",
reco_type="aggregated",
reco_unit="USD",
stco_type="aggregated",
stco_unit="USD")
em.save()
models.ExposureData(exposure_model=em,
taxonomy="RC",
asset_ref="A",
number_of_units=100,
stco=1,
site=geos.GEOSGeometry(self.site.point.to_wkt()),
reco=1).save()
models.ExposureData(exposure_model=em,
taxonomy="RM",
asset_ref="B",
number_of_units=40,
stco=1,
site=geos.GEOSGeometry(self.site.point.to_wkt()),
reco=1).save()
return em
def make_assets(self):
[ism] = models.inputs4job(self.job.id, input_type="exposure")
em = models.ExposureModel(
owner=ism.owner, input=ism,
name="AAA", category="single_asset",
reco_type="aggregated", reco_unit="USD",
stco_type="aggregated", stco_unit="USD")
em.save()
site_1 = shapes.Site(-116.0, 41.0)
site_2 = shapes.Site(-117.0, 42.0)
asset_1 = models.ExposureData(
exposure_model=em, taxonomy="RC",
asset_ref="asset_1", number_of_units=100, stco=1,
site=geos.GEOSGeometry(site_1.point.to_wkt()), reco=1)
asset_2 = models.ExposureData(
exposure_model=em, taxonomy="RM",
asset_ref="asset_2", number_of_units=40, stco=1,
site=geos.GEOSGeometry(site_2.point.to_wkt()), reco=1)
asset_3 = models.ExposureData(
exposure_model=em, taxonomy="RM",
asset_ref="asset_3", number_of_units=40, stco=1,
site=geos.GEOSGeometry(site_2.point.to_wkt()), reco=1)
asset_1.save()
asset_2.save()
asset_3.save()
return asset_1, asset_2, asset_3
def setUpClass(cls):
default_user = helpers.default_user()
cls.job = models.OqJob(owner=default_user)
cls.job.save()
# dmg dist per asset
cls.ddpa_output = models.Output(
owner=default_user, oq_job=cls.job,
display_name='Test dmg dist per asset',
output_type='dmg_dist_per_asset',
db_backed=True)
cls.ddpa_output.save()
cls.ddpa = models.DmgDistPerAsset(
output=cls.ddpa_output, dmg_states=cls.DMG_STATES)
cls.ddpa.save()
# We also need some sample exposure data records (to satisfy the dmg
# dist per asset FK).
test_input = models.Input(
owner=default_user, input_type='exposure', path='fake', size=0)
test_input.save()
i2j = models.Input2job(input=test_input, oq_job=cls.job)
i2j.save()
exp_model = models.ExposureModel(
owner=default_user, input=test_input, name='test-exp-model',
category='economic loss', stco_type='per_asset', stco_unit='CHF')
exp_model.save()
test_site = shapes.Site(3.14, 2.17)
cls.exp_data = models.ExposureData( # Asset
exposure_model=exp_model, asset_ref=helpers.random_string(),
taxonomy=helpers.random_string(), number_of_units=37,
site=test_site.point.to_wkt(), stco=1234.56)
cls.exp_data.save()
# dmg dist per taxonomy
cls.ddpt_output = models.Output(
owner=default_user, oq_job=cls.job,
display_name='Test dmg dist per taxonomy',
output_type='dmg_dist_per_taxonomy',
db_backed=True)
cls.ddpt_output.save()
cls.ddpt = models.DmgDistPerTaxonomy(
output=cls.ddpt_output, dmg_states=cls.DMG_STATES)
cls.ddpt.save()
# total dmg dist
cls.ddt_output = models.Output(
owner=default_user, oq_job=cls.job,
display_name='Test dmg dist total',
output_type='dmg_dist_total',
db_backed=True)
cls.ddt_output.save()
cls.ddt = models.DmgDistTotal(
output=cls.ddt_output, dmg_states=cls.DMG_STATES)
cls.ddt.save()
def test_insert_expo_model_with_unit_type_count(self):
# inserting an exposure model with unit_type = "count" works as long as
# we omit the area/reco/stco type and unit.
mdl = models.ExposureModel(
input=self.emdl_input, owner=self.job.owner, unit_type="count",
name="exposure-data-testing", category="economic loss")
mdl.save()
def test_unit_type_count_and_coco(self):
# When the unit_type is set to "count" the coco type and unit may
# be present.
mdl = models.ExposureModel(
input=self.emdl_input, owner=self.job.owner, unit_type="count",
name="exposure-data-testing", category="economic loss")
mdl.coco_type = "per_asset"
mdl.coco_unit = "ATS"
mdl.save()
def setUp(self):
emdl_input = models.Input(
input_type="exposure", size=123, path="/tmp/fake-exposure-path",
owner=self.job.owner)
emdl_input.save()
i2j = models.Input2job(input=emdl_input, oq_job=self.job)
i2j.save()
self.mdl = models.ExposureModel(
input=emdl_input, owner=self.job.owner,
name="exposure-model-testing", category="economic loss")
def setUp(self):
path = os.path.join(helpers.SCHEMA_EXAMPLES_DIR, "LCB-exposure.yaml")
inputs = [("exposure", path)]
self.job = self.setup_classic_job(inputs=inputs)
[input] = models.inputs4job(self.job.id,
input_type="exposure",
path=path)
owner = models.OqUser.objects.get(user_name="openquake")
emdl = input.model()
if not emdl:
emdl = models.ExposureModel(owner=owner,
input=input,
description="LCB exposure model",
category="LCB cars",
stco_unit="peanuts",
stco_type="aggregated")
emdl.save()
asset_data = [
(Site(-118.077721, 33.852034), {
u'stco': 5.07,
u'asset_ref': u'a5625',
u'taxonomy': u'HAZUS_RM1L_LC'
}),
(Site(-118.077721, 33.852034), {
u'stco': 5.63,
u'asset_ref': u'a5629',
u'taxonomy': u'HAZUS_URML_LC'
}),
(Site(-118.077721, 33.852034), {
u'stco': 11.26,
u'asset_ref': u'a5630',
u'taxonomy': u'HAZUS_URML_LS'
}),
(Site(-118.077721, 33.852034), {
u'stco': 5.5,
u'asset_ref': u'a5636',
u'taxonomy': u'HAZUS_C3L_MC'
}),
]
for idx, (site, adata) in enumerate(asset_data):
location = GEOSGeometry(site.point.to_wkt())
asset = models.ExposureData(exposure_model=emdl,
site=location,
**adata)
asset.save()
RISK_LOSS_CURVE_DATA[idx][1][1] = asset
output_path = self.generate_output_path(self.job)
self.display_name = os.path.basename(output_path)
self.writer = LossCurveDBWriter(output_path, self.job.id)
self.reader = LossCurveDBReader()
def setUp(self):
path = os.path.join(helpers.SCHEMA_EXAMPLES_DIR, "LMB-exposure.yaml")
inputs = [("exposure", path)]
self.job = self.setup_classic_job(inputs=inputs)
[input] = models.inputs4job(self.job.id,
input_type="exposure",
path=path)
owner = models.OqUser.objects.get(user_name="openquake")
emdl = input.model()
if not emdl:
emdl = models.ExposureModel(owner=owner,
input=input,
description="LMB exposure model",
category="LMB yachts",
stco_unit="oranges",
stco_type="aggregated")
emdl.save()
asset_data = [
("asset_a_1", SITE_A, {
u'stco': 5.07,
u'asset_ref': u'a1711',
u'taxonomy': u'HAZUS_RM1L_LC'
}),
("asset_a_2", SITE_A, {
u'stco': 5.63,
u'asset_ref': u'a1712',
u'taxonomy': u'HAZUS_URML_LC'
}),
("asset_b_1", SITE_B, {
u'stco': 5.5,
u'asset_ref': u'a1713',
u'taxonomy': u'HAZUS_C3L_MC'
}),
]
for idx, (name, site, adata) in enumerate(asset_data):
location = GEOSGeometry(site.point.to_wkt())
asset = models.ExposureData(exposure_model=emdl,
site=location,
**adata)
asset.save()
setattr(self, name, asset)
SAMPLE_NONSCENARIO_LOSS_MAP_DATA[1][1][0][1] = self.asset_a_1
SAMPLE_NONSCENARIO_LOSS_MAP_DATA[1][1][1][1] = self.asset_a_2
SAMPLE_NONSCENARIO_LOSS_MAP_DATA[2][1][0][1] = self.asset_b_1
output_path = self.generate_output_path(self.job)
self.display_name = os.path.basename(output_path)
self.writer = LossMapDBWriter(output_path, self.job.id)
self.reader = LossMapDBReader()
def setUp(self):
emdl_input = models.Input(
input_type="exposure", size=123, path="/tmp/fake-exposure-path",
owner=self.job.owner)
emdl_input.save()
i2j = models.Input2job(input=emdl_input, oq_job=self.job)
i2j.save()
self.mdl = models.ExposureModel(
input=emdl_input, owner=self.job.owner, unit_type="count",
name="exposure-data-testing", category="economic loss",
coco_type="per_asset", coco_unit="USD")
self.mdl.save()
def test_unit_type_count_and_stco(self):
# When the unit_type is set to "count" the stco type and unit are not
# allowed.
mdl = models.ExposureModel(
input=self.emdl_input, owner=self.job.owner, unit_type="count",
name="exposure-data-testing", category="economic loss")
mdl.stco_type = "per_stco"
mdl.stco_unit = "ATS"
try:
mdl.save()
except DatabaseError, de:
self.assertEqual(
"Exception: We are in counting mode: neither of these must "
"be set ['stco_unit', 'stco_type'] (exposure_model)",
de.args[0].split('\n', 1)[0])
transaction.rollback()
def setUpClass(cls):
path = os.path.join(helpers.SCHEMA_EXAMPLES_DIR, "SEB-exposure.yaml")
inputs = [("exposure", path)]
cls.job = cls.setup_classic_job(inputs=inputs)
[input] = models.inputs4job(cls.job.id,
input_type="exposure",
path=path)
owner = models.OqUser.objects.get(user_name="openquake")
cls.emdl = input.model()
if not cls.emdl:
cls.emdl = models.ExposureModel(owner=owner,
input=input,
description="SEB exposure model",
category="SEB factory buildings",
stco_unit="screws",
stco_type="aggregated")
cls.emdl.save()
def insert_datum(self, point, occupancy, values):
"""
Insert a single asset entry.
:param point: asset location
:type point: :class:`openquake.shapes.Site`
:param list occupancy: a potentially empty list of named tuples
each having an 'occupants' and a 'description' property
:param values: dictionary of values (see
:class:`openquake.parser.exposure.ExposureModelFile`)
it also inserts the main exposure model entry if not already
present,
"""
if not self.model:
self.model = models.ExposureModel(
owner=self.owner,
input=self.smi,
description=values.get("listDescription"),
taxonomy_source=values.get("taxonomySource"),
category=values["assetCategory"])
for key, tag in self.model_attrs:
value = values.get(tag)
if value:
setattr(self.model, key, value)
self.model.save()
data = models.ExposureData(exposure_model=self.model,
asset_ref=values["assetID"],
taxonomy=values.get("taxonomy"),
site="POINT(%s %s)" %
(point.point.x, point.point.y))
for key, tag in [("coco", "coco"), ("reco", "reco"), ("stco", "stco"),
("area", "area"), ("number_of_units", "number"),
("deductible", "deductible"), ("ins_limit", "limit")]:
value = values.get(tag)
if value:
setattr(data, key, value)
data.save()
for odata in occupancy:
oobj = models.Occupancy(exposure_data=data,
occupants=odata.occupants,
description=odata.description)
oobj.save()
def setUp(self):
self.job_ctxt = helpers.job_from_file(
os.path.join(helpers.DATA_DIR, 'config.gem'))
[input] = models.inputs4job(self.job_ctxt.job_id,
input_type="exposure")
owner = models.OqUser.objects.get(user_name="openquake")
emdl = input.model()
if not emdl:
emdl = models.ExposureModel(owner=owner,
input=input,
description="RCT exposure model",
category="RCT villas",
stco_unit="roofs",
stco_type="aggregated")
emdl.save()
asset_data = [
((0, 0), shapes.Site(10.0, 10.0), {
u'stco': 5.07,
u'asset_ref': u'a5625',
u'taxonomy': u'rctc-ad-83'
}),
((0, 1), shapes.Site(10.1, 10.0), {
u'stco': 5.63,
u'asset_ref': u'a5629',
u'taxonomy': u'rctc-ad-83'
}),
((1, 0), shapes.Site(10.0, 10.1), {
u'stco': 11.26,
u'asset_ref': u'a5630',
u'taxonomy': u'rctc-ad-83'
}),
((1, 1), shapes.Site(10.1, 10.1), {
u'stco': 5.5,
u'asset_ref': u'a5636',
u'taxonomy': u'rctc-ad-83'
}),
]
assets = emdl.exposuredata_set.filter(taxonomy="rctc-ad-83"). \
order_by("id")
for idx, (gcoo, site, adata) in enumerate(asset_data):
if not assets:
location = geos.GEOSGeometry(site.point.to_wkt())
asset = models.ExposureData(exposure_model=emdl,
site=location,
**adata)
asset.save()
else:
asset = assets[idx]
GRID_ASSETS[gcoo] = asset
self.grid = shapes.Grid(
shapes.Region.from_coordinates([(10.0, 10.0), (10.0, 10.1),
(10.1, 10.1), (10.1, 10.0)]), 0.1)
# this is the expected output of grid_assets_iterator and an input of
# asset_losses_per_site
self.grid_assets = [
(shapes.GridPoint(self.grid, 0, 0), GRID_ASSETS[(0, 0)]),
(shapes.GridPoint(self.grid, 1, 0), GRID_ASSETS[(0, 1)]),
(shapes.GridPoint(self.grid, 0, 1), GRID_ASSETS[(1, 0)]),
(shapes.GridPoint(self.grid, 1, 1), GRID_ASSETS[(1, 1)])
]
