コード例 #1
0
ファイル: test.py プロジェクト: gvallarelli/oq-engine
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), "job.ini")
            expected_curve_poes_b1_b2 = [0.00995, 0.00076, 9.7e-5, 0.0]
            expected_curve_poes_b1_b3 = [0.00995, 0.00076, 0.000104, 0.0]

            job = self.run_hazard(cfg)

            # Test the poe values for the two curves:
            curve_b1_b2, curve_b1_b3 = models.HazardCurveData.objects.filter(
                hazard_curve__output__oq_job=job.id
            ).order_by("hazard_curve__lt_realization__sm_lt_path")

            # Sanity check, to make sure we have the curves ordered correctly:
            self.assertEqual(["b1", "b2"], curve_b1_b2.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(["b1", "b3"], curve_b1_b3.hazard_curve.lt_realization.sm_lt_path)

            numpy.testing.assert_array_almost_equal(expected_curve_poes_b1_b2, curve_b1_b2.poes, decimal=4)
            numpy.testing.assert_array_almost_equal(expected_curve_poes_b1_b3, curve_b1_b3.poes, decimal=4)

            # Test the exports as well:
            [exported_file_b1_b2] = hazard_export.export(curve_b1_b2.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_B1_B2), exported_file_b1_b2)

            [exported_file_b1_b3] = hazard_export.export(curve_b1_b3.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_B1_B3), exported_file_b1_b3)
        finally:
            shutil.rmtree(result_dir)
コード例 #2
0
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_poes_b1 = [0.86466, 0.82460, 0.36525]
            expected_curve_poes_b2 = [0.63212, 0.61186, 0.25110]
            expected_mean_poes = [0.794898, 0.760778, 0.331005]

            job = self.run_hazard(cfg)

            # Test the poe values for the two curves.
            actual_curve_b1, actual_curve_b2 = \
                models.HazardCurveData.objects\
                    .filter(hazard_curve__output__oq_job=job.id,
                            hazard_curve__lt_realization__isnull=False)\
                    .order_by('hazard_curve__lt_realization__sm_lt_path')

            # Sanity check, to make sure we have the curves ordered correctly:
            self.assertEqual(
                ['b1'], actual_curve_b1.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b2'], actual_curve_b2.hazard_curve.lt_realization.sm_lt_path)

            numpy.testing.assert_array_almost_equal(expected_curve_poes_b1,
                                                    actual_curve_b1.poes,
                                                    decimal=3)

            numpy.testing.assert_array_almost_equal(expected_curve_poes_b2,
                                                    actual_curve_b2.poes,
                                                    decimal=3)

            # Test the mean curve:
            [mean_curve] = models.HazardCurveData.objects\
                .filter(hazard_curve__output__oq_job=job.id,
                        hazard_curve__statistics='mean')
            numpy.testing.assert_array_almost_equal(expected_mean_poes,
                                                    mean_curve.poes,
                                                    decimal=3)

            # Test the exports as well:
            exported_file_b1 = hazard_export.export(
                actual_curve_b1.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_B1),
                                  exported_file_b1)

            exported_file_b2 = hazard_export.export(
                actual_curve_b2.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_B2),
                                  exported_file_b2)

            # mean:
            exported_file_mean = hazard_export.export(
                mean_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_MEAN),
                                  exported_file_mean)
        finally:
            shutil.rmtree(result_dir)
コード例 #3
0
ファイル: test.py プロジェクト: MohsenKohrangi/oq-engine
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_poes_b1 = [0.86466, 0.82460, 0.36525]
            expected_curve_poes_b2 = [0.63212, 0.61186, 0.25110]
            expected_mean_poes = [0.794898, 0.760778, 0.331005]

            job = self.run_hazard(cfg)

            # Test the poe values for the two curves.
            actual_curve_b1, actual_curve_b2 = (
                models.HazardCurveData.objects
                .filter(hazard_curve__output__oq_job=job.id,
                        hazard_curve__lt_realization__isnull=False)
                .order_by('hazard_curve__lt_realization__lt_model__sm_lt_path')
            )

            # Sanity check, to make sure we have the curves ordered correctly:
            self.assertEqual(
                ['b1'], actual_curve_b1.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b2'], actual_curve_b2.hazard_curve.lt_realization.sm_lt_path)

            numpy.testing.assert_array_almost_equal(
                expected_curve_poes_b1, actual_curve_b1.poes, decimal=3)

            numpy.testing.assert_array_almost_equal(
                expected_curve_poes_b2, actual_curve_b2.poes, decimal=3)

            # Test the mean curve:
            [mean_curve] = models.HazardCurveData.objects\
                .filter(hazard_curve__output__oq_job=job.id,
                        hazard_curve__statistics='mean')
            numpy.testing.assert_array_almost_equal(
                expected_mean_poes, mean_curve.poes, decimal=3)

            # Test the exports as well:
            exported_file_b1 = hazard_export.export(
                actual_curve_b1.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1), exported_file_b1)

            exported_file_b2 = hazard_export.export(
                actual_curve_b2.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B2), exported_file_b2)

            # mean:
            exported_file_mean = hazard_export.export(
                mean_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_MEAN), exported_file_mean)
        finally:
            shutil.rmtree(result_dir)
コード例 #4
0
ファイル: test.py プロジェクト: 4x/oq-engine
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_poes_b1_b2 = [0.095163, 0.012362, 0.002262, 0.0]
            expected_curve_poes_b1_b3 = [0.009950, 0.00076, 9.99995E-6, 0.0]
            expected_curve_poes_b1_b4 = [0.0009995, 4.5489E-5, 4.07365E-6, 0.0]

            job = self.run_hazard(cfg)

            # Test the poe values for the three curves:
            curve_b1_b2, curve_b1_b3, curve_b1_b4 = \
                models.HazardCurveData.objects\
                    .filter(hazard_curve__output__oq_job=job.id)\
                    .order_by('hazard_curve__lt_realization__sm_lt_path')

            # Sanity check, to make sure we have the curves ordered correctly:
            self.assertEqual(
                ['b1', 'b2'],
                curve_b1_b2.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b1', 'b3'],
                curve_b1_b3.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b1', 'b4'],
                curve_b1_b4.hazard_curve.lt_realization.sm_lt_path)

            numpy.testing.assert_array_almost_equal(
                expected_curve_poes_b1_b2, curve_b1_b2.poes, decimal=3)
            numpy.testing.assert_array_almost_equal(
                expected_curve_poes_b1_b3, curve_b1_b3.poes, decimal=3)
            numpy.testing.assert_array_almost_equal(
                expected_curve_poes_b1_b4, curve_b1_b4.poes, decimal=3)

            # Test the exports as well:
            [exported_file_b1_b2] = hazard_export.export(
                curve_b1_b2.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B2),
                exported_file_b1_b2)

            [exported_file_b1_b3] = hazard_export.export(
                curve_b1_b3.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B3),
                exported_file_b1_b3)

            [exported_file_b1_b4] = hazard_export.export(
                curve_b1_b4.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B4),
                exported_file_b1_b4)
        finally:
            shutil.rmtree(result_dir)
コード例 #5
0
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_poes_b1_b2 = [0.095163, 0.012362, 0.002262, 0.0]
            expected_curve_poes_b1_b3 = [0.009950, 0.00076, 9.99995E-6, 0.0]
            expected_curve_poes_b1_b4 = [0.0009995, 4.5489E-5, 4.07365E-6, 0.0]

            job = self.run_hazard(cfg)

            # Test the poe values for the three curves:
            curve_b1_b2, curve_b1_b3, curve_b1_b4 = \
                models.HazardCurveData.objects\
                    .filter(hazard_curve__output__oq_job=job.id)\
                    .order_by('hazard_curve__lt_realization__sm_lt_path')

            # Sanity check, to make sure we have the curves ordered correctly:
            self.assertEqual(
                ['b1', 'b2'],
                curve_b1_b2.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b1', 'b3'],
                curve_b1_b3.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b1', 'b4'],
                curve_b1_b4.hazard_curve.lt_realization.sm_lt_path)

            numpy.testing.assert_array_almost_equal(
                expected_curve_poes_b1_b2, curve_b1_b2.poes, decimal=3)
            numpy.testing.assert_array_almost_equal(
                expected_curve_poes_b1_b3, curve_b1_b3.poes, decimal=3)
            numpy.testing.assert_array_almost_equal(
                expected_curve_poes_b1_b4, curve_b1_b4.poes, decimal=3)

            # Test the exports as well:
            exported_file_b1_b2 = hazard_export.export(
                curve_b1_b2.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B2),
                exported_file_b1_b2)

            exported_file_b1_b3 = hazard_export.export(
                curve_b1_b3.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B3),
                exported_file_b1_b3)

            exported_file_b1_b4 = hazard_export.export(
                curve_b1_b4.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B4),
                exported_file_b1_b4)
        finally:
            shutil.rmtree(result_dir)
コード例 #6
0
ファイル: general.py プロジェクト: kenxshao/oq-engine
    def export(self, *args, **kwargs):
        """
        If requested by the user, automatically export all result artifacts to
        the specified format. (NOTE: The only export format supported at the
        moment is NRML XML.

        :returns:
            A list of the export filenames, including the absolute path to each
            file.
        """
        exported_files = []

        logs.LOG.debug('> starting exports')
        if 'exports' in kwargs and 'xml' in kwargs['exports']:
            outputs = export_core.get_outputs(self.job.id)

            if not self.hc.export_multi_curves:
                outputs = outputs.exclude(output_type='hazard_curve_multi')

            for output in outputs:
                with self.monitor('exporting %s' % output.output_type):
                    fname = hazard_export.export(
                        output.id, self.job.hazard_calculation.export_dir)
                    exported_files.extend(fname)
                    logs.LOG.debug('exported %s' % fname)

        logs.LOG.debug('< done with exports')

        return exported_files
コード例 #7
0
ファイル: hazard_test.py プロジェクト: xpb/oq-engine
    def test_export_for_scenario(self):
        target_dir = tempfile.mkdtemp()

        try:
            cfg = helpers.demo_file('scenario_hazard/job.ini')

            # run the calculation to create something to export
            retcode = helpers.run_hazard_job_sp(cfg, silence=True)
            self.assertEqual(0, retcode)

            job = models.OqJob.objects.latest('id')

            outputs = export_core.get_outputs(job.id)

            self.assertEqual(1, len(outputs))  # 1 GMF

            gmf_outputs = outputs.filter(output_type='gmf_scenario')
            self.assertEqual(1, len(gmf_outputs))

            exported_files = hazard.export(gmf_outputs[0].id, target_dir)

            self.assertEqual(1, len(exported_files))
            # Check the file paths exist, is absolute, and the file isn't
            # empty.
            f = exported_files[0]
            self._test_exported_file(f)

            # Check for the correct number of GMFs in the file:
            tree = etree.parse(f)
            self.assertEqual(10, number_of('nrml:gmf', tree))
        finally:
            shutil.rmtree(target_dir)
コード例 #8
0
ファイル: general.py プロジェクト: 4x/oq-engine
    def export(self, *args, **kwargs):
        """
        If requested by the user, automatically export all result artifacts to
        the specified format. (NOTE: The only export format supported at the
        moment is NRML XML.

        :returns:
            A list of the export filenames, including the absolute path to each
            file.
        """
        exported_files = []

        logs.LOG.debug('> starting exports')
        if 'exports' in kwargs and 'xml' in kwargs['exports']:
            outputs = export_core.get_outputs(self.job.id)

            for output in outputs:
                exported_files.extend(hazard_export.export(
                    output.id, self.job.hazard_calculation.export_dir))

            for exp_file in exported_files:
                logs.LOG.debug('exported %s' % exp_file)
        logs.LOG.debug('< done with exports')

        return exported_files
コード例 #9
0
ファイル: hazard_test.py プロジェクト: marmarques/oq-engine
def check_export(output_id, target):
    """
    Call hazard.export by checking that the exported file is valid
    according to our XML schema.
    """
    out_file = hazard.export(output_id, target, 'xml')
    nrmllib.assert_valid(out_file)
    return out_file
コード例 #10
0
    def _do_export(self, output_id, export_dir, export_type):
        """
        Hazard-specific implementation of
        :meth:`openquake.engine.calculators.base.Calculator._do_export`.

        Calls the hazard exporter.
        """
        return hazard_export.export(output_id, export_dir, export_type)
コード例 #11
0
def check_export(output_id, target):
    """
    Call hazard.export by checking that the exported file is valid
    according to our XML schema.
    """
    out_file = hazard.export(output_id, target, 'xml')
    nrmllib.assert_valid(out_file)
    return out_file
コード例 #12
0
ファイル: general.py プロジェクト: MohsenKohrangi/oq-engine
    def _do_export(self, output_id, export_dir, export_type):
        """
        Hazard-specific implementation of
        :meth:`openquake.engine.calculators.base.Calculator._do_export`.

        Calls the hazard exporter.
        """
        return hazard_export.export(output_id, export_dir, export_type)
コード例 #13
0
ファイル: hazard_test.py プロジェクト: xpb/oq-engine
    def test_classical_hazard_export(self):
        # Run a hazard calculation to compute some curves and maps
        # Call the exporter and verify that files were created
        # Since the hazard curve XML writer is concerned with correctly
        # generating XML, we won't test that here.
        target_dir = tempfile.mkdtemp()

        try:
            cfg = helpers.demo_file('simple_fault_demo_hazard/job.ini')

            # run the calculation to create something to export
            retcode = helpers.run_hazard_job_sp(cfg, silence=True)
            self.assertEqual(0, retcode)

            job = models.OqJob.objects.latest('id')

            outputs = export_core.get_outputs(job.id)
            expected_outputs = 18  # 6 hazard curves + 12 hazard maps
            self.assertEqual(expected_outputs, len(outputs))

            # Export the hazard curves:
            curves = outputs.filter(output_type='hazard_curve')
            hc_files = []
            for curve in curves:
                hc_files.extend(hazard.export(curve.id, target_dir))

            self.assertEqual(6, len(hc_files))

            for f in hc_files:
                self._test_exported_file(f)

            # Test hazard map export as well.
            maps = outputs.filter(output_type='hazard_map')
            hm_files = []
            for haz_map in maps:
                hm_files.extend(hazard.export(haz_map.id, target_dir))

            self.assertEqual(12, len(hm_files))

            for f in hm_files:
                self._test_exported_file(f)
        finally:
            shutil.rmtree(target_dir)
コード例 #14
0
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_pga = [0.4570, 0.0587, 0.0069]
            expected_curve_sa = [
                0.608675003748, 0.330831513139, 0.201472214825
            ]

            job = self.run_hazard(cfg)

            # Test the poe values of the single curve:
            curves = models.HazardCurveData.objects.filter(
                hazard_curve__output__oq_job=job.id
            )

            [pga_curve] = curves.filter(hazard_curve__imt='PGA')
            numpy.testing.assert_array_almost_equal(
                expected_curve_pga, pga_curve.poes, decimal=4
            )

            [sa_curve] = curves.filter(
                hazard_curve__imt='SA', hazard_curve__sa_period=0.1
            )
            numpy.testing.assert_array_almost_equal(
                expected_curve_sa, sa_curve.poes, decimal=4
            )

            # Test the exports as well:
            exported_file = hazard_export.export(
                pga_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_PGA_XML), exported_file)

            exported_file = hazard_export.export(
                sa_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_SA_XML), exported_file)
        finally:
            shutil.rmtree(result_dir)
コード例 #15
0
ファイル: test.py プロジェクト: kenxshao/oq-engine
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_pga = [0.4570, 0.0587, 0.0069]
            expected_curve_sa = [
                0.608675003748, 0.330831513139, 0.201472214825
            ]

            job = self.run_hazard(cfg)

            # Test the poe values of the single curve:
            curves = models.HazardCurveData.objects.filter(
                hazard_curve__output__oq_job=job.id
            )

            [pga_curve] = curves.filter(hazard_curve__imt='PGA')
            numpy.testing.assert_array_almost_equal(
                expected_curve_pga, pga_curve.poes, decimal=4
            )

            [sa_curve] = curves.filter(
                hazard_curve__imt='SA', hazard_curve__sa_period=0.1
            )
            numpy.testing.assert_array_almost_equal(
                expected_curve_sa, sa_curve.poes, decimal=4
            )

            # Test the exports as well:
            [exported_file] = hazard_export.export(
                pga_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_PGA_XML), exported_file)

            [exported_file] = hazard_export.export(
                sa_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_SA_XML), exported_file)
        finally:
            shutil.rmtree(result_dir)
コード例 #16
0
ファイル: test.py プロジェクト: gvallarelli/oq-engine
    def test(self):
        aaae = numpy.testing.assert_array_almost_equal
        # TODO(LB): This is a temporary test case which tests for stability
        # until we can write proper QA tests.

        cfg = os.path.join(os.path.dirname(__file__), 'job.ini')

        job = self.run_hazard(cfg)

        results = models.DisaggResult.objects.filter(output__oq_job=job)

        poe_002_pga = results.filter(imt='PGA', poe=0.02)
        rlz1, rlz2 = poe_002_pga.order_by('lt_realization')

        aaae(test_data.RLZ_1_POE_002_PGA, rlz1.matrix)
        aaae(test_data.RLZ_2_POE_002_PGA, rlz2.matrix)

        poe_002_sa = results.filter(imt='SA', poe=0.02)
        rlz1, rlz2 = poe_002_sa.order_by('lt_realization')

        aaae(test_data.RLZ_1_POE_002_SA, rlz1.matrix)
        aaae(test_data.RLZ_2_POE_002_SA, rlz2.matrix)

        poe_01_pga = results.filter(imt='PGA', poe=0.1)
        rlz1, rlz2 = poe_01_pga.order_by('lt_realization')

        aaae(test_data.RLZ_1_POE_01_PGA, rlz1.matrix)
        aaae(test_data.RLZ_2_POE_01_PGA, rlz2.matrix)

        poe_01_sa = results.filter(imt='SA', poe=0.1)
        rlz1, rlz2 = poe_01_sa.order_by('lt_realization')

        aaae(test_data.RLZ_1_POE_01_SA, rlz1.matrix)
        aaae(test_data.RLZ_2_POE_01_SA, rlz2.matrix)

        # Lastly, we should an export of at least one of these results to
        # ensure that the disagg export/serialization is working properly.
        # The export isn't just a simple dump from the database; it requires
        # extraction of PMFs (Probability Mass Function) from a 6d matrix,
        # which are then serialized to XML.
        # This is not a trivial operation.
        try:
            target_dir = tempfile.mkdtemp()
            [result_file] = haz_export.export(rlz1.output.id, target_dir)

            expected = StringIO.StringIO(test_data.EXPECTED_XML_DISAGG)
            self.assert_xml_equal(expected, result_file)
            self.assertTrue(qa_utils.validates_against_xml_schema(result_file))
        finally:
            shutil.rmtree(target_dir)
コード例 #17
0
ファイル: hazard_test.py プロジェクト: xpb/oq-engine
    def test_disagg_hazard_export(self):
        target_dir = tempfile.mkdtemp()

        try:
            cfg = helpers.demo_file('disaggregation/job.ini')

            retcode = helpers.run_hazard_job_sp(cfg, silence=True)
            self.assertEqual(0, retcode)

            job = models.OqJob.objects.latest('id')

            outputs = export_core.get_outputs(job.id)

            # Test curve export:
            curves = outputs.filter(output_type='hazard_curve')
            self.assertEqual(4, len(curves))
            curve_files = []
            for curve in curves:
                curve_files.extend(hazard.export(curve.id, target_dir))

            self.assertEqual(4, len(curve_files))
            for f in curve_files:
                self._test_exported_file(f)

            # Test disagg matrix export:
            matrices = outputs.filter(output_type='disagg_matrix')
            self.assertEqual(8, len(matrices))
            disagg_files = []
            for matrix in matrices:
                disagg_files.extend(hazard.export(matrix.id, target_dir))

            self.assertEqual(8, len(disagg_files))
            for f in disagg_files:
                self._test_exported_file(f)
        finally:
            shutil.rmtree(target_dir)
コード例 #18
0
    def test(self):
        # TODO(LB): This is a temporary test case which tests for stability
        # until we can write proper QA tests.

        cfg = os.path.join(os.path.dirname(__file__), 'job.ini')

        job = self.run_hazard(cfg)

        results = models.DisaggResult.objects.filter(output__oq_job=job)

        poe_002_pga = results.filter(imt='PGA', poe=0.02)
        rlz1, rlz2 = poe_002_pga.order_by('lt_realization')

        aaae(test_data.RLZ_1_POE_002_PGA, rlz1.matrix)
        aaae(test_data.RLZ_2_POE_002_PGA, rlz2.matrix)

        poe_002_sa = results.filter(imt='SA', poe=0.02)
        rlz1, rlz2 = poe_002_sa.order_by('lt_realization')

        aaae(test_data.RLZ_1_POE_002_SA, rlz1.matrix)
        aaae(test_data.RLZ_2_POE_002_SA, rlz2.matrix)

        poe_01_pga = results.filter(imt='PGA', poe=0.1)
        rlz1, rlz2 = poe_01_pga.order_by('lt_realization')

        aaae(test_data.RLZ_1_POE_01_PGA, rlz1.matrix)
        aaae(test_data.RLZ_2_POE_01_PGA, rlz2.matrix)

        poe_01_sa = results.filter(imt='SA', poe=0.1)
        rlz1, rlz2 = poe_01_sa.order_by('lt_realization')

        aaae(test_data.RLZ_1_POE_01_SA, rlz1.matrix)
        aaae(test_data.RLZ_2_POE_01_SA, rlz2.matrix)

        # Lastly, we should check an export of at least one of these results to
        # ensure that the disagg export/serialization is working properly.
        # The export isn't just a simple dump from the database; it requires
        # extraction of PMFs (Probability Mass Function) from a 6d matrix,
        # which are then serialized to XML.
        # This is not a trivial operation.
        try:
            target_dir = tempfile.mkdtemp()
            result_file = haz_export.export(rlz1.output.id, target_dir)
            expected = StringIO.StringIO(test_data.EXPECTED_XML_DISAGG)
            self.assert_disagg_xml_almost_equal(expected, result_file)
            self.assertTrue(qa_utils.validates_against_xml_schema(result_file))
        finally:
            shutil.rmtree(target_dir)
コード例 #19
0
ファイル: test.py プロジェクト: gvallarelli/oq-engine
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), "job.ini")
            expected_curve_poes = [0.86466, 0.82460, 0.36525]

            job = self.run_hazard(cfg)

            # Test the poe values of the single curve:
            [actual_curve] = models.HazardCurveData.objects.filter(hazard_curve__output__oq_job=job.id)

            numpy.testing.assert_array_almost_equal(expected_curve_poes, actual_curve.poes, decimal=2)

            # Test the export as well:
            [exported_file] = hazard_export.export(actual_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML), exported_file)
        finally:
            shutil.rmtree(result_dir)
コード例 #20
0
ファイル: test.py プロジェクト: scm20008/oq-engine
    def test(self):
        result_dir = tempfile.mkdtemp()
        aaae = numpy.testing.assert_array_almost_equal

        try:
            cfg = os.path.join(os.path.dirname(__file__), "job.ini")
            expected_curve_poes = [0.75421006, 0.08098179, 0.00686616]

            job = self.run_hazard(cfg)

            # Test the poe values of the single curve:
            [curve] = models.HazardCurveData.objects.filter(hazard_curve__output__oq_job=job.id)

            aaae(expected_curve_poes, curve.poes, decimal=2)

            # Test the exports as well:
            exported_file = hazard_export.export(curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML), exported_file)
        finally:
            shutil.rmtree(result_dir)
コード例 #21
0
    def test(self):
        result_dir = tempfile.mkdtemp()

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_poes = [0.63212, 0.61186, 0.25110]

            job = self.run_hazard(cfg)

            # Test the poe values of the single curve:
            [actual_curve] = models.HazardCurveData.objects.filter(
                hazard_curve__output__oq_job=job.id)

            numpy.testing.assert_array_almost_equal(
                expected_curve_poes, actual_curve.poes, decimal=3)

            # Test the export as well:
            exported_file = hazard_export.export(
                actual_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML), exported_file)
        finally:
            shutil.rmtree(result_dir)
コード例 #22
0
    def test(self):
        result_dir = tempfile.mkdtemp()
        aaae = numpy.testing.assert_array_almost_equal

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_poes = [0.75421006, 0.08098179, 0.00686616]

            job = self.run_hazard(cfg)

            # Test the poe values of the single curve:
            [curve] = models.HazardCurveData.objects.filter(
                hazard_curve__output__oq_job=job.id)

            aaae(expected_curve_poes, curve.poes, decimal=2)

            # Test the exports as well:
            exported_file = hazard_export.export(
                curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML),
                exported_file)
        finally:
            shutil.rmtree(result_dir)
コード例 #23
0
    def test(self):
        result_dir = tempfile.mkdtemp()
        aaae = numpy.testing.assert_array_almost_equal

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_poes_b1_b2 = [0.0055, 0.00042, 5.77E-5, 0.0]
            expected_curve_poes_b1_b3 = [0.00995, 0.00076, 9.7E-5, 0.0]
            expected_curve_poes_b1_b4 = [0.018, 0.0013, 0.00014, 0.0]

            expected_mean_poes = [0.01067, 0.0008, 9.774E-5, 0.0]

            expected_q0_1_poes = [0.0055, 0.00042, 5.77E-5, 0.0]
            expected_q0_9_poes = [0.013975, 0.00103, 0.0001185, 0.0]

            job = self.run_hazard(cfg)

            # Test the poe values for the two curves:
            curve_b1_b2, curve_b1_b3, curve_b1_b4 = \
                models.HazardCurveData.objects\
                    .filter(hazard_curve__output__oq_job=job.id,
                            hazard_curve__lt_realization__isnull=False)\
                    .order_by('hazard_curve__lt_realization__sm_lt_path')

            # Sanity check, to make sure we have the curves ordered correctly:
            self.assertEqual(
                ['b1', 'b2'],
                curve_b1_b2.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b1', 'b3'],
                curve_b1_b3.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b1', 'b4'],
                curve_b1_b4.hazard_curve.lt_realization.sm_lt_path)

            aaae(expected_curve_poes_b1_b2, curve_b1_b2.poes, decimal=4)
            aaae(expected_curve_poes_b1_b3, curve_b1_b3.poes, decimal=4)
            aaae(expected_curve_poes_b1_b4, curve_b1_b4.poes, decimal=4)

            # Test the mean curve:
            [mean_curve] = models.HazardCurveData.objects\
                .filter(hazard_curve__output__oq_job=job.id,
                        hazard_curve__statistics='mean')
            aaae(expected_mean_poes, mean_curve.poes, decimal=4)

            # Test the quantile curves:
            quantile_0_1_curve, quantile_0_9_curve = \
                models.HazardCurveData.objects\
                    .filter(hazard_curve__output__oq_job=job.id,
                            hazard_curve__statistics='quantile')\
                    .order_by('hazard_curve__quantile')
            aaae(expected_q0_1_poes, quantile_0_1_curve.poes, decimal=4)
            aaae(expected_q0_9_poes, quantile_0_9_curve.poes, decimal=4)

            # Test the exports as well:
            exported_file_b1_b2 = hazard_export.export(
                curve_b1_b2.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_B1_B2),
                                  exported_file_b1_b2)

            exported_file_b1_b3 = hazard_export.export(
                curve_b1_b3.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_B1_B3),
                                  exported_file_b1_b3)

            exported_file_b1_b4 = hazard_export.export(
                curve_b1_b4.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_B1_B4),
                                  exported_file_b1_b4)

            exported_file_mean = hazard_export.export(
                mean_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(StringIO.StringIO(self.EXPECTED_XML_MEAN),
                                  exported_file_mean)

            q01_file = hazard_export.export(
                quantile_0_1_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_QUANTILE_0_1), q01_file)

            q09_file = hazard_export.export(
                quantile_0_9_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_QUANTILE_0_9), q09_file)
        finally:
            shutil.rmtree(result_dir)
コード例 #24
0
ファイル: hazard_test.py プロジェクト: kenxshao/oq-engine
def check_export(output_id, target_dir):
    """
    Call hazard.export by checking that the exported file is valid
    according to our XML schema.
    """
    return hazard.export(output_id, target_dir, check_schema=True)
コード例 #25
0
ファイル: hazard_test.py プロジェクト: kenxshao/oq-engine
    def test_classical_hazard_export(self):
        # Run a hazard calculation to compute some curves and maps
        # Call the exporter and verify that files were created
        # Since the hazard curve XML writer is concerned with correctly
        # generating XML, we won't test that here.
        target_dir = tempfile.mkdtemp()

        try:
            cfg = helpers.get_data_path('simple_fault_demo_hazard/job.ini')

            # run the calculation to create something to export
            helpers.run_hazard_job(cfg)

            job = models.OqJob.objects.latest('id')
            self.assertEqual(job.status, 'complete')

            outputs = export_core.get_outputs(job.id)

            # 10 hazard curves, 20 maps, 10 uhs, 5 multi curves
            expected_outputs = 45
            self.assertEqual(expected_outputs, outputs.count())

            # Number of curves:
            # (2 imts * 2 realizations)
            # + (2 imts * (1 mean + 2 quantiles)
            # = 10
            curves = outputs.filter(output_type='hazard_curve')
            self.assertEqual(10, curves.count())

            # Number of multi-curves
            # (2 realizations + 1 mean + 2 quantiles)
            multi_curves = outputs.filter(output_type="hazard_curve_multi")
            self.assertEqual(5, multi_curves.count())

            # Number of maps:
            # (2 poes * 2 imts * 2 realizations)
            # + (2 poes * 2 imts * (1 mean + 2 quantiles))
            # = 20
            # Number of UHS:
            maps = outputs.filter(output_type='hazard_map')
            self.assertEqual(20, maps.count())

            # Number of UHS:
            # (20 maps_PGA_SA / 2 poes)
            # = 10
            uhs = outputs.filter(output_type='uh_spectra')
            self.assertEqual(10, uhs.count())

            # Test hazard curve export:
            hc_files = []
            for curve in curves:
                hc_files.extend(check_export(curve.id, target_dir))

            self.assertEqual(10, len(hc_files))

            # Test multi hazard curve export:
            hc_files = []
            for curve in multi_curves:
                hc_files.extend(hazard.export(curve.id, target_dir))

            self.assertEqual(5, len(hc_files))

            for f in hc_files:
                self._test_exported_file(f)

            # Test hazard map export:
            hm_files = []
            for haz_map in maps:
                hm_files.extend(check_export(haz_map.id, target_dir))

            self.assertEqual(20, len(hm_files))

            for f in hm_files:
                self._test_exported_file(f)

            # Test UHS export:
            uhs_files = []
            for u in uhs:
                uhs_files.extend(check_export(u.id, target_dir))
            for f in uhs_files:
                self._test_exported_file(f)
        finally:
            shutil.rmtree(target_dir)
コード例 #26
0
ファイル: test.py プロジェクト: xpb/oq-engine
    def test(self):
        result_dir = tempfile.mkdtemp()
        aaae = numpy.testing.assert_array_almost_equal

        try:
            cfg = os.path.join(os.path.dirname(__file__), 'job.ini')
            expected_curve_poes_b1_b2 = [0.0055, 0.00042, 5.77E-5, 0.0]
            expected_curve_poes_b1_b3 = [0.00995, 0.00076, 9.7E-5, 0.0]
            expected_curve_poes_b1_b4 = [0.018, 0.0013, 0.00014, 0.0]

            expected_mean_poes = [0.01067, 0.0008, 9.774E-5, 0.0]

            expected_q0_1_poes = [0.0055, 0.00042, 5.77E-5, 0.0]
            expected_q0_9_poes = [0.013975, 0.00103, 0.0001185, 0.0]

            job = self.run_hazard(cfg)

            # Test the poe values for the two curves:
            curve_b1_b2, curve_b1_b3, curve_b1_b4 = \
                models.HazardCurveData.objects\
                    .filter(hazard_curve__output__oq_job=job.id,
                            hazard_curve__lt_realization__isnull=False)\
                    .order_by('hazard_curve__lt_realization__sm_lt_path')

            # Sanity check, to make sure we have the curves ordered correctly:
            self.assertEqual(
                ['b1', 'b2'],
                curve_b1_b2.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b1', 'b3'],
                curve_b1_b3.hazard_curve.lt_realization.sm_lt_path)
            self.assertEqual(
                ['b1', 'b4'],
                curve_b1_b4.hazard_curve.lt_realization.sm_lt_path)

            aaae(expected_curve_poes_b1_b2, curve_b1_b2.poes, decimal=4)
            aaae(expected_curve_poes_b1_b3, curve_b1_b3.poes, decimal=4)
            aaae(expected_curve_poes_b1_b4, curve_b1_b4.poes, decimal=4)

            # Test the mean curve:
            [mean_curve] = models.HazardCurveData.objects\
                .filter(hazard_curve__output__oq_job=job.id,
                        hazard_curve__statistics='mean')
            aaae(expected_mean_poes, mean_curve.poes, decimal=4)

            # Test the quantile curves:
            quantile_0_1_curve, quantile_0_9_curve = \
                models.HazardCurveData.objects\
                    .filter(hazard_curve__output__oq_job=job.id,
                            hazard_curve__statistics='quantile')\
                    .order_by('hazard_curve__quantile')
            aaae(expected_q0_1_poes, quantile_0_1_curve.poes, decimal=4)
            aaae(expected_q0_9_poes, quantile_0_9_curve.poes, decimal=4)

            # Test the exports as well:
            [exported_file_b1_b2] = hazard_export.export(
                curve_b1_b2.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B2),
                exported_file_b1_b2)

            [exported_file_b1_b3] = hazard_export.export(
                curve_b1_b3.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B3),
                exported_file_b1_b3)

            [exported_file_b1_b4] = hazard_export.export(
                curve_b1_b4.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_B1_B4),
                exported_file_b1_b4)

            [exported_file_mean] = hazard_export.export(
                mean_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_MEAN),
                exported_file_mean)

            [q01_file] = hazard_export.export(
                quantile_0_1_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_QUANTILE_0_1),
                q01_file)

            [q09_file] = hazard_export.export(
                quantile_0_9_curve.hazard_curve.output.id, result_dir)
            self.assert_xml_equal(
                StringIO.StringIO(self.EXPECTED_XML_QUANTILE_0_9),
                q09_file)
        finally:
            shutil.rmtree(result_dir)
コード例 #27
0
ファイル: hazard_test.py プロジェクト: xpb/oq-engine
    def test_export_for_event_based(self):
        # Run an event-based hazard calculation to compute SESs and GMFs
        # Call the exporters for both SES and GMF results  and verify that
        # files were created
        # Since the XML writers (in `openquake.nrmllib.writers`) are concerned
        # with correctly generating the XML, we don't test that here...
        # but we should still have an end-to-end QA test.
        target_dir = tempfile.mkdtemp()

        try:
            cfg = helpers.demo_file('event_based_hazard/job.ini')

            # run the calculation to create something to export
            retcode = helpers.run_hazard_job_sp(cfg, silence=True)
            self.assertEqual(0, retcode)

            job = models.OqJob.objects.latest('id')

            outputs = export_core.get_outputs(job.id)
            # 2 GMFs, 2 SESs, 1 complete logic tree SES, 1 complete LT GMF,
            # and 4 hazard curve collections
            self.assertEqual(18, len(outputs))

            #######
            # SESs:
            ses_outputs = outputs.filter(output_type='ses')
            self.assertEqual(2, len(ses_outputs))

            exported_files = []
            for ses_output in ses_outputs:
                files = hazard.export(ses_output.id, target_dir)
                exported_files.extend(files)

            self.assertEqual(2, len(exported_files))

            for f in exported_files:
                self._test_exported_file(f)

            ##################
            # Complete LT SES:
            [complete_lt_ses] = outputs.filter(output_type='complete_lt_ses')

            [exported_file] = hazard.export(complete_lt_ses.id, target_dir)

            self._test_exported_file(exported_file)

            #######
            # GMFs:
            gmf_outputs = outputs.filter(output_type='gmf')
            self.assertEqual(2, len(gmf_outputs))

            exported_files = []
            for gmf_output in gmf_outputs:
                files = hazard.export(gmf_output.id, target_dir)
                exported_files.extend(files)

            self.assertEqual(2, len(exported_files))
            # Check the file paths exist, are absolute, and the files aren't
            # empty.
            for f in exported_files:
                self._test_exported_file(f)

            ##################
            # Complete LT GMF:
            [complete_lt_gmf] = outputs.filter(output_type='complete_lt_gmf')

            [exported_file] = hazard.export(complete_lt_gmf.id, target_dir)

            self._test_exported_file(exported_file)

            # Check for the correct number of GMFs in the file:
            tree = etree.parse(exported_file)
            self.assertEqual(442, number_of('nrml:gmf', tree))

            ################
            # Hazard curves:
            haz_curves = outputs.filter(output_type='hazard_curve')
            for curve in haz_curves:
                [exported_file] = hazard.export(curve.id, target_dir)
                self._test_exported_file(exported_file)

        finally:
            shutil.rmtree(target_dir)