Пример #1
0
    def test_events_shaking_a_site(self):
        # Parameters
        output_dir = self.dir
        site_tag = 'ernabella'
        site_lat = -31.5
        site_lon = 150.5
        period = 1.0
        soil_amp = False

        # 1. Create and save analysis objects objects
        self.save_analysis_objects(output_dir, site_tag)

        # 2. Run through events_shaking_a_site
        events_filename = events_shaking_a_site(output_dir, site_tag, site_lat,
                                                site_lon, period, soil_amp)

        # 3. Read in generated CSV to a dict
        events_attributes = {
            'ground_motion': float,
            'ground_motion_model': str,
            'trace_start_lat': float,
            'trace_start_lon': float,
            'trace_end_lat': float,
            'trace_end_lon': float,
            'rupture_centroid_lat': float,
            'rupture_centroid_lon': float,
            'depth': float,
            'azimuth': float,
            'dip': float,
            'Mw': float,
            'length': float,
            'width': float,
            'activity': float,
            'Rjb': float,
            'Rrup': float,
            'site_lat': float,
            'site_lon': float
        }
        events_arrays = csv_to_arrays(events_filename, **events_attributes)

        # 4. Expected results
        expected_ground_motion = asarray([1, 4, 7, 10, 13])  # period == 1.0
        expected_ground_motion_model = asarray([
            'Allen', 'Toro_1997_midcontinent', 'Sadigh_97',
            'Youngs_97_interface', 'Youngs_97_intraslab'
        ])

        # Manually calculated
        expected_trace_start_lat = -29.98204065 * ones(5)
        expected_trace_start_lon = 149.25728051 * ones(5)
        expected_trace_end_lat = -29.97304727 * ones(5)
        expected_trace_end_lon = 149.25764315 * ones(5)

        # Input values
        expected_rupture_centroid_lat = -30 * ones(5)
        expected_rupture_centroid_lon = 150 * ones(5)
        expected_length = 1.0 * ones(5)
        expected_azimuth = 2.0 * ones(5)
        expected_width = 3.0 * ones(5)
        expected_dip = 4.0 * ones(5)
        expected_depth = 5.0 * ones(5)
        expected_Mw = 6.0 * ones(5)

        # Same as atten_model_weights
        expected_activity = 0.2 * ones(5)

        # Manually calculated
        expected_Rjb = 110.59526125 * ones(5)

        # wrong value
        #expected_Rrup = 131.86940242*ones(5)

        # Different to input site lat/lon
        expected_site_lat = -31 * ones(5)
        expected_site_lon = 150 * ones(5)

        # 5. Compare results
        self.assert_(
            allclose(expected_ground_motion, events_arrays['ground_motion']))

        self.assert_(
            string_array_equal(expected_ground_motion_model,
                               events_arrays['ground_motion_model']))

        self.assert_(
            allclose(expected_trace_start_lat,
                     events_arrays['trace_start_lat']))

        self.assert_(
            allclose(expected_trace_start_lon,
                     events_arrays['trace_start_lon']))

        self.assert_(
            allclose(expected_trace_end_lat, events_arrays['trace_end_lat']))

        self.assert_(
            allclose(expected_trace_end_lon, events_arrays['trace_end_lon']))

        self.assert_(
            allclose(expected_rupture_centroid_lat,
                     events_arrays['rupture_centroid_lat']))

        self.assert_(
            allclose(expected_rupture_centroid_lon,
                     events_arrays['rupture_centroid_lon']))

        self.assert_(allclose(expected_length, events_arrays['length']))

        self.assert_(allclose(expected_azimuth, events_arrays['azimuth']))

        self.assert_(allclose(expected_width, events_arrays['width']))

        self.assert_(allclose(expected_dip, events_arrays['dip']))

        self.assert_(allclose(expected_depth, events_arrays['depth']))

        self.assert_(allclose(expected_Mw, events_arrays['Mw']))

        self.assert_(allclose(expected_Rjb, events_arrays['Rjb']))

        #self.assert_(allclose(expected_Rrup,
        #                      events_arrays['Rrup']))

        self.assert_(allclose(expected_activity, events_arrays['activity']))

        self.assert_(allclose(expected_site_lat, events_arrays['site_lat']))

        self.assert_(allclose(expected_site_lon, events_arrays['site_lon']))
Пример #2
0
    def test_getitem(self):

        # Take a slice
        sites_test = self.mmi.sites[1]

        # Check length
        expected_length = 1
        self.assertEqual(len(sites_test), expected_length,
                         self.msg % (expected_length, len(sites_test)))

        # Check lat/lon
        # LATITUDE
        expected_latitude = [-6.4125]
        self.assertTrue(allclose(sites_test.latitude, expected_latitude),
                        self.msg % (expected_latitude, sites_test.latitude))

        # LONGITUDE
        expected_longitude = [110.845833]
        self.assertTrue(allclose(sites_test.longitude, expected_longitude),
                        self.msg % (expected_longitude, sites_test.longitude))

        # Check attributes
        attributes = sites_test.attributes

        # BID
        expected_bid = [3]
        self.assertTrue(allclose(attributes['BID'], expected_bid),
                        self.msg % (expected_bid, attributes['BID']))

        # STRUCTURE_CLASSIFICATION
        expected_struct_class = ['W1BVMETAL']
        self.assertTrue(
            string_array_equal(attributes['STRUCTURE_CLASSIFICATION'],
                               expected_struct_class), self.msg %
            (expected_struct_class, attributes['STRUCTURE_CLASSIFICATION']))

        # BUILDING_COST_DENSITY
        expected_bcd = [861.1128]
        self.assertTrue(
            allclose(attributes['BUILDING_COST_DENSITY'], expected_bcd),
            self.msg % (expected_bcd, attributes['BUILDING_COST_DENSITY']))

        # FLOOR_AREA
        expected_fa = [480]
        self.assertTrue(allclose(attributes['FLOOR_AREA'], expected_fa),
                        self.msg % (expected_fa, attributes['FLOOR_AREA']))

        # SURVEY_FACTOR
        expected_sf = [1]
        self.assertTrue(allclose(attributes['SURVEY_FACTOR'], expected_sf),
                        self.msg % (expected_sf, attributes['SURVEY_FACTOR']))

        # SITE_CLASS
        expected_site_class = ['C']
        self.assertTrue(
            string_array_equal(attributes['SITE_CLASS'], expected_site_class),
            self.msg % (expected_site_class, attributes['SITE_CLASS']))
        # POSTCODE
        expected_postcode = [2612]
        self.assertTrue(allclose(attributes['POSTCODE'], expected_postcode),
                        self.msg % (expected_postcode, attributes['POSTCODE']))

        # SUBURB
        expected_suburb = ['TURNER']
        self.assertTrue(
            string_array_equal(attributes['SUBURB'], expected_suburb),
            self.msg % (expected_suburb, attributes['SUBURB']))
Пример #3
0
    def test_from_csv(self):

        # Check length
        expected_length = 5
        self.assertEqual(len(self.mmi.sites), expected_length,
                         self.msg % (expected_length, len(self.mmi.sites)))

        # Check lat/lon
        # LATITUDE
        expected_latitude = [-6.4125, -6.4125, -6.4125, -6.4125, -6.4125]
        self.assertTrue(
            allclose(self.mmi.sites.latitude, expected_latitude),
            self.msg % (expected_latitude, self.mmi.sites.latitude))

        # LONGITUDE
        expected_longitude = [
            110.837502, 110.845833, 110.854164, 110.845833, 110.854164
        ]
        self.assertTrue(
            allclose(self.mmi.sites.longitude, expected_longitude),
            self.msg % (expected_longitude, self.mmi.sites.longitude))

        # Check attributes
        attributes = self.mmi.sites.attributes

        # BID
        expected_bid = [2, 3, 4, 5, 6]
        self.assertTrue(allclose(attributes['BID'], expected_bid),
                        self.msg % (expected_bid, attributes['BID']))

        # STRUCTURE_CLASSIFICATION
        expected_struct_class = [
            'W1TIMBERMETAL', 'W1BVMETAL', 'W1TIMBERMETAL', 'W1BVMETAL',
            'W1TIMBERMETAL'
        ]
        self.assertTrue(
            string_array_equal(attributes['STRUCTURE_CLASSIFICATION'],
                               expected_struct_class), self.msg %
            (expected_struct_class, attributes['STRUCTURE_CLASSIFICATION']))

        # BUILDING_COST_DENSITY
        expected_bcd = [688.8903, 861.1128, 1087.155, 861.1128, 1087.155]
        self.assertTrue(
            allclose(attributes['BUILDING_COST_DENSITY'], expected_bcd),
            self.msg % (expected_bcd, attributes['BUILDING_COST_DENSITY']))

        # FLOOR_AREA
        expected_fa = [150, 480, 300, 480, 300]
        self.assertTrue(allclose(attributes['FLOOR_AREA'], expected_fa),
                        self.msg % (expected_fa, attributes['FLOOR_AREA']))

        # SURVEY_FACTOR
        expected_sf = [9.8, 1, 1, 1, 1]
        self.assertTrue(allclose(attributes['SURVEY_FACTOR'], expected_sf),
                        self.msg % (expected_sf, attributes['SURVEY_FACTOR']))

        # SITE_CLASS
        expected_site_class = ['C', 'C', 'C', 'C', 'C']
        self.assertTrue(
            string_array_equal(attributes['SITE_CLASS'], expected_site_class),
            self.msg % (expected_site_class, attributes['SITE_CLASS']))

        # POSTCODE
        expected_postcode = [2612, 2612, 2612, 2612, 2612]
        self.assertTrue(allclose(attributes['POSTCODE'], expected_postcode),
                        self.msg % (expected_postcode, attributes['POSTCODE']))

        # SUBURB
        expected_suburb = ['TURNER', 'TURNER', 'TURNER', 'TURNER', 'TURNER']
        self.assertTrue(
            string_array_equal(attributes['SUBURB'], expected_suburb),
            self.msg % (expected_suburb, attributes['SUBURB']))
Пример #4
0
    def test_events_shaking_a_site(self):
        # Parameters
        output_dir = self.dir
        site_tag = 'ernabella'
        site_lat = -31.5
        site_lon = 150.5
        period = 1.0
        soil_amp = False
        
        # 1. Create and save analysis objects objects
        self.save_analysis_objects(output_dir, site_tag)
        
        # 2. Run through events_shaking_a_site
        events_filename = events_shaking_a_site(output_dir,
                                                site_tag,
                                                site_lat,
                                                site_lon,
                                                period,
                                                soil_amp)
        
        # 3. Read in generated CSV to a dict
        events_attributes = {'ground_motion': float,
                             'ground_motion_model': str,
                             'trace_start_lat': float,
                             'trace_start_lon': float,
                             'trace_end_lat': float,
                             'trace_end_lon': float,
                             'rupture_centroid_lat': float,
                             'rupture_centroid_lon': float,
                             'depth': float,
                             'azimuth': float,
                             'dip': float,
                             'Mw': float,
                             'length': float,
                             'width': float,
                             'activity': float,
                             'Rjb': float,
                             'Rrup': float,
                             'site_lat': float,
                             'site_lon': float}
        events_arrays = csv_to_arrays(events_filename, **events_attributes)
        
        # 4. Expected results
        expected_ground_motion = asarray([1, 4, 7, 10, 13]) # period == 1.0
        expected_ground_motion_model = asarray(['Allen', 
                                                'Toro_1997_midcontinent', 
                                                'Sadigh_97', 
                                                'Youngs_97_interface', 
                                                'Youngs_97_intraslab'])
        
        # Manually calculated
        expected_trace_start_lat = -29.98204065*ones(5)
        expected_trace_start_lon = 149.25728051*ones(5)
        expected_trace_end_lat = -29.97304727*ones(5)
        expected_trace_end_lon = 149.25764315*ones(5)
        
        # Input values
        expected_rupture_centroid_lat = -30*ones(5)
        expected_rupture_centroid_lon = 150*ones(5)
        expected_length = 1.0*ones(5)
        expected_azimuth = 2.0*ones(5)
        expected_width = 3.0*ones(5)
        expected_dip = 4.0*ones(5)
        expected_depth = 5.0*ones(5)
        expected_Mw = 6.0*ones(5)
        
        # Same as atten_model_weights
        expected_activity = 0.2*ones(5) 
        
        # Manually calculated
        expected_Rjb = 110.59526125*ones(5)

        # wrong value
        #expected_Rrup = 131.86940242*ones(5)
        
        # Different to input site lat/lon
        expected_site_lat = -31*ones(5) 
        expected_site_lon = 150*ones(5)
        
        # 5. Compare results
        self.assert_(allclose(expected_ground_motion, 
                              events_arrays['ground_motion']))
        
        self.assert_(string_array_equal(expected_ground_motion_model,
                                        events_arrays['ground_motion_model']))
        
        self.assert_(allclose(expected_trace_start_lat, 
                              events_arrays['trace_start_lat']))
        
        self.assert_(allclose(expected_trace_start_lon, 
                              events_arrays['trace_start_lon']))
        
        self.assert_(allclose(expected_trace_end_lat, 
                              events_arrays['trace_end_lat']))
        
        self.assert_(allclose(expected_trace_end_lon, 
                              events_arrays['trace_end_lon']))
        
        self.assert_(allclose(expected_rupture_centroid_lat, 
                              events_arrays['rupture_centroid_lat']))
        
        self.assert_(allclose(expected_rupture_centroid_lon, 
                              events_arrays['rupture_centroid_lon']))
        
        self.assert_(allclose(expected_length, 
                              events_arrays['length']))
        
        self.assert_(allclose(expected_azimuth, 
                              events_arrays['azimuth']))
        
        self.assert_(allclose(expected_width, 
                              events_arrays['width']))
        
        self.assert_(allclose(expected_dip, 
                              events_arrays['dip']))
        
        self.assert_(allclose(expected_depth, 
                              events_arrays['depth']))
        
        self.assert_(allclose(expected_Mw, 
                              events_arrays['Mw']))
        
        self.assert_(allclose(expected_Rjb, 
                              events_arrays['Rjb']))
        
        #self.assert_(allclose(expected_Rrup,
        #                      events_arrays['Rrup']))
        
        self.assert_(allclose(expected_activity, 
                              events_arrays['activity']))
        
        self.assert_(allclose(expected_site_lat, 
                              events_arrays['site_lat']))
        
        self.assert_(allclose(expected_site_lon, 
                              events_arrays['site_lon']))
Пример #5
0
 def test_getitem(self):
     
     # Take a slice
     sites_test = self.mmi.sites[1]
     
     # Check length
     expected_length = 1
     self.assertEqual(len(sites_test), expected_length,
                      self.msg % (expected_length, len(sites_test)))
     
     # Check lat/lon
     # LATITUDE
     expected_latitude = [-6.4125]
     self.assertTrue(allclose(sites_test.latitude, expected_latitude),
                     self.msg % (expected_latitude, sites_test.latitude))
     
     # LONGITUDE
     expected_longitude = [110.845833]
     self.assertTrue(allclose(sites_test.longitude, expected_longitude),
                     self.msg % (expected_longitude, sites_test.longitude))
     
     # Check attributes
     attributes = sites_test.attributes
     
     # BID
     expected_bid = [3]
     self.assertTrue(allclose(attributes['BID'], expected_bid),
                     self.msg % (expected_bid, attributes['BID']))
     
     # STRUCTURE_CLASSIFICATION
     expected_struct_class = ['W1BVMETAL']
     self.assertTrue(string_array_equal(attributes['STRUCTURE_CLASSIFICATION'], 
                                        expected_struct_class),
                     self.msg % (expected_struct_class, 
                                 attributes['STRUCTURE_CLASSIFICATION']))
     
     # BUILDING_COST_DENSITY
     expected_bcd = [861.1128]
     self.assertTrue(allclose(attributes['BUILDING_COST_DENSITY'], 
                              expected_bcd),
                     self.msg % (expected_bcd, 
                                 attributes['BUILDING_COST_DENSITY']))
     
     # FLOOR_AREA
     expected_fa = [480]
     self.assertTrue(allclose(attributes['FLOOR_AREA'], expected_fa),
                     self.msg % (expected_fa, attributes['FLOOR_AREA']))
     
     # SURVEY_FACTOR
     expected_sf = [1]
     self.assertTrue(allclose(attributes['SURVEY_FACTOR'], expected_sf),
                     self.msg % (expected_sf, attributes['SURVEY_FACTOR']))
     
     # SITE_CLASS
     expected_site_class = ['C']
     self.assertTrue(string_array_equal(attributes['SITE_CLASS'], 
                                        expected_site_class),
                     self.msg % (expected_site_class, 
                                 attributes['SITE_CLASS']))
     # POSTCODE
     expected_postcode = [2612]
     self.assertTrue(allclose(attributes['POSTCODE'], expected_postcode),
                     self.msg % (expected_postcode, attributes['POSTCODE']))
     
     # SUBURB
     expected_suburb = ['TURNER']
     self.assertTrue(string_array_equal(attributes['SUBURB'], 
                                        expected_suburb),
                     self.msg % (expected_suburb, attributes['SUBURB']))
Пример #6
0
 def test_from_csv(self):
     
     # Check length
     expected_length = 5
     self.assertEqual(len(self.mmi.sites), expected_length,
                      self.msg % (expected_length, len(self.mmi.sites)))
     
     # Check lat/lon
     # LATITUDE
     expected_latitude = [-6.4125, -6.4125, -6.4125, -6.4125, -6.4125]
     self.assertTrue(allclose(self.mmi.sites.latitude, expected_latitude),
                     self.msg % (expected_latitude, self.mmi.sites.latitude))
     
     # LONGITUDE
     expected_longitude = [110.837502, 110.845833, 110.854164, 110.845833, 110.854164]
     self.assertTrue(allclose(self.mmi.sites.longitude, expected_longitude),
                     self.msg % (expected_longitude, self.mmi.sites.longitude))
     
     # Check attributes
     attributes = self.mmi.sites.attributes
     
     # BID
     expected_bid = [2,3,4,5,6]
     self.assertTrue(allclose(attributes['BID'], expected_bid),
                     self.msg % (expected_bid, attributes['BID']))
     
     # STRUCTURE_CLASSIFICATION
     expected_struct_class = ['W1TIMBERMETAL', 'W1BVMETAL', 'W1TIMBERMETAL', 'W1BVMETAL', 'W1TIMBERMETAL']
     self.assertTrue(string_array_equal(attributes['STRUCTURE_CLASSIFICATION'], 
                                        expected_struct_class),
                     self.msg % (expected_struct_class, 
                                 attributes['STRUCTURE_CLASSIFICATION']))
     
     # BUILDING_COST_DENSITY
     expected_bcd = [688.8903, 861.1128, 1087.155, 861.1128, 1087.155]
     self.assertTrue(allclose(attributes['BUILDING_COST_DENSITY'], 
                              expected_bcd),
                     self.msg % (expected_bcd, 
                                 attributes['BUILDING_COST_DENSITY']))
     
     # FLOOR_AREA
     expected_fa = [150, 480, 300, 480, 300]
     self.assertTrue(allclose(attributes['FLOOR_AREA'], expected_fa),
                     self.msg % (expected_fa, attributes['FLOOR_AREA']))
     
     # SURVEY_FACTOR
     expected_sf = [9.8, 1, 1, 1, 1]
     self.assertTrue(allclose(attributes['SURVEY_FACTOR'], expected_sf),
                     self.msg % (expected_sf, attributes['SURVEY_FACTOR']))
     
     # SITE_CLASS
     expected_site_class = ['C', 'C', 'C', 'C', 'C']
     self.assertTrue(string_array_equal(attributes['SITE_CLASS'], 
                                        expected_site_class),
                     self.msg % (expected_site_class, 
                                 attributes['SITE_CLASS']))
     
     # POSTCODE
     expected_postcode = [2612, 2612, 2612, 2612, 2612]
     self.assertTrue(allclose(attributes['POSTCODE'], expected_postcode),
                     self.msg % (expected_postcode, attributes['POSTCODE']))
     
     # SUBURB
     expected_suburb = ['TURNER', 'TURNER', 'TURNER', 'TURNER', 'TURNER']
     self.assertTrue(string_array_equal(attributes['SUBURB'], 
                                        expected_suburb),
                     self.msg % (expected_suburb, attributes['SUBURB']))