def get_seis_cov_velocity_models(engine,
sources,
targets,
arrival_taper,
filterer,
plot=False,
n_jobs=1):
'''
Calculate model prediction uncertainty matrix with respect to uncertainties
in the velocity model for station and channel.
Input:
:py:class:`gf.Engine` - contains synthetics generation machine
:py:class:`gf.Targets` - targets to be processed
:py:class: `heart.ArrivalTaper` - Determines Tapering around Phase Arrival
'''
ref_target = copy.deepcopy(targets[0])
reference_taperer = heart.get_phase_taperer(engine, sources[0], ref_target,
arrival_taper)
synths, _ = heart.seis_synthetics(engine,
sources,
targets,
arrival_taper,
filterer,
nprocs=n_jobs,
reference_taperer=reference_taperer,
plot=plot)
return num.cov(synths, rowvar=0)
def perform(self, node, inputs, output):
"""
Perform method of the Operator to calculate synthetic displacements.
Parameters
----------
inputs : list
of :class:`numpy.ndarray`
output : list
1) of synthetic waveforms of :class:`numpy.ndarray`
(n x nsamples)
2) of start times of the first waveform samples
:class:`numpy.ndarray` (n x 1)
"""
synths = output[0]
tmins = output[1]
point = {vname: i for vname, i in zip(self.varnames, inputs)}
mpoint = utility.adjust_point_units(point)
source_points = utility.split_point(mpoint)
for i, source in enumerate(self.sources):
utility.update_source(source, **source_points[i])
source.time += self.event.time
synths[0], tmins[0] = heart.seis_synthetics(
engine=self.engine,
sources=self.sources,
targets=self.targets,
arrival_taper=self.arrival_taper,
wavename=self.wavename,
filterer=self.filterer,
pre_stack_cut=self.pre_stack_cut)
def seismic_cov_velocity_models(engine,
sources,
targets,
arrival_taper,
wavename,
filterer,
plot=False,
n_jobs=1):
'''
Calculate model prediction uncertainty matrix with respect to uncertainties
in the velocity model for station and channel.
Parameters
----------
engine : :class:`pyrocko.gf.seismosizer.LocalEngine`
contains synthetics generation machine
sources : list
of :class:`pyrocko.gf.seismosizer.Source`
targets : list
of :class:`pyrocko.gf.seismosizer.Targets`
arrival_taper : :class: `heart.ArrivalTaper`
determines tapering around phase Arrival
filterer : :class:`heart.Filter`
determines the bandpass-filtering corner frequencies
plot : boolean
open snuffler and browse traces if True
n_jobs : int
number of processors to be used for calculation
Returns
-------
:class:`numpy.ndarray` with Covariance due to velocity model uncertainties
'''
ref_target = copy.deepcopy(targets[0])
reference_taperer = heart.get_phase_taperer(engine,
sources[0],
wavename=wavename,
target=ref_target,
arrival_taper=arrival_taper)
t0 = time()
synths, _ = heart.seis_synthetics(engine=engine,
sources=sources,
targets=targets,
arrival_taper=arrival_taper,
wavename=wavename,
filterer=filterer,
nprocs=n_jobs,
reference_taperer=reference_taperer,
plot=plot,
pre_stack_cut=True,
outmode='array')
t1 = time()
logger.debug('Trace generation time %f' % (t1 - t0))
return num.cov(synths, rowvar=0)
def _process_patch_seismic(
engine, gfs, targets, patch, patchidx, durations, starttimes):
# ensur event reference time
logger.debug('Using reference event source time ...')
patch.time = gfs.config.event.time
# ensure stf anchor point at -1
patch.stf.anchor = -1
source_patches_durations = []
logger.info('Patch Number %i', patchidx)
for duration in durations:
pcopy = patch.clone()
pcopy.stf.duration = float(duration)
source_patches_durations.append(pcopy)
for j, target in enumerate(targets):
traces, _ = heart.seis_synthetics(
engine=engine,
sources=source_patches_durations,
targets=[target],
arrival_taper=None,
arrival_times=num.array(None),
wavename=gfs.config.wave_config.name,
filterer=None,
reference_taperer=None,
outmode='data')
# getting event related arrival time valid for all patches
# as common reference
event_arrival_time = heart.get_phase_arrival_time(
engine=engine,
source=gfs.config.event,
target=target,
wavename=gfs.config.wave_config.name)
gfs.set_patch_time(targetidx=j, tmin=event_arrival_time)
for starttime in starttimes:
shifted_arrival_time = event_arrival_time - starttime
synthetics_array = heart.taper_filter_traces(
traces=traces,
arrival_taper=gfs.config.wave_config.arrival_taper,
filterer=gfs.config.wave_config.filterer,
arrival_times=num.ones(durations.size) * shifted_arrival_time,
outmode='array',
chop_bounds=['b', 'c'])
gfs.put(
entries=synthetics_array,
targetidx=j,
patchidx=patchidx,
durations=durations,
starttimes=starttime)
def seismic_cov_velocity_models(engine,
sources,
targets,
arrival_taper,
arrival_time,
wavename,
filterer,
plot=False,
n_jobs=1):
'''
Calculate model prediction uncertainty matrix with respect to uncertainties
in the velocity model for station and channel.
Parameters
----------
engine : :class:`pyrocko.gf.seismosizer.LocalEngine`
contains synthetics generation machine
sources : list
of :class:`pyrocko.gf.seismosizer.Source`
targets : list
of :class:`pyrocko.gf.seismosizer.Targets`
arrival_taper : :class: `heart.ArrivalTaper`
determines tapering around phase Arrival
arrival_time : None or :class:`numpy.NdArray` or float
of phase to apply taper, if None theoretic arrival of ray tracing used
filterer : :class:`heart.Filter`
determines the bandpass-filtering corner frequencies
plot : boolean
open snuffler and browse traces if True
n_jobs : int
number of processors to be used for calculation
Returns
-------
:class:`numpy.ndarray` with Covariance due to velocity model uncertainties
'''
arrival_times = num.ones(len(targets), dtype='float64') * arrival_time
t0 = time()
synths, _ = heart.seis_synthetics(engine=engine,
sources=sources,
targets=targets,
arrival_taper=arrival_taper,
wavename=wavename,
filterer=filterer,
arrival_times=arrival_times,
pre_stack_cut=True,
plot=plot,
outmode='array',
chop_bounds=['b', 'c'])
t1 = time()
logger.debug('Trace generation time %f' % (t1 - t0))
return num.cov(synths, rowvar=0)
def get_synthetics(self, point, **kwargs):
"""
Get synthetics for given point in solution space.
Parameters
----------
point : :func:`pymc3.Point`
Dictionary with model parameters
kwargs especially to change output of seismic forward model
outmode = 'traces'/ 'array' / 'data'
Returns
-------
default: array of synthetics for all targets
"""
self.point2sources(point)
sc = self.config
synths = []
obs = []
for wmap in self.wavemaps:
wc = wmap.config
synthetics, tmins = heart.seis_synthetics(
engine=self.engine,
sources=self.sources,
targets=wmap.targets,
arrival_taper=wc.arrival_taper,
wavename=wmap.name,
filterer=wc.filterer,
pre_stack_cut=sc.pre_stack_cut,
**kwargs)
if self.config.station_corrections:
sh = point[self.correction_name][wmap.station_correction_idxs]
for i, tr in enumerate(synthetics):
tr.tmin += sh[i]
tr.tmax += sh[i]
synths.extend(synthetics)
obs_tr = heart.taper_filter_traces(wmap.datasets,
arrival_taper=wc.arrival_taper,
filterer=wc.filterer,
tmins=tmins,
**kwargs)
obs.extend(obs_tr)
return synths, obs
def perform(self, node, inputs, output):
synths = output[0]
tmins = output[1]
point = {
var: inp
for var, inp in zip(config.joint_vars_geometry, inputs)
}
mpoint = utility.adjust_point_units(point)
source_points = utility.split_point(mpoint)
for i, source in enumerate(self.sources):
utility.update_source(source, **source_points[i])
source.time += self.event.time
heart.adjust_fault_reference(source, input_depth='top')
synths[0], tmins[0] = heart.seis_synthetics(self.engine, self.sources,
self.targets,
self.arrival_taper,
self.filterer)
def get_synthetics(self, point, **kwargs):
"""
Get synthetics for given point in solution space.
Parameters
----------
point : :func:`pymc3.Point`
Dictionary with model parameters
kwargs especially to change output of seismic forward model
outmode = 'traces'/ 'array' / 'data'
Returns
-------
default: array of synthetics for all targets
"""
outmode = kwargs.pop('outmode', 'stacked_traces')
chop_bounds = kwargs.pop('chop_bounds', ['a', 'd'])
order = kwargs.pop('order', 'list')
nprocs = kwargs.pop('nprocs', 1)
self.point2sources(point)
sc = self.config
synths = []
obs = []
for wmap in self.wavemaps:
wc = wmap.config
wmap.prepare_data(source=self.events[wc.event_idx],
engine=self.engine,
outmode=outmode,
chop_bounds=chop_bounds)
arrival_times = wmap._arrival_times
if self.config.station_corrections:
try:
arrival_times += point[wmap.time_shifts_id][
wmap.station_correction_idxs]
except KeyError: # got reference point from config
arrival_times += float(point[self.correction_name]) * \
num.ones(wmap.n_t)
if self.nevents == 1:
logger.debug('Using all sources for each wavemap!')
sources = self.sources
else:
logger.debug('Using individual sources based on event index '
'for each wavemap!')
sources = [self.sources[wc.event_idx]]
synthetics, _ = heart.seis_synthetics(
engine=self.engine,
sources=sources,
targets=wmap.targets,
arrival_taper=wc.arrival_taper,
wavename=wmap.name,
filterer=wc.filterer,
pre_stack_cut=sc.pre_stack_cut,
arrival_times=arrival_times,
outmode=outmode,
chop_bounds=chop_bounds,
nprocs=nprocs,
# plot=True,
**kwargs)
if self.config.station_corrections:
# set tmin to data tmin
for tr, dtr in zip(synthetics, wmap._prepared_data):
if isinstance(tr, list):
for t in tr:
t.tmin = dtr.tmin
t.tmax = dtr.tmax
else:
tr.tmin = dtr.tmin
tr.tmax = dtr.tmax
if order == 'list':
synths.extend(synthetics)
obs.extend(wmap._prepared_data)
elif order == 'wmap':
synths.append(synthetics)
obs.append(wmap._prepared_data)
else:
raise ValueError('Order "%s" is not supported' % order)
return synths, obs
def get_synthetics(self, point, **kwargs):
"""
Get synthetics for given point in solution space.
Parameters
----------
point : :func:`pymc3.Point`
Dictionary with model parameters
kwargs especially to change output of seismic forward model
outmode = 'traces'/ 'array' / 'data'
Returns
-------
default: array of synthetics for all targets
"""
outmode = kwargs.pop('outmode', 'stacked_traces')
chop_bounds = kwargs.pop('chop_bounds', ['a', 'd'])
order = kwargs.pop('order', 'list')
self.point2sources(point)
sc = self.config
synths = []
obs = []
for wmap in self.wavemaps:
wc = wmap.config
wmap.prepare_data(
source=self.event,
engine=self.engine,
outmode=outmode,
chop_bounds=chop_bounds)
arrival_times = wmap._arrival_times
if self.config.station_corrections:
try:
arrival_times += point[
self.correction_name][wmap.station_correction_idxs]
except IndexError: # got reference point from config
arrival_times += float(point[self.correction_name]) * \
num.ones(wmap.n_t)
synthetics, _ = heart.seis_synthetics(
engine=self.engine,
sources=self.sources,
targets=wmap.targets,
arrival_taper=wc.arrival_taper,
wavename=wmap.name,
filterer=wc.filterer,
pre_stack_cut=sc.pre_stack_cut,
arrival_times=arrival_times,
outmode=outmode,
chop_bounds=chop_bounds,
**kwargs)
if order == 'list':
synths.extend(synthetics)
obs.extend(wmap._prepared_data)
elif order == 'wmap':
synths.append(synthetics)
obs.append(wmap._prepared_data)
else:
raise ValueError('Order "%s" is not supported' % order)
return synths, obs
engine = gf.LocalEngine(store_superdirs=store_superdirs)
patchidx = fault.patchmap(
index=0, dipidx=nuc_dip_idx, strikeidx=nuc_strike_idx)
targets = sc.wavemaps[0].targets
filterer = sc.wavemaps[0].config.filterer
ntargets = len(targets)
gfs = ffi.load_gf_library(
directory=project_dir + '/ffi/linear_gfs/',
filename='seismic_uparr_any_P_0')
ats = gfs.reference_times - arrival_taper.b
traces, tmins = heart.seis_synthetics(
engine, patches, targets, arrival_times=ats,
wavename='any_P', arrival_taper=arrival_taper,
filterer=filterer, outmode='stacked_traces')
targetidxs = num.lib.index_tricks.s_[:]
if False:
# for station corrections maybe in the future?
station_corrections = num.zeros(len(traces))
starttimes = (num.tile(starttimes, ntargets) + num.repeat(
station_corrections, fault.npatches)).reshape(
ntargets, fault.npatches)
targetidxs = num.atleast_2d(num.arange(ntargets)).T
gfs.set_stack_mode('numpy')
synthetics_nn = gfs.stack_all(
targetidxs=targetidxs,
def get_synthetics(self, point, **kwargs):
"""
Get synthetics for given point in solution space.
Parameters
----------
point : :func:`pymc3.Point`
Dictionary with model parameters
kwargs especially to change output of seismic forward model
outmode = 'traces'/ 'array' / 'data'
Returns
-------
Dictionary with keys according to datasets containing the synthetics
as lists.
"""
tpoint = copy.deepcopy(point)
tpoint = utility.adjust_point_units(tpoint)
# remove hyperparameters from point
hps = self.config.problem_config.hyperparameters
if len(hps) > 0:
for hyper in hps.keys():
if hyper in tpoint:
tpoint.pop(hyper)
else:
pass
d = dict()
if self._seismic_flag:
tpoint['time'] += self.event.time
source_points = utility.split_point(tpoint)
for i, source in enumerate(self.sources):
utility.update_source(source, **source_points[i])
dsources = utility.transform_sources(
self.sources, self.config.problem_config.datasets)
# seismic
if self._seismic_flag:
sc = self.config.seismic_config
seis_synths, _ = heart.seis_synthetics(
engine=self.engine,
sources=dsources['seismic'],
targets=self.stargets,
arrival_taper=sc.arrival_taper,
filterer=sc.filterer, **kwargs)
d['seismic'] = seis_synths
# geodetic
if self._geodetic_flag:
gc = self.config.geodetic_config
crust_inds = [0]
geo_synths = []
for crust_ind in crust_inds:
for gtarget in self.gtargets:
disp = heart.geo_layer_synthetics(
gc.gf_config.store_superdir,
crust_ind,
lons=gtarget.lons,
lats=gtarget.lats,
sources=dsources['geodetic'])
geo_synths.append((
disp[:, 0] * gtarget.los_vector[:, 0] + \
disp[:, 1] * gtarget.los_vector[:, 1] + \
disp[:, 2] * gtarget.los_vector[:, 2]))
d['geodetic'] = geo_synths
return d