def check_filter(self):
""" Checks filter settings
"""
assert getset(PAR.FILTER) < set(['Bandpass', 'Lowpass', 'Highpass'])
if PAR.FILTER == 'Bandpass':
if 'FREQMIN' not in PAR:
raise ParameterError('FREQMIN')
if 'FREQMAX' not in PAR:
raise ParameterError('FREQMAX')
assert 0 < PAR.FREQMIN
assert PAR.FREQMIN < PAR.FREQMAX
assert PAR.FREQMAX < np.inf
elif PAR.FILTER == 'Lowpass':
raise NotImplementedError
if 'FREQ' not in PAR:
raise ParameterError('FREQ')
assert 0 < PAR.FREQ <= np.inf
elif PAR.FILTER == 'Highpass':
raise NotImplementedError
if 'FREQ' not in PAR:
raise ParameterError('FREQ')
assert 0 <= PAR.FREQ < np.inf
def check(self):
""" Checks parameters and paths
"""
# check paths
if 'GLOBAL' not in PATH:
raise ParameterError(PATH, 'GLOBAL')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'OUTPUT' not in PATH:
raise ParameterError(PATH, 'OUTPUT')
# check input
if 'DATA' not in PATH:
setattr(PATH, 'DATA', None)
if 'MODEL' not in PATH:
raise ParameterError(PATH, 'MODEL')
if 'PERTURB' not in PATH:
raise ParameterError(PATH, 'PERTURB')
if 'MODEL_INIT' not in PATH:
setattr(PATH, 'MODEL_INIT', PATH.MODEL)
if 'MODEL_TRUE' not in PATH:
setattr(PATH, 'MODEL_TRUE', PATH.MODEL)
def check(self):
""" Checks parameters and paths
"""
print msg.Warning_pbs_lg
# name of job
if 'TITLE' not in PAR:
setattr(PAR, 'TITLE', basename(abspath('.')))
# time allocated for entire workflow
if 'WALLTIME' not in PAR:
setattr(PAR, 'WALLTIME', 30.)
# time allocated for each individual task
if 'STEPTIME' not in PAR:
setattr(PAR, 'STEPTIME', 15.)
# number of tasks
if 'NTASK' not in PAR:
raise ParameterError(PAR, 'NTASK')
# number of cores per task
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
# number of cores per node
if 'NODESIZE' not in PAR:
raise ParameterError(PAR, 'NODESIZE')
# optional additional PBS arguments
if 'PBSARGS' not in PAR:
setattr(PAR, 'PBSARGS', '')
# optional environment variable list VAR1=val1,VAR2=val2,...
if 'ENVIRONS' not in PAR:
setattr(PAR, 'ENVIRONS', '')
# level of detail in output messages
if 'VERBOSE' not in PAR:
setattr(PAR, 'VERBOSE', 1)
# where job was submitted
if 'WORKDIR' not in PATH:
setattr(PATH, 'WORKDIR', abspath('.'))
# where output files are written
if 'OUTPUT' not in PATH:
setattr(PATH, 'OUTPUT', PATH.WORKDIR+'/'+'output')
# where temporary files are written
if 'SCRATCH' not in PATH:
setattr(PATH, 'SCRATCH', PATH.WORKDIR+'/'+'scratch')
# where system files are written
if 'SYSTEM' not in PATH:
setattr(PATH, 'SYSTEM', PATH.SCRATCH+'/'+'system')
# optional local scratch path
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
def check(self):
""" Checks parameters and paths
"""
# check paths
if 'GLOBAL' not in PATH:
raise ParameterError(PATH, 'GLOBAL')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'OUTPUT' not in PATH:
raise ParameterError(PATH, 'OUTPUT')
# check input
if 'DATA' not in PATH:
setattr(PATH, 'DATA', None)
if 'MODEL_INIT' not in PATH:
raise ParameterError(PATH, 'MODEL_INIT')
if 'CLIP' not in PAR:
setattr(PAR, 'CLIP', 0.)
# assertions
0. <= PAR.CLIP <= 1.
def check(self):
""" Checks parameters and paths
"""
# check paths
if 'SCRATCH' not in PATH:
raise ParameterError(PATH, 'SCRATCH')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
# Jiang add
if 'FUNC' not in PATH:
setattr(PATH, 'FUNC', join(PATH.SCRATCH, 'evalfunc'))
if 'OUTPUT' not in PATH:
raise ParameterError(PATH, 'OUTPUT')
# check input
if 'DATA' not in PATH:
setattr(PATH, 'DATA', None)
if not exists(PATH.DATA):
assert 'MODEL_TRUE' in PATH
if 'MODEL_INIT' not in PATH:
raise ParameterError(PATH, 'MODEL_INIT')
# check output
if 'SAVEGRADIENT' not in PAR:
setattr(PAR, 'SAVEGRADIENT', 1)
if 'SAVEKERNELS' not in PAR:
setattr(PAR, 'SAVEKERNELS', 0)
if 'SAVETRACES' not in PAR:
setattr(PAR, 'SAVETRACES', 0)
def check(self):
""" Checks parameters and paths
"""
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
# check scratch paths
if 'SCRATCH' not in PATH:
raise ParameterError(PATH, 'SCRATCH')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'SOLVER' not in PATH:
if PATH.LOCAL:
setattr(PATH, 'SOLVER', join(PATH.LOCAL, 'solver'))
else:
setattr(PATH, 'SOLVER', join(PATH.SCRATCH, 'solver'))
# check solver input paths
if 'SPECFEM_BIN' not in PATH:
raise ParameterError(PATH, 'SPECFEM_BIN')
if 'SPECFEM_DATA' not in PATH:
raise ParameterError(PATH, 'SPECFEM_DATA')
# assertions
assert self.parameters != []
def check_filter(self):
""" Checks filter settings
"""
if not PAR.FILTER:
pass
elif PAR.FILTER == 'Bandpass':
if 'FREQMIN' not in PAR: raise ParameterError('FREQMIN')
if 'FREQMAX' not in PAR: raise ParameterError('FREQMAX')
assert 0 < PAR.FREQMIN
assert PAR.FREQMIN < PAR.FREQMIN
assert PAR.FREQMAX < infinity
elif PAR.FILTER == 'Lowpass':
raise NotImplementedError
if 'FREQ' not in PAR: raise ParameterError('FREQ')
assert 0 < PAR.FREQ <= infinity
elif PAR.FILTER == 'Highpass':
raise NotImplementedError
if 'FREQ' not in PAR: raise ParameterError('FREQ')
assert 0 <= PAR.FREQ < infinity
else:
raise ParameterError()
def check(self):
""" Checks parameters and paths
"""
# check paths
if 'SCRATCH' not in PATH:
raise ParameterError(PATH, 'SCRATCH')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'OUTPUT' not in PATH:
raise ParameterError(PATH, 'OUTPUT')
if 'SOLVER' not in PATH:
raise ParameterError(PATH, 'SOLVER')
# check input
if 'DATA' not in PATH:
setattr(PATH, 'DATA', None)
if not exists(PATH.DATA):
assert 'MODEL_TRUE' in PATH
if 'MODEL_INIT' not in PATH:
raise ParameterError(PATH, 'MODEL_INIT')
# assertions
if PAR.NSRC != 1:
raise ParameterError(PAR, 'NSRC')
def check(self):
""" Checks parameters and paths
"""
# check paths
if 'GLOBAL' not in PATH:
raise ParameterError(PATH, 'GLOBAL')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'OUTPUT' not in PATH:
raise ParameterError(PATH, 'OUTPUT')
# check input
if 'DATA' not in PATH:
setattr(PATH, 'DATA', None)
if 'MODEL_INIT' not in PATH:
setattr(PATH, 'MODEL_INIT', PATH.MODEL)
if 'MODEL_TRUE' not in PATH:
setattr(PATH, 'MODEL_TRUE', PATH.MODEL)
if 'EVAL_TRUE' not in PATH:
setattr(PATH, 'EVAL_TRUE', join(PATH.GLOBAL, 'eval_true'))
if 'EVAL_INIT' not in PATH:
setattr(PATH, 'EVAL_INIT', join(PATH.GLOBAL, 'eval_init'))
if 'PERT_POS' not in PATH:
setattr(PATH, 'PERT_POS', join(PATH.GLOBAL, 'pert_pos'))
if 'PERT_NEG' not in PATH:
setattr(PATH, 'PERT_NEG', join(PATH.GLOBAL, 'pert_neg'))
def check(self):
""" Checks parameters and paths
"""
# name of job
if 'TITLE' not in PAR:
setattr(PAR, 'TITLE', basename(abspath('.')))
# time allocated for workflow in minutes
if 'WALLTIME' not in PAR:
setattr(PAR, 'WALLTIME', 30.)
# number of tasks
if 'NTASK' not in PAR:
raise ParameterError(PAR, 'NTASK')
# number of cores per task
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
# how to invoke executables
if 'MPIEXEC' not in PAR:
setattr(PAR, 'MPIEXEC', '')
# optional additional SLURM arguments
if 'SLURMARGS' not in PAR:
setattr(PAR, 'SLURMARGS', '')
# SLURM resource partition
if 'PARTITION' not in PAR:
setattr(PAR, 'PARTITION', 't1small')
# optional environment variable list VAR1=val1,VAR2=val2,...
if 'ENVIRONS' not in PAR:
setattr(PAR, 'ENVIRONS', '')
# level of detail in output messages
if 'VERBOSE' not in PAR:
setattr(PAR, 'VERBOSE', 1)
# where job was submitted
if 'WORKDIR' not in PATH:
setattr(PATH, 'WORKDIR', abspath('.'))
# where temporary files are written
if 'SCRATCH' not in PATH:
setattr(PATH, 'SCRATCH',
join(os.getenv('CENTER1'), 'scratch', str(uuid4())))
# where output files are written
if 'OUTPUT' not in PATH:
setattr(PATH, 'OUTPUT', PATH.WORKDIR + '/' + 'output')
# where system files are written
if 'SYSTEM' not in PATH:
setattr(PATH, 'SYSTEM', PATH.SCRATCH + '/' + 'system')
# optional local scratch path
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
def check(self):
""" Checks parameters and paths
"""
# used for inversion
if 'WINDOW_NUMBER' not in PAR:
raise ParameterError(PAR, 'WINDOW_NUMBER')
if 'WINDOW_LENGTH' not in PAR:
raise ParameterError(PAR, 'WINDOW_LENGTH')
if 'TSHIFT_ACCEPTANCE_LEVEL' not in PAR:
raise ParameterError(PAR, 'TSHIFT_ACCEPTANCE_LEVEL')
if 'DLNA_ACCEPTANCE_LEVEL' not in PAR:
raise ParameterError(PAR, 'DLNA_ACCEPTANCE_LEVEL')
if 'CC_ACCEPTANCE_LEVEL' not in PAR:
raise ParameterError(PAR, 'CC_ACCEPTANCE_LEVEL')
def check_normalize(self):
if not PAR.NORMALIZE:
pass
elif PAR.NORMALIZE in ['L1', 'L2', 'L2_squared']:
pass
else:
raise ParameterError()
def apply_filter(self, traces):
if not PAR.FILTER:
return traces
elif PAR.FILTER == 'Bandpass':
for tr in traces:
tr.detrend('demean')
tr.detrend('linear')
tr.taper(0.05, type='hann')
tr.filter('bandpass',
zerophase=True,
freqmin=PAR.FREQMIN,
freqmax=PAR.FREQMAX)
elif PAR.FILTER == 'Lowpass':
for tr in traces:
tr.detrend('demean')
tr.detrend('linear')
tr.taper(0.05, type='hann')
tr.filter('lowpass', zerophase=True, freq=PAR.FREQ)
elif PAR.FILTER == 'Highpass':
for tr in traces:
tr.detrend('demean')
tr.detrend('linear')
tr.taper(0.05, type='hann')
tr.filter('highpass', zerophase=True, freq=PAR.FREQ)
else:
raise ParameterError()
return traces
def apply_mute(self, traces):
if not PAR.MUTE:
return traces
elif PAR.MUTE == 'MuteEarlyArrivals':
# mutes early arrivals
return mute_early(
traces,
PAR.MUTESLOPE, # (units: time/distance)
PAR.MUTECONST, # (units: time)
self.get_time_scheme(traces),
self.get_source_coords(traces),
self.get_receiver_coords(traces))
elif PAR.MUTE == 'MuteLateArrivals':
return mute_late(
traces,
PAR.MUTESLOPE, # (units: time/distance)
PAR.MUTECONST, # (units: time)
self.get_time_scheme(traces),
self.get_source_coords(traces),
self.get_receiver_coords(traces))
elif PAR.MUTE == 'MuteEarlyAndLateArrivals':
return mute_early_and_late(traces, PAR.MUTESLOPE, PAR.MUTECONST,
self.get_time_scheme(traces),
self.get_source_coords(traces),
self.get_receiver_coords(traces))
else:
raise ParameterError()
def apply_filter(self, traces):
if not PAR.FILTER:
return traces
elif PAR.FILTER == 'Bandpass':
traces = _signal.detrend(traces)
for tr in traces:
tr.filter('bandpass', freqmin=PAR.FREQMIN, freqmax=PAR.FREQMAX)
# workaround obspy dtype conversion
#tr.data = tr.data.astype(np.float32)
elif PAR.FILTER == 'Lowpass':
traces = _signal.detrend(traces)
for tr in traces:
tr.filter('lowpass', freq=PAR.FREQ)
# workaround obspy dtype conversion
#tr.data = tr.data.astype(np.float32)
elif PAR.FILTER == 'Highpass':
traces = _signal.detrend(traces)
for tr in traces:
tr.filter('highpass', freq=PAR.FREQ)
# workaround obspy dtype conversion
#tr.data = tr.data.astype(np.float32)
else:
raise ParameterError()
return traces
def check(self):
""" Checks parameters and paths
"""
# data file format
if 'FORMAT' not in PAR:
raise ParameterError(PAR, 'FORMAT')
# data normalization option
if 'NORMALIZE' not in PAR:
setattr(PAR, 'NORMALIZE', None)
# data muting option
if 'MUTE' not in PAR:
setattr(PAR, 'MUTE', None)
# data filtering option
if 'FILTER' not in PAR:
setattr(PAR, 'FILTER', None)
if 'DATA' not in PATH:
raise Exception
if not exists(PATH.DATA):
raise Exception
if 'SYNTHETICS' not in PATH:
setattr(PATH, 'SYNTHETICS', '')
if PATH.SYNTHETICS:
assert exists(PATH.SYNTHETICS)
if 'WORKDIR' not in PATH:
setattr(PATH, 'WORKDIR', abspath('.'))
def check(self):
""" Checks parameters and paths
"""
# usedf for inversion
if 'MISFIT' not in PAR:
setattr(PAR, 'MISFIT', None)
# used for migration
if 'BACKPROJECT' not in PAR:
setattr(PAR, 'BACKPROJECT', None)
# data file format
if 'FORMAT' not in PAR:
raise ParameterError(PAR, 'FORMAT')
# data normalization option
if 'NORMALIZE' not in PAR:
setattr(PAR, 'NORMALIZE', None)
# data muting option
if 'MUTE' not in PAR:
setattr(PAR, 'MUTE', None)
# data filtering option
if 'FILTER' not in PAR:
setattr(PAR, 'FILTER', None)
# assertions
if PAR.FORMAT not in dir(readers):
print msg.ReaderError
raise ParameterError()
if PAR.FORMAT not in dir(writers):
print msg.WriterError
raise ParameterError()
self.check_filter()
self.check_mute()
self.check_normalize()
def check(self):
""" Checks parameters and paths
"""
# number of processors per simulation
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
# format used by SPECFEM for reading and writing models
# (currently, SPECFEM offers both 'fortran_binary' and 'adios')
if 'SOLVERIO' not in PAR:
setattr(PAR, 'SOLVERIO', 'fortran_binary')
if 'USER_DEFINE_STATION' not in PAR:
setattr(PAR, 'USER_DEFINE_STATION', 'no')
# solver scratch paths
if 'SCRATCH' not in PATH:
raise ParameterError(PATH, 'SCRATCH')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'SOLVER' not in PATH:
if PATH.LOCAL:
setattr(PATH, 'SOLVER', join(PATH.LOCAL, 'solver'))
else:
setattr(PATH, 'SOLVER', join(PATH.SCRATCH, 'solver'))
# solver input paths
if 'SPECFEM_BIN' not in PATH:
raise ParameterError(PATH, 'SPECFEM_BIN')
if 'SPECFEM_DATA' not in PATH:
raise ParameterError(PATH, 'SPECFEM_DATA')
# assertions
assert self.parameters != []
assert hasattr(solver_io, PAR.SOLVERIO)
assert hasattr(self.io, 'read_slice')
assert hasattr(self.io, 'write_slice')
def check(self):
""" Checks parameters and paths
"""
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
# check scratch paths
if 'SCRATCH' not in PATH:
raise ParameterError(PATH, 'SCRATCH')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'SOLVER' not in PATH:
if PATH.LOCAL:
setattr(PATH, 'SOLVER', join(PATH.LOCAL, 'solver'))
else:
setattr(PATH, 'SOLVER', join(PATH.SCRATCH, 'solver'))
# check solver input paths
if 'SPECFEM_BIN' not in PATH:
raise ParameterError(PATH, 'SPECFEM_BIN')
if 'SPECFEM_DATA' not in PATH:
raise ParameterError(PATH, 'SPECFEM_DATA')
# check IO machinery
if 'IOFORMAT' not in PAR:
setattr(PAR, 'IOFORMAT', 'fortran_binary')
full_dotted_name = 'seisflows.plugins.io'+'.'+PAR.IOFORMAT
assert module_exists(full_dotted_name)
module = import_module(full_dotted_name)
assert hasattr(module, 'read_slice')
assert hasattr(module, 'write_slice')
# assertions
assert self.parameters != []
def check(self):
""" Checks parameters and paths
"""
super(multicore, self).check()
# number of tasks
if 'NTASK' not in PAR:
raise ParameterError(PAR, 'NTASK')
# number of cores per task
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
# number of available cores
if 'NPROCMAX' not in PAR:
setattr(PAR, 'NPROCMAX', nproc())
# maximum number of concurrent tasks
if 'NTASKMAX' not in PAR:
setattr(PAR, 'NTASKMAX', PAR.NPROCMAX / PAR.NPROC)
# assertions
assert PAR.NPROC <= PAR.NPROCMAX
def check(self):
""" Checks parameters and paths
"""
# signifiy if data-synth. or synth.-synth. case
if 'CASE' not in PAR:
raise ParameterError(PAR, 'CASE')
# scratch paths
if 'SCRATCH' not in PATH:
raise ParameterError(PATH, 'SCRATCH')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'FUNC' not in PATH:
setattr(PATH, 'FUNC', os.path.join(PATH.SCRATCH, 'evalfunc'))
if 'GRAD' not in PATH:
setattr(PATH, 'GRAD', os.path.join(PATH.SCRATCH, 'evalgrad'))
if 'OPTIMIZE' not in PATH:
setattr(PATH, 'OPTIMIZE', os.path.join(PATH.SCRATCH, 'optimize'))
# input paths
if 'MODEL_INIT' not in PATH:
raise ParameterError(PATH, 'MODEL_INIT')
# output paths
if 'OUTPUT' not in PATH:
raise ParameterError(PATH, 'OUTPUT')
# pyatoa specific paths
# Config file should be present here.
if 'PYATOA_IO' not in PATH:
raise ParameterError(PATH, 'PYATOA_IO')
# make sure the Pyatoa plugin run script is present
if 'PYATOA_RUN' not in PATH:
raise ParameterError(PATH, 'PYATOA_RUN')
# make sure a Python3 binary is avilalable
if 'PYTHON3' not in PATH:
raise ParameterError(PATH, 'PYTHON3')
# check that their is a given starting model
if not exists(PATH.MODEL_INIT):
raise Exception()
# synthetic-synthetic examples require a true model to create the 'data'
if PAR.CASE == 'Synthetic' and not exists(PATH.MODEL_TRUE):
raise Exception()
class anisotropic(custom_import('solver', 'elastic')):
""" Adds elastic inversion machinery
"""
model_parameters = []
model_parameters += ['c11']
model_parameters += ['c13']
model_parameters += ['c15']
model_parameters += ['c33']
model_parameters += ['c35']
model_parameters += ['c55']
if PAR.MATERIALS == 'ChenTromp2d':
from seisflows.plugins.maps import voigt_chentromp_2d as map_forward
from seisflows.plugins.maps import chentromp_voigt_2d as map_inverse
kernel_parameters = []
kernel_parameters += ['A']
kernel_parameters += ['C']
kernel_parameters += ['N']
kernel_parameters += ['L']
kernel_parameters += ['F']
elif PAR.MATERIALS == 'Voigt2d':
from seisflows.plugins.maps import voigt_voigt_2d as map_forward
from seisflows.plugins.maps import voigt_voigt_2d as map_inverse
kernel_parameters = []
kernel_parameters += ['c11']
kernel_parameters += ['c13']
kernel_parameters += ['c15']
kernel_parameters += ['c33']
kernel_parameters += ['c35']
kernel_parameters += ['c55']
elif PAR.MATERIALS == 'Thomsen2d':
from seisflows.plugins.maps import voigt_thomsen_2d as map_forward
from seisflows.plugins.maps import thomsen_voigt_2d as map_inverse
kernel_parameters = []
kernel_parameters += ['vp']
kernel_parameters += ['vs']
kernel_parameters += ['epsilon']
kernel_parameters += ['delta']
kernel_parameters += ['gamma']
kernel_parameters += ['theta']
else:
raise ParameterError(PAR, 'MATERIALS')
def apply_filter(self, traces, freq_min, freq_max):
if not PAR.FILTER:
return traces
elif PAR.FILTER == 'Bandpass':
for tr in traces:
tr.detrend('demean')
tr.detrend('linear')
tr.taper(0.05, type='hann')
tr.filter('bandpass',
zerophase=True,
freqmin=freq_min,
freqmax=freq_max)
else:
raise ParameterError()
return traces
def check_mute(self):
""" Checks mute settings
"""
if not PAR.MUTE:
pass
elif PAR.MUTE in ['MuteEarlyArrivals', 'MuteLateArrivals']:
assert 'MUTESLOPE' in PAR
assert 'MUTECONST' in PAR
assert PAR.MUTESLOPE >= 0.
elif PAR.MUTE in ['MuteEarlyAndLateArrivals']:
assert 'MUTESLOPE' in PAR
assert 'MUTECONST' in PAR
assert len(PAR.MUTESLOPE) == 2
assert len(PAR.MUTECONSTANT) == 2
assert 0. <= PAR.MUTESLOPE[0] < PAR.MUTESLOPE[1]
else:
raise ParameterError()
def write_gradient(self, path):
""" Writes gradient of objective function
"""
# check parameters
if 'OPTIMIZE' not in PATH:
raise ParameterError(PATH, 'OPTIMIZE')
# check input arguments
if not exists(path):
raise Exception()
self.combine_kernels(path)
self.process_kernels(path)
g = solver.merge(solver.load(
path +'/'+ 'kernels/sum',
suffix='_kernel',
verbose=True))
# apply scaling
if float(PAR.SCALE) == 1.:
pass
elif not PAR.SCALE:
pass
else:
g *= PAR.SCALE
# write gradient
solver.save(PATH.GRAD +'/'+ 'gradient', solver.split(g), suffix='_kernel')
savenpy(PATH.OPTIMIZE +'/'+ 'g_new', g)
try:
for iproc in range(PAR.NPROC):
y = g['Gs'][iproc]
x = - g['Gc'][iproc]
t = 0.5*np.arctan2(y, x)
filename = 'proc%06d_%s.bin' % (iproc, 'azimuth')
savebin(t, PATH.GRAD +'/'+ filename)
except:
pass
def apply_normalize(self, traces):
if not PAR.NORMALIZE:
return traces
elif PAR.NORMALIZE == 'L1':
# normalize each trace by its L1 norm
for tr in traces:
w = np.linalg.norm(tr.data, ord=1)
if w > 0:
tr.data /= w
return traces
elif PAR.NORMALIZE == 'L2':
# normalize each trace by its L2 norm
for tr in traces:
w = np.linalg.norm(tr.data, ord=2)
if w > 0:
tr.data /= w
return traces
elif PAR.NORMALIZE == 'L2_squared':
# normalize each trace by its L2 norm squared
for tr in traces:
w = np.linalg.norm(tr.data, ord=2)
if w > 0:
tr.data /= w**2.
return traces
elif PAR.NORMALIZE == 'L2_summed':
# normalize all traces by their combined L2 norm
w = 0.
for tr in traces:
w += np.linalg.norm(tr.data, ord=2)**2.
for tr in traces:
tr.data /= w**0.5
return traces
else:
raise ParameterError()
def apply_filter(self, traces):
if not PAR.FILTER:
return traces
elif PAR.FILTER == 'Bandpass':
#traces = signal.detrend(traces)
for tr in traces:
tr.filter('bandpass', freqmin=PAR.FREQMIN, freqmax=PAR.FREQMAX)
elif PAR.FILTER == 'Lowpass':
#traces = signal.detrend(traces)
for tr in traces:
tr.filter('lowpass', freq=PAR.FREQ)
elif PAR.FILTER == 'Highpass':
#traces = signal.detrend(traces)
for tr in traces:
tr.filter('highpass', freq=PAR.FREQ)
else:
raise ParameterError()
return traces
def check(self):
""" Checks parameters and paths
"""
# starting and stopping iterations
if 'BEGIN' not in PAR:
raise ParameterError(PAR, 'BEGIN')
if 'END' not in PAR:
raise ParameterError(PAR, 'END')
# signifiy if data-synth. or synth.-synth. case
if 'CASE' not in PAR:
raise ParameterError(PAR, 'CASE')
# scratch paths
if 'SCRATCH' not in PATH:
raise ParameterError(PATH, 'SCRATCH')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'FUNC' not in PATH:
setattr(PATH, 'FUNC', os.path.join(PATH.SCRATCH, 'evalfunc'))
if 'GRAD' not in PATH:
setattr(PATH, 'GRAD', os.path.join(PATH.SCRATCH, 'evalgrad'))
if 'HESS' not in PATH:
setattr(PATH, 'HESS', os.path.join(PATH.SCRATCH, 'evalhess'))
if 'OPTIMIZE' not in PATH:
setattr(PATH, 'OPTIMIZE', os.path.join(PATH.SCRATCH, 'optimize'))
# input paths
if 'MODEL_INIT' not in PATH:
raise ParameterError(PATH, 'MODEL_INIT')
# output paths
if 'OUTPUT' not in PATH:
raise ParameterError(PATH, 'OUTPUT')
if 'SAVEMODEL' not in PAR:
setattr(PAR, 'SAVEMODEL', True)
if 'SAVEGRADIENT' not in PAR:
setattr(PAR, 'SAVEGRADIENT', False)
if 'SAVEKERNELS' not in PAR:
setattr(PAR, 'SAVEKERNELS', False)
if 'SAVEAS' not in PAR:
setattr(PAR, 'SAVEAS', 'binary')
if 'SAVETRACES' not in PAR:
setattr(PAR, 'SAVETRACES', False)
if 'SAVERESIDUALS' not in PAR:
setattr(PAR, 'SAVERESIDUALS', False)
# pyatoa specific paths
# Config file should be present here.
if 'PYATOA_IO' not in PATH:
raise ParameterError(PATH, 'PYATOA_IO')
# make sure the Pyatoa plugin run script is present
if 'PYATOA_RUN' not in PATH:
raise ParameterError(PATH, 'PYATOA_RUN')
# make sure a Python3 binary is avilalable
if 'PYTHON3' not in PATH:
raise ParameterError(PATH, 'PYTHON3')
# parameter assertions
assert 1 <= PAR.BEGIN <= PAR.END
# check that there is a given starting model
if not exists(PATH.MODEL_INIT):
raise Exception()
# synthetic-synthetic examples require a true model to create the 'data'
if PAR.CASE == 'Synthetic' and not exists(PATH.MODEL_TRUE):
raise Exception()
def check(self):
""" Checks parameters and paths
"""
# starting and stopping iterations
if 'BEGIN' not in PAR:
raise ParameterError(PAR, 'BEGIN')
if 'END' not in PAR:
raise ParameterError(PAR, 'END')
# scratch paths
if 'SCRATCH' not in PATH:
raise ParameterError(PATH, 'SCRATCH')
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'FUNC' not in PATH:
setattr(PATH, 'FUNC', join(PATH.SCRATCH, 'evalfunc'))
if 'GRAD' not in PATH:
setattr(PATH, 'GRAD', join(PATH.SCRATCH, 'evalgrad'))
if 'HESS' not in PATH:
setattr(PATH, 'HESS', join(PATH.SCRATCH, 'evalhess'))
if 'OPTIMIZE' not in PATH:
setattr(PATH, 'OPTIMIZE', join(PATH.SCRATCH, 'optimize'))
# input paths
if 'DATA' not in PATH:
setattr(PATH, 'DATA', None)
if 'MODEL_INIT' not in PATH:
raise ParameterError(PATH, 'MODEL_INIT')
# output paths
if 'OUTPUT' not in PATH:
raise ParameterError(PATH, 'OUTPUT')
if 'SAVEMODEL' not in PAR:
setattr(PAR, 'SAVEMODEL', 1)
if 'SAVEGRADIENT' not in PAR:
setattr(PAR, 'SAVEGRADIENT', 0)
if 'SAVEKERNELS' not in PAR:
setattr(PAR, 'SAVEKERNELS', 0)
if 'SAVETRACES' not in PAR:
setattr(PAR, 'SAVETRACES', 0)
if 'SAVERESIDUALS' not in PAR:
setattr(PAR, 'SAVERESIDUALS', 0)
# parameter assertions
assert 1 <= PAR.BEGIN <= PAR.END
# path assertions
if not exists(PATH.DATA):
assert 'MODEL_TRUE' in PATH
assert exists(PATH.MODEL_TRUE)
if not exists(PATH.MODEL_INIT):
raise Exception()
def check(self):
""" Checks parameters and paths
"""
# name of job
if 'TITLE' not in PAR:
setattr(PAR, 'TITLE', basename(abspath('.')))
# time allocated for workflow in minutes
if 'WALLTIME' not in PAR:
setattr(PAR, 'WALLTIME', 30.)
# time allocated for each individual task in minutes
if 'TASKTIME' not in PAR:
setattr(PAR, 'TASKTIME', 15.)
# number of tasks
if 'NTASK' not in PAR:
raise ParameterError(PAR, 'NTASK')
# number of cores per task
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
# limit on number of concurrent tasks
if 'NTASKMAX' not in PAR:
setattr(PAR, 'NTASKMAX', PAR.NTASK)
# number of cores per node
if 'NODESIZE' not in PAR:
raise ParameterError(PAR, 'NODESIZE')
# how to invoke executables
if 'MPIEXEC' not in PAR:
setattr(PAR, 'MPIEXEC', 'mpiexec')
# optional additional LSF arguments
if 'LSFARGS' not in PAR:
setattr(PAR, 'LSFARGS', '')
# optional environment variable list VAR1=val1,VAR2=val2,...
if 'ENVIRONS' not in PAR:
setattr(PAR, 'ENVIRONS', '')
# level of detail in output messages
if 'VERBOSE' not in PAR:
setattr(PAR, 'VERBOSE', 1)
# where job was submitted
if 'WORKDIR' not in PATH:
setattr(PATH, 'WORKDIR', abspath('.'))
# where output files are written
if 'OUTPUT' not in PATH:
setattr(PATH, 'OUTPUT', PATH.WORKDIR + '/' + 'output')
# where temporary files are written
if 'SCRATCH' not in PATH:
setattr(PATH, 'SCRATCH', PATH.WORKDIR + '/' + 'scratch')
# where system files are written
if 'SYSTEM' not in PATH:
setattr(PATH, 'SYSTEM', PATH.SCRATCH + '/' + 'system')
# optional local scratch path
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)