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 , multipoint . convex_hull | 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 ( polygon , shapely . geometry . Polygon ) : polygon = polygon . buffer ( self . DIST_TOLERANCE , 1 ) mesh_xx , mesh_yy = proj ( mesh . lons [ idxs ] , mesh . lats [ idxs ] ) distances [ idxs ] = geo_utils . point_to_polygon_distance ( polygon , mesh_xx , mesh_yy ) return distances | 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 . _from_2d ( polygon2d , proj ) | 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 = len ( points [ 0 ] ) for i , row in enumerate ( points ) : assert len ( row ) == num_cols , 'lists of points are not of uniform length' for j , point in enumerate ( row ) : lons [ i , j ] = point . longitude lats [ i , j ] = point . latitude depths [ i , j ] = point . depth if not depths . any ( ) : depths = None return cls ( lons , lats , depths ) | 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 ) else : lon1 , lon2 = self . lons [ mid_row , mid_col - 1 : mid_col + 1 ] lat1 , lat2 = self . lats [ mid_row , mid_col - 1 : mid_col + 1 ] depth1 = self . depths [ mid_row , mid_col - 1 ] depth2 = self . depths [ mid_row , mid_col ] else : submesh1 = self [ mid_row - 1 : mid_row ] submesh2 = self [ mid_row : mid_row + 1 ] p1 , p2 = submesh1 . get_middle_point ( ) , submesh2 . get_middle_point ( ) lon1 , lat1 , depth1 = p1 . longitude , p1 . latitude , p1 . depth lon2 , lat2 , depth2 = p2 . longitude , p2 . latitude , p2 . depth depth = ( depth1 + depth2 ) / 2.0 lon , lat = geo_utils . get_middle_point ( lon1 , lat1 , lon2 , lat2 ) return Point ( lon , lat , depth ) | 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 . sum ( left * left , axis = - 1 ) ) bottom = along_azimuth [ 1 : ] right = updip [ : , 1 : ] br_area = geo_utils . triangle_area ( bottom , right , diag ) bottom_length = numpy . sqrt ( numpy . sum ( bottom * bottom , axis = - 1 ) ) right_length = numpy . sqrt ( numpy . sum ( right * right , axis = - 1 ) ) cell_area = tl_area + br_area tl_center = ( points [ : - 1 , : - 1 ] + points [ : - 1 , 1 : ] + points [ 1 : , : - 1 ] ) / 3 br_center = ( points [ : - 1 , 1 : ] + points [ 1 : , : - 1 ] + points [ 1 : , 1 : ] ) / 3 cell_center = ( ( tl_center * tl_area . reshape ( tl_area . shape + ( 1 , ) ) + br_center * br_area . reshape ( br_area . shape + ( 1 , ) ) ) / cell_area . reshape ( cell_area . shape + ( 1 , ) ) ) cell_length = ( ( top_length * tl_area + bottom_length * br_area ) / cell_area ) cell_width = ( ( left_length * tl_area + right_length * br_area ) / cell_area ) return cell_center , cell_length , cell_width , cell_area | 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 ] ) if is_3d : dist_val = np . sqrt ( dist_val . flatten ( ) ** 2.0 + ( data [ : , 2 ] - data [ iloc , 2 ] ) ** 2.0 ) id0 = np . where ( dist_val <= max_dist ) [ 0 ] w_val = ( np . exp ( - ( dist_val [ id0 ] ** 2.0 ) / ( config [ 'BandWidth' ] ** 2. ) ) ) . flatten ( ) smoothed_value [ iloc ] = np . sum ( w_val * data [ id0 , 3 ] ) / np . sum ( w_val ) return smoothed_value , np . sum ( data [ : , - 1 ] ) , np . sum ( smoothed_value ) | 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 ( mo . group ( 1 ) ) purge_one ( calc_id , user ) | 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 = [ Polygon ( polygon ) ] elif ptype == 'MultiPolygon' : polygon = [ Polygon ( p ) for p in polygon ] else : raise ValueError ( "A polygon or multi-polygon representation is required" ) else : polygon = getattr ( polygon , '__geo_interface__' , polygon ) ptype = polygon [ "type" ] if ptype == 'Polygon' : polygon = [ Polygon ( polygon ) ] elif ptype == 'MultiPolygon' : polygon = [ Polygon ( p ) for p in polygon [ 'coordinates' ] ] else : raise ValueError ( "A polygon or multi-polygon representation is required" ) vertices = concatenate ( [ concatenate ( [ asarray ( t . exterior ) [ : , : 2 ] ] + [ asarray ( r ) [ : , : 2 ] for r in t . interiors ] ) for t in polygon ] ) codes = concatenate ( [ concatenate ( [ coding ( t . exterior ) ] + [ coding ( r ) for r in t . interiors ] ) for t in polygon ] ) return PathPatch ( Path ( vertices , codes ) , ** kwargs ) | 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 [ "SA" ] [ : ] fle . close ( ) | 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" ] ) + c3 * ( rval - self . CONSTANTS [ "Rref" ] ) return f_r | 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 . mags , sigma_mu , axis = 0 ) sigma_mu_m = intpl1 ( rup . mag ) intpl2 = interp1d ( self . dists , sigma_mu_m , bounds_error = False , fill_value = ( sigma_mu_m [ 0 ] , sigma_mu_m [ - 1 ] ) ) return intpl2 ( dists . rjb ) if rup . mag <= self . mags [ 0 ] : sigma_mu_m = self . s_a [ 0 , : , : ] elif rup . mag >= self . mags [ - 1 ] : sigma_mu_m = self . s_a [ - 1 , : , : ] else : intpl1 = interp1d ( self . mags , self . s_a , axis = 0 ) sigma_mu_m = intpl1 ( rup . mag ) if imt . period <= self . periods [ 0 ] : sigma_mu_t = sigma_mu_m [ : , 0 ] elif imt . period >= self . periods [ - 1 ] : sigma_mu_t = sigma_mu_m [ : , - 1 ] else : intpl2 = interp1d ( np . log ( self . periods ) , sigma_mu_m , axis = 1 ) sigma_mu_t = intpl2 ( np . log ( imt . period ) ) intpl3 = interp1d ( self . dists , sigma_mu_t , bounds_error = False , fill_value = ( sigma_mu_t [ 0 ] , sigma_mu_t [ - 1 ] ) ) return intpl3 ( dists . rjb ) | 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 . log ( sites . vs30 [ idx ] ) ) return ampl | 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 . sqrt ( C [ "phi0" ] ** 2.0 + sigma_s ** 2. ) for stddev_type in stddev_types : assert stddev_type in self . DEFINED_FOR_STANDARD_DEVIATION_TYPES if stddev_type == const . StdDev . TOTAL : stddevs . append ( np . sqrt ( tau ** 2. + phi ** 2. ) + np . zeros ( stddev_shape ) ) elif stddev_type == const . StdDev . INTRA_EVENT : stddevs . append ( phi + np . zeros ( stddev_shape ) ) elif stddev_type == const . StdDev . INTER_EVENT : stddevs . append ( tau + np . zeros ( stddev_shape ) ) return stddevs | 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 . sin ( ( lons1 - lons2 ) / 2.0 ) ** 2.0 ) ) return diameter * distance | 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 ( lats1 ) * cos_lat2 * numpy . cos ( lons1 - lons2 ) ) ) return ( 360 - true_course ) % 360 | 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 ] , lons , lats ) idx_in = numpy . nonzero ( ( numpy . cos ( numpy . radians ( seg_azim - azimuth1 ) ) >= 0.0 ) & ( numpy . cos ( numpy . radians ( seg_azim - azimuth2 ) ) <= 0.0 ) ) idx_out = numpy . nonzero ( ( numpy . cos ( numpy . radians ( seg_azim - azimuth1 ) ) < 0.0 ) | ( numpy . cos ( numpy . radians ( seg_azim - azimuth2 ) ) > 0.0 ) ) idx_neg = numpy . nonzero ( numpy . sin ( numpy . radians ( ( azimuth1 - seg_azim ) ) ) < 0.0 ) dists = numpy . zeros_like ( lons ) if len ( idx_in [ 0 ] ) : dists [ idx_in ] = distance_to_arc ( seglons [ 0 ] , seglats [ 0 ] , seg_azim , lons [ idx_in ] , lats [ idx_in ] ) if len ( idx_out [ 0 ] ) : dists [ idx_out ] = min_geodetic_distance ( ( seglons , seglats ) , ( lons [ idx_out ] , lats [ idx_out ] ) ) dists = abs ( dists ) dists [ idx_neg ] = - dists [ idx_neg ] return dists | 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_intervals == 0 : return numpy . array ( [ lon1 ] ) , numpy . array ( [ lat1 ] ) , numpy . array ( [ depth1 ] ) dist_factor = ( length * num_intervals ) / total_distance return npoints_towards ( lon1 , lat1 , depth1 , azimuth ( lon1 , lat1 , lon2 , lat2 ) , hdist * dist_factor , vdist * dist_factor , num_intervals + 1 ) | 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 [ - 1 ] = lat2 rdepths [ - 1 ] = depth2 return rlons , rlats , rdepths | 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 = numpy . arange ( npoints , dtype = float ) vdists *= vdist / ( npoints - 1 ) sin_dists = numpy . sin ( hdists ) cos_dists = numpy . cos ( hdists ) sin_lat = numpy . sin ( rlat ) cos_lat = numpy . cos ( rlat ) sin_lats = sin_lat * cos_dists + cos_lat * sin_dists * numpy . cos ( tc ) lats = numpy . degrees ( numpy . arcsin ( sin_lats ) ) dlon = numpy . arctan2 ( numpy . sin ( tc ) * sin_dists * cos_lat , cos_dists - sin_lat * sin_lats ) lons = numpy . mod ( rlon - dlon + numpy . pi , 2 * numpy . pi ) - numpy . pi lons = numpy . degrees ( lons ) depths = vdists + depth lons [ 0 ] = lon lats [ 0 ] = lat depths [ 0 ] = depth return lons , lats , depths | 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 ) : self . catalogue = selector . within_rupture_distance ( self . geometry , distance , upper_depth = upper_eq_depth , lower_depth = lower_eq_depth ) else : self . catalogue = selector . within_joyner_boore_distance ( self . geometry , distance , upper_depth = upper_eq_depth , lower_depth = lower_eq_depth ) if self . catalogue . get_number_events ( ) < 5 : warnings . warn ( 'Source %s (%s) has fewer than 5 events' % ( self . id , self . name ) ) | 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_figure ( ) for config in configs : model = RecurrenceBranch ( area , slip , msr , rake , shear_modulus , disp_length_ratio , msr_sigma , weight = 1.0 ) model . get_recurrence ( config ) occurrence = model . recurrence . occur_rates cumulative = np . array ( [ np . sum ( occurrence [ iloc : ] ) for iloc in range ( 0 , len ( occurrence ) ) ] ) if 'AndersonLuco' in config [ 'Model_Name' ] : flt_label = config [ 'Model_Name' ] + ' - ' + config [ 'Model_Type' ] + ' Type' else : flt_label = config [ 'Model_Name' ] flt_color = np . random . uniform ( 0.1 , 1.0 , 3 ) ax . semilogy ( model . magnitudes , cumulative , '-' , label = flt_label , color = flt_color , linewidth = 2. ) ax . semilogy ( model . magnitudes , model . recurrence . occur_rates , '--' , color = flt_color , linewidth = 2. ) ax . set_xlabel ( 'Magnitude' ) ax . set_ylabel ( 'Annual Rate' ) ax . legend ( bbox_to_anchor = ( 1.1 , 1.0 ) ) _save_image ( fig , filename , filetype , dpi ) | 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 ( "gml:exterior" , nodes = [ linear_ring_node ] ) polygon_node = Node ( "gml:Polygon" , nodes = [ exterior_node ] ) upper_depth_node = Node ( "upperSeismoDepth" , text = area_source . upper_seismogenic_depth ) lower_depth_node = Node ( "lowerSeismoDepth" , text = area_source . lower_seismogenic_depth ) return Node ( "areaGeometry" , { 'discretization' : area_source . area_discretization } , nodes = [ polygon_node , upper_depth_node , lower_depth_node ] ) | 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_node = Node ( "lowerSeismoDepth" , text = point_source . lower_seismogenic_depth ) return Node ( "pointGeometry" , nodes = [ point_node , upper_depth_node , lower_depth_node ] ) | 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 ( "lowerSeismoDepth" , text = fault_source . lower_seismogenic_depth ) return Node ( "simpleFaultGeometry" , nodes = [ linestring_node , dip_node , upper_depth_node , lower_depth_node ] ) | 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 . append ( Node ( node_name , nodes = [ build_linestring_node ( edge , with_depth = True ) ] ) ) return Node ( "complexFaultGeometry" , nodes = 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 ( values , [ ] ) node . append ( Node ( name , text = values ) ) if 'occurRates' in mfd . kwargs : lengths = [ len ( rates ) for rates in mfd . kwargs [ 'occurRates' ] ] node . append ( Node ( 'lengths' , text = lengths ) ) return node | 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_node ( source . mfd ) ) source_nodes . append ( build_nodal_plane_dist ( source . nodal_plane_distribution ) ) source_nodes . append ( build_hypo_depth_dist ( source . hypocenter_distribution ) ) return source_nodes | 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 . mfd ) ) source_nodes . append ( Node ( "rake" , text = source . rake ) ) if len ( getattr ( source , 'hypo_list' , [ ] ) ) : source_nodes . append ( build_hypo_list_node ( source . hypo_list ) ) if len ( getattr ( source , 'slip_list' , [ ] ) ) : source_nodes . append ( build_slip_list_node ( source . slip_list ) ) return source_nodes | 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 ( data [ 0 ] . weight ) attrs [ 'rup_weights' ] = numpy . array ( weights ) print ( attrs ) return attrs | 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 . SourceGroup ) : groups = sources_or_groups else : srcs_by_trt = groupby ( sources_or_groups , operator . attrgetter ( 'tectonic_region_type' ) ) groups = [ sourceconverter . SourceGroup ( trt , srcs_by_trt [ trt ] ) for trt in srcs_by_trt ] name = name or os . path . splitext ( os . path . basename ( dest ) ) [ 0 ] nodes = list ( map ( obj_to_node , sorted ( groups ) ) ) attrs = { "name" : name } if investigation_time is not None : attrs [ 'investigation_time' ] = investigation_time source_model = Node ( "sourceModel" , attrs , nodes = nodes ) with open ( dest , 'wb' ) as f : nrml . write ( [ source_model ] , f , '%s' ) return dest | 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 supported by %s; ' 'treating as strike-slip' % type ( self ) . __name__ ) warnings . warn ( msg , UserWarning ) self . ALREADY_WARNED = True is_strike_slip = ~ is_reverse | is_normal is_strike_slip = is_strike_slip . astype ( float ) return is_strike_slip | 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 , [ ] ) for name in reader . fieldnames ] ) for row in reader : for name in row . keys ( ) : if 'region' in name . lower ( ) : self . strain . data [ name ] . append ( row [ name ] ) elif name in self . strain . data_variables : self . strain . data [ name ] . append ( scaling_factor * float ( row [ name ] ) ) else : self . strain . data [ name ] . append ( float ( row [ name ] ) ) for key in self . strain . data . keys ( ) : if 'region' in key : self . strain . data [ key ] = np . array ( self . strain . data [ key ] , dtype = 'S13' ) else : self . strain . data [ key ] = np . array ( self . strain . data [ key ] ) self . _check_invalid_longitudes ( ) if 'region' not in self . strain . data : print ( 'No tectonic regionalisation found in input file!' ) self . strain . data_variables = self . strain . data . keys ( ) self . strain . get_secondary_strain_data ( ) return self . strain | 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 ] = strain . data [ key ] / scaling_factor strain , output_variables = self . slice_rates_to_data ( strain ) outfile = open ( self . filename , 'wt' ) print ( 'Writing strain data to file %s' % self . filename ) writer = csv . DictWriter ( outfile , fieldnames = output_variables ) writer . writeheader ( ) for iloc in range ( 0 , strain . get_number_observations ( ) ) : row_dict = { } for key in output_variables : if len ( strain . data [ key ] ) > 0 : row_dict [ key ] = strain . data [ key ] [ iloc ] writer . writerow ( row_dict ) outfile . close ( ) print ( 'done!' ) | 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_variables assert np . shape ( strain . seismicity_rate ) [ 0 ] == strain . get_number_observations ( ) for iloc , magnitude in enumerate ( magnitude_list ) : strain . data [ magnitude ] = strain . seismicity_rate [ : , iloc ] output_variables . extend ( magnitude_list ) return strain , output_variables | 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 = found config . clear ( ) for section in parser . sections ( ) : config [ section ] = sec = DotDict ( parser . items ( section ) ) for k , v in sec . items ( ) : sec [ k ] = validators . get ( k , lambda x : x ) ( v ) | 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 , f2 , SC , mag , rrup , vs30 , scale_fac ) mean = np . zeros_like ( vs30 ) self . _compute_mean ( C_HR , f0 , f1 , f2 , SC , mag , rrup , vs30 >= 2000.0 , mean , scale_fac ) self . _compute_mean ( C_BC , f0 , f1 , f2 , SC , mag , rrup , vs30 < 2000.0 , mean , scale_fac ) self . _compute_soil_amplification ( C_SR , vs30 , pga_bc , mean ) if imt == PGV ( ) : mean = np . log ( 10 ** mean ) else : mean = np . log ( ( 10 ** mean ) * 1e-2 / g ) return mean | 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 self . poes = self . poes or oq . poes self . data = { } try : hcurves = self . get_hcurves ( self . imtls ) except IndexError : return for sid , hcurve_by_rlz in zip ( self . sids , hcurves . T ) : self . data [ sid ] = datadict = { } for rlzi , hcurve in enumerate ( hcurve_by_rlz ) : datadict [ rlzi ] = lst = [ None for imt in self . imtls ] for imti , imt in enumerate ( self . imtls ) : lst [ imti ] = hcurve [ imt ] | 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 : self . dstore [ 'poes/' + g ] for g in self . dstore [ 'poes' ] } if grp is None else { grp : self . dstore [ 'poes/' + grp ] } ) pmaps = self . rlzs_assoc . combine_pmaps ( dic ) return stats . compute_pmap_stats ( pmaps , [ stats . mean_curve , stats . std_curve ] , self . weights , self . imtls ) | 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 : computer = calc . gmf . GmfComputer ( ebr , sitecol , self . oqparam . imtls , self . cmaker , self . oqparam . truncation_level , self . correl_model ) except FarAwayRupture : continue self . computers . append ( computer ) | 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 = np . zeros ( len ( dists . rhypo ) ) ind3 = np . logical_and ( ( dists . rhypo < 240 ) , ( dists . rhypo >= 140 ) ) flag3 [ ind3 ] = 1.0 flag4 = np . zeros ( len ( dists . rhypo ) ) ind4 = ( dists . rhypo >= 240 ) flag4 [ ind4 ] = 1.0 A = flag1 * ( ( 205 - dists . rhypo ) / 150 ) + flag2 B = flag3 * ( ( 140 - dists . rhypo ) / 100 ) + flag4 if ( rup . hypo_depth < 80 ) : FHR = A else : FHR = B H0 = 100 if ( rup . hypo_depth >= H0 ) : H = 1 else : H = 0 ARC = np . zeros ( len ( sites . backarc ) ) idxarc = ( sites . backarc == 1 ) ARC [ idxarc ] = 1.0 return ( ( C [ 'c41' ] * ( 1 - ARC ) * H ) + ( C [ 'c42' ] * ( 1 - ARC ) * H * FHR ) + ( C [ 'c51' ] * ARC * H ) + ( C [ 'c52' ] * ARC * H * FHR ) ) | 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 ) , ( n_m , len ( self . magnitudes ) ) self . mean = { "SA" : numpy . ones ( [ n_d , n_p , n_m , n_levels ] ) , "PGA" : numpy . ones ( [ n_d , 1 , n_m , n_levels ] ) , "PGV" : numpy . ones ( [ n_d , 1 , n_m , n_levels ] ) } self . sigma = { } for stddev_type in [ const . StdDev . TOTAL , const . StdDev . INTER_EVENT , const . StdDev . INTRA_EVENT ] : level = next ( iter ( amplification_group ) ) if stddev_type in amplification_group [ level ] : self . sigma [ stddev_type ] = deepcopy ( self . mean ) for iloc , ( level , amp_model ) in enumerate ( amplification_group . items ( ) ) : if "SA" in amp_model [ "IMLs" ] : if iloc == 0 : self . periods = amp_model [ "IMLs/T" ] [ : ] else : assert numpy . allclose ( self . periods , amp_model [ "IMLs/T" ] [ : ] ) for imt in [ "SA" , "PGA" , "PGV" ] : if imt in amp_model [ "IMLs" ] : self . mean [ imt ] [ : , : , : , self . argidx [ iloc ] ] = amp_model [ "IMLs/" + imt ] [ : ] for stddev_type in self . sigma : self . sigma [ stddev_type ] [ imt ] [ : , : , : , self . argidx [ iloc ] ] = amp_model [ "/" . join ( [ stddev_type , imt ] ) ] [ : ] self . shape = ( n_d , n_p , n_m , n_levels ) | 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_interpolators = [ interp1d ( self . values , sigma_table , axis = 1 ) for sigma_table in sigma_tables ] if self . element == "Rupture" : mean_amp = 10.0 ** mean_interpolator ( getattr ( rctx , self . parameter ) ) [ 0 ] * numpy . ones_like ( dists ) sigma_amps = [ ] for sig_interpolator in sigma_interpolators : sigma_amps . append ( sig_interpolator ( getattr ( rctx , self . parameter ) ) [ 0 ] * numpy . ones_like ( dists ) ) else : mean_amp = 10.0 ** mean_interpolator ( getattr ( sctx , self . parameter ) ) [ 0 , : ] sigma_amps = [ ] for sig_interpolator in sigma_interpolators : sigma_amps . append ( sig_interpolator ( getattr ( sctx , self . parameter ) ) [ 0 , : ] * numpy . ones_like ( dists ) ) return mean_amp , sigma_amps | 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 ( numpy . log10 ( self . periods ) , numpy . log10 ( self . mean [ "SA" ] ) , axis = 1 ) period_table = interpolator ( numpy . log10 ( imt . period ) ) mag_interpolator = interp1d ( self . magnitudes , period_table , axis = 1 ) output_table = 10.0 ** mag_interpolator ( rctx . mag ) return output_table | 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 . shape [ 0 ] , self . shape [ 3 ] ) ) else : interpolator = interp1d ( numpy . log10 ( self . periods ) , self . sigma [ stddev_type ] [ "SA" ] , axis = 1 ) period_table = interpolator ( numpy . log10 ( imt . period ) ) mag_interpolator = interp1d ( self . magnitudes , period_table , axis = 1 ) output_tables . append ( mag_interpolator ( rctx . mag ) ) return output_tables | 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 . join ( self . GMPE_DIR , fname ) ) fle = h5py . File ( self . GMPE_TABLE , "r" ) try : self . distance_type = fle [ "distance_type" ] . value except KeyError : self . distance_type = decode ( fle [ "Distances" ] . attrs [ "metric" ] ) self . REQUIRES_DISTANCES = set ( [ self . distance_type ] ) self . m_w = fle [ "Mw" ] [ : ] self . distances = fle [ "Distances" ] [ : ] self . imls = hdf_arrays_to_dict ( fle [ "IMLs" ] ) self . DEFINED_FOR_INTENSITY_MEASURE_TYPES = set ( self . _supported_imts ( ) ) if "SA" in self . imls and "T" not in self . imls : raise ValueError ( "Spectral Acceleration must be accompanied by " "periods" ) self . _setup_standard_deviations ( fle ) if "Amplification" in fle : self . _setup_amplification ( fle ) | 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" : self . REQUIRES_SITES_PARAMETERS = set ( ) self . REQUIRES_RUPTURE_PARAMETERS = ( self . REQUIRES_RUPTURE_PARAMETERS | { self . amplification . parameter } ) | 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 ( dists , rctx . mag , dctx , imt , stddev_types ) if self . amplification : mean_amp , sigma_amp = self . amplification . get_amplification_factors ( imt , sctx , rctx , getattr ( dctx , self . distance_type ) , stddev_types ) mean = numpy . log ( mean ) + numpy . log ( mean_amp ) for iloc in range ( len ( stddev_types ) ) : stddevs [ iloc ] *= sigma_amp [ iloc ] return mean , stddevs else : return numpy . log ( mean ) , stddevs | 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 ) interpolator_std = interp1d ( dists , sigma , bounds_error = False ) stddev = interpolator_std ( getattr ( dctx , self . distance_type ) ) stddev [ getattr ( dctx , self . distance_type ) < dists [ 0 ] ] = sigma [ 0 ] stddev [ getattr ( dctx , self . distance_type ) > dists [ - 1 ] ] = sigma [ - 1 ] stddevs . append ( stddev ) return stddevs | 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_type == "IMLs" : periods = self . imls [ "T" ] [ : ] iml_table = self . imls [ "SA" ] [ : ] else : periods = self . stddevs [ val_type ] [ "T" ] [ : ] iml_table = self . stddevs [ val_type ] [ "SA" ] [ : ] low_period = round ( periods [ 0 ] , 7 ) high_period = round ( periods [ - 1 ] , 7 ) if ( round ( imt . period , 7 ) < low_period ) or ( round ( imt . period , 7 ) > high_period ) : raise ValueError ( "Spectral period %.3f outside of valid range " "(%.3f to %.3f)" % ( imt . period , periods [ 0 ] , periods [ - 1 ] ) ) interpolator = interp1d ( numpy . log10 ( periods ) , numpy . log10 ( iml_table ) , axis = 1 ) iml_table = 10. ** interpolator ( numpy . log10 ( imt . period ) ) return self . apply_magnitude_interpolation ( mag , iml_table ) | 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_interpolator = interp1d ( self . m_w , numpy . log10 ( iml_table ) , axis = 1 ) return 10.0 ** m_interpolator ( mag ) | 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_INDEPENDENT [ 'c5himag' ] c2 = self . COEFFS_SOIL_IMT_INDEPENDENT [ 'c2' ] c3 = self . COEFFS_SOIL_IMT_INDEPENDENT [ 'c3' ] C = self . COEFFS_SOIL [ imt ] if is_reverse : c1 = self . COEFFS_SOIL_IMT_INDEPENDENT [ 'c1r' ] c6 = C [ 'c6r' ] else : c1 = self . COEFFS_SOIL_IMT_INDEPENDENT [ 'c1ss' ] c6 = C [ 'c6ss' ] mag = 8.5 if mag > 8.5 else mag return ( c1 + c2 * mag + c6 + C [ 'c7' ] * ( ( 8.5 - mag ) ** 2.5 ) - c3 * numpy . log ( rrup + c4 * numpy . exp ( c5 * mag ) ) ) | 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' ] * numpy . log ( rrup + numpy . exp ( C [ 'c5' ] + C [ 'c6' ] * mag ) ) + C [ 'c7' ] * numpy . log ( rrup + 2 ) ) if is_reverse : mean += 0.1823215567939546 return mean | 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 ( 512 ) : oqzip . zip_exposure ( what , archive_zip ) elif what . endswith ( '.ini' ) : oqzip . zip_job ( what , archive_zip , risk_file ) else : sys . exit ( 'Cannot zip %s' % what ) | 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_lines , reduction_factor ) shutil . copy ( fname , fname + '.bak' ) print ( 'Copied the original file in %s.bak' % fname ) _save_csv ( fname , lines , header ) print ( 'Extracted %d lines out of %d' % ( len ( lines ) , len ( all_lines ) ) ) return elif fname . endswith ( '.npy' ) : array = numpy . load ( fname ) shutil . copy ( fname , fname + '.bak' ) print ( 'Copied the original file in %s.bak' % fname ) arr = numpy . array ( general . random_filter ( array , reduction_factor ) ) numpy . save ( fname , arr ) print ( 'Extracted %d rows out of %d' % ( len ( arr ) , len ( array ) ) ) return node = nrml . read ( fname ) model = node [ 0 ] if model . tag . endswith ( 'exposureModel' ) : total = len ( model . assets ) model . assets . nodes = general . random_filter ( model . assets , reduction_factor ) num_nodes = len ( model . assets ) elif model . tag . endswith ( 'siteModel' ) : total = len ( model ) model . nodes = general . random_filter ( model , reduction_factor ) num_nodes = len ( model ) elif model . tag . endswith ( 'sourceModel' ) : reduce_source_model ( fname , reduction_factor ) return elif model . tag . endswith ( 'logicTree' ) : for smpath in logictree . collect_info ( fname ) . smpaths : reduce_source_model ( smpath , reduction_factor ) return else : raise RuntimeError ( 'Unknown model tag: %s' % model . tag ) save_bak ( fname , node , num_nodes , total ) | 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 . lats [ : , idx ] ) | 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 ] , top_edge . lats [ 0 , - 1 ] , ( mean_strike + 90. ) % 360 , mesh . lons , mesh . lats ) idx = numpy . sign ( dst1 ) == numpy . sign ( dst2 ) dst = numpy . zeros_like ( dst1 ) dst [ idx ] = numpy . fmin ( numpy . abs ( dst1 [ idx ] ) , numpy . abs ( dst2 [ idx ] ) ) return dst | 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 . depths [ 0 , i + 1 ] ) azimuth = p1 . azimuth ( p2 ) dists . append ( geodetic . distance_to_arc ( p1 . longitude , p1 . latitude , azimuth , mesh . lons , mesh . lats ) ) else : for i in range ( top_edge . lons . shape [ 1 ] - 1 ) : 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 . depths [ 0 , i + 1 ] ) if i == 0 : pt = p1 p1 = p2 p2 = pt if i == 0 or i == top_edge . lons . shape [ 1 ] - 2 : azimuth = p1 . azimuth ( p2 ) tmp = geodetic . distance_to_semi_arc ( p1 . longitude , p1 . latitude , azimuth , mesh . lons , mesh . lats ) else : tmp = geodetic . min_distance_to_segment ( numpy . array ( [ p1 . longitude , p2 . longitude ] ) , numpy . array ( [ p1 . latitude , p2 . latitude ] ) , mesh . lons , mesh . lats ) if i == 0 : tmp *= - 1 dists . append ( tmp ) dists = numpy . array ( dists ) iii = abs ( dists ) . argmin ( axis = 0 ) dst = dists [ iii , list ( range ( dists . shape [ 1 ] ) ) ] return dst | 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 [ - 1 , : - 1 ] [ : : - 1 ] , mesh . lats [ : - 1 , 0 ] [ : : - 1 ] ) ) return [ lons ] , [ 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 = numpy . asarray ( mesh . triangulate ( ) [ 1 ] [ 0 ] [ i + 1 ] ) cosang = numpy . dot ( v1 , v2 ) sinang = numpy . linalg . norm ( numpy . cross ( v1 , v2 ) ) angle = math . degrees ( numpy . arctan2 ( sinang , cosang ) ) if abs ( angle ) > angle_var : top_edge . append ( Point ( mesh . lons [ 0 ] [ i + 1 ] , mesh . lats [ 0 ] [ i + 1 ] , mesh . depths [ 0 ] [ i + 1 ] ) ) top_edge . append ( Point ( mesh . lons [ 0 ] [ - 1 ] , mesh . lats [ 0 ] [ - 1 ] , mesh . depths [ 0 ] [ - 1 ] ) ) line_top_edge = Line ( top_edge ) return line_top_edge | 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 ) ) total_len_x = ( len ( mesh . lons [ y_node ] ) - 1 ) * mesh_spacing x_distance = hypo_loc [ 0 ] * total_len_x x_node = int ( numpy . round ( x_distance / mesh_spacing ) ) hypocentre = Point ( mesh . lons [ y_node ] [ x_node ] , mesh . lats [ y_node ] [ x_node ] , mesh . depths [ y_node ] [ x_node ] ) return hypocentre | 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 += len ( rows ) time . sleep ( 1 ) except : pass | 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 more memory than allowed by configuration ' '(Used: %d%% / Allowed: %d%%)! Shutting down.' % ( used_mem_percent , hard_percent ) ) elif used_mem_percent > soft_percent : msg = 'Using over %d%% of the memory in %s!' return msg % ( used_mem_percent , socket . gethostname ( ) ) | 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 ] == name , ( res . name , name ) else : res . name = iresult . name . split ( '#' ) [ 0 ] return res | 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 > self . prev_percent : self . progress ( '%s %3d%% [of %d tasks]' , self . name , percent , len ( self . tasks ) ) self . prev_percent = percent return done | 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://%s:%s' % ( config . dbserver . host , self . socket . port ) assert not isinstance ( args [ - 1 ] , Monitor ) dist = 'no' if self . num_tasks == 1 else self . distribute if dist != 'no' : args = pickle_sequence ( args ) self . sent += numpy . array ( [ len ( p ) for p in args ] ) res = submit [ dist ] ( self , func , args , monitor ) self . tasks . append ( res ) | 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.