def test_case_master(self): self.assert_stats_ok(case_master, 'job.ini', individual_curves='false') fnames = export(('loss_maps-rlzs', 'csv'), self.calc.datastore) for fname in fnames: self.assertEqualFiles('expected/' + strip_calc_id(fname), fname) fname = writetmp(view('portfolio_loss', self.calc.datastore)) self.assertEqualFiles('expected/portfolio_loss.txt', fname, delta=1E-5) # check rup_data is stored correctly fname = writetmp(view('ruptures_events', self.calc.datastore)) self.assertEqualFiles('expected/ruptures_events.txt', fname) # export a specific eid fnames = export(('all_loss_ratios:0', 'csv'), self.calc.datastore) for fname in fnames: self.assertEqualFiles('expected/' + strip_calc_id(fname), fname) self.assertEqualFiles('expected/losses-eid=0.csv', fname) # export a specific pair (sm_id, eid) fnames = export(('all_loss_ratios:1:0', 'csv'), self.calc.datastore) for fname in fnames: self.assertEqualFiles('expected/%s' % strip_calc_id(fname), fname)
def test_event_based(self): self.run_calc(ucerf.__file__, 'job.ini') gmv_uc = view('global_gmfs', self.calc.datastore) # check the distribution of the events self.assertEventsByRlz([2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 6, 6, 2, 2, 3, 3, 6, 6, 1, 1, 1, 1, 6, 6, 2, 2, 3, 3, 2, 2, 2, 2, 3, 3, 2, 2, 3, 3, 3, 3, 2, 2, 3, 3, 3, 3, 3, 3]) [fname] = export(('ruptures', 'csv'), self.calc.datastore) # check that we get the expected number of ruptures with open(fname) as f: self.assertEqual(len(f.readlines()), 72) self.assertEqualFiles('expected/ruptures.csv', fname, lastline=20, delta=1E-5) # run a regular event based on top of the UCERF ruptures and # check the generated hazard maps self.run_calc(ucerf.__file__, 'job.ini', calculation_mode='event_based', hazard_calculation_id=str(self.calc.datastore.calc_id)) # check ucerf_hazard and event_based produces the same GMFs gmv_eb = view('global_gmfs', self.calc.datastore) self.assertEqual(gmv_uc, gmv_eb) # check the mean hazard map [fname] = [f for f in export(('hmaps', 'csv'), self.calc.datastore) if 'mean' in f] self.assertEqualFiles('expected/hazard_map-mean.csv', fname, delta=1E-5)
def test_case_8(self): # a complex scenario_risk from GMFs where the hazard sites are # not in the asset locations self.run_calc(case_8.__file__, 'job.ini') agglosses = extract(self.calc.datastore, 'agg_losses/structural') aac(agglosses.array, [1159817.1]) # make sure the fullreport can be extracted view('fullreport', self.calc.datastore)
def test_classical_time_dep(self): ucerf_base.RUPTURES_PER_BLOCK = 10 # check splitting out = self.run_calc(ucerf.__file__, 'job_classical_time_dep_redux.ini', exports='csv') ucerf_base.RUPTURES_PER_BLOCK = 1000 # resume default fname = out['hcurves', 'csv'][0] self.assertEqualFiles('expected/hazard_curve-td-mean.csv', fname, delta=1E-6) # make sure this runs view('fullreport', self.calc.datastore)
def test_classical(self): ucerf_base.RUPTURES_PER_BLOCK = 50 # check splitting self.run_calc(ucerf.__file__, 'job_classical_redux.ini', exports='csv') ucerf_base.RUPTURES_PER_BLOCK = 1000 # resume default fnames = export(('hcurves/', 'csv'), self.calc.datastore) expected = ['hazard_curve-0-PGA.csv', 'hazard_curve-0-SA(0.1).csv', 'hazard_curve-1-PGA.csv', 'hazard_curve-1-SA(0.1).csv'] for fname, exp in zip(fnames, expected): self.assertEqualFiles('expected/' + exp, fname) # make sure this runs view('fullreport', self.calc.datastore)
def test_case_miriam(self): # this is a case with a grid and asset-hazard association self.run_calc(case_miriam.__file__, 'job.ini') # check minimum_magnitude >= 5.2 minmag = self.calc.datastore['ruptures']['mag'].min() self.assertGreaterEqual(minmag, 5.2) # check asset_loss_table tot = self.calc.datastore['asset_loss_table'].value.sum() self.assertEqual(tot, 15787827.0) [fname] = export(('agg_loss_table', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/agg_losses-rlz000-structural.csv', fname, delta=1E-5) fname = gettemp(view('portfolio_losses', self.calc.datastore)) self.assertEqualFiles( 'expected/portfolio_losses.txt', fname, delta=1E-5) # this is a case with exposure and region_grid_spacing=1 self.run_calc(case_miriam.__file__, 'job2.ini') hcurves = dict(extract(self.calc.datastore, 'hcurves'))['all'] sitecol = self.calc.datastore['sitecol'] # filtered sitecol self.assertEqual(len(hcurves), len(sitecol)) assetcol = self.calc.datastore['assetcol'] self.assertEqual(len(sitecol), 15) self.assertGreater(sitecol.vs30.sum(), 0) self.assertEqual(len(assetcol), 548)
def test_case_1(self): self.assert_curves_ok( ['hazard_curve-PGA.csv', 'hazard_curve-SA(0.1).csv'], case_1.__file__) if parallel.oq_distribute() != 'no': info = view('job_info', self.calc.datastore) self.assertIn('task', info) self.assertIn('sent', info) self.assertIn('received', info) # there is a single source self.assertEqual(len(self.calc.datastore['source_info']), 1) # check npz export export(('hcurves', 'npz'), self.calc.datastore) # check extraction sitecol = extract(self.calc.datastore, 'sitecol') self.assertEqual(len(sitecol.array), 1) # check minimum_magnitude discards the source with self.assertRaises(RuntimeError) as ctx: self.run_calc(case_1.__file__, 'job.ini', minimum_magnitude='4.5') self.assertEqual(str(ctx.exception), 'All sources were filtered away!')
def test_case_16(self): # an example with site model raising warnings and autogridded exposure self.run_calc(case_16.__file__, 'job.ini', ground_motion_fields='false') hid = str(self.calc.datastore.calc_id) self.run_calc(case_16.__file__, 'job.ini', hazard_calculation_id=hid) tmp = gettemp(view('global_gmfs', self.calc.datastore)) self.assertEqualFiles('expected/global_gmfs.txt', tmp)
def test_case_4(self): # this test is sensitive to the ordering of the epsilons # in openquake.riskinput.make_eps out = self.run_calc(case_4.__file__, 'job.ini', exports='csv') fname = gettemp(view('totlosses', self.calc.datastore)) self.assertEqualFiles('expected/totlosses.txt', fname) [fname] = out['agglosses', 'csv'] self.assertEqualFiles('expected/agglosses.csv', fname, delta=1E-6)
def test_case_miriam(self): # this is a case with a grid and asset-hazard association out = self.run_calc(case_miriam.__file__, 'job.ini', exports='csv') [fname] = out['agg_loss_table', 'csv'] self.assertEqualFiles('expected/agg_losses-rlz000-structural.csv', fname) fname = writetmp(view('portfolio_loss', self.calc.datastore)) self.assertEqualFiles( 'expected/portfolio_loss.txt', fname, delta=1E-5)
def test_event_based_sampling(self): self.run_calc(ucerf.__file__, 'job_ebh.ini') # check the distribution of the events self.assertEventsByRlz([29, 25]) # check the mean hazard map got = gettemp(view('hmap', self.calc.datastore)) self.assertEqualFiles('expected/hmap.rst', got)
def add(self, name, obj=None): """Add the view named `name` to the report text""" title = self.title[name] line = '-' * len(title) if obj: text = '\n::\n\n' + indent(str(obj)) else: text = views.view(name, self.dstore) self.text += '\n'.join(['\n\n' + title, line, text])
def test_case_2(self): self.run_calc(case_2.__file__, 'job.ini') # check view_pmap for a single realization got = view('pmap:grp-00', self.calc.datastore) self.assertEqual(got, '''\ {0: <ProbabilityCurve [[2.26776679e-03 0.00000000e+00] [1.67915423e-05 0.00000000e+00] [0.00000000e+00 0.00000000e+00] [0.00000000e+00 0.00000000e+00]]>}''') # check view inputs lines = view('inputs', self.calc.datastore).splitlines() self.assertEqual(len(lines), 9) [fname] = export(('hcurves', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/hcurve.csv', fname)
def test_event_based_risk_sampling(self): # the fast calculator ucerf_risk raise unittest.SkipTest('ucerf_risk has been removed') self.run_calc(ucerf.__file__, 'job_ebr.ini', number_of_logic_tree_samples='2') # check the right number of events was stored self.assertEqual(len(self.calc.datastore['events']), 79) fname = gettemp(view('portfolio_loss', self.calc.datastore)) self.assertEqualFiles( 'expected/portfolio_loss2.txt', fname, delta=1E-5) # check the mean losses_by_period [fname] = export(('agg_curves-stats', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/losses_by_period2-mean.csv', fname) # make sure this runs view('fullreport', self.calc.datastore)
def test_case_master(self): # this tests exercise the case of a complex logic tree; it also # prints the warning on poe_agg very different from the expected poe self.run_calc(case_master.__file__, 'job.ini') fname = gettemp(view('mean_disagg', self.calc.datastore)) self.assertEqualFiles('expected/mean_disagg.rst', fname) os.remove(fname) # check stats fnames = export(('disagg-stats', 'csv'), self.calc.datastore) self.assertEqual(len(fnames), 192) # 2 sid x 8 keys x 2 poe x 2 imt
def test_event_based_risk(self): # the fast calculator ucerf_risk raise unittest.SkipTest('ucerf_risk has been removed') self.run_calc(ucerf.__file__, 'job_ebr.ini') fname = gettemp(view('portfolio_loss', self.calc.datastore)) self.assertEqualFiles('expected/portfolio_loss.txt', fname, delta=1E-5) # check the mean losses_by_period [fname] = export(('agg_curves-stats', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/losses_by_period-mean.csv', fname)
def test_case_5(self): # test with different curve resolution for different taxonomies self.run_calc(case_5.__file__, 'job_h.ini,job_r.ini') # check mean loss curves [fname] = export(('loss_curves-stats', 'xml'), self.calc.datastore) self.assertEqualFiles('expected/loss_curves-mean.xml', fname) # check individual avg losses fname = writetmp(view('loss_curves_avg', self.calc.datastore)) self.assertEqualFiles('expected/loss_curves_avg.txt', fname)
def test_event_based_risk(self): if h5py.__version__ < '2.6.0': raise unittest.SkipTest # UCERF requires vlen arrays self.run_calc(ucerf.__file__, 'job_ebr.ini', number_of_logic_tree_samples='2') fnames = export(('agg_loss_table', 'csv'), self.calc.datastore) for fname in fnames: self.assertEqualFiles('expected/%s' % strip_calc_id(fname), fname) fname = writetmp(view('portfolio_loss', self.calc.datastore)) self.assertEqualFiles('expected/portfolio_loss.txt', fname)
def test_case_6a(self): # case with two gsims out = self.run_calc(case_6a.__file__, 'job_haz.ini,job_risk.ini', exports='csv') f1, f2 = out['agglosses-rlzs', 'csv'] self.assertEqualFiles('expected/agg-gsimltp_b1_structural.csv', f1) self.assertEqualFiles('expected/agg-gsimltp_b2_structural.csv', f2) # testing the totlosses view dstore = self.calc.datastore fname = writetmp(view('totlosses', dstore)) self.assertEqualFiles('expected/totlosses.txt', fname)
def test_case_2(self): self.assert_stats_ok(case_2, 'job.ini', individual_curves='true') fname = writetmp(view('mean_avg_losses', self.calc.datastore)) self.assertEqualFiles('expected/mean_avg_losses.txt', fname) # test the case when all GMFs are filtered out with self.assertRaises(RuntimeError) as ctx: self.run_calc(case_2.__file__, 'job.ini', minimum_intensity='10.0') self.assertEqual( str(ctx.exception), 'No GMFs were generated, perhaps they were all below the ' 'minimum_intensity threshold')
def show(what, calc_id=-1): """ Show the content of a datastore (by default the last one). """ if what == 'all': # show all if not os.path.exists(datastore.DATADIR): return rows = [] for calc_id in datastore.get_calc_ids(datastore.DATADIR): try: ds = datastore.read(calc_id) oq = ds['oqparam'] cmode, descr = oq.calculation_mode, oq.description except: # invalid datastore file, or missing calculation_mode # and description attributes, perhaps due to a manual kill f = os.path.join(datastore.DATADIR, 'calc_%s.hdf5' % calc_id) logging.warn('Unreadable datastore %s', f) continue else: rows.append((calc_id, cmode, descr.encode('utf-8'))) for row in sorted(rows, key=lambda row: row[0]): # by calc_id print('#%d %s: %s' % row) return ds = read(calc_id) # this part is experimental if what == 'rlzs' and 'hcurves' in ds: min_value = 0.01 # used in rmsep curves_by_rlz, mean_curves = get_hcurves_and_means(ds) dists = [] for rlz, curves in curves_by_rlz.items(): dist = sum(rmsep(mean_curves[imt], curves[imt], min_value) for imt in mean_curves.dtype.fields) dists.append((dist, rlz)) print('Realizations in order of distance from the mean curves') for dist, rlz in sorted(dists): print('%s: rmsep=%s' % (rlz, dist)) elif view.keyfunc(what) in view: print(view(what, ds)) elif what in ds: obj = ds[what] if hasattr(obj, 'value'): # an array print(write_csv(io.StringIO(), obj.value)) else: print(obj) else: print('%s not found' % what) ds.close()
def test_case_master(self): self.run_calc(case_master.__file__, 'job.ini', insured_losses='false') calc0 = self.calc.datastore # single file event_based_risk self.run_calc(case_master.__file__, 'job.ini', insured_losses='false', calculation_mode='event_based') calc1 = self.calc.datastore # event_based self.run_calc(case_master.__file__, 'job.ini', insured_losses='false', hazard_calculation_id=str(calc1.calc_id), source_model_logic_tree_file='', gsim_logic_tree_file='') calc2 = self.calc.datastore # two files event_based_risk check_csm_info(calc0, calc1) # the csm_info arrays must be equal check_csm_info(calc0, calc2) # the csm_info arrays must be equal if sys.platform == 'darwin': raise unittest.SkipTest('MacOSX') # compare the event loss table generated by a event_based_risk # case_master calculation from ruptures f0 = gettemp(view('elt', calc0)) self.assertEqualFiles('expected/elt.txt', f0, delta=1E-5) f2 = gettemp(view('elt', calc2)) self.assertEqualFiles('expected/elt.txt', f2, delta=1E-5)
def test_case_master_ebr(self): out = self.run_calc(case_master.__file__, 'job.ini', calculation_mode='ebrisk', investigation_time='1', insured_losses='false', exports='csv') for fname in out['losses_by_taxon', 'csv']: self.assertEqualFiles('expected/%s' % strip_calc_id(fname), fname) for fname in out['agg_loss_table', 'csv']: self.assertEqualFiles('expected/%s' % strip_calc_id(fname), fname) fname = writetmp(view('portfolio_loss', self.calc.datastore)) self.assertEqualFiles( 'expected/portfolio_loss_ebr.txt', fname, delta=1E-5)
def test_ebr(self): # test a single case of `run_job`, but it is the most complex one, # event based risk with post processing job_ini = os.path.join( os.path.dirname(case_master.__file__), 'job.ini') with Print.patch() as p: job_id = run_job(job_ini, log_level='error') self.assertIn('id | name', str(p)) # sanity check on the performance view: make sure that the most # relevant information is stored (it can be lost for instance due # to a wrong refactoring of the safely_call function) with read(job_id) as dstore: perf = view('performance', dstore) self.assertIn('total event_based_risk', perf)
def test_case_6a(self): # case with two gsims self.run_calc(case_6a.__file__, 'job_haz.ini,job_risk.ini', exports='csv') [f] = export(('agglosses', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/agg_structural.csv', f) # testing the totlosses view dstore = self.calc.datastore fname = gettemp(view('totlosses', dstore)) self.assertEqualFiles('expected/totlosses.txt', fname) # two equal gsims with self.assertRaises(InvalidLogicTree): self.run_calc(case_6a.__file__, 'job_haz.ini', gsim_logic_tree_file='wrong_gmpe_logic_tree.xml')
def test_case_14(self): # test preclassical and OQ_SAMPLE_SOURCES with mock.patch.dict(os.environ, OQ_SAMPLE_SOURCES='1'): self.run_calc( case_14.__file__, 'job.ini', calculation_mode='preclassical') rpt = view('ruptures_per_trt', self.calc.datastore) self.assertEqual(rpt, """\ ================ ====== ==================== ============ ============ source_model grp_id trt eff_ruptures tot_ruptures ================ ====== ==================== ============ ============ simple_fault.xml 0 Active Shallow Crust 447 447 ================ ====== ==================== ============ ============""") # test classical self.assert_curves_ok([ 'hazard_curve-smltp_simple_fault-gsimltp_AbrahamsonSilva2008.csv', 'hazard_curve-smltp_simple_fault-gsimltp_CampbellBozorgnia2008.csv' ], case_14.__file__)
def test_case_1(self): self.run_calc(case_1.__file__, 'job.ini') ekeys = [('agg_curves-stats', 'csv')] for ekey in ekeys: for fname in export(ekey, self.calc.datastore): self.assertEqualFiles( 'expected/%s' % strip_calc_id(fname), fname) # make sure the agg_curves-stats has the right attrs self.check_attr('return_periods', [30, 60, 120, 240, 480, 960]) self.check_attr('units', [b'EUR', b'EUR']) self.check_attr('nbytes', 96) # test the loss curves exporter [f1] = export(('loss_curves/rlz-0', 'csv'), self.calc.datastore) [f2] = export(('loss_curves/rlz-1', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/loss_curves-rlz-000.csv', f1) self.assertEqualFiles('expected/loss_curves-rlz-001.csv', f2) [f] = export(('loss_curves/mean', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/loss_curves-mean.csv', f) # test the loss maps exporter fnames = export(('loss_maps-stats', 'csv'), self.calc.datastore) assert fnames for fname in fnames: self.assertEqualFiles('expected/' + strip_calc_id(fname), fname, delta=1E-5) # test portfolio loss tmp = gettemp(view('portfolio_loss', self.calc.datastore)) self.assertEqualFiles('expected/portfolio_loss.txt', tmp) # test the rup_loss_table exporter fnames = export(('rup_loss_table', 'xml'), self.calc.datastore) self.assertEqual(len(fnames), 2) for fname in fnames: self.assertEqualFiles('expected/' + strip_calc_id(fname), fname) # test the src_loss_table extractor arr = extract(self.calc.datastore, 'src_loss_table/structural') tmp = gettemp(rst_table(arr)) self.assertEqualFiles('expected/src_loss_table.txt', tmp)
def test_case_2(self): self.assert_stats_ok(case_2, 'job.ini', individual_curves='true') fname = writetmp(view('mean_avg_losses', self.calc.datastore)) self.assertEqualFiles('expected/mean_avg_losses.txt', fname) # test the composite_risk_model keys (i.e. slash escaping) crm = sorted(self.calc.datastore.getitem('composite_risk_model')) self.assertEqual(crm, ['RC%2B', 'RM', 'W%2F1']) # export a specific eid [fname] = export(('all_loss_ratios:0', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/losses-eid=0.csv', fname) # test the case when all GMFs are filtered out with self.assertRaises(RuntimeError) as ctx: self.run_calc(case_2.__file__, 'job.ini', minimum_intensity='10.0') self.assertEqual( str(ctx.exception), 'No GMFs were generated, perhaps they were all below the ' 'minimum_intensity threshold')
def test_case_1(self): # test with a single event self.assert_ok(case_1, 'job_risk.ini') got = view('num_units', self.calc.datastore) self.assertEqual('''\ ======== ========= taxonomy num_units ======== ========= RC 2,000 RM 4,000 *ALL* 6,000 ======== =========''', got) # test agg_damages, 1 realization x 3 damage states [dmg] = extract(self.calc.datastore, 'agg_damages/structural?' 'taxonomy=RC&CRESTA=01.1') numpy.testing.assert_almost_equal( [1498.0121, 472.96616, 29.021801], dmg, decimal=4) # test no intersection dmg = extract(self.calc.datastore, 'agg_damages/structural?' 'taxonomy=RM&CRESTA=01.1') self.assertEqual(dmg.shape, ())
def test_case_1g(self): # vulnerability function with PMF self.run_calc(case_1g.__file__, 'job.ini') fname = writetmp(view('mean_avg_losses', self.calc.datastore)) self.assertEqualFiles('expected/avg_losses.txt', fname) os.remove(fname)
def test_case_1f(self): # vulnerability function with BT self.run_calc(case_1f.__file__, 'job_h.ini,job_r.ini') fname = gettemp(view('portfolio_losses', self.calc.datastore)) self.assertEqualFiles('portfolio_losses.txt', fname, delta=1E-6) os.remove(fname)
def test_case_master(self): if sys.platform == 'darwin': raise unittest.SkipTest('MacOSX') self.run_calc(case_master.__file__, 'job.ini', exports='csv') fnames = export(('avg_losses-stats', 'csv'), self.calc.datastore) assert fnames, 'avg_losses-stats not exported?' for fname in fnames: self.assertEqualFiles('expected/' + strip_calc_id(fname), fname, delta=1E-5) # check event loss table [fname] = export(('losses_by_event', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/' + strip_calc_id(fname), fname, delta=1E-5) # extract loss_curves/rlz-1 (with the first asset having zero losses) [fname] = export(('loss_curves/rlz-1', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/' + strip_calc_id(fname), fname, delta=1E-5) fnames = export(('loss_maps-rlzs', 'csv'), self.calc.datastore) assert fnames, 'loss_maps-rlzs not exported?' for fname in fnames: self.assertEqualFiles('expected/' + strip_calc_id(fname), fname, delta=1E-5) fname = gettemp(view('portfolio_losses', self.calc.datastore)) self.assertEqualFiles('expected/portfolio_losses.txt', fname, delta=1E-5) os.remove(fname) # check ruptures are stored correctly fname = gettemp(view('ruptures_events', self.calc.datastore)) self.assertEqualFiles('expected/ruptures_events.txt', fname) os.remove(fname) # check losses_by_tag fnames = export( ('aggregate_by/avg_losses?tag=occupancy&kind=mean', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/losses_by_occupancy.csv', fnames[0]) self.check_multi_tag(self.calc.datastore) # ------------------------- ebrisk calculator ---------------------- # self.run_calc(case_master.__file__, 'job.ini', calculation_mode='ebrisk', exports='', aggregate_by='id') # agg_losses-rlzs has shape (L=5, R=9) # agg_losses-stats has shape (L=5, S=4) fname = export(('agg_losses-stats', 'csv'), self.calc.datastore)[0] self.assertEqualFiles('expected/agglosses.csv', fname, delta=1E-5) fname = export(('agg_curves-stats', 'csv'), self.calc.datastore)[0] self.assertEqualFiles('expected/aggcurves.csv', fname, delta=1E-5) fname = export(('agg_maps-stats', 'csv'), self.calc.datastore)[0] self.assertEqualFiles('expected/aggmaps.csv', fname, delta=1E-5) fname = export(('avg_losses', 'csv'), self.calc.datastore)[0] self.assertEqualFiles('expected/avg_losses-mean.csv', fname, delta=1E-5) fname = export(('losses_by_event', 'csv'), self.calc.datastore)[0] self.assertEqualFiles('expected/elt.csv', fname)
def test_case_master(self): check_platform('xenial') self.assert_stats_ok(case_master, 'job.ini') fname = writetmp(view('portfolio_loss', self.calc.datastore)) self.assertEqualFiles('expected/portfolio_loss.txt', fname, delta=1E-5)
def export_fullreport(ekey, dstore): with open(dstore.export_path('report.rst'), 'w') as f: f.write(view('fullreport', dstore)) return [f.name]
def test_case_master(self): if sys.platform == 'darwin': raise unittest.SkipTest('MacOSX') self.run_calc(case_master.__file__, 'job.ini', exports='csv') fnames = export(('avg_losses-stats', 'csv'), self.calc.datastore) assert fnames, 'avg_losses-stats not exported?' for fname in fnames: self.assertEqualFiles('expected/' + strip_calc_id(fname), fname, delta=1E-5) # extract loss_curves/rlz-1 (with the first asset having zero losses) [fname] = export(('loss_curves/rlz-1', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/' + strip_calc_id(fname), fname, delta=1E-5) fnames = export(('loss_maps-rlzs', 'csv'), self.calc.datastore) assert fnames, 'loss_maps-rlzs not exported?' for fname in fnames: self.assertEqualFiles('expected/' + strip_calc_id(fname), fname, delta=1E-5) # extract curves by tag tags = 'taxonomy=tax1&state=01&cresta=0.11' a = extract(self.calc.datastore, 'agg_curves/structural?' + tags) self.assertEqual(a.array.shape, (4, 3)) # 4 stats, 3 return periods fname = gettemp(view('portfolio_losses', self.calc.datastore)) self.assertEqualFiles('expected/portfolio_losses.txt', fname, delta=1E-5) os.remove(fname) # check ruptures are stored correctly fname = gettemp(view('ruptures_events', self.calc.datastore)) self.assertEqualFiles('expected/ruptures_events.txt', fname) os.remove(fname) # check losses_by_tag fnames = export(('aggregate_by/occupancy/avg_losses', 'csv'), self.calc.datastore) self.assertEqualFiles('expected/losses_by_occupancy.csv', fnames[0]) self.check_multi_tag(self.calc.datastore) # ------------------------- ebrisk calculator ---------------------- # self.run_calc(case_master.__file__, 'job.ini', hazard_calculation_id=str(self.calc.datastore.calc_id), calculation_mode='ebrisk', exports='', aggregate_by='taxonomy', insured_losses='false') # agg_losses-rlzs has shape (L=5, R=9) # agg_losses-stats has shape (L=5, S=4) fname = export(('agg_losses-stats', 'csv'), self.calc.datastore)[0] self.assertEqualFiles('expected/agglosses.csv', fname) fname = export(('avg_losses', 'csv'), self.calc.datastore)[0] self.assertEqualFiles('expected/avglosses.csv', fname, delta=1E-5)