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')
# 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 'MISFIT' not in PAR:
setattr(PAR, 'MISFIT', 'wav')
if 'FORMAT' not in PAR:
raise ParameterError(PAR, 'FORMAT')
if 'CHANNELS' not in PAR:
raise ParameterError(PAR, 'CHANNELS')
if 'NORMALIZE' not in PAR:
setattr(PAR, 'NORMALIZE', True)
# mute settings
if 'MUTE' not in PAR:
setattr(PAR, 'MUTE', False)
if 'MUTESLOPE' not in PAR:
setattr(PAR, 'MUTESLOPE', 0.)
if 'MUTECONST' not in PAR:
setattr(PAR, 'MUTECONST', 0.)
# filter settings
if 'BANDPASS' not in PAR:
setattr(PAR, 'BANDPASS', False)
if 'FREQLO' not in PAR:
setattr(PAR, 'FREQLO', 0.)
if 'FREQHI' not in PAR:
setattr(PAR, 'FREQHI', 0.)
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
"""
if 'MISFIT' not in PAR:
setattr(PAR, 'MISFIT', None)
if 'BACKPROJECT' not in PAR:
setattr(PAR, 'BACKPROJECT', None)
if 'FORMAT' not in PAR:
raise ParameterError(PAR, 'FORMAT')
if 'NORMALIZE' not in PAR:
setattr(PAR, 'NORMALIZE', 'L2')
if 'MUTE' not in PAR:
setattr(PAR, 'MUTE', None)
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
"""
# check parameters
if 'TITLE' not in PAR:
setattr(PAR, 'TITLE', basename(abspath('.')))
if 'WALLTIME' not in PAR:
setattr(PAR, 'WALLTIME', 30.)
if 'VERBOSE' not in PAR:
setattr(PAR, 'VERBOSE', 1)
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
if 'NTASK' not in PAR:
raise ParameterError(PAR, 'NTASK')
if 'SLURMARGS' not in PAR:
setattr(PAR, 'SLURMARGS', '')
# check paths
if 'SCRATCH' not in PATH:
setattr(PATH, 'SCRATCH', join(abspath('.'), 'scratch'))
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'SUBMIT' not in PATH:
setattr(PATH, 'SUBMIT', abspath('.'))
if 'OUTPUT' not in PATH:
setattr(PATH, 'OUTPUT', join(PATH.SUBMIT, 'output'))
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(self):
""" Checks parameters and paths
"""
if 'MISFIT' not in PAR:
setattr(PAR, 'MISFIT', 'Waveform')
if 'CHANNELS' not in PAR:
raise ParameterError(PAR, 'CHANNELS')
if 'READER' not in PAR:
raise ParameterError(PAR, 'READER')
if 'WRITER' not in PAR:
setattr(PAR, 'WRITER', PAR.READER)
if 'NORMALIZE' not in PAR:
setattr(PAR, 'NORMALIZE', True)
if 'PAR_CULL' not in PAR:
setattr(PAR, 'PAR_CULL', True)
# mute settings
if 'MUTE' not in PAR:
setattr(PAR, 'MUTE', False)
if 'MUTESLOPE' not in PAR:
setattr(PAR, 'MUTESLOPE', 0.)
if 'MUTECONST' not in PAR:
setattr(PAR, 'MUTECONST', 0.)
# filter settings
if 'BANDPASS' not in PAR:
setattr(PAR, 'BANDPASS', False)
if 'FREQLO' not in PAR:
setattr(PAR, 'FREQLO', 0.)
if 'FREQHI' not in PAR:
setattr(PAR, 'FREQHI', 0.)
if 'NORMALIZE_ALL' not in PAR:
setattr(PAR, 'NORMALIZE_ALL', False)
# assertions
if PAR.READER not in dir(readers):
print msg.ReaderError
raise ParameterError()
if PAR.WRITER not in dir(writers):
print msg.WriterError
raise ParameterError()
def generate_adjoint_traces(self, s, d, h):
""" Generates adjoint traces from observed and synthetic traces
"""
for i in range(h.nr):
s[:, i] = self.call_adjoint(s[:, i], d[:, i], h.nt, h.dt)
# bandpass once more
if PAR.BANDPASS:
if PAR.FREQLO and PAR.FREQHI:
s = sbandpass(s, h, PAR.FREQLO, PAR.FREQHI, 'reverse')
elif PAR.FREQHI:
s = shighpass(s, h, PAR.FREQLO, 'reverse')
elif PAR.FREQHI:
s = slowpass(s, h, PAR.FREQHI, 'reverse')
else:
raise ParameterError(PAR, 'BANDPASS')
# normalize traces
if PAR.NORMALIZE:
for ir in range(h.nr):
w = np.linalg.norm(d[:, ir], ord=2)
if w > 0:
s[:, ir] /= w
return s
def check_normalize(self):
if not PAR.NORMALIZE:
pass
elif PAR.NORMALIZE in ['L1', 'L2', 'L2_squared']:
pass
else:
raise ParameterError()
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))
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
"""
if 'TITLE' not in PAR:
setattr(PAR, 'TITLE', unix.basename(abspath('..')))
if 'SUBTITLE' not in PAR:
setattr(PAR, 'SUBTITLE', unix.basename(abspath('.')))
# check parameters
if 'WALLTIME' not in PAR:
setattr(PAR, 'WALLTIME', 30.)
if 'STEPTIME' not in PAR:
setattr(PAR, 'STEPTIME', 30.)
if 'SLEEPTIME' not in PAR:
setattr(PAR, 'SLEEPTIME', 1.)
if 'VERBOSE' not in PAR:
setattr(PAR, 'VERBOSE', 1)
if 'NTASK' not in PAR:
raise ParameterError(PAR, 'NTASK')
if 'NPROC' not in PAR:
raise ParameterError(PAR, 'NPROC')
if 'NODESIZE' not in PAR:
raise ParameterError(PAR, 'NODESIZE')
# check paths
if 'GLOBAL' not in PATH:
setattr(PATH, 'GLOBAL', join(abspath('.'), 'scratch'))
if 'LOCAL' not in PATH:
setattr(PATH, 'LOCAL', None)
if 'SUBMIT' not in PATH:
setattr(PATH, 'SUBMIT', unix.pwd())
if 'OUTPUT' not in PATH:
setattr(PATH, 'OUTPUT', join(PATH.SUBMIT, 'output'))
if 'SYSTEM' not in PATH:
setattr(PATH, 'SYSTEM', join(PATH.GLOBAL, 'system'))
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.
else:
raise ParameterError()
def check(self):
""" Checks parameters and paths
"""
super(pbs_sm, self).check()
# check parameters
if 'WALLTIME' not in PAR:
setattr(PAR, 'WALLTIME', 30.)
if 'MEMORY' not in PAR:
setattr(PAR, 'MEMORY', 0)
if 'NODESIZE' not in PAR:
raise ParameterError(PAR, 'NODESIZE')
if 'PBSARGS' not in PAR:
setattr(PAR, 'PBSARGS', '')
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 process_traces(self, s, h):
""" Performs data processing operations on traces
"""
# filter data
if PAR.BANDPASS:
if PAR.FREQLO and PAR.FREQHI:
s = sbandpass(s, h, PAR.FREQLO, PAR.FREQHI)
elif PAR.FREQHI:
s = shighpass(s, h, PAR.FREQLO)
elif PAR.FREQHI:
s = slowpass(s, h, PAR.FREQHI)
else:
raise ParameterError(PAR, 'BANDPASS')
# mute direct arrival
if PAR.MUTE:
vel = PAR.MUTESLOPE
off = PAR.MUTECONST
s = smute(s, h, vel, off, constant_spacing=False)
return s
def check(self):
""" Checks parameters and paths
"""
# check parameters
if 'BEGIN' not in PAR:
raise ParameterError(PAR, 'BEGIN')
if 'END' not in PAR:
raise ParameterError(PAR, 'END')
if 'VERBOSE' not in PAR:
setattr(PAR, 'VERBOSE', 1)
# 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()