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)