def run_in_project(
main,
project_dir_source,
project_dir,
event_name,
config_path):
playground_dir = get_playground_dir()
with chdir(playground_dir):
if os.path.exists(project_dir):
shutil.rmtree(project_dir)
put_test_data(project_dir_source + '/', project_dir)
with chdir(project_dir):
link_test_data(
'events/%s/' % event_name, 'data/events/%s/' % event_name)
env = Environment([config_path, event_name])
conf = env.get_config()
store_ids = conf.get_elements('target_groups[:].store_id')
for store_id in store_ids:
store_path = 'gf_stores/%s/' % store_id
if not os.path.exists(store_path):
link_test_data(store_path)
problem_name = env.get_problem().name
rundir_path = expand_template(
conf.rundir_template,
dict(problem_name=problem_name))
return main(env, rundir_path)
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
def get_rundir_paths(config_path, event_names):
env = Environment([config_path] + event_names)
conf = env.get_config()
rundir_paths = []
for event_name in event_names:
env.set_current_event_name(event_name)
problem_name = env.get_problem().name
rundir_paths.append(expand_template(
conf.rundir_template,
dict(problem_name=problem_name)))
return rundir_paths
def get_problem(self, event, target_groups, targets):
base_source = gf.RectangularSource.from_pyrocko_event(
event, anchor='top', decimation_factor=self.decimation_factor)
subs = dict(event_name=event.name,
event_time=util.time_to_str(event.time))
problem = RectangularProblem(name=expand_template(
self.name_template, subs),
base_source=base_source,
distance_min=self.distance_min,
target_groups=target_groups,
targets=targets,
ranges=self.ranges,
norm_exponent=self.norm_exponent)
return problem
def get_problem(self, event, target_groups, targets):
if event.depth is None:
event.depth = 0.
base_source = gf.VLVDSource.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 = VLVDProblem(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
def run_example(project_name, config_path, quick_config_path, event_name):
project_dir = project_name
if os.path.exists(project_dir):
shutil.rmtree(project_dir)
grond('init', project_name, project_dir)
with chdir(project_dir):
assert os.path.isdir('config')
common.link_test_data('events/%s/' % event_name,
'data/events/%s/' % event_name)
env = Environment([config_path, event_name])
conf = env.get_config()
store_ids = conf.get_elements('target_groups[:].store_id')
for store_id in store_ids:
store_path = 'gf_stores/%s/' % store_id
if not os.path.exists(store_path):
common.link_test_data(store_path)
problem_name = env.get_problem().name
rundir_path = expand_template(conf.rundir_template,
dict(problem_name=problem_name))
grond('check', config_path, event_name,
'--save-stations-used=used_stations.txt')
sorted(s.station for s in model.load_stations('used_stations.txt'))
mod_conf = conf.clone()
mod_conf.set_elements('analyser_configs[:].niterations', 100)
mod_conf.set_elements('optimiser_config.sampler_phases[:].niterations',
100)
mod_conf.set_elements('optimiser_config.nbootstrap', 10)
mod_conf.set_basepath(conf.get_basepath())
config.write_config(mod_conf, quick_config_path)
grond('go', quick_config_path, event_name)
grond('harvest', '--force', '--export-fits=best,mean', rundir_path)
grond('report', rundir_path)
def get_problem(self, event, target_groups, targets):
if self.decimation_factor != 1:
logger.warn(
'Decimation factor for rectangular source set to %i. Results '
'may be inaccurate.' % self.decimation_factor)
base_source = gf.RectangularSource.from_pyrocko_event(
event, anchor='top', decimation_factor=self.decimation_factor)
subs = dict(event_name=event.name,
event_time=util.time_to_str(event.time))
problem = RectangularProblem(name=expand_template(
self.name_template, subs),
base_source=base_source,
distance_min=self.distance_min,
target_groups=target_groups,
targets=targets,
ranges=self.ranges,
norm_exponent=self.norm_exponent,
nthreads=self.nthreads)
return problem
def report(env, report_config=None, update_without_plotting=False):
if report_config is None:
report_config = ReportConfig()
report_config.set_basepath('.')
event_name = env.get_current_event_name()
problem = env.get_problem()
logger.info('Creating report for event %s...' % event_name)
fp = report_config.expand_path
report_path = expand_template(
op.join(fp(report_config.reports_base_path),
report_config.report_sub_path),
dict(event_name=event_name, problem_name=problem.name))
if op.exists(report_path) and not update_without_plotting:
shutil.rmtree(report_path)
try:
problem.dump_problem_info(report_path)
guts.dump(env.get_config(),
filename=op.join(report_path, 'config.yaml'),
header=True)
util.ensuredir(report_path)
plots_dir_out = op.join(report_path, 'plots')
util.ensuredir(plots_dir_out)
event = env.get_dataset().get_event()
guts.dump(event, filename=op.join(report_path, 'event.reference.yaml'))
try:
rundir_path = env.get_rundir_path()
core.export('stats', [rundir_path],
filename=op.join(report_path, 'stats.yaml'))
core.export('best', [rundir_path],
filename=op.join(report_path,
'event.solution.best.yaml'),
type='event-yaml')
core.export('mean', [rundir_path],
filename=op.join(report_path,
'event.solution.mean.yaml'),
type='event-yaml')
core.export('ensemble', [rundir_path],
filename=op.join(report_path,
'event.solution.ensemble.yaml'),
type='event-yaml')
except (environment.NoRundirAvailable, ProblemInfoNotAvailable,
ProblemDataNotAvailable):
pass
if not update_without_plotting:
from grond import plot
plot.make_plots(env, plots_path=op.join(report_path, 'plots'))
rie = ReportIndexEntry(path='.',
problem_name=problem.name,
grond_version=problem.grond_version)
fn = op.join(report_path, 'event.solution.best.yaml')
if op.exists(fn):
rie.event_best = guts.load(filename=fn)
fn = op.join(report_path, 'event.reference.yaml')
if op.exists(fn):
rie.event_reference = guts.load(filename=fn)
fn = op.join(report_path, 'index.yaml')
guts.dump(rie, filename=fn)
except Exception as e:
logger.warn(
'report generation failed, removing incomplete report dir: %s' %
report_path)
raise e
if op.exists(report_path):
shutil.rmtree(report_path)
report_index(report_config)
report_archive(report_config)
def report(env,
report_config=None,
update_without_plotting=False,
make_index=True,
make_archive=True,
nthreads=0):
if report_config is None:
report_config = ReportConfig()
report_config.set_basepath('.')
event_name = env.get_current_event_name()
problem = env.get_problem()
logger.info('Creating report entry for run "%s"...' % problem.name)
optimiser = env.get_optimiser()
optimiser.set_nthreads(nthreads)
fp = report_config.expand_path
entry_path = expand_template(
op.join(fp(report_config.report_base_path),
report_config.entries_sub_path),
dict(event_name=event_name, problem_name=problem.name))
if op.exists(entry_path) and not update_without_plotting:
shutil.rmtree(entry_path)
try:
problem.dump_problem_info(entry_path)
guts.dump(env.get_config(),
filename=op.join(entry_path, 'config.yaml'),
header=True)
util.ensuredir(entry_path)
plots_dir_out = op.join(entry_path, 'plots')
util.ensuredir(plots_dir_out)
event = env.get_dataset().get_event()
guts.dump(event, filename=op.join(entry_path, 'event.reference.yaml'))
try:
rundir_path = env.get_rundir_path()
core.export('stats', [rundir_path],
filename=op.join(entry_path, 'stats.yaml'))
core.export('best', [rundir_path],
filename=op.join(entry_path,
'event.solution.best.yaml'),
type='event-yaml')
core.export('mean', [rundir_path],
filename=op.join(entry_path,
'event.solution.mean.yaml'),
type='event-yaml')
core.export('ensemble', [rundir_path],
filename=op.join(entry_path,
'event.solution.ensemble.yaml'),
type='event-yaml')
except (environment.NoRundirAvailable, ProblemInfoNotAvailable,
ProblemDataNotAvailable):
pass
if not update_without_plotting:
from grond import plot
pcc = report_config.plot_config_collection.get_weeded(env)
plot.make_plots(env,
plots_path=op.join(entry_path, 'plots'),
plot_config_collection=pcc)
try:
run_info = env.get_run_info()
except environment.NoRundirAvailable:
run_info = None
rie = ReportIndexEntry(path='.',
problem_name=problem.name,
grond_version=problem.grond_version,
run_info=run_info)
fn = op.join(entry_path, 'event.solution.best.yaml')
if op.exists(fn):
rie.event_best = guts.load(filename=fn)
fn = op.join(entry_path, 'event.reference.yaml')
if op.exists(fn):
rie.event_reference = guts.load(filename=fn)
fn = op.join(entry_path, 'index.yaml')
guts.dump(rie, filename=fn)
except Exception as e:
logger.warn(
'Failed to create report entry, removing incomplete subdirectory: '
'%s' % entry_path)
raise e
if op.exists(entry_path):
shutil.rmtree(entry_path)
logger.info('Done creating report entry for run "%s".' % problem.name)
if make_index:
report_index(report_config)
if make_archive:
report_archive(report_config)