idx int64 0 63k | question stringlengths 61 4.03k | target stringlengths 6 1.23k |
|---|---|---|
44,200 | def _get_proj_convex_hull ( self ) : proj = geo_utils . OrthographicProjection ( * geo_utils . get_spherical_bounding_box ( self . lons , self . lats ) ) coords = numpy . transpose ( proj ( self . lons . flat , self . lats . flat ) ) . copy ( ) multipoint = shapely . geometry . MultiPoint ( coords ) return proj , multi... | Create a projection centered in the center of this mesh and define a convex polygon in that projection enveloping all the points of the mesh . |
44,201 | def get_joyner_boore_distance ( self , mesh ) : distances = geodetic . min_geodetic_distance ( ( self . lons , self . lats ) , ( mesh . lons , mesh . lats ) ) idxs = ( distances < 40 ) . nonzero ( ) [ 0 ] if not len ( idxs ) : return distances proj , polygon = self . _get_proj_enclosing_polygon ( ) if not isinstance ( ... | Compute and return Joyner - Boore distance to each point of mesh . Point s depth is ignored . |
44,202 | def get_convex_hull ( self ) : proj , polygon2d = self . _get_proj_convex_hull ( ) if isinstance ( polygon2d , ( shapely . geometry . LineString , shapely . geometry . Point ) ) : polygon2d = polygon2d . buffer ( self . DIST_TOLERANCE , 1 ) from openquake . hazardlib . geo . polygon import Polygon return Polygon . _fro... | Get a convex polygon object that contains projections of all the points of the mesh . |
44,203 | def from_points_list ( cls , points ) : assert points is not None and len ( points ) > 0 and len ( points [ 0 ] ) > 0 , 'list of at least one non-empty list of points is required' lons = numpy . zeros ( ( len ( points ) , len ( points [ 0 ] ) ) , dtype = float ) lats = lons . copy ( ) depths = lons . copy ( ) num_cols ... | Create a rectangular mesh object from a list of lists of points . Lists in a list are supposed to have the same length . |
44,204 | def get_middle_point ( self ) : num_rows , num_cols = self . lons . shape mid_row = num_rows // 2 depth = 0 if num_rows & 1 == 1 : mid_col = num_cols // 2 if num_cols & 1 == 1 : depth = self . depths [ mid_row , mid_col ] return Point ( self . lons [ mid_row , mid_col ] , self . lats [ mid_row , mid_col ] , depth ) els... | Return the middle point of the mesh . |
44,205 | def get_cell_dimensions ( self ) : points , along_azimuth , updip , diag = self . triangulate ( ) top = along_azimuth [ : - 1 ] left = updip [ : , : - 1 ] tl_area = geo_utils . triangle_area ( top , left , diag ) top_length = numpy . sqrt ( numpy . sum ( top * top , axis = - 1 ) ) left_length = numpy . sqrt ( numpy . s... | Calculate centroid width length and area of each mesh cell . |
44,206 | def triangulate ( self ) : points = geo_utils . spherical_to_cartesian ( self . lons , self . lats , self . depths ) along_azimuth = points [ : , 1 : ] - points [ : , : - 1 ] updip = points [ : - 1 ] - points [ 1 : ] diag = points [ : - 1 , 1 : ] - points [ 1 : , : - 1 ] return points , along_azimuth , updip , diag | Convert mesh points to vectors in Cartesian space . |
44,207 | def smooth_data ( self , data , config , is_3d = False ) : max_dist = config [ 'Length_Limit' ] * config [ 'BandWidth' ] smoothed_value = np . zeros ( len ( data ) , dtype = float ) for iloc in range ( 0 , len ( data ) ) : dist_val = haversine ( data [ : , 0 ] , data [ : , 1 ] , data [ iloc , 0 ] , data [ iloc , 1 ] ) ... | Applies the smoothing kernel to the data |
44,208 | def purge_one ( calc_id , user ) : filename = os . path . join ( datadir , 'calc_%s.hdf5' % calc_id ) err = dbcmd ( 'del_calc' , calc_id , user ) if err : print ( err ) elif os . path . exists ( filename ) : os . remove ( filename ) print ( 'Removed %s' % filename ) | Remove one calculation ID from the database and remove its datastore |
44,209 | def purge_all ( user = None , fast = False ) : user = user or getpass . getuser ( ) if os . path . exists ( datadir ) : if fast : shutil . rmtree ( datadir ) print ( 'Removed %s' % datadir ) else : for fname in os . listdir ( datadir ) : mo = re . match ( 'calc_(\d+)\.hdf5' , fname ) if mo is not None : calc_id = int (... | Remove all calculations of the given user |
44,210 | def purge ( calc_id ) : if calc_id < 0 : try : calc_id = datastore . get_calc_ids ( datadir ) [ calc_id ] except IndexError : print ( 'Calculation %d not found' % calc_id ) return purge_one ( calc_id , getpass . getuser ( ) ) | Remove the given calculation . If you want to remove all calculations use oq reset . |
44,211 | def PolygonPatch ( polygon , ** kwargs ) : def coding ( ob ) : n = len ( getattr ( ob , 'coords' , None ) or ob ) vals = ones ( n , dtype = Path . code_type ) * Path . LINETO vals [ 0 ] = Path . MOVETO return vals if hasattr ( polygon , 'geom_type' ) : ptype = polygon . geom_type if ptype == 'Polygon' : polygon = [ Pol... | Constructs a matplotlib patch from a geometric object |
44,212 | def retreive_sigma_mu_data ( self ) : fle = h5py . File ( os . path . join ( BASE_PATH , "KothaEtAl2019_SigmaMu_Fixed.hdf5" ) , "r" ) self . mags = fle [ "M" ] [ : ] self . dists = fle [ "R" ] [ : ] self . periods = fle [ "T" ] [ : ] self . pga = fle [ "PGA" ] [ : ] self . pgv = fle [ "PGV" ] [ : ] self . s_a = fle [ "... | For the general form of the GMPE this retrieves the sigma mu values from the hdf5 file using the general model i . e . sigma mu factors that are independent of the choice of region or depth |
44,213 | def get_magnitude_scaling ( self , C , mag ) : d_m = mag - self . CONSTANTS [ "Mh" ] if mag < self . CONSTANTS [ "Mh" ] : return C [ "e1" ] + C [ "b1" ] * d_m + C [ "b2" ] * ( d_m ** 2.0 ) else : return C [ "e1" ] + C [ "b3" ] * d_m | Returns the magnitude scaling term |
44,214 | def get_distance_term ( self , C , rup , rjb , imt ) : h = self . _get_h ( C , rup . hypo_depth ) rval = np . sqrt ( rjb ** 2. + h ** 2. ) c3 = self . get_distance_coefficients ( C , imt ) f_r = ( C [ "c1" ] + C [ "c2" ] * ( rup . mag - self . CONSTANTS [ "Mref" ] ) ) * np . log ( rval / self . CONSTANTS [ "Rref" ] ) +... | Returns the distance attenuation factor |
44,215 | def get_distance_coefficients ( self , C , imt ) : c3 = self . c3 [ imt ] [ "c3" ] if self . c3 else C [ "c3" ] return c3 | Returns the c3 term |
44,216 | def get_sigma_mu_adjustment ( self , C , imt , rup , dists ) : if imt . name in "PGA PGV" : sigma_mu = getattr ( self , imt . name . lower ( ) ) if rup . mag <= self . mags [ 0 ] : sigma_mu_m = sigma_mu [ 0 , : ] elif rup . mag >= self . mags [ - 1 ] : sigma_mu_m = sigma_mu [ - 1 , : ] else : intpl1 = interp1d ( self .... | Returns the sigma mu adjustment factor |
44,217 | def get_site_amplification ( self , C , sites ) : ampl = np . zeros ( sites . vs30 . shape ) ampl [ sites . vs30measured ] = ( C [ "d0_obs" ] + C [ "d1_obs" ] * np . log ( sites . vs30 [ sites . vs30measured ] ) ) idx = np . logical_not ( sites . vs30measured ) ampl [ idx ] = ( C [ "d0_inf" ] + C [ "d1_inf" ] * np . lo... | Returns the linear site amplification term depending on whether the Vs30 is observed of inferred |
44,218 | def get_stddevs ( self , C , stddev_shape , stddev_types , sites ) : stddevs = [ ] tau = C [ "tau_event" ] sigma_s = np . zeros ( sites . vs30measured . shape , dtype = float ) sigma_s [ sites . vs30measured ] += C [ "sigma_s_obs" ] sigma_s [ np . logical_not ( sites . vs30measured ) ] += C [ "sigma_s_inf" ] phi = np .... | Returns the standard deviations with different site standard deviation for inferred vs . observed vs30 sites . |
44,219 | def geodetic_distance ( lons1 , lats1 , lons2 , lats2 , diameter = 2 * EARTH_RADIUS ) : lons1 , lats1 , lons2 , lats2 = _prepare_coords ( lons1 , lats1 , lons2 , lats2 ) distance = numpy . arcsin ( numpy . sqrt ( numpy . sin ( ( lats1 - lats2 ) / 2.0 ) ** 2.0 + numpy . cos ( lats1 ) * numpy . cos ( lats2 ) * numpy . si... | Calculate the geodetic distance between two points or two collections of points . |
44,220 | def azimuth ( lons1 , lats1 , lons2 , lats2 ) : lons1 , lats1 , lons2 , lats2 = _prepare_coords ( lons1 , lats1 , lons2 , lats2 ) cos_lat2 = numpy . cos ( lats2 ) true_course = numpy . degrees ( numpy . arctan2 ( numpy . sin ( lons1 - lons2 ) * cos_lat2 , numpy . cos ( lats1 ) * numpy . sin ( lats2 ) - numpy . sin ( la... | Calculate the azimuth between two points or two collections of points . |
44,221 | def min_distance_to_segment ( seglons , seglats , lons , lats ) : assert len ( seglons ) == len ( seglats ) == 2 seg_azim = azimuth ( seglons [ 0 ] , seglats [ 0 ] , seglons [ 1 ] , seglats [ 1 ] ) azimuth1 = azimuth ( seglons [ 0 ] , seglats [ 0 ] , lons , lats ) azimuth2 = azimuth ( seglons [ 1 ] , seglats [ 1 ] , lo... | This function computes the shortest distance to a segment in a 2D reference system . |
44,222 | def min_geodetic_distance ( a , b ) : if isinstance ( a , tuple ) : a = spherical_to_cartesian ( a [ 0 ] . flatten ( ) , a [ 1 ] . flatten ( ) ) if isinstance ( b , tuple ) : b = spherical_to_cartesian ( b [ 0 ] . flatten ( ) , b [ 1 ] . flatten ( ) ) return cdist ( a , b ) . min ( axis = 0 ) | Compute the minimum distance between first mesh and each point of the second mesh when both are defined on the earth surface . |
44,223 | def intervals_between ( lon1 , lat1 , depth1 , lon2 , lat2 , depth2 , length ) : assert length > 0 hdist = geodetic_distance ( lon1 , lat1 , lon2 , lat2 ) vdist = depth2 - depth1 total_distance = round ( numpy . sqrt ( hdist ** 2 + vdist ** 2 ) , 7 ) num_intervals = int ( round ( total_distance / length ) ) if num_inte... | Find a list of points between two given ones that lie on the same great circle arc and are equally spaced by length km . |
44,224 | def npoints_between ( lon1 , lat1 , depth1 , lon2 , lat2 , depth2 , npoints ) : hdist = geodetic_distance ( lon1 , lat1 , lon2 , lat2 ) vdist = depth2 - depth1 rlons , rlats , rdepths = npoints_towards ( lon1 , lat1 , depth1 , azimuth ( lon1 , lat1 , lon2 , lat2 ) , hdist , vdist , npoints ) rlons [ - 1 ] = lon2 rlats ... | Find a list of specified number of points between two given ones that are equally spaced along the great circle arc connecting given points . |
44,225 | def npoints_towards ( lon , lat , depth , azimuth , hdist , vdist , npoints ) : assert npoints > 1 rlon , rlat = numpy . radians ( lon ) , numpy . radians ( lat ) tc = numpy . radians ( 360 - azimuth ) hdists = numpy . arange ( npoints , dtype = float ) hdists *= ( hdist / EARTH_RADIUS ) / ( npoints - 1 ) vdists = nump... | Find a list of specified number of points starting from a given one along a great circle arc with a given azimuth measured in a given point . |
44,226 | def _prepare_coords ( lons1 , lats1 , lons2 , lats2 ) : lons1 = numpy . radians ( lons1 ) lats1 = numpy . radians ( lats1 ) assert lons1 . shape == lats1 . shape lons2 = numpy . radians ( lons2 ) lats2 = numpy . radians ( lats2 ) assert lons2 . shape == lats2 . shape return lons1 , lats1 , lons2 , lats2 | Convert two pairs of spherical coordinates in decimal degrees to numpy arrays of radians . Makes sure that respective coordinates in pairs have the same shape . |
44,227 | def select_catalogue ( self , selector , distance , distance_metric = 'joyner-boore' , upper_eq_depth = None , lower_eq_depth = None ) : if selector . catalogue . get_number_events ( ) < 1 : raise ValueError ( 'No events found in catalogue!' ) if ( 'rupture' in distance_metric ) and ( fabs ( self . dip - 90 ) > 1E-5 ) ... | Selects earthquakes within a distance of the fault |
44,228 | def plot_recurrence_models ( configs , area , slip , msr , rake , shear_modulus = 30.0 , disp_length_ratio = 1.25E-5 , msr_sigma = 0. , figure_size = ( 8 , 6 ) , filename = None , filetype = 'png' , dpi = 300 , ax = None ) : if ax is None : fig , ax = plt . subplots ( figsize = figure_size ) else : fig = ax . get_figur... | Plots a set of recurrence models |
44,229 | def build_area_source_geometry ( area_source ) : geom = [ ] for lon_lat in zip ( area_source . polygon . lons , area_source . polygon . lats ) : geom . extend ( lon_lat ) poslist_node = Node ( "gml:posList" , text = geom ) linear_ring_node = Node ( "gml:LinearRing" , nodes = [ poslist_node ] ) exterior_node = Node ( "g... | Returns the area source geometry as a Node |
44,230 | def build_point_source_geometry ( point_source ) : xy = point_source . location . x , point_source . location . y pos_node = Node ( "gml:pos" , text = xy ) point_node = Node ( "gml:Point" , nodes = [ pos_node ] ) upper_depth_node = Node ( "upperSeismoDepth" , text = point_source . upper_seismogenic_depth ) lower_depth_... | Returns the poing source geometry as a Node |
44,231 | def build_linestring_node ( line , with_depth = False ) : geom = [ ] for p in line . points : if with_depth : geom . extend ( ( p . x , p . y , p . z ) ) else : geom . extend ( ( p . x , p . y ) ) poslist_node = Node ( "gml:posList" , text = geom ) return Node ( "gml:LineString" , nodes = [ poslist_node ] ) | Parses a line to a Node class |
44,232 | def build_simple_fault_geometry ( fault_source ) : linestring_node = build_linestring_node ( fault_source . fault_trace , with_depth = False ) dip_node = Node ( "dip" , text = fault_source . dip ) upper_depth_node = Node ( "upperSeismoDepth" , text = fault_source . upper_seismogenic_depth ) lower_depth_node = Node ( "l... | Returns the simple fault source geometry as a Node |
44,233 | def build_complex_fault_geometry ( fault_source ) : num_edges = len ( fault_source . edges ) edge_nodes = [ ] for iloc , edge in enumerate ( fault_source . edges ) : if iloc == 0 : node_name = "faultTopEdge" elif iloc == ( num_edges - 1 ) : node_name = "faultBottomEdge" else : node_name = "intermediateEdge" edge_nodes ... | Returns the complex fault source geometry as a Node |
44,234 | def build_evenly_discretised_mfd ( mfd ) : occur_rates = Node ( "occurRates" , text = mfd . occurrence_rates ) return Node ( "incrementalMFD" , { "binWidth" : mfd . bin_width , "minMag" : mfd . min_mag } , nodes = [ occur_rates ] ) | Returns the evenly discretized MFD as a Node |
44,235 | def build_truncated_gr_mfd ( mfd ) : return Node ( "truncGutenbergRichterMFD" , { "aValue" : mfd . a_val , "bValue" : mfd . b_val , "minMag" : mfd . min_mag , "maxMag" : mfd . max_mag } ) | Parses the truncated Gutenberg Richter MFD as a Node |
44,236 | def build_arbitrary_mfd ( mfd ) : magnitudes = Node ( "magnitudes" , text = mfd . magnitudes ) occur_rates = Node ( "occurRates" , text = mfd . occurrence_rates ) return Node ( "arbitraryMFD" , nodes = [ magnitudes , occur_rates ] ) | Parses the arbitrary MFD as a Node |
44,237 | def build_youngs_coppersmith_mfd ( mfd ) : return Node ( "YoungsCoppersmithMFD" , { "minMag" : mfd . min_mag , "bValue" : mfd . b_val , "characteristicMag" : mfd . char_mag , "characteristicRate" : mfd . char_rate , "binWidth" : mfd . bin_width } ) | Parses the Youngs & Coppersmith MFD as a node . Note that the MFD does not hold the total moment rate but only the characteristic rate . Therefore the node is written to the characteristic rate version regardless of whether or not it was originally created from total moment rate |
44,238 | def build_multi_mfd ( mfd ) : node = Node ( "multiMFD" , dict ( kind = mfd . kind , size = mfd . size ) ) for name in sorted ( mfd . kwargs ) : values = mfd . kwargs [ name ] if name in ( 'magnitudes' , 'occurRates' ) : if len ( values [ 0 ] ) > 1 : values = list ( numpy . concatenate ( values ) ) else : values = sum (... | Parses the MultiMFD as a Node |
44,239 | def build_nodal_plane_dist ( npd ) : npds = [ ] for prob , npd in npd . data : nodal_plane = Node ( "nodalPlane" , { "dip" : npd . dip , "probability" : prob , "strike" : npd . strike , "rake" : npd . rake } ) npds . append ( nodal_plane ) return Node ( "nodalPlaneDist" , nodes = npds ) | Returns the nodal plane distribution as a Node instance |
44,240 | def build_hypo_depth_dist ( hdd ) : hdds = [ ] for ( prob , depth ) in hdd . data : hdds . append ( Node ( "hypoDepth" , { "depth" : depth , "probability" : prob } ) ) return Node ( "hypoDepthDist" , nodes = hdds ) | Returns the hypocentral depth distribution as a Node instance |
44,241 | def get_distributed_seismicity_source_nodes ( source ) : source_nodes = [ ] source_nodes . append ( Node ( "magScaleRel" , text = source . magnitude_scaling_relationship . __class__ . __name__ ) ) source_nodes . append ( Node ( "ruptAspectRatio" , text = source . rupture_aspect_ratio ) ) source_nodes . append ( obj_to_... | Returns list of nodes of attributes common to all distributed seismicity source classes |
44,242 | def get_fault_source_nodes ( source ) : source_nodes = [ ] source_nodes . append ( Node ( "magScaleRel" , text = source . magnitude_scaling_relationship . __class__ . __name__ ) ) source_nodes . append ( Node ( "ruptAspectRatio" , text = source . rupture_aspect_ratio ) ) source_nodes . append ( obj_to_node ( source . m... | Returns list of nodes of attributes common to all fault source classes |
44,243 | def get_source_attributes ( source ) : attrs = { "id" : source . source_id , "name" : source . name , "tectonicRegion" : source . tectonic_region_type } if isinstance ( source , NonParametricSeismicSource ) : if source . data [ 0 ] [ 0 ] . weight is not None : weights = [ ] for data in source . data : weights . append ... | Retreives a dictionary of source attributes from the source class |
44,244 | def build_area_source_node ( area_source ) : source_nodes = [ build_area_source_geometry ( area_source ) ] source_nodes . extend ( get_distributed_seismicity_source_nodes ( area_source ) ) return Node ( "areaSource" , get_source_attributes ( area_source ) , nodes = source_nodes ) | Parses an area source to a Node class |
44,245 | def build_simple_fault_source_node ( fault_source ) : source_nodes = [ build_simple_fault_geometry ( fault_source ) ] source_nodes . extend ( get_fault_source_nodes ( fault_source ) ) return Node ( "simpleFaultSource" , get_source_attributes ( fault_source ) , nodes = source_nodes ) | Parses a simple fault source to a Node class |
44,246 | def build_complex_fault_source_node ( fault_source ) : source_nodes = [ build_complex_fault_geometry ( fault_source ) ] source_nodes . extend ( get_fault_source_nodes ( fault_source ) ) return Node ( "complexFaultSource" , get_source_attributes ( fault_source ) , nodes = source_nodes ) | Parses a complex fault source to a Node class |
44,247 | def write_source_model ( dest , sources_or_groups , name = None , investigation_time = None ) : if isinstance ( sources_or_groups , nrml . SourceModel ) : with open ( dest , 'wb' ) as f : nrml . write ( [ obj_to_node ( sources_or_groups ) ] , f , '%s' ) return if isinstance ( sources_or_groups [ 0 ] , sourceconverter .... | Writes a source model to XML . |
44,248 | def _get_stddevs ( self , coeffs , stddev_types , num_sites ) : stddevs = [ ] for stddev_type in stddev_types : assert stddev_type in self . DEFINED_FOR_STANDARD_DEVIATION_TYPES stddevs . append ( coeffs [ 'sigma' ] + np . zeros ( num_sites ) ) return np . array ( stddevs ) | Return total sigma as reported in Table 2 p . 1202 . |
44,249 | def get_fault_type_dummy_variables ( self , rup ) : is_normal = np . array ( self . RAKE_THRESH < - rup . rake < ( 180. - self . RAKE_THRESH ) ) is_reverse = np . array ( self . RAKE_THRESH < rup . rake < ( 180. - self . RAKE_THRESH ) ) if not self . ALREADY_WARNED and is_normal . any ( ) : msg = ( 'Normal faulting not... | Fault - type classification dummy variable based on rup . rake . |
44,250 | def read_data ( self , scaling_factor = 1E-9 , strain_headers = None ) : if strain_headers : self . strain . data_variables = strain_headers else : self . strain . data_variables = STRAIN_VARIABLES datafile = open ( self . filename , 'r' ) reader = csv . DictReader ( datafile ) self . strain . data = dict ( [ ( name , ... | Reads the data from the csv file |
44,251 | def _check_invalid_longitudes ( self ) : idlon = self . strain . data [ 'longitude' ] > 180. if np . any ( idlon ) : self . strain . data [ 'longitude' ] [ idlon ] = self . strain . data [ 'longitude' ] [ idlon ] - 360. | Checks to ensure that all longitudes are in the range - 180 . to 180 |
44,252 | def write_file ( self , strain , scaling_factor = 1E-9 ) : if not isinstance ( strain , GeodeticStrain ) : raise ValueError ( 'Strain data must be instance of GeodeticStrain' ) for key in strain . data . keys ( ) : if key in strain . data_variables : if key in [ 'longitude' , 'latitude' ] : continue strain . data [ key... | Main writer function for the csv file |
44,253 | def slice_rates_to_data ( self , strain ) : output_variables = list ( strain . data ) cond = ( isinstance ( strain . target_magnitudes , np . ndarray ) or isinstance ( strain . target_magnitudes , list ) ) if cond : magnitude_list = [ '%.3f' % mag for mag in strain . target_magnitudes ] else : return strain , output_va... | For the strain data checks to see if seismicity rates have been calculated . If so each column in the array is sliced and stored as a single vector in the strain . data dictionary with the corresponding magnitude as a key . |
44,254 | def read ( * paths , ** validators ) : paths = config . paths + list ( paths ) parser = configparser . ConfigParser ( ) found = parser . read ( os . path . normpath ( os . path . expanduser ( p ) ) for p in paths ) if not found : raise IOError ( 'No configuration file found in %s' % str ( paths ) ) config . found = fou... | Load the configuration make each section available in a separate dict . |
44,255 | def boolean ( flag ) : s = flag . lower ( ) if s in ( '1' , 'yes' , 'true' ) : return True elif s in ( '0' , 'no' , 'false' ) : return False raise ValueError ( 'Unknown flag %r' % s ) | Convert string in boolean |
44,256 | def _get_mean ( self , vs30 , mag , rrup , imt , scale_fac ) : C_HR , C_BC , C_SR , SC = self . _extract_coeffs ( imt ) rrup = self . _clip_distances ( rrup ) f0 = self . _compute_f0_factor ( rrup ) f1 = self . _compute_f1_factor ( rrup ) f2 = self . _compute_f2_factor ( rrup ) pga_bc = self . _get_pga_bc ( f0 , f1 , f... | Compute and return mean |
44,257 | def _get_pga_bc ( self , f0 , f1 , f2 , SC , mag , rrup , vs30 , scale_fac ) : pga_bc = np . zeros_like ( vs30 ) self . _compute_mean ( self . COEFFS_BC [ PGA ( ) ] , f0 , f1 , f2 , SC , mag , rrup , vs30 < 2000.0 , pga_bc , scale_fac ) return ( 10 ** pga_bc ) * 1e-2 / g | Compute and return PGA on BC boundary |
44,258 | def _extract_coeffs ( self , imt ) : C_HR = self . COEFFS_HARD_ROCK [ imt ] C_BC = self . COEFFS_BC [ imt ] C_SR = self . COEFFS_SOIL_RESPONSE [ imt ] SC = self . COEFFS_STRESS [ imt ] return C_HR , C_BC , C_SR , SC | Extract dictionaries of coefficients specific to required intensity measure type . |
44,259 | def init ( self ) : if hasattr ( self , 'data' ) : return if isinstance ( self . dstore , str ) : self . dstore = hdf5 . File ( self . dstore , 'r' ) else : self . dstore . open ( 'r' ) if self . sids is None : self . sids = self . dstore [ 'sitecol' ] . sids oq = self . dstore [ 'oqparam' ] self . imtls = oq . imtls s... | Read the poes and set the . data attribute with the hazard curves |
44,260 | def get_mean ( self , grp = None ) : self . init ( ) if len ( self . weights ) == 1 : pmap = self . get ( 0 , grp ) for sid , pcurve in pmap . items ( ) : array = numpy . zeros ( pcurve . array . shape [ : - 1 ] + ( 2 , ) ) array [ : , 0 ] = pcurve . array [ : , 0 ] pcurve . array = array return pmap else : dic = ( { g... | Compute the mean curve as a ProbabilityMap |
44,261 | def init ( self ) : if hasattr ( self , 'computers' ) : return with hdf5 . File ( self . rupgetter . filename , 'r' ) as parent : self . weights = parent [ 'weights' ] . value self . computers = [ ] for ebr in self . rupgetter . get_ruptures ( self . srcfilter ) : sitecol = self . sitecol . filtered ( ebr . sids ) try ... | Initialize the computers . Should be called on the workers |
44,262 | def _compute_forearc_backarc_term ( self , C , sites , dists , rup ) : flag1 = np . zeros ( len ( dists . rhypo ) ) ind1 = np . logical_and ( ( dists . rhypo < 335 ) , ( dists . rhypo >= 205 ) ) flag1 [ ind1 ] = 1.0 flag2 = np . zeros ( len ( dists . rhypo ) ) ind2 = ( dists . rhypo >= 335 ) flag2 [ ind2 ] = 1.0 flag3 ... | Compute back - arc term of Equation 3 |
44,263 | def _build_data ( self , amplification_group ) : n_levels = len ( amplification_group ) level = next ( iter ( amplification_group ) ) n_d , n_p , n_m = amplification_group [ level ] [ "IMLs/SA" ] . shape assert n_d == len ( self . distances ) , ( n_d , len ( self . distances ) ) assert n_m == len ( self . magnitudes ) ... | Creates the numpy array tables from the hdf5 tables |
44,264 | def get_amplification_factors ( self , imt , sctx , rctx , dists , stddev_types ) : dist_level_table = self . get_mean_table ( imt , rctx ) sigma_tables = self . get_sigma_tables ( imt , rctx , stddev_types ) mean_interpolator = interp1d ( self . values , numpy . log10 ( dist_level_table ) , axis = 1 ) sigma_interpolat... | Returns the amplification factors for the given rupture and site conditions . |
44,265 | def get_mean_table ( self , imt , rctx ) : if imt . name in 'PGA PGV' : interpolator = interp1d ( self . magnitudes , numpy . log10 ( self . mean [ imt . name ] ) , axis = 2 ) output_table = 10.0 ** ( interpolator ( rctx . mag ) . reshape ( self . shape [ 0 ] , self . shape [ 3 ] ) ) else : interpolator = interp1d ( nu... | Returns amplification factors for the mean given the rupture and intensity measure type . |
44,266 | def get_sigma_tables ( self , imt , rctx , stddev_types ) : output_tables = [ ] for stddev_type in stddev_types : if imt . name in 'PGA PGV' : interpolator = interp1d ( self . magnitudes , self . sigma [ stddev_type ] [ imt . name ] , axis = 2 ) output_tables . append ( interpolator ( rctx . mag ) . reshape ( self . sh... | Returns modification factors for the standard deviations given the rupture and intensity measure type . |
44,267 | def init ( self , fle = None ) : if fle is None : fname = self . kwargs . get ( 'gmpe_table' , self . GMPE_TABLE ) if fname is None : raise ValueError ( 'You forgot to set GMPETable.GMPE_TABLE!' ) elif os . path . isabs ( fname ) : self . GMPE_TABLE = fname else : self . GMPE_TABLE = os . path . abspath ( os . path . j... | Executes the preprocessing steps at the instantiation stage to read in the tables from hdf5 and hold them in memory . |
44,268 | def _setup_amplification ( self , fle ) : self . amplification = AmplificationTable ( fle [ "Amplification" ] , self . m_w , self . distances ) if self . amplification . element == "Sites" : self . REQUIRES_SITES_PARAMETERS = set ( [ self . amplification . parameter ] ) elif self . amplification . element == "Rupture" ... | If amplification data is specified then reads into memory and updates the required rupture and site parameters |
44,269 | def _supported_imts ( self ) : imt_list = [ ] for key in self . imls : if "SA" in key : imt_list . append ( imt_module . SA ) elif key == "T" : continue else : try : factory = getattr ( imt_module , key ) except Exception : continue imt_list . append ( factory ) return imt_list | Updates the list of supported IMTs from the tables |
44,270 | def get_mean_and_stddevs ( self , sctx , rctx , dctx , imt , stddev_types ) : imls = self . _return_tables ( rctx . mag , imt , "IMLs" ) idx = numpy . searchsorted ( self . m_w , rctx . mag ) dists = self . distances [ : , 0 , idx - 1 ] mean = self . _get_mean ( imls , dctx , dists ) stddevs = self . _get_stddevs ( dis... | Returns the mean and standard deviations |
44,271 | def _get_stddevs ( self , dists , mag , dctx , imt , stddev_types ) : stddevs = [ ] for stddev_type in stddev_types : if stddev_type not in self . DEFINED_FOR_STANDARD_DEVIATION_TYPES : raise ValueError ( "Standard Deviation type %s not supported" % stddev_type ) sigma = self . _return_tables ( mag , imt , stddev_type ... | Returns the total standard deviation of the intensity measure level from the tables . |
44,272 | def _return_tables ( self , mag , imt , val_type ) : if imt . name in 'PGA PGV' : if val_type == "IMLs" : iml_table = self . imls [ imt . name ] [ : ] else : iml_table = self . stddevs [ val_type ] [ imt . name ] [ : ] n_d , n_s , n_m = iml_table . shape iml_table = iml_table . reshape ( [ n_d , n_m ] ) else : if val_t... | Returns the vector of ground motions or standard deviations corresponding to the specific magnitude and intensity measure type . |
44,273 | def apply_magnitude_interpolation ( self , mag , iml_table ) : if mag > self . m_w [ - 1 ] : mag = self . m_w [ - 1 ] if mag < self . m_w [ 0 ] or mag > self . m_w [ - 1 ] : raise ValueError ( "Magnitude %.2f outside of supported range " "(%.2f to %.2f)" % ( mag , self . m_w [ 0 ] , self . m_w [ - 1 ] ) ) m_interpolato... | Interpolates the tables to the required magnitude level |
44,274 | def _get_mean_deep_soil ( self , mag , rake , rrup , is_reverse , imt ) : if mag <= self . NEAR_FIELD_SATURATION_MAG : c4 = self . COEFFS_SOIL_IMT_INDEPENDENT [ 'c4lowmag' ] c5 = self . COEFFS_SOIL_IMT_INDEPENDENT [ 'c5lowmag' ] else : c4 = self . COEFFS_SOIL_IMT_INDEPENDENT [ 'c4himag' ] c5 = self . COEFFS_SOIL_IMT_IN... | Calculate and return the mean intensity for deep soil sites . |
44,275 | def _get_mean_rock ( self , mag , _rake , rrup , is_reverse , imt ) : if mag <= self . NEAR_FIELD_SATURATION_MAG : C = self . COEFFS_ROCK_LOWMAG [ imt ] else : C = self . COEFFS_ROCK_HIMAG [ imt ] mag = 8.5 if mag > 8.5 else mag mean = ( C [ 'c1' ] + C [ 'c2' ] * mag + C [ 'c3' ] * ( ( 8.5 - mag ) ** 2.5 ) + C [ 'c4' ]... | Calculate and return the mean intensity for rock sites . |
44,276 | def _get_stddev_rock ( self , mag , imt ) : C = self . COEFFS_ROCK_STDDERR [ imt ] if mag > C [ 'maxmag' ] : return C [ 'maxsigma' ] else : return C [ 'sigma0' ] + C [ 'magfactor' ] * mag | Calculate and return total standard deviation for rock sites . |
44,277 | def _get_stddev_deep_soil ( self , mag , imt ) : if mag > 7 : mag = 7 C = self . COEFFS_SOIL [ imt ] return C [ 'sigma0' ] + C [ 'magfactor' ] * mag | Calculate and return total standard deviation for deep soil sites . |
44,278 | def zip ( what , archive_zip = '' , risk_file = '' ) : if os . path . isdir ( what ) : oqzip . zip_all ( what ) elif what . endswith ( '.xml' ) and '<logicTree' in open ( what ) . read ( 512 ) : oqzip . zip_source_model ( what , archive_zip ) elif what . endswith ( '.xml' ) and '<exposureModel' in open ( what ) . read ... | Zip into an archive one or two job . ini files with all related files |
44,279 | def reduce ( fname , reduction_factor ) : if fname . endswith ( '.csv' ) : with open ( fname ) as f : line = f . readline ( ) if csv . Sniffer ( ) . has_header ( line ) : header = line all_lines = f . readlines ( ) else : header = None f . seek ( 0 ) all_lines = f . readlines ( ) lines = general . random_filter ( all_l... | Produce a submodel from fname by sampling the nodes randomly . Supports source models site models and exposure models . As a special case it is also able to reduce . csv files by sampling the lines . This is a debugging utility to reduce large computations to small ones . |
44,280 | def downsample_mesh ( mesh , tol = 1.0 ) : idx = _find_turning_points ( mesh , tol ) if mesh . depths is not None : return RectangularMesh ( lons = mesh . lons [ : , idx ] , lats = mesh . lats [ : , idx ] , depths = mesh . depths [ : , idx ] ) else : return RectangularMesh ( lons = mesh . lons [ : , idx ] , lats = mesh... | Returns a mesh sampled at a lower resolution - if the difference in azimuth is larger than the specified tolerance a turn is assumed |
44,281 | def downsample_trace ( mesh , tol = 1.0 ) : idx = _find_turning_points ( mesh , tol ) if mesh . depths is not None : return numpy . column_stack ( [ mesh . lons [ 0 , idx ] , mesh . lats [ 0 , idx ] , mesh . depths [ 0 , idx ] ] ) else : return numpy . column_stack ( [ mesh . lons [ 0 , idx ] , mesh . lats [ 0 , idx ] ... | Downsamples the upper edge of a fault within a rectangular mesh retaining node points only if changes in direction on the order of tol are found |
44,282 | def get_ry0_distance ( self , mesh ) : top_edge = self . mesh [ 0 : 1 ] mean_strike = self . get_strike ( ) dst1 = geodetic . distance_to_arc ( top_edge . lons [ 0 , 0 ] , top_edge . lats [ 0 , 0 ] , ( mean_strike + 90. ) % 360 , mesh . lons , mesh . lats ) dst2 = geodetic . distance_to_arc ( top_edge . lons [ 0 , - 1 ... | Compute the minimum distance between each point of a mesh and the great circle arcs perpendicular to the average strike direction of the fault trace and passing through the end - points of the trace . |
44,283 | def get_rx_distance ( self , mesh ) : top_edge = self . mesh [ 0 : 1 ] dists = [ ] if top_edge . lons . shape [ 1 ] < 3 : i = 0 p1 = Point ( top_edge . lons [ 0 , i ] , top_edge . lats [ 0 , i ] , top_edge . depths [ 0 , i ] ) p2 = Point ( top_edge . lons [ 0 , i + 1 ] , top_edge . lats [ 0 , i + 1 ] , top_edge . depth... | Compute distance between each point of mesh and surface s great circle arc . |
44,284 | def get_top_edge_depth ( self ) : top_edge = self . mesh [ 0 : 1 ] if top_edge . depths is None : return 0 else : return numpy . min ( top_edge . depths ) | Return minimum depth of surface s top edge . |
44,285 | def get_area ( self ) : mesh = self . mesh _ , _ , _ , area = mesh . get_cell_dimensions ( ) return numpy . sum ( area ) | Compute area as the sum of the mesh cells area values . |
44,286 | def get_surface_boundaries ( self ) : mesh = self . mesh lons = numpy . concatenate ( ( mesh . lons [ 0 , : ] , mesh . lons [ 1 : , - 1 ] , mesh . lons [ - 1 , : - 1 ] [ : : - 1 ] , mesh . lons [ : - 1 , 0 ] [ : : - 1 ] ) ) lats = numpy . concatenate ( ( mesh . lats [ 0 , : ] , mesh . lats [ 1 : , - 1 ] , mesh . lats [... | Returns the boundaries in the same format as a multiplanar surface with two one - element lists of lons and lats |
44,287 | def get_resampled_top_edge ( self , angle_var = 0.1 ) : mesh = self . mesh top_edge = [ Point ( mesh . lons [ 0 ] [ 0 ] , mesh . lats [ 0 ] [ 0 ] , mesh . depths [ 0 ] [ 0 ] ) ] for i in range ( len ( mesh . triangulate ( ) [ 1 ] [ 0 ] ) - 1 ) : v1 = numpy . asarray ( mesh . triangulate ( ) [ 1 ] [ 0 ] [ i ] ) v2 = num... | This methods computes a simplified representation of a fault top edge by removing the points that are not describing a change of direction provided a certain tolerance angle . |
44,288 | def get_hypo_location ( self , mesh_spacing , hypo_loc = None ) : mesh = self . mesh centroid = mesh . get_middle_point ( ) if hypo_loc is None : return centroid total_len_y = ( len ( mesh . depths ) - 1 ) * mesh_spacing y_distance = hypo_loc [ 1 ] * total_len_y y_node = int ( numpy . round ( y_distance / mesh_spacing ... | The method determines the location of the hypocentre within the rupture |
44,289 | def viewlog ( calc_id , host = 'localhost' , port = 8000 ) : base_url = 'http://%s:%s/v1/calc/' % ( host , port ) start = 0 psize = 10 try : while True : url = base_url + '%d/log/%d:%d' % ( calc_id , start , start + psize ) rows = json . load ( urlopen ( url ) ) for row in rows : print ( ' ' . join ( row ) ) start += l... | Extract the log of the given calculation ID from the WebUI |
44,290 | def pickle_sequence ( objects ) : cache = { } out = [ ] for obj in objects : obj_id = id ( obj ) if obj_id not in cache : if isinstance ( obj , Pickled ) : cache [ obj_id ] = obj else : cache [ obj_id ] = Pickled ( obj ) out . append ( cache [ obj_id ] ) return out | Convert an iterable of objects into a list of pickled objects . If the iterable contains copies the pickling will be done only once . If the iterable contains objects already pickled they will not be pickled again . |
44,291 | def check_mem_usage ( soft_percent = None , hard_percent = None ) : soft_percent = soft_percent or config . memory . soft_mem_limit hard_percent = hard_percent or config . memory . hard_mem_limit used_mem_percent = psutil . virtual_memory ( ) . percent if used_mem_percent > hard_percent : raise MemoryError ( 'Using mor... | Display a warning if we are running out of memory |
44,292 | def init_workers ( ) : setproctitle ( 'oq-worker' ) signal . signal ( signal . SIGTERM , signal . SIG_DFL ) try : import prctl except ImportError : pass else : prctl . set_pdeathsig ( signal . SIGKILL ) | Waiting function used to wake up the process pool |
44,293 | def get ( self ) : val = self . pik . unpickle ( ) if self . tb_str : etype = val . __class__ msg = '\n%s%s: %s' % ( self . tb_str , etype . __name__ , val ) if issubclass ( etype , KeyError ) : raise RuntimeError ( msg ) else : raise etype ( msg ) return val | Returns the underlying value or raise the underlying exception |
44,294 | def sum ( cls , iresults ) : res = object . __new__ ( cls ) res . received = [ ] res . sent = 0 for iresult in iresults : res . received . extend ( iresult . received ) res . sent += iresult . sent name = iresult . name . split ( '#' , 1 ) [ 0 ] if hasattr ( res , 'name' ) : assert res . name . split ( '#' , 1 ) [ 0 ] ... | Sum the data transfer information of a set of results |
44,295 | def log_percent ( self ) : done = self . total - self . todo percent = int ( float ( done ) / self . total * 100 ) if not hasattr ( self , 'prev_percent' ) : self . prev_percent = 0 self . progress ( 'Sent %s of data in %d %s task(s)' , humansize ( self . sent . sum ( ) ) , self . total , self . name ) elif percent > s... | Log the progress of the computation in percentage |
44,296 | def submit ( self , * args , func = None , monitor = None ) : monitor = monitor or self . monitor func = func or self . task_func if not hasattr ( self , 'socket' ) : self . __class__ . running_tasks = self . tasks self . socket = Socket ( self . receiver , zmq . PULL , 'bind' ) . __enter__ ( ) monitor . backurl = 'tcp... | Submit the given arguments to the underlying task |
44,297 | def reduce ( self , agg = operator . add , acc = None ) : return self . submit_all ( ) . reduce ( agg , acc ) | Submit all tasks and reduce the results |
44,298 | def convert ( self , imtls , idx = 0 ) : curve = numpy . zeros ( 1 , imtls . dt ) for imt in imtls : curve [ imt ] = self . array [ imtls ( imt ) , idx ] return curve [ 0 ] | Convert a probability curve into a record of dtype imtls . dt . |
44,299 | def nbytes ( self ) : try : N , L , I = get_shape ( [ self ] ) except AllEmptyProbabilityMaps : return 0 return BYTES_PER_FLOAT * N * L * I | The size of the underlying array |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.