Ejemplo n.º 1
0
class QSeisConfig(Object):

    qseis_version = String.T(default='2006')
    time_region = Tuple.T(2,
                          Timing.T(),
                          default=(Timing('-10'), Timing('+890')))

    cut = Tuple.T(2, Timing.T(), optional=True)
    fade = Tuple.T(4, Timing.T(), optional=True)
    relevel_with_fade_in = Bool.T(default=False)

    sw_algorithm = Int.T(default=0)
    slowness_window = Tuple.T(4, Float.T(default=0.0))
    wavenumber_sampling = Float.T(default=2.5)
    aliasing_suppression_factor = Float.T(default=0.1)

    filter_surface_effects = Int.T(default=0)
    filter_shallow_paths = Int.T(default=0)
    filter_shallow_paths_depth = Float.T(default=0.0)
    propagation_filters = List.T(QSeisPropagationFilter.T())
    receiver_filter = QSeisPoleZeroFilter.T(optional=True)

    sw_flat_earth_transform = Int.T(default=0)

    gradient_resolution_vp = Float.T(default=0.0)
    gradient_resolution_vs = Float.T(default=0.0)
    gradient_resolution_density = Float.T(default=0.0)

    wavelet_duration_samples = Float.T(default=0.0)
    wavelet_type = Int.T(default=2)
    user_wavelet_samples = List.T(Float.T())

    def items(self):
        return dict(self.T.inamevals(self))
Ejemplo n.º 2
0
class SandboxSceneConfig(Object):
    frame = FrameConfig.T(default=FrameConfig(),
                          help='Frame/reference configuration')
    extent_north = Int.T(default=800, help='Model size towards north in [px]')
    extent_east = Int.T(default=800, help='Model size towards east in [px]')
    sources = List.T(help='List of sources')
    reference_scene = String.T(optional=True,
                               help='Reference kite.Scene container')
Ejemplo n.º 3
0
class Decimation(Object):
    '''Corresponds to SEED blockette 57.'''

    input_sample_rate = Frequency.T(xmltagname='InputSampleRate')
    factor = Int.T(xmltagname='Factor')
    offset = Int.T(xmltagname='Offset')
    delay = FloatWithUnit.T(xmltagname='Delay')
    correction = FloatWithUnit.T(xmltagname='Correction')
Ejemplo n.º 4
0
class Similarity(Object):
    '''CC result of one event pair at one target.'''
    ievent = Int.T(help='Event identifier')
    jevent = Int.T(help='Event identifier')
    itarget = Int.T(help='Target identifier')
    cross_correlation = Float.T()
    cross_correlation_trace = SeismosizerTrace.T(optional=True)
    relative_amplitude = Float.T(
        help='Relative amplitude with reference to ievent.')
    time_lag = Float.T(help='Time lag at maximum of cross correlation')
Ejemplo n.º 5
0
class OriginQuality(Object):
    associated_phase_count = Int.T(optional=True)
    used_phase_count = Int.T(optional=True)
    associated_station_count = Int.T(optional=True)
    used_station_count = Int.T(optional=True)
    depth_phase_count = Int.T(optional=True)
    standard_error = Float.T(optional=True)
    azimuthal_gap = Float.T(optional=True)
    secondary_azimuthal_gap = Float.T(optional=True)
    ground_truth_level = GroundTruthLevel.T(optional=True)
    maximum_distance = Float.T(optional=True)
    minimum_distance = Float.T(optional=True)
    median_distance = Float.T(optional=True)
Ejemplo n.º 6
0
class PoelConfig(Object):
    s_radius = Float.T(default=0.0)
    s_type = Int.T(default=0)
    source_function_p = Float.T(default=1.0)
    source_function_i = PoelSourceFunction.T(default=PoelSourceFunction.D(
        data=num.array([[0., 0.], [10., 1.]], dtype=num.float)))

    t_window = Float.T(default=500.)
    accuracy = Float.T(default=0.025)
    isurfcon = Int.T(default=1)
    model = PoelModel.T(default=PoelModel(data=num.array(
        [[0.00, 0.4E+09, 0.2, 0.4, 0.75, 5.00]], dtype=num.float)))

    def items(self):
        return dict(self.T.inamevals(self))
Ejemplo n.º 7
0
class MetropolisConfig(SamplerParameters):
    """
    Config for optimization parameters of the Adaptive Metropolis algorithm.
    """
    n_steps = Int.T(default=25000, help='Number of steps for the MC chain.')
    n_chains = Int.T(default=20,
                     help='Number of Metropolis chains for sampling.')
    thin = Int.T(
        default=2,
        help='Thinning parameter of the sampled trace. Every "thin"th sample'
        ' is taken.')
    burn = Float.T(
        default=0.5,
        help='Burn-in parameter between 0. and 1. to discard fraction of'
        ' samples from the beginning of the chain.')
Ejemplo n.º 8
0
class PNG(PlotFormat):
    name = 'png'

    dpi = Int.T(
        optional=True,
        help='DPI of the figure')
    size_pixels = Int.T(
        optional=True,
        help='Size in pixels')
    width_pixels = Int.T(
        optional=True,
        help='Width in pixels')
    height_pixels = Int.T(
        optional=True,
        help='Height in pixels')

    @property
    def extension(self):
        if self.dpi is not None:
            return 'd%i.png' % self.dpi
        elif self.size_pixels is not None:
            return 's%i.png' % self.size_pixels
        elif self.width_pixels is not None:
            return 'w%i.png' % self.width_pixels
        elif self.height_pixels is not None:
            return 'h%i.png' % self.height_pixels
        else:
            return 'd100.png'

    def get_dpi(self, size_cm):
        w_cm, h_cm = size_cm
        w_inch, h_inch = w_cm/inch, h_cm/inch
        if self.dpi:
            return self.dpi
        elif self.size_pixels is not None:
            return min(self.size_pixels/w_inch, self.size_pixels/h_inch)
        elif self.width_pixels is not None:
            return self.width_pixels/w_inch
        elif self.height_pixels is not None:
            return self.height_pixels/h_inch
        else:
            return 100.0

    def render_mpl(self, fig, path, **kwargs):
        return fig.savefig(path, format=self.name, **kwargs)

    def render_automap(self, automap, path, **kwargs):
        return automap.save(path, **kwargs)
Ejemplo n.º 9
0
Archivo: base.py Proyecto: wsja/pyrocko
class Generator(Object):
    seed = Int.T(optional=True,
                 help='Random seed for a reproducible scenario.')

    def __init__(self, **kwargs):
        Object.__init__(self, **kwargs)
        self._seed = None
        self._parent = None
        self.update_hierarchy()
        self._retry_offset = 0

    def retry(self):
        self.clear()
        self._retry_offset += 1
        for val in self.T.ivals(self):
            if isinstance(val, Generator):
                val.retry()

    def clear(self):
        self._seed = None

    def hash(self):
        return hashlib.sha1(
            (self.dump() + '\n\n%i' % self._retry_offset).encode('utf8'))\
            .hexdigest()

    def get_seed_offset(self):
        return int(self.hash(), base=16) % N

    def update_hierarchy(self, parent=None):
        self._parent = parent
        for val in self.T.ivals(self):
            if isinstance(val, Generator):
                val.update_hierarchy(parent=self)

    def get_seed(self):
        if self._seed is None:
            if self.seed is None:
                if self._parent is not None:
                    self._seed = self._parent.get_seed()
                else:
                    self._seed = num.random.randint(N)
            elif self.seed == 0:
                self._seed = num.random.randint(N)
            else:
                self._seed = self.seed

        return self._seed + self.get_seed_offset()

    def get_rstate(self, i):
        return num.random.RandomState(self.get_seed() + i)

    def get_center_latlon(self):
        return self._parent.get_center_latlon()

    def get_radius(self):
        return self._parent.get_radius()

    def get_stations(self):
        return []
Ejemplo n.º 10
0
class PalantiriXcorrConfig(Object):
    '''Configuration of data IO and data preprocessing'''

    xcorr = Bool.T(default=True, optional=True, help='')

    xcorrtreshold = Float.T(default=0.6, optional=True, help='')

    autoxcorrcorrectur = Bool.T(default=False, optional=True, help='')

    refstationfreqmin = Float.T(default=0.03,
                                optional=True,
                                help='Length in seconds. Not needed \
                                when using TFRecordData')

    refstationfreqmax = Float.T(default=1,
                                optional=True,
                                help='Length in seconds. Not needed \
                                when using TFRecordData')

    refstationcorners = Int.T(default=2,
                              optional=True,
                              help='Length in seconds. Not needed \
                              when using TFRecordData')

    refstationzph = Bool.T(default=False, optional=True, help='')

    refsta = Float.T(default=0.5,
                     optional=True,
                     help='Length in seconds. Not needed \
                     when using TFRecordData')

    reflta = Float.T(default=2,
                     optional=True,
                     help='Length in seconds. Not needed \
                     when using TFRecordData')
Ejemplo n.º 11
0
class PyrockoRectangularSource(SandboxSourceRectangular, PyrockoSource):
    """Classical Haskell source model modified for bilateral rupture.
    See :class:`pyrocko.gf.seismosizer.RectangularSource`.
    """

    __implements__ = "pyrocko"

    decimation_factor = Int.T(optional=True,
                              default=10,
                              help="Sub-source decimation factor.")
    store_dir = String.T(help="Pyrocko GF Store path")

    parametersUpdated = PyrockoSource.parametersUpdated

    def __init__(self, *args, **kwargs):
        SandboxSourceRectangular.__init__(self, *args, **kwargs)
        self.pyrocko_source = gf.RectangularSource(**self._src_args)

    @property
    def _src_args(self):
        return {
            "lat": 0.0,
            "lon": 0.0,
            "north_shift": self.northing,
            "east_shift": self.easting,
            "depth": self.depth,
            "length": self.length,
            "width": self.width,
            "strike": self.strike,
            "dip": self.dip,
            "rake": self.rake,
            "slip": self.slip,
            "decimation_factor": self.decimation_factor,
            "anchor": "top",
        }
Ejemplo n.º 12
0
class CMTProblemConfig(ProblemConfig):

    ranges = Dict.T(String.T(), gf.Range.T())
    distance_min = Float.T(default=0.0)
    mt_type = MTType.T(default='full')
    stf_type = STFType.T(default='HalfSinusoidSTF')
    nthreads = Int.T(default=1)

    def get_problem(self, event, target_groups, targets):
        if event.depth is None:
            event.depth = 0.

        base_source = gf.MTSource.from_pyrocko_event(event)

        stf = STFType.base_stf(self.stf_type)
        stf.duration = event.duration or 0.0

        base_source.stf = stf

        subs = dict(event_name=event.name,
                    event_time=util.time_to_str(event.time))

        problem = CMTProblem(name=expand_template(self.name_template, subs),
                             base_source=base_source,
                             target_groups=target_groups,
                             targets=targets,
                             ranges=self.ranges,
                             distance_min=self.distance_min,
                             mt_type=self.mt_type,
                             stf_type=self.stf_type,
                             norm_exponent=self.norm_exponent,
                             nthreads=self.nthreads)

        return problem
Ejemplo n.º 13
0
class VolumePointProblemConfig(ProblemConfig):
    ranges = Dict.T(String.T(), gf.Range.T())
    distance_min = Float.T(default=0.0)
    nthreads = Int.T(default=1)

    def get_problem(self, event, target_groups, targets):
        if event.depth is None:
            event.depth = 0.

        base_source = gf.ExplosionSource.from_pyrocko_event(event)
        base_source.stf = gf.HalfSinusoidSTF(duration=event.duration or 0.0)

        subs = dict(event_name=event.name,
                    event_time=util.time_to_str(event.time))

        problem = VolumePointProblem(name=expand_template(
            self.name_template, subs),
                                     base_source=base_source,
                                     target_groups=target_groups,
                                     targets=targets,
                                     ranges=self.ranges,
                                     distance_min=self.distance_min,
                                     norm_exponent=self.norm_exponent,
                                     nthreads=self.nthreads)

        return problem
Ejemplo n.º 14
0
class PyrockoRectangularSource(SandboxSourceRectangular, PyrockoSource):
    '''Classical Haskell source model modified for bilateral rupture.
    See :class:`pyrocko.gf.seismosizer.RectangularSource`.
    '''
    __implements__ = 'pyrocko'

    decimation_factor = Int.T(optional=True,
                              default=10,
                              help='Sub-source decimation factor.')
    store_dir = String.T(help='Pyrocko GF Store path')

    parametersUpdated = PyrockoSource.parametersUpdated

    def __init__(self, *args, **kwargs):
        SandboxSourceRectangular.__init__(self, *args, **kwargs)
        self.pyrocko_source = gf.RectangularSource(**self._src_args)

    @property
    def _src_args(self):
        return {
            'lat': 0.,
            'lon': 0.,
            'north_shift': self.northing,
            'east_shift': self.easting,
            'depth': self.depth,
            'length': self.length,
            'width': self.width,
            'strike': self.strike,
            'dip': self.dip,
            'rake': self.rake,
            'slip': self.slip,
            'decimation_factor': self.decimation_factor,
            'anchor': 'top',
        }
Ejemplo n.º 15
0
class City(Object):
    def __init__(self, name, lat, lon, population=None, asciiname=None):
        name = unicode(name)
        lat = float(lat)
        lon = float(lon)
        if asciiname is None:
            asciiname = name.encode('ascii', errors='replace')

        if population is None:
            population = 0
        else:
            population = int(population)

        Object.__init__(self,
                        name=name,
                        lat=lat,
                        lon=lon,
                        population=population,
                        asciiname=asciiname)

    name = Unicode.T()
    lat = Float.T()
    lon = Float.T()
    population = Int.T()
    asciiname = String.T()
Ejemplo n.º 16
0
class CatalogConfig(Object):
    search_events = Bool.T()
    use_local_catalog = Bool.T()
    subset_of_local_catalog = Bool.T()
    use_local_subsets = Bool.T()
    subset_fns = Dict.T()
    # catalog
    catalog_fn = String.T(
        optional=True, help='Name of local catalog to save to or to read from')
    dist = Float.T(default=165.0,
                   help='Max. distance to show on catalog plot (map) [deg]')
    min_mag = Float.T()
    max_mag = Float.T()
    tmin_str = String.T()
    tmax_str = String.T()
    wedges_width = Int.T(
        help='Find one event in backazimuthal wedge of this width')
    mid_point = List.T(
        optional=True,
        help='Enter some estimation on centre point of array, needed for\
             subset based on distances and plotting only.')
    median_ev_in_bin = Bool.T(default=True)
    # weighted_magn_baz_ev = Bool.T()

    min_dist_km = Float.T()
    max_dist_km = Float.T()
    depth_options = Dict.T()

    plot_catalog_all = Bool.T(default=False)
    plot_hist_wedges = Bool.T(default=False)
    plot_wedges_vs_dist = Bool.T(default=False)
    plot_wedges_vs_magn = Bool.T(default=False)
    plot_dist_vs_magn = Bool.T(default=False)
    plot_catalog_subset = Bool.T(default=False)
Ejemplo n.º 17
0
class QSeisRBandpassFilter(Object):
    order = Int.T(default=-1)
    lower_cutoff = Float.T(default=0.1)  # [Hz]
    upper_cutoff = Float.T(default=10.0)

    def string_for_config(self):
        return '%(order) %(lower_cutoff)5e %(upper_cutoff)5e' % self.__dict__
Ejemplo n.º 18
0
class StationGenerator(TargetGenerator):
    nstations = Int.T(default=10,
                      help='Number of randomly distributed stations.')

    network_name = String.T(default='CO', help='Network name')

    with_channels = Bool.T(default=True,
                           help='Generate seismic channels: BHN, BHE, BHZ')
Ejemplo n.º 19
0
class GFLibaryConfig(Object):
    """
    Baseconfig for GF Libraries
    """
    component = String.T(default='uparr')
    event = model.Event.T(default=model.Event.D())
    datatype = String.T(default='undefined')
    crust_ind = Int.T(default=0)
Ejemplo n.º 20
0
class QSeisPropagationFilter(Object):
    min_depth = Float.T(default=0.0)
    max_depth = Float.T(default=0.0)
    filtered_phase = Int.T(default=0)

    def string_for_config(self):
        return '%(min_depth)15e %(max_depth)15e ' \
               '%(filtered_phase)i' % self.__dict__
Ejemplo n.º 21
0
class TargetBalancingAnalyserConfig(AnalyserConfig):
    """Configuration parameters of the target balancing."""
    niterations = Int.T(default=1000,
                        help='Number of random forward models for mean \
                             phase amplitude estimation')

    def get_analyser(self):
        return TargetBalancingAnalyser(niter=self.niterations)
Ejemplo n.º 22
0
class ProblemConfig(Object):
    '''
    Base class for config section defining the objective function setup.

    Factory for :py:class:`Problem` objects.
    '''
    name_template = String.T()
    norm_exponent = Int.T(default=2)
    nthreads = Int.T(default=1)

    def get_problem(self, event, target_groups, targets):
        '''
        Instantiate the problem with a given event and targets.

        :returns: :py:class:`Problem` object
        '''
        raise NotImplementedError
Ejemplo n.º 23
0
class PsGrnSpatialSampling(Object):
    n_steps = Int.T(default=10)
    start_distance = Float.T(default=0.)  # start sampling [km] from source
    end_distance = Float.T(default=100.)  # end

    def string_for_config(self):
        return '%i %15e %15e' \
            % (self.n_steps, self.start_distance, self.end_distance)
Ejemplo n.º 24
0
class PoleZero(Object):
    '''Complex numbers used as poles or zeros in channel response.'''

    number = Int.T(optional=True, xmlstyle='attribute')
    real = FloatNoUnit.T(xmltagname='Real')
    imaginary = FloatNoUnit.T(xmltagname='Imaginary')

    def value(self):
        return self.real.value + 1J * self.imaginary.value
Ejemplo n.º 25
0
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
Ejemplo n.º 26
0
class GRLawSTF(STF):
    '''Poisson distributed random impulses based on the Gutenberg-Richter law.'''

    duration = Float.T(default=0.0, help='baseline of the ramp')

    anchor = Float.T(
        default=0.0,
        help='anchor point with respect to source-time: ('
        '-1.0: left -> source duration [0, T] ~ hypocenter time, '
        ' 0.0: center -> source duration [-T/2, T/2] ~ centroid time, '
        '+1.0: right -> source duration [-T, 0] ~ rupture end time)')

    mag = Float.T(default=5.0, help='magnitude used for Gutenberg-Richter law')

    b = Float.T(default=1.2, help='b parameter for Gutenberg-Richter law')

    poisson_envelope = Int.T(
        default=0,
        help=
        'Whether to apply a Poisson distribution envelope to the magnitudes of the asperities.'
    )

    mu = Float.T(default=10, help='Mu parameter for Poisson envelope')

    loc = Float.T(optional=True,
                  help="'loc' parameter for Poisson distribution function")

    def discretize_t(self, deltat, tref):
        # Gutenberg-Ricther law
        M = np.linspace(0, self.mag, 1000)
        pdf = self.b * np.log(10) * 10**(-self.b * M)
        self.cdf = 1 - 10**(-self.b * M)

        # method returns discrete times and the respective amplitudes
        tmin_stf = tref - self.duration * (self.anchor + 1.) * 0.5
        tmax_stf = tref + self.duration * (1. - self.anchor) * 0.5
        tmin = round(tmin_stf / deltat) * deltat
        tmax = round(tmax_stf / deltat) * deltat
        nt = int(round((tmax - tmin) / deltat)) + 1
        times = np.linspace(tmin, tmax, nt)
        if nt > 1:
            self._amplitudes = np.random.uniform(min(self.cdf), max(self.cdf),
                                                 nt)
            if self.poisson_envelope:
                x = np.linspace(0, nt - 1, nt)
                self.envelope = poisson.pmf(x, mu=self.mu, loc=self.loc)
                self.amplitudes = self.mag * (self._amplitudes * self.envelope)
            else:
                self.amplitudes = self._amplitudes
        else:
            self.amplitudes = np.ones(1)

        return times, self.amplitudes

    def base_key(self):
        # method returns STF name and the values
        return (self.__class__.__name__, self.duration, self.anchor)
Ejemplo n.º 27
0
class NormalizeNthRoot(Normalization):
    '''Normalize traces by their Nth root.

    Note: polarities get lost.'''
    nth_root = Int.T(default=4)

    def __call__(self, chunk):
        chunk -= num.nanmean(chunk)
        chunk[:] = num.power(num.abs(chunk), 1./self.nth_root)
        chunk += num.nanmean(chunk)
Ejemplo n.º 28
0
class MapParameters(Object):
    width = Float.T(help="width of map", optional=True, default=16)
    height = Float.T(help="heigth of map", optional=True, default=16)
    lat = Float.T(help="center latitude")
    lon = Float.T(help="center longitude")
    radius = Float.T(help="radius of map")
    outfn = String.T(help="output filename", optional=True, default="map.png")
    stations = List.T(model.Station.T(), optional=True)
    station_label_mapping = List.T(String.T(), optional=True)
    station_colors = Dict.T(String.T(), String.T(), optional=True)
    events = List.T(model.Event.T(), optional=True)
    show_topo = Bool.T(optional=True, default=True)
    show_grid = Bool.T(optional=True, default=True)
    color_wet = Tuple.T(3, Int.T(), default=(200, 200, 200))
    color_dry = Tuple.T(3, Int.T(), default=(253, 253, 253))

    @classmethod
    def process_args(cls, *args, **kwargs):
        return cls(**kwargs)
Ejemplo n.º 29
0
class SeismicGFLibraryConfig(GFLibaryConfig):
    """
    Config for the linear Seismic GF Library for dumping and loading.
    """
    wave_config = WaveformFitConfig.T(default=WaveformFitConfig.D())
    starttime_sampling = Float.T(default=0.5)
    duration_sampling = Float.T(default=0.5)
    starttime_min = Float.T(default=0.)
    duration_min = Float.T(default=0.1)
    dimensions = Tuple.T(5, Int.T(), default=(0, 0, 0, 0, 0))
Ejemplo n.º 30
0
class SamplerParameters(Object):

    n_jobs = Int.T(
        default=1,
        help='Number of processors to use, i.e. chains to sample in parallel.')
    tune_interval = Int.T(
        default=50,
        help='Tune interval for adaptive tuning of Metropolis step size.')
    proposal_dist = String.T(
        default='Normal',
        help='Normal Proposal distribution, for Metropolis steps;'
        'Alternatives: Cauchy, Laplace, Poisson, MultivariateNormal')
    check_bnd = Bool.T(
        default=True,
        help='Flag for checking whether proposed step lies within'
        ' variable bounds.')

    rm_flag = Bool.T(default=False,
                     help='Remove existing results prior to sampling.')