def test_sgrid2(self):
expect = [10., 12., 14., 16., 18., 20.]
source = gf.DCSource()
sgrid = source.grid(dip=gf.Range(10, 20, 2))
dips = []
for source in sgrid:
dips.append(source.dip)
num.testing.assert_array_almost_equal(dips, expect)
source = gf.DCSource(dip=10)
sgrid = source.grid(dip=gf.Range(1, 2, 0.2, relative='mult'))
dips = []
for source in sgrid:
dips.append(source.dip)
num.testing.assert_array_almost_equal(dips, expect)
def test_combine_covariance():
nmodels = 1 # noqa
nmisfits = 15
target = ToyTarget(path='t_corr',
north=4.,
east=3.,
depth=0.,
obs_distance=0.,
nmisfits=nmisfits)
source = ToySource(north=0, east=0, depth=5.)
p = ToyProblem(name='toy_problem',
ranges={
'north': gf.Range(start=-10., stop=10.),
'east': gf.Range(start=-10., stop=10.),
'depth': gf.Range(start=0., stop=10.)
},
base_source=source,
targets=[target])
rstate = num.random.RandomState(123)
misfits = num.zeros((nmisfits, 2))
misfits[:, 0] = rstate.normal(size=nmisfits)
misfits[:, 1] = rstate.normal(size=nmisfits) + 3.
weights = rstate.normal(size=nmisfits)
corr = num.zeros((nmisfits, nmisfits))
num.fill_diagonal(corr, weights)
extra_residuals = num.array([])
res_weights = p.combine_misfits(misfits,
extra_weights=weights[num.newaxis, :],
extra_residuals=extra_residuals)
res_corr = p.combine_misfits(misfits,
extra_correlated_weights={0: corr},
extra_residuals=extra_residuals)
num.testing.assert_almost_equal(res_weights, res_corr)
def test_combine_misfits(dump=False, reference=None):
source, targets = scenario('wellposed', 'noisefree')
p = ToyProblem(name='toy_problem',
ranges={
'north': gf.Range(start=-10., stop=10.),
'east': gf.Range(start=-10., stop=10.),
'depth': gf.Range(start=0., stop=10.)
},
base_source=source,
targets=targets)
ngx, ngy, ngz = 11, 11, 11
xg = num.zeros((ngz * ngy * ngx, 3))
xbounds = p.get_parameter_bounds()
cx = num.linspace(xbounds[0][0], xbounds[0][1], ngx)
cy = num.linspace(xbounds[1][0], xbounds[1][1], ngy)
cz = num.linspace(xbounds[2][0], xbounds[2][1], ngz)
xg[:, 0] = num.tile(cx, ngy * ngz)
xg[:, 1] = num.tile(num.repeat(cy, ngx), ngz)
xg[:, 2] = num.repeat(cz, ngx * ngy)
misfitss = p.misfits_many(xg)
# misfitss[imodel, itarget, 0], misfitss[imodel, itarget, 1]
gms = p.combine_misfits(misfitss)
gms_contrib = p.combine_misfits(misfitss, get_contributions=True)
# gms[imodel]
# gms_contrib[imodel, itarget]
bweights = num.ones((2, p.ntargets))
gms_2 = p.combine_misfits(misfitss, extra_weights=bweights)
gms_2_contrib = p.combine_misfits(misfitss,
extra_weights=bweights,
get_contributions=True)
if dump:
num.savez(dump, gms, gms_contrib, gms_2)
# gms_2[imodel, ibootstrap]
# gms_2_contrib[imodel, ibootstrap, itarget]
for ix, x in enumerate(xg):
misfits = p.misfits(x)
# misfits[itarget, 0], misfits[itarget, 1]
gm = p.combine_misfits(misfits)
# gm is scalar
t.assert_equal(gm, gms[ix])
gm_contrib = p.combine_misfits(misfits, get_contributions=True)
assert_ae(gms_contrib[ix, :], gm_contrib)
gm_2 = p.combine_misfits(misfits, extra_weights=bweights)
assert gm_2[0] == gm
assert gm_2[1] == gm
assert gms_2[ix, 0] == gm
assert gms_2[ix, 1] == gm
gm_2_contrib = p.combine_misfits(misfits,
extra_weights=bweights,
get_contributions=True)
assert_ae(gm_2_contrib[0, :], gm_contrib)
assert_ae(gm_2_contrib[1, :], gm_contrib)
assert_ae(gms_2_contrib[ix, 0, :], gm_contrib)
assert_ae(gms_2_contrib[ix, 1, :], gm_contrib)
if reference:
ref_data = num.load(reference)
assert_ae(ref_data['arr_0'], gms)
assert_ae(ref_data['arr_1'], gms_contrib)
assert_ae(ref_data['arr_2'], gms_2)
def get_grond_problem_config(self):
return grond.RectangularProblemConfig(
name_template='rect_source_${event_name}',
decimation_factor=8,
ranges=dict(north_shift=gf.Range(-15 * km, 15 * km),
east_shift=gf.Range(-15 * km, 15 * km),
depth=gf.Range(5 * km, 15 * km),
length=gf.Range(20 * km, 40 * km),
width=gf.Range(5 * km, 10 * km),
dip=gf.Range(0, 90),
strike=gf.Range(0, 180),
rake=gf.Range(0, 90),
slip=gf.Range(.5, 10),
nucleation_x=gf.Range(-1., 1.),
nucleation_y=gf.Range(-1., 1.),
time=gf.Range(-5.0, 5.0, relative='add')))
def get_grond_problem_config(self):
s2 = math.sqrt(2)
return grond.CMTProblemConfig(
name_template='cmt_${event_name}',
distance_min=2. * km,
mt_type='full',
ranges=dict(time=gf.Range(-5.0, 5.0, relative='add'),
north_shift=gf.Range(-15 * km, 15 * km),
east_shift=gf.Range(-15 * km, 15 * km),
depth=gf.Range(5 * km, 20 * km),
magnitude=gf.Range(self.magnitude_min,
self.magnitude_max),
rmnn=gf.Range(-1.0, 1.0),
rmee=gf.Range(-1.0, 1.0),
rmdd=gf.Range(-1.0, 1.0),
rmne=gf.Range(-s2, s2),
rmnd=gf.Range(-s2, s2),
rmed=gf.Range(-s2, s2),
duration=gf.Range(1.0, 15.0)))
def run_grond(rundir,
datafolder,
eventname,
store_id,
domain="time_domain",
problem_type="CMTProblem"):
if domain == "envelope":
problem_type = "magnitude"
km = 1000.
ds = grond.Dataset(event_name=eventname)
ds.add_waveforms(paths=['%s' % datafolder])
ds.add_events(filename='%s/event.txt' % datafolder)
ds.add_stations(stationxml_filenames=['%s/stations.xml' % datafolder])
ds.add_responses(stationxml_filenames=['%s/stations.xml' % datafolder])
ds._event_name = eventname
print(eventname)
ds.add_blacklist([])
ds.empty_cache()
quantity = 'displacement'
group = 'all'
tmin = '{stored:begin}+0.1'
tmax = '{stored:begin}+2.5'
fmin = 1
fmax = 13.
ffactor = 1.
engine = gf.LocalEngine(store_superdirs=['/home/asteinbe/gf_stores'])
gf_interpolation = 'nearest_neighbor'
imc_Z = grond.WaveformMisfitConfig(fmin=fmin,
fmax=fmax,
ffactor=ffactor,
tmin=tmin,
tmax=tmax,
norm_exponent=1,
domain=domain,
quantity=quantity)
cha_Z = 'Z'
imc_T = grond.WaveformMisfitConfig(
fmin=fmin,
fmax=fmax,
ffactor=ffactor,
tmin=tmin,
tmax=tmax,
norm_exponent=1,
domain=domain,
quantity=quantity,
)
cha_T = 'T'
imc_R = grond.WaveformMisfitConfig(
fmin=fmin,
fmax=fmax,
ffactor=ffactor,
tmin=tmin,
tmax=tmax,
norm_exponent=1,
domain=domain,
quantity=quantity,
)
cha_R = 'R'
event = ds.get_events()[0]
event_origin = gf.Source(lat=event.lat, lon=event.lon)
if event.depth is None:
event.depth = 7 * km
if len(event.tags) > 0:
for tag in event.tags:
if tag[0:6] == "stress":
problem_type = "VLVDProblem"
problem_type = "volume_point"
distance_min = None
distance_max = 30000.
targets = []
for st in ds.get_stations():
for cha in cha_Z:
target = grond.WaveformMisfitTarget(interpolation=gf_interpolation,
store_id=store_id,
codes=st.nsl() + (cha, ),
lat=st.lat,
lon=st.lon,
quantity=quantity,
misfit_config=imc_Z,
normalisation_family="td",
path="Z")
_, bazi = event_origin.azibazi_to(target)
if cha == 'Z':
target.azimuth = 0.
target.dip = -90.
target.set_dataset(ds)
targets.append(target)
for st in ds.get_stations():
for cha in cha_T:
target = grond.WaveformMisfitTarget(codes=st.nsl() + (cha, ),
lat=st.lat,
lon=st.lon,
interpolation=gf_interpolation,
store_id=store_id,
normalisation_family="td",
path="T",
quantity=quantity,
misfit_config=imc_T)
_, bazi = event_origin.azibazi_to(target)
if cha == 'T':
target.azimuth = bazi - 90.
target.dip = 0.
target.set_dataset(ds)
targets.append(target)
for st in ds.get_stations():
for cha in cha_R:
target = grond.WaveformMisfitTarget(codes=st.nsl() + (cha, ),
lat=st.lat,
lon=st.lon,
interpolation=gf_interpolation,
store_id=store_id,
normalisation_family="td",
path="R",
quantity=quantity,
misfit_config=imc_R)
_, bazi = event_origin.azibazi_to(target)
if cha == 'R':
target.azimuth = bazi - 180.
target.dip = 0.
target.set_dataset(ds)
targets.append(target)
if problem_type == "CMTProblem":
base_source = gf.MTSource.from_pyrocko_event(event)
stf_type = 'HalfSinusoidSTF'
base_source.set_origin(event_origin.lat, event_origin.lon)
base_source.set_depth = event_origin.depth
stf = STFType.base_stf(stf_type)
stf.duration = event.duration or 0.0
base_source.stf = stf
ranges = dict(time=gf.Range(-0.1, 0.1, relative='add'),
north_shift=gf.Range(-1 * km, 1 * km),
east_shift=gf.Range(-1 * km, 1 * km),
depth=gf.Range(3400, 14000),
magnitude=gf.Range(-0.7, 3.1),
duration=gf.Range(0., 0.2),
rmnn=gf.Range(-1.4, 1.4),
rmee=gf.Range(-1.4, 1.4),
rmdd=gf.Range(-1.4, 1.4),
rmne=gf.Range(-1.4, 1.4),
rmnd=gf.Range(-1.4, 1.4),
rmed=gf.Range(-1.4, 1.4))
problem = grond.problems.CMTProblem(
name=event.name,
base_source=base_source,
distance_min=600.,
mt_type='deviatoric',
ranges=ranges,
targets=targets,
norm_exponent=1,
stf_type=stf_type,
)
elif problem_type == "magnitude":
base_source = gf.MTSource.from_pyrocko_event(event)
stf_type = 'HalfSinusoidSTF'
base_source.set_origin(event_origin.lat, event_origin.lon)
base_source.set_depth = event_origin.depth
stf = STFType.base_stf(stf_type)
stf.duration = event.duration or 0.0
base_source.stf = stf
ranges = dict(time=gf.Range(-0.1, 0.1, relative='add'),
north_shift=gf.Range(-0.5 * km, 0.5 * km),
east_shift=gf.Range(-0.5 * km, 0.5 * km),
depth=gf.Range(3400, 14000),
magnitude=gf.Range(-0.7, 3.1),
duration=gf.Range(0., 0.2),
rmnn=gf.Range(0, 0),
rmee=gf.Range(0, 0),
rmdd=gf.Range(0, 0),
rmne=gf.Range(0, 0),
rmnd=gf.Range(0, 0),
rmed=gf.Range(0, 0))
problem = grond.problems.CMTProblem(
name=event.name,
base_source=base_source,
distance_min=600.,
mt_type='deviatoric',
ranges=ranges,
targets=targets,
norm_exponent=1,
stf_type=stf_type,
)
elif problem_type == "volume_point":
base_source = gf.ExplosionSource.from_pyrocko_event(event)
stf_type = 'HalfSinusoidSTF'
base_source.set_origin(event_origin.lat, event_origin.lon)
base_source.set_depth = event_origin.depth
stf = STFType.base_stf(stf_type)
stf.duration = event.duration or 0.0
base_source.stf = stf
ranges = dict(time=gf.Range(-0.1, 0.1, relative='add'),
north_shift=gf.Range(-0.5 * km, 0.5 * km),
east_shift=gf.Range(-0.5 * km, 0.5 * km),
depth=gf.Range(3400, 14000),
magnitude=gf.Range(-0.7, 3.1),
duration=gf.Range(0., 0.2),
volume_change=gf.Range(0.001, 10000.1))
problem = grond.problems.VolumePointProblem(
name=event.name,
base_source=base_source,
distance_min=600.,
ranges=ranges,
targets=targets,
norm_exponent=1,
)
elif problem_type == "VLVDProblem":
base_source = gf.VLVDSource.from_pyrocko_event(event)
stf_type = 'HalfSinusoidSTF'
base_source.set_origin(event_origin.lat, event_origin.lon)
base_source.set_depth = event_origin.depth
stf = STFType.base_stf(stf_type)
stf.duration = event.duration or 0.0
base_source.stf = stf
ranges = dict(time=gf.Range(-0.1, 0.1, relative='add'),
north_shift=gf.Range(-1 * km, 1 * km),
east_shift=gf.Range(-1 * km, 1 * km),
depth=gf.Range(6000, 14000),
volume_change=gf.Range(0.001, 10000.1),
duration=gf.Range(0.01, 0.2),
dip=gf.Range(0., 90.),
azimuth=gf.Range(0., 360.),
clvd_moment=gf.Range(0.1, 1e13))
problem = grond.problems.VLVDProblem(
name=event.name,
base_source=base_source,
distance_min=3000.,
ranges=ranges,
targets=targets,
norm_exponent=1,
)
print(problem_type)
problem.set_engine(engine)
monitor = GrondMonitor.watch(rundir)
print("analysing")
analyser_iter = 1000
analyser = grond.analysers.target_balancing.TargetBalancingAnalyser(
niter=analyser_iter, use_reference_magnitude=False, cutoff=None)
analyser.analyse(problem, ds)
problem.dump_problem_info(rundir)
from grond import config
from grond import Environment
config_path = '%s/scenario.gronf' % datafolder
quick_config_path = '%sconfig/config.yaml' % datafolder
util.ensuredir("%sconfig" % datafolder)
configs_dir = os.path.dirname(os.path.abspath(__file__)) + "/configs"
os.system("cp -r %s/config.yaml* %s" % (configs_dir, quick_config_path))
from grond.config import read_config
conf = read_config(quick_config_path)
uniform_iter = 1200
directed_iter = 20000
mod_conf = conf.clone()
# mod_conf.set_elements(
# 'path_prefix', ".")
mod_conf.set_elements('analyser_configs[:].niterations', analyser_iter)
mod_conf.set_elements('optimiser_config.sampler_phases[0].niterations',
uniform_iter)
mod_conf.set_elements('optimiser_config.sampler_phases[0].niterations',
directed_iter)
mod_conf.set_elements('optimiser_config.nbootstrap', 100)
mod_conf.set_elements('target_groups[:].misfit_config.tmin', "%s" % tmin)
mod_conf.set_elements('target_groups[:].misfit_config.tmax', "%s" % tmax)
mod_conf.set_elements('target_groups[:].misfit_config.fmin', "%s" % fmin)
mod_conf.set_elements('target_groups[:].misfit_config.fmax', "%s" % fmax)
mod_conf.set_elements('target_groups[:].misfit_config.domain',
"%s" % domain)
mod_conf.set_elements('target_groups[:].misfit_config.ffactor',
"%s" % ffactor)
mod_conf.set_basepath(conf.get_basepath())
config.write_config(mod_conf, quick_config_path)
config.write_config(mod_conf, rundir + "/config.yaml")
sampler_phases = [
UniformSamplerPhase(niterations=uniform_iter),
DirectedSamplerPhase(niterations=directed_iter)
]
optimiser = grond.optimisers.highscore.HighScoreOptimiser(
sampler_phases=list(sampler_phases),
chain_length_factor=8,
nbootstrap=100)
optimiser.set_nthreads(1)
optimiser.init_bootstraps(problem)
tstart = time.time()
optimiser.optimise(problem, rundir=rundir)
grond.harvest(rundir, problem, force=True)
#solverscipy.solve(problem, quiet=False, niter_explorative=2000, niter=10000)
tstop = time.time()
#os.system("grond report %s" % rundir)
os.system("grond plot fits_waveform %s" % rundir)
os.system("grond plot hudson %s" % rundir)
os.system("grond plot fits_waveform_ensemble %s" % rundir)
os.system("grond plot location_mt %s" % rundir)
os.system("grond plot seismic_stations %s" % rundir)
os.system("grond plot sequence %s" % rundir)
ds.empty_cache()
print("done with grond")
