def from_csv(cls, file): """Construct Bridges instance from csv file. file open file handle for site data attribute_conversions dictionary defining required data from file and format of the data use: X = Bridges.from_csv('blg_wr.csv', PEOPLE=float, WALLS=str, ROOF_TYPE=str) or: d = {'PEOPLE': float, 'WALLS': str, 'ROOF_TYPE': str} X = Bridges.from_csv('blg_wr.csv', **d) """ # read in data from file bridges_dict = csv_to_arrays(file, **attribute_conversions) # remove lat&lon from attributes dictionary latitude = bridges_dict.pop("LATITUDE") longitude = bridges_dict.pop("LONGITUDE") # copy remaining attributes - don't need user changes reflected attributes = copy.copy(bridges_dict) # call class constructor return cls(latitude, longitude, **attributes)
def from_csv(cls, file, **attribute_conversions): """Construct Site instance from csv file. file open file handle for site data attribute_conversions dictionary defining required data from file and format of the data use: X = Sites.from_csv('blg_wr.csv', PEOPLE=float, WALLS=str, ROOF_TYPE=str) or: d = {'PEOPLE': float, 'WALLS': str, 'ROOF_TYPE': str} X = Sites.from_csv('blg_wr.csv', **d) """ # force lat & lon - required attributes attribute_conversions["LATITUDE"] = float attribute_conversions["LONGITUDE"] = float # remove VS30 if exists - we'll deal with this later if attribute_conversions.get('VS30') is not None: attribute_conversions.pop('VS30') # read in data from file sites_dict = csv_to_arrays(file, **attribute_conversions) # remove lat&lon from attributes dictionary latitude = sites_dict.pop("LATITUDE") longitude = sites_dict.pop("LONGITUDE") # copy remaining attributes - don't need user changes reflected attributes = copy.copy(sites_dict) # now lets do VS30 try: attribute_conversions['VS30'] = float sites_dict = csv_to_arrays(file, **attribute_conversions) attributes['Vs30'] = sites_dict['VS30'] except: # If not present in the file, analysis will add the mapping based # on site class pass # call class constructor return cls(latitude, longitude, **attributes)
def calc_loss_deagg_suburb(bval_path_file, total_building_loss_path_file, site_db_path_file, file_out): """ Given EQRM ouput data, produce a csv file showing loss per suburb The produced csv file shows total building loss, total building value and loss as a percentage. All of this is shown per suburb. bval_path_file - location and name of building value file produced by EQRM total_building_loss_path_file - location and name of the total building loss file site_db_path_file - location and name of the site database file Note: This can be generalised pretty easily, to get results deaggregated on other columns of the site_db """ aggregate_on = ["SUBURB"] # Load all of the files. site = csv_to_arrays(site_db_path_file, **attribute_conversions) # print "site", site bvals = loadtxt(bval_path_file, dtype=scipy.float64, delimiter=",", skiprows=0) # print "bvals", bvals # print "len(bvals", len(bvals) total_building_loss = loadtxt(total_building_loss_path_file, dtype=scipy.float64, delimiter=" ", skiprows=1) # print "total_building_loss", total_building_loss # print "total_building_loss shape", total_building_loss.shape site_count = len(site["BID"]) assert site_count == len(bvals) assert site_count == total_building_loss.shape[1] # For aggregates # key is the unique AGGREGATE_ON combination .eg ('Hughes', 2605,...) # Values are a list of indices where the combinations are repeated in site aggregates = {} for i in range(site_count): assert site["BID"][i] == int(total_building_loss[0, i]) marker = [] for name in aggregate_on: marker.append(site[name][i]) marker = tuple(marker) aggregates.setdefault(marker, []).append(i) # print "aggregates", aggregates handle = csv.writer(open(file_out, "w"), lineterminator="\n") handle.writerow(["percent losses (building and content) by suburb"]) handle.writerow(["suburb", "loss", "value", "percent loss"]) handle.writerow(["", " ($ millions)", " ($ millions)", ""]) keys = aggregates.keys() keys.sort() for key in keys: sum_loss = 0 sum_bval = 0 for row in aggregates[key]: sum_loss += total_building_loss[1][row] sum_bval += bvals[row] handle.writerow([key[0], sum_loss / 1000000.0, sum_bval / 1000000.0, sum_loss / sum_bval * 100.0])
def write_aggregate_read_csv(attribute_dic=None, buildings_usage_classification="HAZUS"): handle, file_name = tempfile.mkstemp(".csv", "test_aggregate_csv_") os.close(handle) file_name, attribute_dic = write_test_file(file_name, attribute_dic) attribute_conversions_extended = copy.deepcopy(attribute_conversions) attribute_conversions_extended["UFI"] = int file_out = file_name + "out" aggregate_building_db(file_name, file_out) site = csv_to_arrays(file_out, **attribute_conversions_extended) os.remove(file_name) os.remove(file_out) return attribute_dic, site
def test_csv_to_arrays(self): (handle, file_name) = tempfile.mkstemp('.csv', 'test_csv_interface_') os.close(handle) f = open(file_name, "wb") f.write('\n'.join(self.dummy_f)) f.close() lon = csvi.csv_to_arrays(file_name, LONGITUDE=float) assert lon.keys()[0] == 'LONGITUDE' assert len(lon.keys()) == 1 assert scipy.alltrue(self.LONGITUDE == lon['LONGITUDE']) all_conversions = {'LONGITUDE': float, 'LATITUDE': float, 'WALLS': str} all = csvi.csv_to_arrays(file_name, **all_conversions) assert len(all.keys()) == 3 assert scipy.alltrue(self.LATITUDE == all['LATITUDE']) assert scipy.alltrue(self.LONGITUDE == all['LONGITUDE']) assert scipy.alltrue(self.WALLS == all['WALLS']) os.remove(file_name)
def write_aggregate_read_csv(attribute_dic=None, buildings_usage_classification='HAZUS'): handle, file_name = tempfile.mkstemp('.csv', 'test_aggregate_csv_') os.close(handle) file_name, attribute_dic = write_test_file(file_name, attribute_dic) attribute_conversions_extended = copy.deepcopy(attribute_conversions) attribute_conversions_extended['UFI'] = int file_out = file_name + "out" aggregate_building_db(file_name, file_out) site = csv_to_arrays(file_out, **attribute_conversions_extended) os.remove(file_name) os.remove(file_out) return attribute_dic, site
def test_csv_to_arrays(self): (handle, file_name) = tempfile.mkstemp('.csv', 'test_csv_interface_') os.close(handle) f = open(file_name,"wb") f.write('\n'.join(self.dummy_f)) f.close() lon = csvi.csv_to_arrays(file_name, LONGITUDE=float) assert lon.keys()[0] == 'LONGITUDE' assert len(lon.keys()) == 1 assert scipy.alltrue(self.LONGITUDE == lon['LONGITUDE']) all_conversions = {'LONGITUDE': float, 'LATITUDE': float, 'WALLS': str} all = csvi.csv_to_arrays(file_name, **all_conversions) assert len(all.keys()) == 3 assert scipy.alltrue(self.LATITUDE == all['LATITUDE']) assert scipy.alltrue(self.LONGITUDE == all['LONGITUDE']) assert scipy.alltrue(self.WALLS == all['WALLS']) os.remove(file_name)
def from_csv(cls, sites_filename, eqrm_flags): """Read structures data from a file. Extract structure parameters from building_parameters_table. parameters sites_filename is actually a file handle """ sites_dict = csv_to_arrays(sites_filename, **attribute_conversions) latitude = sites_dict.pop("LATITUDE") longitude = sites_dict.pop("LONGITUDE") # create copy of attributes attributes = copy.copy(sites_dict) # Create the vulnerability curves vulnerability_set = Vulnerability_Set.from_xml(eqrm_flags) # create structures: return cls(latitude, longitude, vulnerability_set, **attributes)
def get_lat_long_eloss(structure_dir_file, output_dir, total_buildinging_loss_file, out_file): """ From the EQRM input dir load a structure csv, to get the lats and longs. From the EQRM output dir load the _total_buildinging_loss.txt file to get the building loss. File format: First row comments , 2nd building id subsequent rows are events. This will just take the first event. """ total_building_loss = loadtxt(path.join(output_dir, total_buildinging_loss_file), dtype=scipy.float64, delimiter=' ', skiprows=1) print "total_building_loss shape", total_building_loss.shape # BID is int(total_building_loss[0,i] # eloss is int(total_building_loss[1,i] sites_dict = csv_to_arrays(structure_dir_file, **attribute_conversions) print "len(sites_dict['BID'])", len(sites_dict['BID']) out_h = open(path.join(output_dir, out_file), 'w') for i in range(len(sites_dict['BID'])): if not sites_dict['BID'][i] == total_building_loss[0, i]: print "Don't match ", i import sys sys.exit() else: line_list = [ str(sites_dict['LATITUDE'][i]), str(sites_dict['LONGITUDE'][i]), str(total_building_loss[1, i]) ] line = ','.join(line_list) + '\n' out_h.write(line) out_h.close()
def calc_loss_deagg_suburb(bval_path_file, total_building_loss_path_file, site_db_path_file, file_out): """ Given EQRM ouput data, produce a csv file showing loss per suburb The produced csv file shows total building loss, total building value and loss as a percentage. All of this is shown per suburb. bval_path_file - location and name of building value file produced by EQRM total_building_loss_path_file - location and name of the total building loss file site_db_path_file - location and name of the site database file Note: This can be generalised pretty easily, to get results deaggregated on other columns of the site_db """ aggregate_on = ['SUBURB'] # Load all of the files. site = csv_to_arrays(site_db_path_file, **attribute_conversions) # print "site", site bvals = loadtxt(bval_path_file, dtype=scipy.float64, delimiter=',', skiprows=0) # print "bvals", bvals # print "len(bvals", len(bvals) total_building_loss = loadtxt(total_building_loss_path_file, dtype=scipy.float64, delimiter=' ', skiprows=1) # print "total_building_loss", total_building_loss # print "total_building_loss shape", total_building_loss.shape site_count = len(site['BID']) assert site_count == len(bvals) assert site_count == total_building_loss.shape[1] # For aggregates # key is the unique AGGREGATE_ON combination .eg ('Hughes', 2605,...) # Values are a list of indices where the combinations are repeated in site aggregates = {} for i in range(site_count): assert site['BID'][i] == int(total_building_loss[0, i]) marker = [] for name in aggregate_on: marker.append(site[name][i]) marker = tuple(marker) aggregates.setdefault(marker, []).append(i) # print "aggregates", aggregates handle = csv.writer(open(file_out, 'w'), lineterminator='\n') handle.writerow(['percent losses (building and content) by suburb']) handle.writerow(['suburb', 'loss', 'value', 'percent loss']) handle.writerow(['', ' ($ millions)', ' ($ millions)', '']) keys = aggregates.keys() keys.sort() for key in keys: sum_loss = 0 sum_bval = 0 for row in aggregates[key]: sum_loss += total_building_loss[1][row] sum_bval += bvals[row] handle.writerow([key[0], sum_loss / 1000000., sum_bval / 1000000., sum_loss / sum_bval * 100.])
def aggregate_building_db(sites_filename_in, sites_filename_out=None): """ Aggregate building data base data. All structures with the same 'POSTCODE', 'SITE_CLASS', 'STRUCTURE_CLASSIFICATION', 'FCB_USAGE', 'PRE1989', 'STRUCTURE_CATEGORY', 'HAZUS_USAGE', 'SUBURB', 'HAZUS_STRUCTURE_CLASSIFICATION' Are aggregated as one structure. These attributes are averaged; 'FLOOR_AREA', 'LATITUDE', 'LONGITUDE', 'CONTENTS_COST_DENSITY', 'BUILDING_COST_DENSITY' #FIXME DSG Add a column that gives the BID's (building ID) from the unaggredated data for each structure """ if sites_filename_out is None: sites_filename_out = sites_filename_in # if aggregate_on is None: aggregate_on = AGGREGATE_ON # if average_on is None: average_on = AVERAGE_ON survey_factor = 'SURVEY_FACTOR' ufi_name = 'BID' site = csv_to_arrays(sites_filename_in, **attribute_conversions) writer = Building_db_writer(sites_filename_out) writer.write_header() # For aggregates # key is the unique AGGREGATE_ON combination .eg ('Hughes', 2605,...) # Values are a list of indices where the combinations are repeated in site aggregates = {} for i in range(len(site['BID'])): # print "site['BID'][i]",site['BID'][i] marker = [] for name in aggregate_on: marker.append(site[name][i]) marker = tuple(marker) aggregates.setdefault(marker, []).append(i) for agg, agg_indexes in aggregates.iteritems(): # An agg_indexes is a collection of rows, specified by index, # to be aggregated row_sum = zeros(len(average_on), dtype=float) survey_factor_sum = 0.0 UFI = site[ufi_name][agg_indexes[0]] for row in agg_indexes: survey_factor_sum += site[survey_factor][row] for i, name in enumerate(average_on): row_sum[i] += site[name][row] * site[survey_factor][row] row_aggrigate = row_sum / survey_factor_sum writer.write_row(agg, row_aggrigate, survey_factor_sum, UFI)
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']))
def from_csv(cls, sites_filename, building_classification_tag, damage_extent_tag, default_input_dir, input_dir=None, eqrm_dir=None, buildings_usage_classification='HAZUS', use_refined_btypes=True, force_btype_flag=False, determ_btype=None, determ_buse=None, loss_aus_contents=0): """Read structures data from a file. Extract strucuture parameters from building_parameters_table. parameters sites_filename is actually a file handle - some parameters depend on structure classification (hazus or refined hazus, depending on use_refined_btypes) - some parameters depend on usage (fcb or hazus, depending on use_fcb_usage) - force_btype_flag will force all buildings to be of type determ_btype, and usage determ_buse. See page 11 of the tech manual to understand the flags refined_btypes = Edwards building classification """ if eqrm_dir is None: eqrm_dir = determine_eqrm_path(__file__) if force_btype_flag: raise NotImplementedError sites_dict = csv_to_arrays(sites_filename, **attribute_conversions) latitude = sites_dict.pop("LATITUDE") longitude = sites_dict.pop("LONGITUDE") # create copy of attributes attributes = copy.copy(sites_dict) # Do we use refined_btypes or hazus btypes? if not use_refined_btypes: attributes['STRUCTURE_CLASSIFICATION'] = \ attributes['HAZUS_STRUCTURE_CLASSIFICATION'] # building_parameters_table has alot of info read in from # varrious files in resources data. # it is a dic, when the key signifies what the info is about, eg # height, ductility. The index of the data represents the structure # classification, which is stored in # building_parameters_table['structure_classification'] building_parameters_table = \ building_params_from_csv(building_classification_tag, damage_extent_tag, default_input_dir=default_input_dir, input_dir=input_dir) # get index that maps attributes -> # building_parameters_table (joined by 'structure_classification') structure_classification = attributes['STRUCTURE_CLASSIFICATION'] building_parameter_index = \ get_index( building_parameters_table['structure_classification'], structure_classification) # Now extract building_parameters from the table, # using building_parameter_index building_parameters = {} for key in building_parameters_table.keys(): building_parameters[key] = \ building_parameters_table[key][building_parameter_index] # Get non-structural drift thesholds (depending on whether or not # they are residential) # extract usage dependent parameters if buildings_usage_classification is 'HAZUS': usages = attributes['HAZUS_USAGE'] is_residential = (array([(usage[0:4] in ['RES1', 'RES2', 'RES3']) for usage in usages])) elif buildings_usage_classification is 'FCB': usages = attributes['FCB_USAGE'] is_residential = ((usages <= 113) + (usages == 131)) else: msg = ('b_usage_type_flat = ' + str(buildings_usage_classification) + " not 'FCB' or 'HAZUS'") raise ValueError(msg) is_residential.shape = (-1, 1) # reshape so it can be broadcast nr = building_parameters['non_residential_drift_threshold'] r = building_parameters['residential_drift_threshold'] drift_threshold = r * is_residential + nr * (1 - is_residential) building_parameters['drift_threshold'] = drift_threshold is_residential.shape = (-1,) if loss_aus_contents == 1: attributes['CONTENTS_COST_DENSITY'] *= \ (is_residential * 0.6 + (is_residential - 1) * 1.0) # reduce contents rcp = build_replacement_ratios(usages, buildings_usage_classification) building_parameters['structure_ratio'] = rcp['structural'] building_parameters['nsd_d_ratio'] = \ rcp['nonstructural drift sensitive'] building_parameters['nsd_a_ratio'] = \ rcp['nonstructural acceleration sensitive'] # create structures: return cls(latitude, longitude, building_parameters, **attributes)
def from_csv(cls, sites_filename, building_classification_tag, damage_extent_tag, default_input_dir, input_dir=None, eqrm_dir=None, buildings_usage_classification='HAZUS', use_refined_btypes=True, force_btype_flag=False, determ_btype=None, determ_buse=None, loss_aus_contents=0): """Read structures data from a file. Extract strucuture parameters from building_parameters_table. parameters sites_filename is actually a file handle - some parameters depend on structure classification (hazus or refined hazus, depending on use_refined_btypes) - some parameters depend on usage (fcb or hazus, depending on use_fcb_usage) - force_btype_flag will force all buildings to be of type determ_btype, and usage determ_buse. See page 11 of the tech manual to understand the flags refined_btypes = Edwards building classification """ if eqrm_dir is None: eqrm_dir = determine_eqrm_path(__file__) if force_btype_flag: raise NotImplementedError sites_dict = csv_to_arrays(sites_filename, **attribute_conversions) latitude = sites_dict.pop("LATITUDE") longitude = sites_dict.pop("LONGITUDE") # create copy of attributes attributes = copy.copy(sites_dict) # Do we use refined_btypes or hazus btypes? if not use_refined_btypes: attributes['STRUCTURE_CLASSIFICATION'] = \ attributes['HAZUS_STRUCTURE_CLASSIFICATION'] # building_parameters_table has alot of info read in from # varrious files in resources data. # it is a dic, when the key signifies what the info is about, eg # height, ductility. The index of the data represents the structure # classification, which is stored in # building_parameters_table['structure_classification'] building_parameters_table = \ building_params_from_csv(building_classification_tag, damage_extent_tag, default_input_dir=default_input_dir, input_dir=input_dir) # get index that maps attributes -> # building_parameters_table (joined by 'structure_classification') structure_classification = attributes['STRUCTURE_CLASSIFICATION'] building_parameter_index = \ get_index( building_parameters_table['structure_classification'], structure_classification) # Now extract building_parameters from the table, # using building_parameter_index building_parameters = {} for key in building_parameters_table.keys(): building_parameters[key] = \ building_parameters_table[key][building_parameter_index] # Get non-structural drift thesholds (depending on whether or not # they are residential) # extract usage dependent parameters if buildings_usage_classification is 'HAZUS': usages = attributes['HAZUS_USAGE'] is_residential = (array([(usage[0:4] in ['RES1', 'RES2', 'RES3']) for usage in usages])) elif buildings_usage_classification is 'FCB': usages = attributes['FCB_USAGE'] is_residential = ((usages <= 113) + (usages == 131)) else: msg = ('b_usage_type_flat = ' + str(buildings_usage_classification) + " not 'FCB' or 'HAZUS'") raise ValueError(msg) is_residential.shape = (-1, 1) # reshape so it can be broadcast nr = building_parameters['non_residential_drift_threshold'] r = building_parameters['residential_drift_threshold'] drift_threshold = r * is_residential + nr * (1 - is_residential) building_parameters['drift_threshold'] = drift_threshold is_residential.shape = (-1, ) if loss_aus_contents == 1: attributes['CONTENTS_COST_DENSITY'] *= \ (is_residential * 0.6 + (is_residential - 1) * 1.0) # reduce contents rcp = build_replacement_ratios(usages, buildings_usage_classification) building_parameters['structure_ratio'] = rcp['structural'] building_parameters['nsd_d_ratio'] = \ rcp['nonstructural drift sensitive'] building_parameters['nsd_a_ratio'] = \ rcp['nonstructural acceleration sensitive'] # create structures: return cls(latitude, longitude, building_parameters, **attributes)
def building_params_from_csv(building_classification_tag, damage_extent_tag, default_input_dir, input_dir=None): """create building parameters dictionary This loads the building_parameters_workshop file, as well as other building related files that are hard-coded in this function. Args: csv_name: The name of the parameter file with the _params.csv part removed, eg building_parameters_workshop_3 main_dir: the python_eqrm directory Returns: A dict with the parameter info. """ # Get the data out of _params.csv attribute_conversions = {} attribute_conversions['structure_class'] = str attribute_conversions['structure_classification'] = str for name in [ 'design_strength', 'height', 'natural_elastic_period', 'fraction_in_first_mode', 'height_to_displacement', 'yield_to_design', 'ultimate_to_yield', 'ductility', 'damping_s', 'damping_m', 'damping_l', 'damping_Be', 'structural_damage_slight', 'structural_damage_moderate', 'structural_damage_extreme', 'structural_damage_complete' ]: attribute_conversions[name] = float fid = get_local_or_default( 'building_parameters%s.csv' % building_classification_tag, default_input_dir, input_dir) #file_location = join(default_input_dir, csv_name+'_params.csv') building_parameters = csv_to_arrays(fid, **attribute_conversions) # Get the data out of _non_structural_damage_params.csv attribute_conversions = {} for name in [ 'non_residential_drift_threshold', 'residential_drift_threshold', 'acceleration_threshold' ]: attribute_conversions[name] = float fid = get_local_or_default('damage_extent%s.csv' % damage_extent_tag, default_input_dir, input_dir) building_nsd_parameters = csv_to_arrays(fid, **attribute_conversions) for name in [ 'non_residential_drift_threshold', 'residential_drift_threshold', 'acceleration_threshold' ]: building_parameters[name] = building_nsd_parameters[name][newaxis, :] # transform the data: # turn height from feet to mm # multiply drift damage by height # return building_parameters cvt_in2mm = 25.40 # Conversion for structural damage # building height: convert feet to inches to mm building_parameters['height'] *= 12 * cvt_in2mm height_to_displacement = building_parameters['height_to_displacement'] height = building_parameters['height'] # setup damage state median thresholds (also feet -> mm) structural_damage_slight = building_parameters.pop( 'structural_damage_slight') structural_damage_moderate = building_parameters.pop( 'structural_damage_moderate') structural_damage_extreme = building_parameters.pop( 'structural_damage_extreme') structural_damage_complete = building_parameters.pop( 'structural_damage_complete') structural_damage_threshold = asarray( (structural_damage_slight, structural_damage_moderate, structural_damage_extreme, structural_damage_complete)) structural_damage_threshold = structural_damage_threshold.swapaxes(0, 1) structural_damage_threshold = structural_damage_threshold * ( (height_to_displacement * height)[:, newaxis]) building_parameters[ 'structural_damage_threshold'] = structural_damage_threshold # setup damage state median thresholds (also feet -> inches) non_residential_drift_threshold = building_parameters[ 'non_residential_drift_threshold'] non_residential_drift_threshold = non_residential_drift_threshold * ( (height_to_displacement * height)[:, newaxis]) building_parameters[ 'non_residential_drift_threshold'] = non_residential_drift_threshold residential_drift_threshold = building_parameters[ 'residential_drift_threshold'] residential_drift_threshold = residential_drift_threshold * ( (height_to_displacement * height)[:, newaxis]) building_parameters[ 'residential_drift_threshold'] = residential_drift_threshold # expand acceleleration_threshold to be the same size as the rest. acceleration_threshold = building_parameters['acceleration_threshold'] acceleration_threshold = acceleration_threshold + 0 * height[:, newaxis] building_parameters['acceleration_threshold'] = acceleration_threshold return building_parameters
def building_params_from_csv(building_classification_tag, damage_extent_tag, default_input_dir, input_dir=None): """create building parameters dictionary This loads the building_parameters_workshop file, as well as other building related files that are hard-coded in this function. Args: csv_name: The name of the parameter file with the _params.csv part removed, eg building_parameters_workshop_3 main_dir: the python_eqrm directory Returns: A dict with the parameter info. """ # Get the data out of _params.csv attribute_conversions = {} attribute_conversions['structure_class'] = str attribute_conversions['structure_classification'] = str for name in ['design_strength', 'height', 'natural_elastic_period', 'fraction_in_first_mode', 'height_to_displacement', 'yield_to_design', 'ultimate_to_yield', 'ductility', 'damping_s', 'damping_m', 'damping_l', 'damping_Be', 'structural_damage_slight', 'structural_damage_moderate', 'structural_damage_extreme', 'structural_damage_complete']: attribute_conversions[name] = float fid = get_local_or_default( 'building_parameters%s.csv' % building_classification_tag, default_input_dir, input_dir) #file_location = join(default_input_dir, csv_name+'_params.csv') building_parameters = csv_to_arrays(fid, **attribute_conversions) # Get the data out of _non_structural_damage_params.csv attribute_conversions = {} for name in ['non_residential_drift_threshold', 'residential_drift_threshold', 'acceleration_threshold']: attribute_conversions[name] = float fid = get_local_or_default('damage_extent%s.csv' % damage_extent_tag, default_input_dir, input_dir) building_nsd_parameters = csv_to_arrays(fid, **attribute_conversions) for name in ['non_residential_drift_threshold', 'residential_drift_threshold', 'acceleration_threshold']: building_parameters[name] = building_nsd_parameters[name][newaxis, :] # transform the data: # turn height from feet to mm # multiply drift damage by height # return building_parameters cvt_in2mm = 25.40 # Conversion for structural damage # building height: convert feet to inches to mm building_parameters['height'] *= 12 * cvt_in2mm height_to_displacement = building_parameters['height_to_displacement'] height = building_parameters['height'] # setup damage state median thresholds (also feet -> mm) structural_damage_slight = building_parameters.pop( 'structural_damage_slight') structural_damage_moderate = building_parameters.pop( 'structural_damage_moderate') structural_damage_extreme = building_parameters.pop( 'structural_damage_extreme') structural_damage_complete = building_parameters.pop( 'structural_damage_complete') structural_damage_threshold = asarray((structural_damage_slight, structural_damage_moderate, structural_damage_extreme, structural_damage_complete)) structural_damage_threshold = structural_damage_threshold.swapaxes(0, 1) structural_damage_threshold = structural_damage_threshold * ( (height_to_displacement * height)[:, newaxis]) building_parameters[ 'structural_damage_threshold'] = structural_damage_threshold # setup damage state median thresholds (also feet -> inches) non_residential_drift_threshold = building_parameters[ 'non_residential_drift_threshold'] non_residential_drift_threshold = non_residential_drift_threshold * ( (height_to_displacement * height)[:, newaxis]) building_parameters[ 'non_residential_drift_threshold'] = non_residential_drift_threshold residential_drift_threshold = building_parameters[ 'residential_drift_threshold'] residential_drift_threshold = residential_drift_threshold * ( (height_to_displacement * height)[:, newaxis]) building_parameters[ 'residential_drift_threshold'] = residential_drift_threshold # expand acceleleration_threshold to be the same size as the rest. acceleration_threshold = building_parameters['acceleration_threshold'] acceleration_threshold = acceleration_threshold + 0 * height[:, newaxis] building_parameters['acceleration_threshold'] = acceleration_threshold return building_parameters
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']))