class SatelliteMisfitResult(gf.Result, MisfitResult): """Carries the observations for a target and corresponding synthetics.""" statics_syn = Dict.T( String.T(), Array.T(dtype=num.float, shape=(None,), serialize_as='base64'), optional=True, help='Predicted static displacements for a target (synthetics).') statics_obs = Dict.T( String.T(), Array.T(dtype=num.float, shape=(None,), serialize_as='base64'), optional=True, help='Observed static displacement for a target.')
class CovarianceConfig(guts.Object): noise_coord = Array.T( shape=(None, ), dtype=num.float, serialize_as="list", optional=True, help="Noise patch coordinates and size,", ) model_coefficients = guts.Tuple.T( optional=True, help="Covariance model coefficients. Either two (exponential) " "or three (exponential and cosine term) coefficients." "See also :func:`~kite.covariance.modelCovariance`.", ) model_function = guts.StringChoice.T( choices=["exponential", "exponential_cosine"], default="exponential", help="Covariance approximation function.", ) sampling_method = guts.StringChoice.T( choices=["spectral", "spatial"], default="spatial", help="Method for estimating the covariance and structure function.", ) spatial_bins = guts.Int.T( default=75, help="Number of distance bins for spatial covariance sampling.") spatial_pairs = guts.Int.T( default=200000, help="Number of random pairs for spatial covariance sampling.") variance = guts.Float.T(optional=True, help="Variance of the model.") adaptive_subsampling = guts.Bool.T( default=True, help="Adaptive subsampling flag for full covariance calculation.") covariance_matrix = Array.T( dtype=num.float, optional=True, serialize_as="base64", help="Cached covariance matrix, " "see :attr:`~kite.Covariance.covariance_matrix`.", ) def __init__(self, *args, **kwargs): if len(kwargs) != 0: if "a" in kwargs and "b" in kwargs: kwargs["model_coefficients"] = (kwargs.pop("a"), kwargs.pop("b")) guts.Object.__init__(self, *args, **kwargs)
class A(Object): xmltagname = 'aroot' arr = Array.T( shape=shape, dtype=num.int, serialize_as=serialize_as, serialize_dtype='>i8')
class InjectionSamplerPhase(SamplerPhase): xs_inject = Array.T(dtype=num.float, shape=(None, None), help='Array with the reference model.') def get_raw_sample(self, problem, iiter, chains): return Sample(model=self.xs_inject[iiter, :])
class FloatTile(Object): xmin = Float.T() ymin = Float.T() dx = Float.T() dy = Float.T() data = Array.T(shape=(None, None), dtype=num.float, serialize_as='table') def __init__(self, xmin, ymin, dx, dy, data): Object.__init__(self, init_props=False) self.xmin = float(xmin) self.ymin = float(ymin) self.dx = float(dx) self.dy = float(dy) self.data = data self._set_maxes() def _set_maxes(self): self.ny, self.nx = self.data.shape self.xmax = self.xmin + (self.nx-1) * self.dx self.ymax = self.ymin + (self.ny-1) * self.dy def x(self): return self.xmin + num.arange(self.nx) * self.dx def y(self): return self.ymin + num.arange(self.ny) * self.dy def get(self, x, y): ix = int(round((x - self.xmin) / self.dx)) iy = int(round((y - self.ymin) / self.dy)) if 0 <= ix < self.nx and 0 <= iy < self.ny: return self.data[iy, ix] else: raise OutOfBounds()
class PoelSourceFunction(Object): data = Array.T(shape=(None, 2), dtype=num.float) def string_for_config(self): return '\n'.join([ '%i %s' % (i+1, str_float_vals(row)) for (i, row) in enumerate(self.data)])
class SatelliteTarget(StaticTarget): ''' A computation request for a spatial multi-location target of static/geodetic quantities measured from a satellite instrument. The line of sight angles are provided and projecting post-processing is applied. ''' theta = Array.T( shape=(None,), dtype=num.float, serialize_as='base64-compat', help='Horizontal angle towards satellite\'s line of sight in radians.' '\n\n .. important::\n\n' ' :math:`0` is **east** and' ' :math:`\\frac{\\pi}{2}` is **north**.\n\n') phi = Array.T( shape=(None,), dtype=num.float, serialize_as='base64-compat', help='Theta is look vector elevation angle towards satellite from' ' horizon in radians. Matrix of theta towards satellite\'s' ' line of sight.' '\n\n .. important::\n\n' ' :math:`-\\frac{\\pi}{2}` is **down** and' ' :math:`\\frac{\\pi}{2}` is **up**.\n\n') def __init__(self, *args, **kwargs): super(SatelliteTarget, self).__init__(*args, **kwargs) self._los_factors = None def get_los_factors(self): if (self.theta.size != self.phi.size != self.lats.size): raise AttributeError('LOS angles inconsistent with provided' ' coordinate shape.') if self._los_factors is None: self._los_factors = num.empty((self.theta.shape[0], 3)) self._los_factors[:, 0] = num.sin(self.theta) self._los_factors[:, 1] = num.cos(self.theta) * num.cos(self.phi) self._los_factors[:, 2] = num.cos(self.theta) * num.sin(self.phi) return self._los_factors def post_process(self, engine, source, statics): return meta.SatelliteResult( result=statics, theta=self.theta, phi=self.phi)
class Boundary(Object): name1 = String.T() name2 = String.T() kind = String.T() points = Array.T(dtype=num.float, shape=(None, 2)) cpoints = Array.T(dtype=num.float, shape=(None, 2)) itypes = Array.T(dtype=num.int, shape=(None)) def split_types(self, groups=None): xyz = od.latlon_to_xyz(self.points) xyzmid = (xyz[1:] + xyz[:-1, :]) * 0.5 cxyz = od.latlon_to_xyz(self.cpoints) d = od.distances3d(xyzmid[num.newaxis, :, :], cxyz[:, num.newaxis, :]) idmin = num.argmin(d, axis=0) itypes = self.itypes[idmin] if groups is None: groupmap = num.arange(len(self._index_to_type)) else: d = {} for igroup, group in enumerate(groups): for name in group: d[name] = igroup groupmap = num.array([d[name] for name in self._index_to_type], dtype=num.int) iswitch = num.concatenate( ([0], num.where(groupmap[itypes[1:]] != groupmap[itypes[:-1]])[0] + 1, [itypes.size])) results = [] for ii in range(iswitch.size - 1): if groups is not None: tt = [ self._index_to_type[ityp] for ityp in num.unique(itypes[iswitch[ii]:iswitch[ii + 1]]) ] else: tt = self._index_to_type[itypes[iswitch[ii]]] results.append((tt, self.points[iswitch[ii]:iswitch[ii + 1] + 1])) return results
class CovarianceConfig(guts.Object): noise_coord = Array.T( shape=(None,), dtype=num.float, serialize_as='list', optional=True, help='Noise patch coordinates and size,') model_coefficients = guts.Tuple.T( optional=True, help='Covariance model coefficients. Either two (exponential) ' 'or three (exponential and cosine term) coefficients.' 'See also :func:`~kite.covariance.modelCovariance`.') model_function = guts.StringChoice.T( choices=['exponential', 'exponential_cosine'], default='exponential', help='Covariance approximation function.') sampling_method = guts.StringChoice.T( choices=['spectral', 'spatial'], default='spatial', help='Method for estimating the covariance and structure function.') spatial_bins = guts.Int.T( default=75, help='Number of distance bins for spatial covariance sampling.') spatial_pairs = guts.Int.T( default=200000, help='Number of random pairs for spatial covariance sampling.') variance = guts.Float.T( optional=True, help='Variance of the model.') adaptive_subsampling = guts.Bool.T( default=True, help='Adaptive subsampling flag for full covariance calculation.') covariance_matrix = Array.T( dtype=num.float, optional=True, serialize_as='base64', help='Cached covariance matrix, ' 'see :attr:`~kite.Covariance.covariance_matrix`.') def __init__(self, *args, **kwargs): if len(kwargs) != 0: if 'a' in kwargs and 'b' in kwargs: kwargs['model_coefficients'] = ( kwargs.pop('a'), kwargs.pop('b')) guts.Object.__init__(self, *args, **kwargs)
class PoelModel(Object): data = Array.T(shape=(None, 6), dtype=num.float) def string_for_config(self): srows = [] for i, row in enumerate(self.data): srows.append('%i %s' % (i+1, str_float_vals(row))) return '\n'.join(srows) def get_nlines(self): return self.data.shape[0]
class CovarianceConfig(guts.Object): noise_coord = Array.T(shape=(None, ), dtype=num.float, serialize_as='list', optional=True, help='Noise patch coordinates and size,') a = guts.Float.T(optional=True, help='Exponential covariance model; scaling factor. ' 'See :func:`~kite.covariance.modelCovariance`') b = guts.Float.T(optional=True, help='Exponential covariance model; exponential decay. ' 'See :func:`~kite.covariance.modelCovariance`') variance = guts.Float.T(optional=True, help='Variance of the model') adaptive_subsampling = guts.Bool.T( default=True, help='Adaptive subsampling flag for full covariance calculation.') covariance_matrix = Array.T( optional=True, serialize_as='base64', help='Cached covariance matrix, ' 'see :attr:`~kite.Covariance.covariance_matrix`', )
class TraceSpectrum(Object): network = String.T() station = String.T() location = String.T() channel = String.T() deltaf = Float.T(default=1.0) fmin = Float.T(default=0.0) ydata = Array.T(shape=(None, ), dtype=num.complex, serialize_as='list') def get_ydata(self): return self.ydata def get_xdata(self): return self.fmin + num.arange(self.ydata.size) * self.deltaf
class Plate(Object): name = String.T() points = Array.T(dtype=num.float, shape=(None, 2)) def max_interpoint_distance(self): p = od.latlon_to_xyz(self.points) return math.sqrt( num.max( num.sum((p[num.newaxis, :, :] - p[:, num.newaxis, :])**2, axis=2))) def contains_point(self, point): return od.contains_point(self.points, point) def contains_points(self, points): return od.contains_points(self.points, points)
class Sample(Object): '''Sample model with context about how it was generated.''' model = Array.T(shape=(None, ), dtype=num.float, serialize_as='list') iphase = Int.T(optional=True) ichain_base = Int.T(optional=True) ilink_base = Int.T(optional=True) imodel_base = Int.T(optional=True) def preconstrain(self, problem): self.model = problem.preconstrain(self.model) def pack_context(self): i = num.zeros(4, dtype=num.int) i[:] = (fnone(self.iphase), fnone(self.ichain_base), fnone(self.ilink_base), fnone(self.imodel_base)) return i
class MisfitTarget(Object): manual_weight = Float.T( default=1.0, help='Relative weight of this target') analyser_results = Dict.T( gf.StringID.T(), AnalyserResult.T(), help='Dictionary of analyser results') normalisation_family = gf.StringID.T( optional=True, help='Normalisation family of this misfit target') path = gf.StringID.T( help='A path identifier used for plotting') misfit_config = MisfitConfig.T( default=MisfitConfig.D(), help='Misfit configuration') bootstrap_weights = Array.T( dtype=num.float, serialize_as='base64', optional=True) bootstrap_residuals = Array.T( dtype=num.float, serialize_as='base64', optional=True) can_bootstrap_weights = False can_bootstrap_residuals = False def __init__(self, **kwargs): Object.__init__(self, **kwargs) self.parameters = [] self._ds = None self._result_mode = 'sparse' self._combined_weight = None self._target_parameters = None self._target_ranges = None self._combined_weight = None @classmethod def get_plot_classes(cls): return [] def set_dataset(self, ds): self._ds = ds def get_dataset(self): return self._ds @property def nmisfits(self): return 1 @property def nparameters(self): if self._target_parameters is None: return 0 return len(self._target_parameters) @property def target_parameters(self): if self._target_parameters is None: self._target_parameters = copy.deepcopy(self.parameters) for p in self._target_parameters: p.set_groups([self.string_id()]) return self._target_parameters @property def target_ranges(self): return {} def set_parameter_values(self, model): for i, p in enumerate(self.parameters): self.parameter_values[p.name_nogroups] = model[i] def set_result_mode(self, result_mode): self._result_mode = result_mode def post_process(self, engine, source, statics): raise NotImplementedError() def get_combined_weight(self): if self._combined_weight is None: self._combined_weight = num.ones(1, dtype=num.float) return self._combined_weight def set_bootstrap_weights(self, weights): self.bootstrap_weights = weights def get_bootstrap_weights(self): if self.bootstrap_weights is None: raise Exception('Bootstrap weights have not been set!') nbootstraps = self.bootstrap_weights.size // self.nmisfits return self.bootstrap_weights.reshape(nbootstraps, self.nmisfits) def init_bootstrap_residuals(self, nbootstrap, rstate=None): raise NotImplementedError def set_bootstrap_residuals(self, residuals): self.bootstrap_residuals = residuals def get_bootstrap_residuals(self): if self.bootstrap_residuals is None: raise Exception('Bootstrap residuals have not been set!') nbootstraps = self.bootstrap_residuals.size // self.nmisfits return self.bootstrap_residuals.reshape(nbootstraps, self.nmisfits) def prepare_modelling(self, engine, source, targets): return [] def finalize_modelling( self, engine, source, modelling_targets, modelling_results): raise NotImplemented('must be overloaded in subclass')
class A(Object): arr = Array.T(serialize_as='base64+meta')
class A(Object): xmltagname = 'aroot' arr = Array.T( shape=(s0, s1), dtype=num.int)
class MisfitResult(Object): misfits = Array.T(shape=(None, 2), dtype=num.float)
def testOptionalDefault(self): from pyrocko.guts_array import Array, array_equal import numpy as num assert_ae = num.testing.assert_almost_equal def array_equal_noneaware(a, b): if a is None: return b is None elif b is None: return a is None else: return array_equal(a, b) data = [ ('a', Int.T(), [None, 0, 1, 2], ['aerr', 0, 1, 2]), ('b', Int.T(optional=True), [None, 0, 1, 2], [None, 0, 1, 2]), ('c', Int.T(default=1), [None, 0, 1, 2], [1, 0, 1, 2]), ('d', Int.T(default=1, optional=True), [None, 0, 1, 2], [1, 0, 1, 2]), ('e', List.T(Int.T()), [None, [], [1], [2]], [[], [], [1], [2]]), ('f', List.T(Int.T(), optional=True), [None, [], [1], [2]], [None, [], [1], [2]]), ('g', List.T(Int.T(), default=[1]), [ None, [], [1], [2]], [[1], [], [1], [2]]), ('h', List.T(Int.T(), default=[1], optional=True), [None, [], [1], [2]], [[1], [], [1], [2]]), ('i', Tuple.T(2, Int.T()), [None, (1, 2)], ['err', (1, 2)]), ('j', Tuple.T(2, Int.T(), optional=True), [None, (1, 2)], [None, (1, 2)]), ('k', Tuple.T(2, Int.T(), default=(1, 2)), [None, (1, 2), (3, 4)], [(1, 2), (1, 2), (3, 4)]), ('l', Tuple.T(2, Int.T(), default=(1, 2), optional=True), [None, (1, 2), (3, 4)], [(1, 2), (1, 2), (3, 4)]), ('i2', Tuple.T(None, Int.T()), [None, (1, 2)], [(), (1, 2)]), ('j2', Tuple.T(None, Int.T(), optional=True), [None, (), (3, 4)], [None, (), (3, 4)]), ('k2', Tuple.T(None, Int.T(), default=(1,)), [None, (), (3, 4)], [(1,), (), (3, 4)]), ('l2', Tuple.T(None, Int.T(), default=(1,), optional=True), [None, (), (3, 4)], [(1,), (), (3, 4)]), ('m', Array.T(shape=(None,), dtype=num.int, serialize_as='list'), [num.arange(0), num.arange(2)], [num.arange(0), num.arange(2)]), ('n', Array.T(shape=(None,), dtype=num.int, serialize_as='list', optional=True), [None, num.arange(0), num.arange(2)], [None, num.arange(0), num.arange(2)]), ('o', Array.T(shape=(None,), dtype=num.int, serialize_as='list', default=num.arange(2)), [None, num.arange(0), num.arange(2), num.arange(3)], [num.arange(2), num.arange(0), num.arange(2), num.arange(3)]), ('p', Array.T(shape=(None,), dtype=num.int, serialize_as='list', default=num.arange(2), optional=True), [None, num.arange(0), num.arange(2), num.arange(3)], [num.arange(2), num.arange(0), num.arange(2), num.arange(3)]), ('q', Dict.T(String.T(), Int.T()), [None, {}, {'a': 1}], [{}, {}, {'a': 1}]), ('r', Dict.T(String.T(), Int.T(), optional=True), [None, {}, {'a': 1}], [None, {}, {'a': 1}]), ('s', Dict.T(String.T(), Int.T(), default={'a': 1}), [None, {}, {'a': 1}], [{'a': 1}, {}, {'a': 1}]), ('t', Dict.T(String.T(), Int.T(), default={'a': 1}, optional=True), [None, {}, {'a': 1}], [{'a': 1}, {}, {'a': 1}]), ] for k, t, vals, exp, in data: last = [None] class A(Object): def __init__(self, **kwargs): last[0] = len(kwargs) Object.__init__(self, **kwargs) v = t A.T.class_signature() for v, e in zip(vals, exp): if isinstance(e, str) and e == 'aerr': with self.assertRaises(ArgumentError): if v is not None: a1 = A(v=v) else: a1 = A() continue else: if v is not None: a1 = A(v=v) else: a1 = A() if isinstance(e, str) and e == 'err': with self.assertRaises(ValidationError): a1.validate() else: a1.validate() a2 = load_string(dump(a1)) if isinstance(e, num.ndarray): assert last[0] == int( not (array_equal_noneaware(t.default(), a1.v) and t.optional)) assert_ae(a1.v, e) assert_ae(a1.v, e) else: assert last[0] == int( not(t.default() == a1.v and t.optional)) self.assertEqual(a1.v, e) self.assertEqual(a2.v, e)
class MisfitTarget(Object): manual_weight = Float.T(default=1.0, help='Relative weight of this target') analyser_results = Dict.T(gf.StringID.T(), AnalyserResult.T(), help='Dictionary of analyser results') normalisation_family = gf.StringID.T( optional=True, help='Normalisation family of this misfit target') path = gf.StringID.T(help='A path identifier used for plotting') misfit_config = MisfitConfig.T(default=MisfitConfig.D(), help='Misfit configuration') bootstrap_weights = Array.T(dtype=num.float, serialize_as='base64', optional=True) bootstrap_residuals = Array.T(dtype=num.float, serialize_as='base64', optional=True) can_bootstrap_weights = False can_bootstrap_residuals = False plot_misfits_cumulative = True def __init__(self, **kwargs): Object.__init__(self, **kwargs) self.parameters = [] self._ds = None self._result_mode = 'sparse' self._combined_weight = None self._target_parameters = None self._target_ranges = None self._combined_weight = None @classmethod def get_plot_classes(cls): return [] def set_dataset(self, ds): self._ds = ds def get_dataset(self): return self._ds def string_id(self): return str(self.path) def misfits_string_ids(self): raise NotImplementedError('%s does not implement misfits_string_id' % self.__class__.__name__) @property def nmisfits(self): return 1 def noise_weight_matrix(self): return num.array([[1]]) @property def nparameters(self): if self._target_parameters is None: return 0 return len(self._target_parameters) @property def target_parameters(self): if self._target_parameters is None: self._target_parameters = copy.deepcopy(self.parameters) for p in self._target_parameters: p.set_groups([self.string_id()]) return self._target_parameters @property def target_ranges(self): return {} def set_parameter_values(self, model): for i, p in enumerate(self.parameters): self.parameter_values[p.name_nogroups] = model[i] def set_result_mode(self, result_mode): self._result_mode = result_mode def post_process(self, engine, source, statics): raise NotImplementedError() def get_combined_weight(self): if self._combined_weight is None: w = self.manual_weight for analyser in self.analyser_results.values(): w *= analyser.weight self._combined_weight = num.array([w], dtype=num.float) return self._combined_weight def get_correlated_weights(self, nthreads=0): pass def set_bootstrap_weights(self, weights): self.bootstrap_weights = weights def get_bootstrap_weights(self): if self.bootstrap_weights is None: raise Exception('Bootstrap weights have not been set!') nbootstraps = self.bootstrap_weights.size // self.nmisfits return self.bootstrap_weights.reshape(nbootstraps, self.nmisfits) def init_bootstrap_residuals(self, nbootstrap, rstate=None, nthreads=0): raise NotImplementedError() def set_bootstrap_residuals(self, residuals): self.bootstrap_residuals = residuals def get_bootstrap_residuals(self): if self.bootstrap_residuals is None: raise Exception('Bootstrap residuals have not been set!') nbootstraps = self.bootstrap_residuals.size // self.nmisfits return self.bootstrap_residuals.reshape(nbootstraps, self.nmisfits) def prepare_modelling(self, engine, source, targets): ''' Prepare modelling target This function shall return a list of :class:`pyrocko.gf.Target` for forward modelling in the :class:`pyrocko.gf.LocalEngine`. ''' return [self] def finalize_modelling(self, engine, source, modelling_targets, modelling_results): ''' Manipulate modelling before misfit calculation This function can be overloaded interact with the modelling results. ''' return modelling_results[0]
class PoelConfigFull(PoelConfig): s_start_depth = Float.T(default=25.0) s_end_depth = Float.T(default=25.0) sw_equidistant_z = Int.T(default=1) no_depths = Int.T(default=10) depths = Array.T( shape=(None,), dtype=num.float, default=num.array([10.0, 100.0], dtype=num.float)) sw_equidistant_x = Int.T(default=1) no_distances = Int.T(default=10) distances = Array.T( shape=(None,), dtype=num.float, default=num.array([10., 100.])) no_t_samples = Int.T(default=51) t_files = List.T(String.T(), default=[x+'.t' for x in poel_components]) sw_t_files = List.T(Int.T(), default=[1 for x in poel_components]) def get_output_filenames(self, rundir): return [pjoin(rundir, fn) for fn in self.t_files] def string_for_config(self): d = self.__dict__.copy() if not self.sw_equidistant_x: d['no_distances'] = len(self.distances) d['str_distances'] = str_float_vals(self.distances) if not self.sw_equidistant_z: d['no_depths'] = len(self.depths) d['str_depths'] = str_float_vals(self.depths) d['sw_t_files_1_2'] = ' '.join( ['%i' % i for i in self.sw_t_files[0:2]]) d['t_files_1_2'] = ' '.join( ["'%s'" % s for s in self.t_files[0:2]]) d['sw_t_files_3_7'] = ' '.join( ['%i' % i for i in self.sw_t_files[2:7]]) d['t_files_3_7'] = ' '.join( ["'%s'" % s for s in self.t_files[2:7]]) d['sw_t_files_8_10'] = ' '.join( ['%i' % i for i in self.sw_t_files[7:10]]) d['t_files_8_10'] = ' '.join( ["'%s'" % s for s in self.t_files[7:10]]) d['no_model_lines'] = self.model.get_nlines() if self.s_type == 0: d['source_function'] = str(self.source_function_p) elif self.s_type == 1: d['source_function'] = self.source_function_i.string_for_config() d['model'] = self.model.string_for_config() template = ''' # This is the input file of FORTRAN77 program "poel06" for modeling # coupled deformation-diffusion processes based on a multi-layered (half- # or full-space) poroelastic media induced by an injection (pump) of # from a borehole or by a (point) reservoir loading. # # by R. Wang, # GeoForschungsZentrum Potsdam # e-mail: [email protected] # phone 0049 331 2881209 # fax 0049 331 2881204 # # Last modified: Potsdam, July, 2012 # ############################################################## ## ## ## Cylindrical coordinates (Z positive downwards!) are used ## ## If not others specified, SI Unit System is used overall! ## ## ## ## Tilt is positive when the upper end of a borehole tilt- ## ## meter body moves away from the pumping well. ## ## ## ############################################################## # ############################################################################### # # SOURCE PARAMETERS A: SOURCE GEOMETRY # ==================================== # 1. source top and bottom depth [m] # Note: top depth < bottom depth for a vertical line source # top depth = bottom depth for a vertical point source # # ! whole source screen should be within a homogeneous layer, and ! # ! both top and bottom should not coincide with any interface of ! # ! the model used (see below) ! # # 2. source radius (> 0) [m] # Note: source radius > 0 for a horizontal disk source # source radius = 0 for a horizontal point source #------------------------------------------------------------------------------ %(s_start_depth)g %(s_end_depth)g |dble: s_top_depth, s_bottom_de %(s_radius)g |dble: s_radius; #------------------------------------------------------------------------------ # # SOURCE PARAMETERS B: SOURCE TYPE # ================================ # 1. selection of source type: # 0 = initial excess pore pressure within the source volume # (initial value problem) # 1 = injection within the source volume # (boundary value problem) #------------------------------------------------------------------------------ %(s_type)i |int: sw_source_type; #------------------------------------------------------------------------------ %(source_function)s ############################################################################### # # RECEIVER PARAMETERS A: RECEIVER DEPTH SAMPLING # ============================================== # 1. switch for equidistant steping (1/0 = yes/no) # 2. number of receiver depth samples (<= nzrmax defined in "peglobal.h") # 3. if equidistant, start depth [m], end depth [m]; else list of depths # (all >= 0 and ordered from small to large!) #------------------------------------------------------------------------------ %(sw_equidistant_z)i |int: sw_receiver_depth_samplin %(no_depths)i |int: no_depths; %(str_depths)s |dble: zr_1,zr_n; or zr_1,zr_2, #------------------------------------------------------------------------------ # # RECEIVER PARAMETERS B: RECEIVER DISTANCE SAMPLING # ================================================= # 1. switch for equidistant steping (1/0 = yes/no) # 2. number of receiver distance samples (<= nrmax defined in "peglobal.h") # 3. if equidistant, start distance [m], end distance [m]; else list of # distances (all >= 0 and ordered from small to large!) #------------------------------------------------------------------------------ %(sw_equidistant_x)i |int: sw_equidistant; %(no_distances)i |int: no_distances; %(str_distances)s |dble: d_1,d_n; or d_1,d_2, ... #------------------------------------------------------------------------------ # # RECEIVER PARAMETERS C: Time SAMPLING # ==================================== # 1. time window [s] # 2. number of time samples # Note: the caracteristic diffusion time = # max_receiver_distance^2 / diffusivity_of_source_layer #------------------------------------------------------------------------------ %(t_window)s |dble: time_window; %(no_t_samples)i |int: no_time_samples; #------------------------------------------------------------------------------ # # WAVENUMBER INTEGRATION PARAMETERS # ================================= # 1. relative accuracy (0.01 for 1%% error) for numerical wavenumber integratio #------------------------------------------------------------------------------ %(accuracy)s |dble: accuracy; #------------------------------------------------------------------------------ ############################################################################### # # OUTPUTS A: DISPLACEMENT TIME SERIES # =================================== # 1. select the 2 displacement time series (1/0 = yes/no) # Note Ut = 0 # 2. file names of these 2 time series #------------------------------------------------------------------------------ %(sw_t_files_1_2)s |int: sw_t_files(1-2); %(t_files_1_2)s |char: t_files(1-2); #------------------------------------------------------------------------------ # # OUTPUTS B: STRAIN TENSOR & TILT TIME SERIES # =========================================== # 1. select strain time series (1/0 = yes/no): Ezz, Err, Ett, Ezr (4 tensor # components) and Tlt (= -dur/dz, the radial component of the vertical tilt) # Note Ezt, Ert and Tlt (tangential tilt) = 0 # 2. file names of these 5 time series #------------------------------------------------------------------------------ %(sw_t_files_3_7)s |int: sw_t_files(3-7); %(t_files_3_7)s |char: t_files(3-7); #------------------------------------------------------------------------------ # # OUTPUTS C: PORE PRESSURE & DARCY VELOCITY TIME SERIES # ===================================================== # 1. select pore pressure and Darcy velocity time series (1/0 = yes/no): # Pp (excess pore pressure), Dvz, Dvr (2 Darcy velocity components) # Note Dvt = 0 # 2. file names of these 3 time series #------------------------------------------------------------------------------ %(sw_t_files_8_10)s |int: sw_t_files(8-10); %(t_files_8_10)s |char: t_files(8-10); #------------------------------------------------------------------------------ # # OUTPUTS D: SNAPSHOTS OF ALL OBSERVABLES # ======================================= # 1. number of snapshots # 2. time[s] (within the time window, see above) and output filename of # the 1. snapshot # 3. ... #------------------------------------------------------------------------------ 1 |int: no_sn; %(t_window)s 'snapshot.dat' |dable: sn_time(i),sn_file(i) ############################################################################### # # GLOBAL MODEL PARAMETERS # ======================= # 1. switch for surface conditions: # 0 = without free surface (whole space), # 1 = unconfined free surface (p = 0), # 2 = confined free surface (dp/dz = 0). # 2. number of data lines of the layered model (<= lmax as defined in # "peglobal.h") (see Note below) #------------------------------------------------------------------------------ %(isurfcon)i |int: isurfcon %(no_model_lines)i |int: no_model_lines; #------------------------------------------------------------------------------ # # MULTILAYERED MODEL PARAMETERS # ============================= # # Note: mu = shear modulus # nu = Poisson ratio under drained condition # nu_u = Poisson ratio under undrained condition (nu_u > nu) # B = Skempton parameter (the change in pore pressure per unit change # in confining pressure under undrained condition) # D = hydraulic diffusivity # # no depth[m] mu[Pa] nu nu_u B D[m^2/s] Explanations #------------------------------------------------------------------------------ %(model)s ###########################end of all inputs################################### Note for the model input format and the step-function approximation for model parameters varying linearly with depth: The surface and the upper boundary of the lowest half-space as well as the interfaces at which the poroelastic parameters are continuous, are all defined by a single data line; All other interfaces, at which the poroelastic parameters are discontinuous, are all defined by two data lines (upper-side and lower-side values). This input format would also be needed for a graphic plot of the layered model. Layers which have different parameter values at top and bottom, will be treated as layers with a constant gradient, and will be discretised to a number of homogeneous sublayers. Errors due to the discretisation are limited within about 5%% (changeable, see peglobal.h). '''.lstrip() return template % d
class VelocityProfile(Object): uid = Int.T(optional=True, help='Unique ID of measurement') lat = Float.T(help='Latitude [deg]') lon = Float.T(help='Longitude [deg]') elevation = Float.T(default=num.nan, help='Elevation [m]') vp = Array.T(shape=(None, 1), help='P Wave velocities [m/s]') vs = Array.T(shape=(None, 1), help='S Wave velocities [m/s]') d = Array.T(shape=(None, 1), help='Interface depth, top [m]') h = Array.T(shape=(None, 1), help='Interface thickness [m]') heatflow = Float.T(optional=True, help='Heatflow [W/m^2]') geographical_location = String.T(optional=True, help='Geographic Location') geological_province = String.T(optional=True, help='Geological Province') geological_age = String.T(optional=True, help='Geological Age') measurement_method = Int.T(optional=True, help='Measurement method') publication_reference = String.T(optional=True, help='Publication Reference') publication_year__ = Int.T(help='Publication Date') def __init__(self, *args, **kwargs): Object.__init__(self, *args, **kwargs) self.h = num.abs(self.d - num.roll(self.d, -1)) self.h[-1] = 0 self.nlayers = self.h.size self.geographical_location = '%s (%s)' % (provinceKey( self.geographical_location), self.geographical_location) self.vs[self.vs == 0] = num.nan self.vp[self.vp == 0] = num.nan self._step_vp = num.repeat(self.vp, 2) self._step_vs = num.repeat(self.vs, 2) self._step_d = num.roll(num.repeat(self.d, 2), -1) self._step_d[-1] = self._step_d[-2] + THICKNESS_HALFSPACE @property def publication_year__(self): return pubYear(self.publication_reference) def interpolateProfile(self, depths, phase='p', stepped=True): '''Get a continuous velocity function at arbitrary depth :param depth: Depths to interpolate :type depth: :class:`numpy.ndarray` :param phase: P or S wave velocity, **p** or **s** :type phase: str, optional :param stepped: Use a stepped velocity function or gradient :type stepped: bool :returns: velocities at requested depths :rtype: :class:`numpy.ndarray` ''' if phase not in ['s', 'p']: raise AttributeError('Phase has to be either \'p\' or \'s\'.') if phase == 'p': vel = self._step_vp if stepped else self.vp elif phase == 's': vel = self._step_vs if stepped else self.vs d = self._step_d if stepped else self.d if vel.size == 0: raise ProfileEmpty('Phase %s does not contain velocities' % phase) try: res = num.interp(depths, d, vel, left=num.nan, right=num.nan) except ValueError: raise ValueError('Could not interpolate velocity profile.') return res def plot(self, axes=None): ''' Plot the velocity profile, see :class:`pyrocko.cake`. :param axes: Axes to plot into. :type axes: :class:`matplotlib.Axes`''' import matplotlib.pyplot as plt fig, ax = _getCanvas(axes) my_model_plot(self.getLayeredModel(), axes=axes) ax.set_title('Global Crustal Database\n' 'Velocity Structure at {p.lat:.4f}N, ' ' {p.lat:.4f}E (uid {p.uid})'.format(p=self)) if axes is None: plt.show() def getLayeredModel(self): ''' Get a layered model, see :class:`pyrocko.cake.LayeredModel`. ''' def iterLines(): for il, m in enumerate(self.iterLayers()): yield self.d[il], m, '' return LayeredModel.from_scanlines(iterLines()) def iterLayers(self): ''' Iterator returns a :class:`pyrocko.cake.Material` for each layer''' for il in range(self.nlayers): yield Material(vp=self.vp[il], vs=self.vs[il]) @property def geog_loc_long(self): return provinceKey(self.geog_loc) @property def geol_age_long(self): return ageKey(self.geol_age) @property def has_s(self): return num.any(self.vp) @property def has_p(self): return num.any(self.vs) def get_weeded(self): ''' Get weeded representation of layers used in the profile. See :func:`pyrocko.cake.get_weeded` for details. ''' weeded = num.zeros((self.nlayers, 4)) weeded[:, 0] = self.d weeded[:, 1] = self.vp weeded[:, 2] = self.vs def _csv(self): output = '' for d in range(len(self.h)): output += ( '{p.uid}, {p.lat}, {p.lon},' ' {vp}, {vs}, {h}, {d}, {p.publication_reference}\n').format( p=self, vp=self.vp[d], vs=self.vs[d], h=self.h[d], d=self.d[d]) return output