def load_bridge_data(): """Preload bridge damage data from external files.""" global ClassificationDamageParams, EQCoefficients # check dictionaries - if empty, load from file if ClassificationDamageParams is None: eqrm_dir = determine_eqrm_path(__file__) path = os.path.join(eqrm_dir, DataFilePath, ClassificationDamageParamsCSVFile) ClassificationDamageParams = csvi.csv2rowdict(path, columns=['CLASS', 'K3D', 'Ishape', 'Slight', 'Moderate', 'Extensive', 'Complete'], convert={'Ishape': int, 'Slight': float, 'Moderate': float, 'Extensive': float, 'Complete': float}) if EQCoefficients is None: eqrm_dir = determine_eqrm_path(__file__) path = os.path.join(eqrm_dir, DataFilePath, EQCoefficientsCSVFile) EQCoefficients = csvi.csv2rowdict(path, columns=['Equation','A','B'], convert={'A': float, 'B': int})
def get_sites_from_dic(attribute_dic=None, buildings_usage_classification='HAZUS' ): handle, file_name = tempfile.mkstemp('.csv','test_struct_') os.close(handle) file_name, attribute_dic = write_test_file(file_name,attribute_dic) eqrm_dir = determine_eqrm_path() data_dir = os.path.join(eqrm_dir, 'resources', 'data') #print "data_dir", data_dir # Build lookup table for building parameters building_classification_tag = '' damage_extent_tag = '' default_input_dir=os.path.join(eqrm_dir, 'resources', 'data') sites=Structures.from_csv( file_name, building_classification_tag, damage_extent_tag, default_input_dir, eqrm_dir=eqrm_dir, buildings_usage_classification=buildings_usage_classification ) os.remove(file_name) return sites, attribute_dic
def test_cadel_ground_motion(self): eqrm_dir = determine_eqrm_path() cadel_dir = join(eqrm_dir, "..", "test_cadell", "Cadell") natcadell_loc = join(cadel_dir, "natcadell.csv") # Silently return from the test if the data set does not exist. # The data is in python_eqrm if not exists(natcadell_loc): return default_input_dir = join(eqrm_dir, "resources", "data", "") sites = Structures.from_csv( natcadell_loc, "", "", default_input_dir, eqrm_dir=eqrm_dir, buildings_usage_classification="FCB" ) magnitudes = array([7.2]) cadell_periods_loc = join(cadel_dir, "Cadell_periods.csv") periods = csv.reader(open(cadell_periods_loc)).next() periods = array([float(v) for v in periods]) num_periods = len(periods) num_sites = len(sites.latitude) assert allclose(periods, [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5]) cadell_gm_loc = join(cadel_dir, "Cadell_ground_motions_precision.csv") SA = self.ground_motions_from_csv(cadell_gm_loc, num_periods, num_sites) # SA = SA[0:1,...] # set up damage model csm_use_variability = None csm_standard_deviation = None damage_model = Damage_model(sites, SA, periods, magnitudes, csm_use_variability, csm_standard_deviation) damage_model.csm_use_variability = False damage_model.csm_standard_deviation = 0.3 point = damage_model.get_building_displacement() # point is SA,SD # SA should by of shape # (number of buildings,number of events,number of samples). # print point[0].shape # check that SA is the right shape assert point[0].shape == (num_sites, 1) # check that SD is the same shape as SA assert point[1].shape == point[0].shape point = (point[0][..., 0], point[1][..., 0]) # collapse out sample dimension so it matches the shape of matlab cadell_bd_loc = join(cadel_dir, "Cadell_building_displacements.csv") matlab_point = open(cadell_bd_loc) matlab_point = array([[float(p) for p in mpoint.split(",")] for mpoint in matlab_point]) matlab_point = (matlab_point[:, 1], matlab_point[:, 0]) assert allclose(point, matlab_point, 5e-3) assert allclose(point, matlab_point, 1e-2) # check that we are 1% of matlabs SA and SD assert allclose(point, matlab_point, 5e-3)
def get_sites_from_dic(attribute_dic=None, buildings_usage_classification='HAZUS'): handle, file_name = tempfile.mkstemp('.csv', 'test_struct_') os.close(handle) file_name, attribute_dic = write_test_file(file_name, attribute_dic) eqrm_dir = determine_eqrm_path() data_dir = os.path.join(eqrm_dir, 'resources', 'data') #print "data_dir", data_dir # Build lookup table for building parameters building_classification_tag = '' damage_extent_tag = '' default_input_dir = os.path.join(eqrm_dir, 'resources', 'data') sites = Structures.from_csv( file_name, building_classification_tag, damage_extent_tag, default_input_dir, eqrm_dir=eqrm_dir, buildings_usage_classification=buildings_usage_classification) os.remove(file_name) return sites, attribute_dic
def load_external_data(fp): """Load mean and sigma values from an external file. Data is placed in a numpy array where row number is the state number and the columns are the ppf() function for each pf value That is, if the source data file contains: State,StateIndex,Mean,Sigma none,0,0.0,0.00001 slight,1,0.6,0.6 moderate,2,2.5,2.7 extensive,3,75.0,42.0 complete,4,230.0,110.0 and the fp value is [10, 20] then the resulting array will be: fp(10) fp(20) vvv vvv [[ 0 0 ] <- state 0 (none) [ 1 1 ] <- state 1 (slight) [ 1 2 ] <- state 2 (moderate) [ 40 53 ] <- state 3 (extensive) [ 138 173 ]] <- state 4 (complete) All 'none' state days will be 0 days. All other states have values computed with ceil() and if less than 1 changed to 1. """ eqrm_dir = determine_eqrm_path(__file__) path = os.path.join(eqrm_dir, eqrm_filesystem.Resources_Data_Path, MeanSigmaValuesCSVFile) dict = csvi.csv2rowdict(path, columns=['StateIndex', 'Mean', 'Sigma'], convert={'StateIndex': int, 'Mean': float, 'Sigma': float }) data = [] for i in range(5): (mean, sigma) = dict[str(i)] data.append(scipy.stats.norm.ppf(fp, mean, sigma)) data = numpy.array(data) # 'normalise' results # if value < 0, convert to 1 # if value < 1 and > 0, convert to 1 result = data.clip(1.0, 99999999999.0) result = numpy.ceil(numpy.array(result)) result[0,:] = 0.0 # force all 'none' times to 0 return result
def load_external_data(fp): """Load mean and sigma values from an external file. Data is placed in a numpy array where row number is the state number and the columns are the ppf() function for each pf value That is, if the source data file contains: State,StateIndex,Mean,Sigma none,0,0.0,0.00001 slight,1,0.6,0.6 moderate,2,2.5,2.7 extensive,3,75.0,42.0 complete,4,230.0,110.0 and the fp value is [10, 20] then the resulting array will be: fp(10) fp(20) vvv vvv [[ 0 0 ] <- state 0 (none) [ 1 1 ] <- state 1 (slight) [ 1 2 ] <- state 2 (moderate) [ 40 53 ] <- state 3 (extensive) [ 138 173 ]] <- state 4 (complete) All 'none' state days will be 0 days. All other states have values computed with ceil() and if less than 1 changed to 1. """ eqrm_dir = determine_eqrm_path(__file__) path = os.path.join(eqrm_dir, eqrm_filesystem.Resources_Data_Path, MeanSigmaValuesCSVFile) dict = csvi.csv2rowdict(path, columns=['StateIndex', 'Mean', 'Sigma'], convert={ 'StateIndex': int, 'Mean': float, 'Sigma': float }) data = [] for i in range(5): (mean, sigma) = dict[str(i)] data.append(scipy.stats.norm.ppf(fp, mean, sigma)) data = numpy.array(data) # 'normalise' results # if value < 0, convert to 1 # if value < 1 and > 0, convert to 1 result = data.clip(1.0, 99999999999.0) result = numpy.ceil(numpy.array(result)) result[0, :] = 0.0 # force all 'none' times to 0 return result
def _test_get_independent_polygons(self): from eqrm_code.generation_polygon import polygons_from_xml eqrm_dir = determine_eqrm_path() #print "eqrm_dir", eqrm_dir file_location = join(eqrm_dir, 'test_resources','sample_event.xml') #print "file_location", file_location polygons,mag_type = polygons_from_xml(file_location, azi=[180,180], dazi=[10,10], fault_dip=[30,30], fault_width=15, override_xml=True) independent_polygons=get_independent_polygons_obsolete(polygons) assert len(independent_polygons)==3 #conformance tests, could change if I change the way area works assert allclose(independent_polygons[0].area,80.685560816) assert allclose(independent_polygons[1].area,16.314439184) assert allclose(independent_polygons[2].area, 27.919220365) #no more conformance tests (these are real ones): for i in range(len(independent_polygons)): for j in range(len(independent_polygons)): if not i == j: polygoni = independent_polygons[i] polygonj = independent_polygons[j] int = polygoni.intersection(polygonj) assert int.area == 0 area1=0 area2=0 for poly in polygons: area1+=poly.area for poly in independent_polygons: area2+=poly.area assert not allclose(area1,area2) assert allclose(area2,area1-polygons[0].intersection(polygons[1]).area)
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 build_replacement_ratios(usage_per_struct, buildings_usage_classification): """Return an array of the building components replacement cost ratios. shape (# of buildings, 3 (# of components in a structure)) A structure has 3 components; structural nonstructural acceleration sensitive nonstructural drift sensitive The ratio of the replacement cost for each component differs for different usage types. Also, there are two scales of usage types; Functional classification of buildings (FCB)(ABS usage) HAZUS usage Parameters: usage_per_struct: An array, shape (# of buildings) of usage values for each structure. buildings_usage_classification: The usage scale used. Return: A dictionary of cost ratios for the strucutures. The keys are the structural components; 'structural', 'nonstructural drift sensitive', 'nonstructural acceleration sensitive' Note: This should only be used once, since it is loading a file. """ usage_column = 'Functional classification of buildings (ABS usage)' components = ['structural', 'nonstructural drift sensitive', 'nonstructural acceleration sensitive'] convert = {} # extract usage dependent parameters if buildings_usage_classification is 'HAZUS': # HAZUS_USAGE file = 'replacement_cost_ratios_wrt_HAZUS_Usage.csv' elif buildings_usage_classification is 'FCB': # FCB_USAGE file = 'replacement_cost_ratios_wrt_FCB_Usage.csv' convert[usage_column] = int else: msg = ('b_usage_type_flat = ' + str(buildings_usage_classification) + ' not "FCB" or "HAZUS"') raise ValueError(msg) for comp in components: convert[comp] = float root_dir = determine_eqrm_path() data_dir = join(root_dir, 'resources', 'data') (att_dic, _) = csv2dict(join(data_dir, file), convert=convert) # This way does not have an assert # Build a dict with # key (usage, component), value = cost ratio # cost_ratios = {} # for comp in components: # tmp = {} # for i,usage in enumerate(att_dic[usage_column]): # tmp[usage] = att_dic[comp][i] # cost_ratios[comp] = tmp # replacement_cost_ratios = {} # for comp in components: # this_cost_ratios = cost_ratios[comp] # tmp = [this_cost_ratios[usage] for usage in usage_per_struct] # replacement_cost_ratios[comp] = array(tmp) cost_ratios = {} for (i, usage) in enumerate(att_dic[usage_column]): cost_ratios[usage] = [att_dic[components[0]][i], att_dic[components[1]][i], att_dic[components[2]][i]] rcp_array = asarray([cost_ratios[usage] for usage in usage_per_struct]) assert allclose(sum(rcp_array), rcp_array.shape[0], 0.0000001) replacement_cost_ratios = {} for (i, comp) in enumerate(components): replacement_cost_ratios[comp] = rcp_array[:, i] return replacement_cost_ratios
if mini_check_scenarios is True: # mini_check_scenarios is not packaged up with the distribution if verbose: print "Start mini_check_scenarios.py" chdir(eqrm_root_dir) Retcode = run_call('mini_check_scenarios.py', eqrm_root_dir, python_command=python_command) if not Retcode == 0: print 'ERROR: mini_check_scenarios.py failed.' stop_message() return False if demo_batchrun is True: if verbose: print "Start demo_batchrun.py" chdir(join(eqrm_root_dir, 'demo')) run_call(join('demo', 'demo_batchrun.py'), eqrm_root_dir, python_command=python_command) # No return code, since no comparisions are made return True if __name__ == '__main__': do_tests_checks_demos_audits(determine_eqrm_path(), check_scenarios=False, ip_audit=True, test_all=False, mini_check_scenarios=False, demo_batchrun=False, python_command='python')
def test_cadel_ground_motion(self): eqrm_dir = determine_eqrm_path() cadel_dir = join(eqrm_dir,'..','test_cadell', 'Cadell') natcadell_loc = join(cadel_dir, 'natcadell.csv') # Silently return from the test if the data set does not exist. # The data is in python_eqrm if not exists(natcadell_loc): return default_input_dir = join(eqrm_dir,'resources', 'data', '') sites=Structures.from_csv(natcadell_loc, '', '', default_input_dir, eqrm_dir=eqrm_dir, buildings_usage_classification='FCB') magnitudes=array([7.2]) cadell_periods_loc = join(cadel_dir, 'Cadell_periods.csv') periods=csv.reader(open(cadell_periods_loc)).next() periods=array([float(v) for v in periods]) num_periods=len(periods) num_sites=len(sites.latitude) assert allclose(periods,[0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8, 0.9,1,1.5,2,2.5,3,3.5,4,4.5,5]) cadell_gm_loc = join(cadel_dir, 'Cadell_ground_motions_precision.csv') SA=self.ground_motions_from_csv(cadell_gm_loc, num_periods,num_sites) #SA = SA[0:1,...] # set up damage model csm_use_variability = None csm_standard_deviation = None damage_model=Damage_model(sites,SA,periods,magnitudes, csm_use_variability, csm_standard_deviation) damage_model.csm_use_variability=False damage_model.csm_standard_deviation=0.3 point=damage_model.get_building_displacement() # point is SA,SD # SA should by of shape # (number of buildings,number of events,number of samples). # print point[0].shape # check that SA is the right shape assert point[0].shape==(num_sites,1) # check that SD is the same shape as SA assert point[1].shape== point[0].shape point = (point[0][...,0],point[1][...,0]) #collapse out sample dimension so it matches the shape of matlab cadell_bd_loc = join(cadel_dir, 'Cadell_building_displacements.csv') matlab_point=open(cadell_bd_loc) matlab_point=array([[float(p) for p in mpoint.split(',')] for mpoint in matlab_point]) matlab_point=(matlab_point[:,1],matlab_point[:,0]) assert allclose(point,matlab_point,5e-3) assert allclose(point,matlab_point,1e-2) # check that we are 1% of matlabs SA and SD assert allclose(point,matlab_point,5e-3)
The variables below describe where in the EQRM filesystem certain parts of the system live. Version: $Revision$ ModifiedBy: $Author$ ModifiedDate: $Date$ Copyright 2007 by Geoscience Australia """ import os import eqrm_code.util as util eqrm_path = util.determine_eqrm_path() # define various paths Resources_Data_Path = os.path.join(eqrm_path, 'resources', 'data') demo_path = os.path.join(eqrm_path, 'demo') Implementation_Path = os.path.join(eqrm_path, 'implementation_tests') mini_scenario_scenarios_path = os.path.join(eqrm_path, 'implementation_tests', 'mini_scenarios', 'scenarios') mini_scenario_Path = os.path.join(eqrm_path, 'implementation_tests', 'mini_scenarios') scenario_input_path = os.path.join(eqrm_path, 'implementation_tests', 'input')
def test_building_response(self): #Test that building response is the same as matlab periods=array([0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3]) SA = array([0.017553049, 0.028380350, 0.036142210, 0.037701113, 0.039325398, 0.038083417, 0.036880517, 0.036190107, 0.035512489, 0.035088679, 0.034669917, 0.033162774, 0.030871523, 0.027841184, 0.025094836, 0.022850476, 0.021322256, 0.019895084, 0.018562342, 0.017317833, 0.016160874, 0.015195155, 0.014287144, 0.013433394, 0.012630662, 0.011875899, 0.011166239, 0.010498986, 0.009871606, 0.009281717, 0.008727078, 0.008140645, 0.007593619, 0.007083352, 0.006607374, 0.006163380]) SA = SA[newaxis, newaxis, :] magnitudes = array([6.5]) Btype = 'RM2L' eqrm_dir = determine_eqrm_path() default_input_dir = join(eqrm_dir, 'resources', 'data', '') building_parameters = \ building_params_from_csv(building_classification_tag = '', damage_extent_tag = '', default_input_dir=default_input_dir) # Pull the parameters out: b_index = where([(bt == Btype) for bt in building_parameters['structure_classification']]) new_bp = {} for key in building_parameters: try: new_bp[key] = building_parameters[key][b_index] except: new_bp[key] = building_parameters[key] structures = Structures(latitude=[-31], longitude=[150], building_parameters=new_bp, #bridge_parameters={}, FCB_USAGE=array([111]), STRUCTURE_CLASSIFICATION=array([Btype]), STRUCTURE_CATEGORY=array(['BUILDING'])) building_parameters = structures.building_parameters # All the same for this type anyway csm_use_variability = None csm_standard_deviation = None damage_model = Damage_model(structures, SA, periods, magnitudes, csm_use_variability, csm_standard_deviation) # set up the capacity model capacity_spectrum_model = Capacity_spectrum_model(periods, magnitudes, building_parameters) capacity_spectrum_model.smooth_damping = True capacity_spectrum_model.use_displacement_corner_period = True capacity_spectrum_model.damp_corner_periods = True capacity_spectrum_model.use_exact_area = True capacity_spectrum_model.rtol = 0.01 capacity_spectrum_model.csm_damping_max_iterations = 7 ########################################################### damage_model.capacity_spectrum_model = capacity_spectrum_model # Warning, point is not used point = damage_model.get_building_displacement() # matlab values SAcr = 0.032208873 SDcr = 0.97944026 assert allclose(point[0], SAcr) assert allclose(point[1], SDcr) assert allclose(point, [[[SAcr]], [[SDcr]]])
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 build_replacement_ratios(usage_per_struct, buildings_usage_classification): """Return an array of the building components replacement cost ratios. shape (# of buildings, 3 (# of components in a structure)) A structure has 3 components; structural nonstructural acceleration sensitive nonstructural drift sensitive The ratio of the replacement cost for each component differs for different usage types. Also, there are two scales of usage types; Functional classification of buildings (FCB)(ABS usage) HAZUS usage Parameters: usage_per_struct: An array, shape (# of buildings) of usage values for each structure. buildings_usage_classification: The usage scale used. Return: A dictionary of cost ratios for the strucutures. The keys are the structural components; 'structural', 'nonstructural drift sensitive', 'nonstructural acceleration sensitive' Note: This should only be used once, since it is loading a file. """ usage_column = 'Functional classification of buildings (ABS usage)' components = [ 'structural', 'nonstructural drift sensitive', 'nonstructural acceleration sensitive' ] convert = {} # extract usage dependent parameters if buildings_usage_classification is 'HAZUS': # HAZUS_USAGE file = 'replacement_cost_ratios_wrt_HAZUS_Usage.csv' elif buildings_usage_classification is 'FCB': # FCB_USAGE file = 'replacement_cost_ratios_wrt_FCB_Usage.csv' convert[usage_column] = int else: msg = ('b_usage_type_flat = ' + str(buildings_usage_classification) + ' not "FCB" or "HAZUS"') raise ValueError(msg) for comp in components: convert[comp] = float root_dir = determine_eqrm_path() data_dir = join(root_dir, 'resources', 'data') (att_dic, _) = csv2dict(join(data_dir, file), convert=convert) # This way does not have an assert # Build a dict with # key (usage, component), value = cost ratio # cost_ratios = {} # for comp in components: # tmp = {} # for i,usage in enumerate(att_dic[usage_column]): # tmp[usage] = att_dic[comp][i] # cost_ratios[comp] = tmp # replacement_cost_ratios = {} # for comp in components: # this_cost_ratios = cost_ratios[comp] # tmp = [this_cost_ratios[usage] for usage in usage_per_struct] # replacement_cost_ratios[comp] = array(tmp) cost_ratios = {} for (i, usage) in enumerate(att_dic[usage_column]): cost_ratios[usage] = [ att_dic[components[0]][i], att_dic[components[1]][i], att_dic[components[2]][i] ] rcp_array = asarray([cost_ratios[usage] for usage in usage_per_struct]) assert allclose(sum(rcp_array), rcp_array.shape[0], 0.0000001) replacement_cost_ratios = {} for (i, comp) in enumerate(components): replacement_cost_ratios[comp] = rcp_array[:, i] return replacement_cost_ratios
def obsolete_convert_Py2Mat_Risk(site_tag, datadir, param_t, default_data=None): """Get python data as attributes of object. site_tag Site Location (?) should get from PARAM_T (whatever *that* is) datadir path to directory containing data param_t name of the PARAM_T file default_data path to default data directory Returns a data object. See module docstring. """ # get EQRM root path eqrm_path = util.determine_eqrm_path() # handle missing default_data if default_data is None: default_data = os.path.join(eqrm_path, eqrm_filesystem.Resources_Data_Path) # easy stuff saved_ecbval2_file = os.path.join( eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_bval.txt') saved_ecbval2 = load_data(saved_ecbval2_file) saved_ecbval2 = num.array(saved_ecbval2).flat[:] # make a row vector saved_rjb_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_distance_rjb.txt') saved_rjb = load_data(saved_rjb_file) saved_rjb = saved_rjb.transpose() # get loss values - note: we only do contents+building saved_ecloss_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_total_building_loss.txt') saved_ecloss = load_data(saved_ecloss_file) saved_ecloss = saved_ecloss[1:] # strip building ID row saved_ecloss = saved_ecloss.transpose() # get aus_mag and nu data tmp1_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_event_set.txt') tmp1 = load_data(tmp1_file) nu = tmp1[:, 8] aus_mag = tmp1[:, 9] # structure information saved_struct_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_structures.txt') print('saved_struct_file=%s' % saved_struct_file) saved_struct = load_struct_data(saved_struct_file) # convert certain fields in-situ convert_btype_to_btypeindex(saved_struct, default_data) convert_uses_to_usesindex(saved_struct, default_data) convert_suburb_to_suburbindex(saved_struct, default_data) # create result object, add data attributes result = Result() result.ecbval2 = num.array(saved_ecbval2) result.ecloss = num.array(saved_ecloss) result.rjb = num.array(saved_rjb) result.aus_mag = num.array(aus_mag) result.nu = num.array(nu) # convert structures array to lists, add to data attributes result.latitude = num.array([x[0] for x in saved_struct]) result.longitude = num.array([x[1] for x in saved_struct]) result.pre1989 = [x[2] for x in saved_struct] result.postcode = num.array([x[3] for x in saved_struct]) result.site_class = [x[4] for x in saved_struct] result.suburb = [x[5] for x in saved_struct] result.survey_factor = num.array([x[6] for x in saved_struct]) result.structure_classification = [x[7] for x in saved_struct] result.hazus_structure_classification = [x[8] for x in saved_struct] result.bid = num.array([x[9] for x in saved_struct]) result.fcb_usage = num.array([x[10] for x in saved_struct]) result.hazus_usage = [x[11] for x in saved_struct] return result
def regressionTest(path=None): """ Args: path: The directory to look for files. Assumed to be eqrm_code. Return: suite: The test suit to use with the unit tests moduleNames: The names of all the modules. This can be used to import all the modules. Used in do_coverage. """ if path is None: path = util.determine_eqrm_path() print if False: # I never really looked at this info print "The following directories will be skipped over;" for dir in EXCLUDE_DIRS: print dir, print "\n" # print 'Recursing into;' test_files, subdirectories = get_test_files(path) files = [x for x in test_files if not x == 'test_all.py'] print 'Testing path %s:' % path if False: # I never really looked at this info print print 'Files tested;' #print_files = [] for file in files: #print_files += file + ' ' print file + ',', print print if 'EXCLUDE_FILES' in globals(): for file in EXCLUDE_FILES: print 'WARNING: File ' + file + ' to be excluded from testing' try: files.remove(file) except ValueError as e: msg = 'File "%s" was not found in test suite.\n' % file msg += 'Original error is "%s"\n' % e msg += 'Perhaps it should be removed from exclude list?' raise Exception(msg) filenameToModuleName = lambda f: os.path.splitext(f)[0] moduleNames = map(filenameToModuleName, files) # print "moduleNames", moduleNames # Note, if there are duplicate file names, from different directories # only one of them will be used. # Add directorys to the sys. path, # so the load works. for file in subdirectories: sys.path.append(file) sys.path.append(path) modules = map(__import__, moduleNames) # sys.path.remove(path) # Fix up the system path for file in subdirectories: sys.path.remove(file) load = unittest.defaultTestLoader.loadTestsFromModule testCaseClasses = map(load, modules) return unittest.TestSuite(testCaseClasses), moduleNames
Version: $Revision$ ModifiedBy: $Author$ ModifiedDate: $Date$ Copyright 2007 by Geoscience Australia """ import os import eqrm_code.util as util eqrm_path = util.determine_eqrm_path() # define various paths Resources_Data_Path = os.path.join(eqrm_path, 'resources', 'data') demo_path = os.path.join(eqrm_path, 'demo') Implementation_Path = os.path.join(eqrm_path, 'implementation_tests') mini_scenario_scenarios_path = os.path.join(eqrm_path, 'implementation_tests', 'mini_scenarios', 'scenarios') mini_scenario_Path = os.path.join(eqrm_path, 'implementation_tests', 'mini_scenarios')
def obsolete_convert_Py2Mat_Risk(site_tag, datadir, param_t, default_data=None): """Get python data as attributes of object. site_tag Site Location (?) should get from PARAM_T (whatever *that* is) datadir path to directory containing data param_t name of the PARAM_T file default_data path to default data directory Returns a data object. See module docstring. """ # get EQRM root path eqrm_path = util.determine_eqrm_path() # handle missing default_data if default_data is None: default_data = os.path.join(eqrm_path, eqrm_filesystem.Resources_Data_Path) # easy stuff saved_ecbval2_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_bval.txt') saved_ecbval2 = load_data(saved_ecbval2_file) saved_ecbval2 = num.array(saved_ecbval2).flat[:] # make a row vector saved_rjb_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_distance_rjb.txt') saved_rjb = load_data(saved_rjb_file) saved_rjb = saved_rjb.transpose() # get loss values - note: we only do contents+building saved_ecloss_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_total_building_loss.txt') saved_ecloss = load_data(saved_ecloss_file) saved_ecloss = saved_ecloss[1:] # strip building ID row saved_ecloss = saved_ecloss.transpose() # get aus_mag and nu data tmp1_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_event_set.txt') tmp1 = load_data(tmp1_file) nu = tmp1[:,8] aus_mag = tmp1[:,9] # structure information saved_struct_file = os.path.join(eqrm_path, eqrm_filesystem.Demo_Output_ProbRisk_Path, site_tag + '_structures.txt') print('saved_struct_file=%s' % saved_struct_file) saved_struct = load_struct_data(saved_struct_file) # convert certain fields in-situ convert_btype_to_btypeindex(saved_struct, default_data) convert_uses_to_usesindex(saved_struct, default_data) convert_suburb_to_suburbindex(saved_struct, default_data) # create result object, add data attributes result = Result() result.ecbval2 = num.array(saved_ecbval2) result.ecloss = num.array(saved_ecloss) result.rjb = num.array(saved_rjb) result.aus_mag = num.array(aus_mag) result.nu = num.array(nu) # convert structures array to lists, add to data attributes result.latitude = num.array([x[0] for x in saved_struct]) result.longitude = num.array([x[1] for x in saved_struct]) result.pre1989 = [x[2] for x in saved_struct] result.postcode = num.array([x[3] for x in saved_struct]) result.site_class = [x[4] for x in saved_struct] result.suburb = [x[5] for x in saved_struct] result.survey_factor = num.array([x[6] for x in saved_struct]) result.structure_classification = [x[7] for x in saved_struct] result.hazus_structure_classification = [x[8] for x in saved_struct] result.bid = num.array([x[9] for x in saved_struct]) result.fcb_usage = num.array([x[10] for x in saved_struct]) result.hazus_usage = [x[11] for x in saved_struct] return result