marcel/pylot
3
0
Fork 0
Code Issues 7 Pull Requests 1 Releases Wiki Activity

Merge branch 'filterOptions' into develop

Browse Source
This commit is contained in:
Marcel Paffrath 2017-07-12 16:33:14 +02:00
commit aa6f4324d0
8 changed files with 521 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
QtPyLoT.py
View File

@ -65,7 +65,8 @@ from pylot.core.pick.compare import Comparison
from pylot.core.pick.utils import symmetrize_error from pylot.core.pick.utils import symmetrize_error
from pylot.core.io.phases import picksdict_from_picks from pylot.core.io.phases import picksdict_from_picks
import pylot.core.loc.nll as nll import pylot.core.loc.nll as nll
from pylot.core.util.defaults import FILTERDEFAULTS, OUTPUTFORMATS, SetChannelComponents from pylot.core.util.defaults import FILTERDEFAULTS, OUTPUTFORMATS, SetChannelComponents, \
readFilterInformation
from pylot.core.util.errors import FormatError, DatastructureError, \ from pylot.core.util.errors import FormatError, DatastructureError, \
OverwriteError, ProcessingError OverwriteError, ProcessingError
from pylot.core.util.connection import checkurl from pylot.core.util.connection import checkurl
@ -180,7 +181,15 @@ class MainWindow(QMainWindow):
# setup UI # setup UI
self.setupUi() self.setupUi()
self.filteroptions = {} filter_info = readFilterInformation(self._inputs)
p_filter = filter_info['P']
s_filter = filter_info['S']
self.filteroptions = {'P': FilterOptions(p_filter['filtertype'],
p_filter['freq'],
p_filter['order']),
'S': FilterOptions(s_filter['filtertype'],
s_filter['freq'],
s_filter['order'])}
self.pylot_picks = {} self.pylot_picks = {}
self.pylot_autopicks = {} self.pylot_autopicks = {}
self.loc = False self.loc = False
@ -1539,44 +1548,84 @@ class MainWindow(QMainWindow):
def filterWaveformData(self): def filterWaveformData(self):
if self.get_data(): if self.get_data():
if self.getFilterOptions() and self.filterAction.isChecked(): if self.getFilterOptions() and self.filterAction.isChecked():
kwargs = self.getFilterOptions().parseFilterOptions() kwargs = self.getFilterOptions()[self.getSeismicPhase()].parseFilterOptions()
self.pushFilterWF(kwargs) self.pushFilterWF(kwargs)
elif self.filterAction.isChecked(): elif self.filterAction.isChecked():
self.adjustFilterOptions() self.adjustFilterOptions()
else: else:
self.get_data().resetWFData() self.get_data().resetWFData()
self.plotWaveformData() self.plotWaveformDataThread()
self.drawPicks() self.drawPicks()
self.draw() self.draw()
def adjustFilterOptions(self): def adjustFilterOptions(self):
fstring = "Filter Options ({0})".format(self.getSeismicPhase()) fstring = "Filter Options"
filterDlg = FilterOptionsDialog(titleString=fstring, self.filterDlg = FilterOptionsDialog(titleString=fstring,
parent=self) parent=self)
if filterDlg.exec_(): if self.filterDlg.exec_():
filteroptions = filterDlg.getFilterOptions() filteroptions = self.filterDlg.getFilterOptions()
self.setFilterOptions(filteroptions) self.setFilterOptions(filteroptions)
if self.filterAction.isChecked(): if self.filterAction.isChecked():
kwargs = self.getFilterOptions().parseFilterOptions() kwargs = self.getFilterOptions()[self.getSeismicPhase()].parseFilterOptions()
self.pushFilterWF(kwargs) self.pushFilterWF(kwargs)
self.plotWaveformData() self.plotWaveformDataThread()
def checkFilterOptions(self):
fstring = "Filter Options"
self.filterDlg = FilterOptionsDialog(titleString=fstring,
parent=self)
filteroptions = self.filterDlg.getFilterOptions()
self.setFilterOptions(filteroptions)
filterP = filteroptions['P']
filterS = filteroptions['S']
minP, maxP = filterP.getFreq()
minS, maxS = filterS.getFreq()
self.paraBox.params_to_gui()
def getFilterOptions(self): def getFilterOptions(self):
try: return self.filteroptions
return self.filteroptions[self.getSeismicPhase()] # try:
except AttributeError as e: # return self.filteroptions[self.getSeismicPhase()]
print(e) # except AttributeError as e:
return FilterOptions(None, None, None) # print(e)
# return FilterOptions(None, None, None)
def getFilters(self): def getFilters(self):
return self.filteroptions return self.filteroptions
def setFilterOptions(self, filterOptions, seismicPhase=None): def setFilterOptions(self, filterOptions):#, seismicPhase=None):
if seismicPhase is None: # if seismicPhase is None:
self.getFilters()[self.getSeismicPhase()] = filterOptions # self.getFilterOptions()[self.getSeismicPhase()] = filterOptions
else: # else:
self.getFilters()[seismicPhase] = filterOptions # self.getFilterOptions()[seismicPhase] = filterOptions
self.filterOptions = filterOptions
filterP = filterOptions['P']
filterS = filterOptions['S']
minP, maxP = filterP.getFreq()
minS, maxS = filterS.getFreq()
self._inputs.setParamKV('minfreq', (minP, minS))
self._inputs.setParamKV('maxfreq', (maxP, maxS))
self._inputs.setParamKV('filter_order', (filterP.getOrder(), filterS.getOrder()))
self._inputs.setParamKV('filter_type', (filterP.getFilterType(), filterS.getFilterType()))
def filterOptionsFromParameter(self):
minP, minS = self._inputs['minfreq']
maxP, maxS = self._inputs['maxfreq']
orderP, orderS = self._inputs['filter_order']
typeP, typeS = self._inputs['filter_type']
filterP = self.getFilterOptions()['P']
filterP.setFreq([minP, maxP])
filterP.setOrder(orderP)
filterP.setFilterType(typeP)
filterS = self.getFilterOptions()['S']
filterS.setFreq([minS, maxS])
filterS.setOrder(orderS)
filterS.setFilterType(typeS)
self.checkFilterOptions()
def updateFilterOptions(self): def updateFilterOptions(self):
try: try:
settings = QSettings() settings = QSettings()
@ -2477,11 +2526,12 @@ class MainWindow(QMainWindow):
def setParameter(self, show=True): def setParameter(self, show=True):
if not self.paraBox: if not self.paraBox:
self.paraBox = PylotParaBox(self._inputs) self.paraBox = PylotParaBox(self._inputs)
self.paraBox._apply.clicked.connect(self._setDirty) self.paraBox.accepted.connect(self._setDirty)
self.paraBox._okay.clicked.connect(self._setDirty) self.paraBox.accepted.connect(self.filterOptionsFromParameter)
if show: if show:
self.paraBox.params_to_gui()
self.paraBox.show() self.paraBox.show()
def PyLoTprefs(self): def PyLoTprefs(self):
if not self._props: if not self._props:
self._props = PropertiesDlg(self, infile=self.infile) self._props = PropertiesDlg(self, infile=self.infile)

4
README.md
View File

@ -50,9 +50,9 @@ for regional distance seismicity
cp path-to-pylot/inputs/autoPyLoT_regional.in ~/.pylot/autoPyLoT.in cp path-to-pylot/inputs/autoPyLoT_regional.in ~/.pylot/autoPyLoT.in
and some extra information on filtering, error estimates (just needed for reading old PILOT data) and the Richter magnitude scaling relation and some extra information on error estimates (just needed for reading old PILOT data) and the Richter magnitude scaling relation
cp path-to-pylot/inputs/filter.in path-to-pylot/inputs/PILOT_TimeErrors.in path-to-pylot/inputs/richter_scaling.data ~/.pylot/ cp path-to-pylot/inputs/PILOT_TimeErrors.in path-to-pylot/inputs/richter_scaling.data ~/.pylot/
You may need to do some modifications to these files. Especially folder names should be reviewed. You may need to do some modifications to these files. Especially folder names should be reviewed.

173
inputs/pylot.in
View File

@ -1,98 +1,97 @@
%This is a example parameter input file for PyLoT. %This is a parameter input file for PyLoT/autoPyLoT.
%All main and special settings regarding data handling %All main and special settings regarding data handling
%and picking are to be set here! %and picking are to be set here!
%Parameters shown here are optimized for local data sets! %Parameters are optimized for %extent data sets!
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#main settings# #main settings#
/data/Geothermie/Insheim #rootpath# %project path #rootpath# %project path
EVENT_DATA/LOCAL #datapath# %data path #datapath# %data path
2013.02_Insheim #database# %name of data base #database# %name of data base
e0019.048.13 #eventID# %event ID for single event processing e0010.065.17 #eventID# %event ID for single event processing (* for all events found in database)
/data/Geothermie/Insheim/STAT_INFO #invdir# %full path to inventory or dataless-seed file #invdir# %full path to inventory or dataless-seed file
PILOT #datastructure# %choose data structure PILOT #datastructure# %choose data structure
0 #iplot# %flag for plotting: 0 none, 1 partly, >1 everything True #apverbose# %choose 'True' or 'False' for terminal output
True #apverbose# %choose 'True' or 'False' for terminal output
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#NLLoc settings#
/progs/bin #nllocbin# %path to NLLoc executable
/data/Geothermie/Insheim/LOCALISATION/NLLoc #nllocroot# %root of NLLoc-processing directory
AUTOPHASES.obs #phasefile# %name of autoPyLoT-output phase file for NLLoc
%(in nllocroot/obs)
Insheim_min1d2015.in #ctrfile# %name of PyLoT-output control file for NLLoc
%(in nllocroot/run)
ttime #ttpatter# %pattern of NLLoc ttimes from grid
%(in nllocroot/times)
AUTOLOC_nlloc #outpatter# %pattern of NLLoc-output file
%(returns 'eventID_outpatter')
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#parameters for seismic moment estimation#
3530 #vp# %average P-wave velocity
2500 #rho# %average rock density [kg/m^3]
300 0.8 #Qp# %quality factor for P waves (Qp*f^a); list(Qp, a)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
AUTOFOCMEC_AIC_HOS4_ARH.in #focmecin# %name of focmec input file containing derived polarities #NLLoc settings#
#nllocbin# %path to NLLoc executable
#nllocroot# %root of NLLoc-processing directory
AUTOPHASES.obs #phasefile# %name of autoPyLoT-output phase file for NLLoc
Insheim_min1d2015_auto.in #ctrfile# %name of autoPyLoT-output control file for NLLoc
ttime #ttpatter# %pattern of NLLoc ttimes from grid
AUTOLOC_nlloc #outpatter# %pattern of NLLoc-output file
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#parameters for seismic moment estimation#
3530.0 #vp# %average P-wave velocity
2500.0 #rho# %average rock density [kg/m^3]
300.0 0.8 #Qp# %quality factor for P waves (Qp*f^a); list(Qp, a)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#settings local magnitude#
0.0 0.0 0.0 #WAscaling# %Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm] If zeros are set, original Richter magnitude is calculated!
0.0 0.0 #magscaling# %Scaling relation for derived local magnitude [a*Ml+b]. If zeros are set, no scaling of network magnitude is applied!
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#filter settings#
1.0 1.0 #minfreq# %Lower filter frequency [P, S]
10.0 10.0 #maxfreq# %Upper filter frequency [P, S]
2 2 #filter_order# %filter order [P, S]
bandpass bandpass #filter_type# %filter type (bandpass, bandstop, lowpass, highpass) [P, S]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#common settings picker# #common settings picker#
15.0 #pstart# %start time [s] for calculating CF for P-picking local #extent# %extent of array ("local", "regional" or "global")
60.0 #pstop# %end time [s] for calculating CF for P-picking 15.0 #pstart# %start time [s] for calculating CF for P-picking
-1.0 #sstart# %start time [s] relative to P-onset for calculating CF for S-picking 60.0 #pstop# %end time [s] for calculating CF for P-picking
10.0 #sstop# %end time [s] after P-onset for calculating CF for S-picking -1.0 #sstart# %start time [s] relative to P-onset for calculating CF for S-picking
2 20 #bpz1# %lower/upper corner freq. of first band pass filter Z-comp. [Hz] 10.0 #sstop# %end time [s] after P-onset for calculating CF for S-picking
2 30 #bpz2# %lower/upper corner freq. of second band pass filter Z-comp. [Hz] 2.0 20.0 #bpz1# %lower/upper corner freq. of first band pass filter Z-comp. [Hz]
2 15 #bph1# %lower/upper corner freq. of first band pass filter H-comp. [Hz] 2.0 30.0 #bpz2# %lower/upper corner freq. of second band pass filter Z-comp. [Hz]
2 20 #bph2# %lower/upper corner freq. of second band pass filter z-comp. [Hz] 2.0 15.0 #bph1# %lower/upper corner freq. of first band pass filter H-comp. [Hz]
2.0 20.0 #bph2# %lower/upper corner freq. of second band pass filter z-comp. [Hz]
#special settings for calculating CF# #special settings for calculating CF#
%!!Edit the following only if you know what you are doing!!% %!!Edit the following only if you know what you are doing!!%
#Z-component# #Z-component#
HOS #algoP# %choose algorithm for P-onset determination (HOS, ARZ, or AR3) HOS #algoP# %choose algorithm for P-onset determination (HOS, ARZ, or AR3)
7.0 #tlta# %for HOS-/AR-AIC-picker, length of LTA window [s] 7.0 #tlta# %for HOS-/AR-AIC-picker, length of LTA window [s]
4 #hosorder# %for HOS-picker, order of Higher Order Statistics 4 #hosorder# %for HOS-picker, order of Higher Order Statistics
2 #Parorder# %for AR-picker, order of AR process of Z-component 2 #Parorder# %for AR-picker, order of AR process of Z-component
1.2 #tdet1z# %for AR-picker, length of AR determination window [s] for Z-component, 1st pick 1.2 #tdet1z# %for AR-picker, length of AR determination window [s] for Z-component, 1st pick
0.4 #tpred1z# %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick 0.4 #tpred1z# %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick
0.6 #tdet2z# %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick 0.6 #tdet2z# %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick
0.2 #tpred2z# %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick 0.2 #tpred2z# %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick
0.001 #addnoise# %add noise to seismogram for stable AR prediction 0.001 #addnoise# %add noise to seismogram for stable AR prediction
3 0.1 0.5 0.5 #tsnrz# %for HOS/AR, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s] 3.0 0.1 0.5 1.0 #tsnrz# %for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]
3.0 #pickwinP# %for initial AIC pick, length of P-pick window [s] 3.0 #pickwinP# %for initial AIC pick, length of P-pick window [s]
6.0 #Precalcwin# %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick) 6.0 #Precalcwin# %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)
0.2 #aictsmooth# %for HOS/AR, take average of samples for smoothing of AIC-function [s] 0.2 #aictsmooth# %for HOS/AR, take average of samples for smoothing of AIC-function [s]
0.1 #tsmoothP# %for HOS/AR, take average of samples for smoothing CF [s] 0.1 #tsmoothP# %for HOS/AR, take average of samples for smoothing CF [s]
0.001 #ausP# %for HOS/AR, artificial uplift of samples (aus) of CF (P) 0.001 #ausP# %for HOS/AR, artificial uplift of samples (aus) of CF (P)
1.3 #nfacP# %for HOS/AR, noise factor for noise level determination (P) 1.3 #nfacP# %for HOS/AR, noise factor for noise level determination (P)
#H-components# #H-components#
ARH #algoS# %choose algorithm for S-onset determination (ARH or AR3) ARH #algoS# %choose algorithm for S-onset determination (ARH or AR3)
0.8 #tdet1h# %for HOS/AR, length of AR-determination window [s], H-components, 1st pick 0.8 #tdet1h# %for HOS/AR, length of AR-determination window [s], H-components, 1st pick
0.4 #tpred1h# %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick 0.4 #tpred1h# %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick
0.6 #tdet2h# %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick 0.6 #tdet2h# %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick
0.3 #tpred2h# %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick 0.3 #tpred2h# %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick
4 #Sarorder# %for AR-picker, order of AR process of H-components 4 #Sarorder# %for AR-picker, order of AR process of H-components
5.0 #Srecalcwin# %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H) 5.0 #Srecalcwin# %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)
3.0 #pickwinS# %for initial AIC pick, length of S-pick window [s] 3.0 #pickwinS# %for initial AIC pick, length of S-pick window [s]
2 0.2 1.5 0.5 #tsnrh# %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s] 2.0 0.2 1.5 0.5 #tsnrh# %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]
0.5 #aictsmoothS# %for AIC-picker, take average of samples for smoothing of AIC-function [s] 0.5 #aictsmoothS# %for AIC-picker, take average of samples for smoothing of AIC-function [s]
0.7 #tsmoothS# %for AR-picker, take average of samples for smoothing CF [s] (S) 0.7 #tsmoothS# %for AR-picker, take average of samples for smoothing CF [s] (S)
0.9 #ausS# %for HOS/AR, artificial uplift of samples (aus) of CF (S) 0.9 #ausS# %for HOS/AR, artificial uplift of samples (aus) of CF (S)
1.5 #nfacS# %for AR-picker, noise factor for noise level determination (S) 1.5 #nfacS# %for AR-picker, noise factor for noise level determination (S)
%first-motion picker% #first-motion picker#
1 #minfmweight# %minimum required P weight for first-motion determination 1 #minfmweight# %minimum required P weight for first-motion determination
2 #minFMSNR# %miniumum required SNR for first-motion determination 2.0 #minFMSNR# %miniumum required SNR for first-motion determination
0.2 #fmpickwin# %pick window around P onset for calculating zero crossings 0.2 #fmpickwin# %pick window around P onset for calculating zero crossings
%quality assessment% #quality assessment#
#inital AIC onset# 0.01 0.02 0.04 0.08 #timeerrorsP# %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P
0.01 0.02 0.04 0.08 #timeerrorsP# %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P 0.04 0.08 0.16 0.32 #timeerrorsS# %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S
0.04 0.08 0.16 0.32 #timeerrorsS# %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S 0.8 #minAICPslope# %below this slope [counts/s] the initial P pick is rejected
4 #minAICPslope# %below this slope [counts/s] the initial P pick is rejected 1.1 #minAICPSNR# %below this SNR the initial P pick is rejected
1.2 #minAICPSNR# %below this SNR the initial P pick is rejected 1.0 #minAICSslope# %below this slope [counts/s] the initial S pick is rejected
2 #minAICSslope# %below this slope [counts/s] the initial S pick is rejected 1.5 #minAICSSNR# %below this SNR the initial S pick is rejected
1.5 #minAICSSNR# %below this SNR the initial S pick is rejected 1.0 #minsiglength# %length of signal part for which amplitudes must exceed noiselevel [s]
#check duration of signal using envelope function# 1.0 #noisefactor# %noiselevel*noisefactor=threshold
3 #minsiglength# %minimum required length of signal [s] 10.0 #minpercent# %required percentage of amplitudes exceeding threshold
1.0 #noisefactor# %noiselevel*noisefactor=threshold 1.5 #zfac# %P-amplitude must exceed at least zfac times RMS-S amplitude
40 #minpercent# %required percentage of samples higher than threshold 6.0 #mdttolerance# %maximum allowed deviation of P picks from median [s]
#check for spuriously picked S-onsets# 1.0 #wdttolerance# %maximum allowed deviation from Wadati-diagram
2.0 #zfac# %P-amplitude must exceed at least zfac times RMS-S amplitude
#check statistics of P onsets#
2.5 #mdttolerance# %maximum allowed deviation of P picks from median [s]
#wadati check#
1.0 #wdttolerance# %maximum allowed deviation from Wadati-diagram

3
makePyLoT.py
View File

@ -159,8 +159,7 @@ def buildPyLoT(verbosity=None):
def installPyLoT(verbosity=None): def installPyLoT(verbosity=None):
files_to_copy = {'autoPyLoT_local.in':['~', '.pylot'], files_to_copy = {'autoPyLoT_local.in':['~', '.pylot'],
'autoPyLoT_regional.in':['~', '.pylot'], 'autoPyLoT_regional.in':['~', '.pylot']}
'filter.in':['~', '.pylot']}
if verbosity > 0: if verbosity > 0:
print ('starting installation of PyLoT ...') print ('starting installation of PyLoT ...')
if verbosity > 1: if verbosity > 1:

246
pylot/core/io/default_parameters.py
View File

@ -3,289 +3,380 @@
defaults = {'rootpath': {'type': str, defaults = {'rootpath': {'type': str,
'tooltip': 'project path', 'tooltip': 'project path',
'value': ''}, 'value': '',
'namestring': 'Root path'},
'datapath': {'type': str, 'datapath': {'type': str,
'tooltip': 'data path', 'tooltip': 'data path',
'value': ''}, 'value': '',
'namestring': 'Data path'},
'database': {'type': str, 'database': {'type': str,
'tooltip': 'name of data base', 'tooltip': 'name of data base',
'value': ''}, 'value': '',
'namestring': 'Database path'},
'eventID': {'type': str, 'eventID': {'type': str,
'tooltip': 'event ID for single event processing (* for all events found in database)', 'tooltip': 'event ID for single event processing (* for all events found in database)',
'value': ''}, 'value': '',
'namestring': 'Event ID'},
'extent': {'type': str, 'extent': {'type': str,
'tooltip': 'extent of array ("local", "regional" or "global")', 'tooltip': 'extent of array ("local", "regional" or "global")',
'value': 'local'}, 'value': 'local',
'namestring': 'Array extent'},
'invdir': {'type': str, 'invdir': {'type': str,
'tooltip': 'full path to inventory or dataless-seed file', 'tooltip': 'full path to inventory or dataless-seed file',
'value': ''}, 'value': '',
'namestring': 'Inversion dir'},
'datastructure': {'type': str, 'datastructure': {'type': str,
'tooltip': 'choose data structure', 'tooltip': 'choose data structure',
'value': 'PILOT'}, 'value': 'PILOT',
'namestring': 'Datastructure'},
'apverbose': {'type': bool, 'apverbose': {'type': bool,
'tooltip': "choose 'True' or 'False' for terminal output", 'tooltip': "choose 'True' or 'False' for terminal output",
'value': True}, 'value': True,
'namestring': 'App. verbosity'},
'nllocbin': {'type': str, 'nllocbin': {'type': str,
'tooltip': 'path to NLLoc executable', 'tooltip': 'path to NLLoc executable',
'value': ''}, 'value': '',
'namestring': 'NLLoc bin path'},
'nllocroot': {'type': str, 'nllocroot': {'type': str,
'tooltip': 'root of NLLoc-processing directory', 'tooltip': 'root of NLLoc-processing directory',
'value': ''}, 'value': '',
'namestring': 'NLLoc root path'},
'phasefile': {'type': str, 'phasefile': {'type': str,
'tooltip': 'name of autoPyLoT-output phase file for NLLoc', 'tooltip': 'name of autoPyLoT-output phase file for NLLoc',
'value': 'AUTOPHASES.obs'}, 'value': 'AUTOPHASES.obs',
'namestring': 'Phase filename'},
'ctrfile': {'type': str, 'ctrfile': {'type': str,
'tooltip': 'name of autoPyLoT-output control file for NLLoc', 'tooltip': 'name of autoPyLoT-output control file for NLLoc',
'value': 'Insheim_min1d2015_auto.in'}, 'value': 'Insheim_min1d2015_auto.in',
'namestring': 'Control filename'},
'ttpatter': {'type': str, 'ttpatter': {'type': str,
'tooltip': 'pattern of NLLoc ttimes from grid', 'tooltip': 'pattern of NLLoc ttimes from grid',
'value': 'ttime'}, 'value': 'ttime',
'namestring': 'Traveltime pattern'},
'outpatter': {'type': str, 'outpatter': {'type': str,
'tooltip': 'pattern of NLLoc-output file', 'tooltip': 'pattern of NLLoc-output file',
'value': 'AUTOLOC_nlloc'}, 'value': 'AUTOLOC_nlloc',
'namestring': 'NLLoc output pattern'},
'vp': {'type': float, 'vp': {'type': float,
'tooltip': 'average P-wave velocity', 'tooltip': 'average P-wave velocity',
'value': 3530.}, 'value': 3530.,
'namestring': 'P-velocity'},
'rho': {'type': float, 'rho': {'type': float,
'tooltip': 'average rock density [kg/m^3]', 'tooltip': 'average rock density [kg/m^3]',
'value': 2500.}, 'value': 2500.,
'namestring': 'Density'},
'Qp': {'type': (float, float), 'Qp': {'type': (float, float),
'tooltip': 'quality factor for P waves (Qp*f^a); list(Qp, a)', 'tooltip': 'quality factor for P waves (Qp*f^a); list(Qp, a)',
'value': (300., 0.8)}, 'value': (300., 0.8),
'namestring': ('Quality factor', 'Qp1', 'Qp2')},
'pstart': {'type': float, 'pstart': {'type': float,
'tooltip': 'start time [s] for calculating CF for P-picking', 'tooltip': 'start time [s] for calculating CF for P-picking',
'value': 15.0}, 'value': 15.0,
'namestring': 'P start'},
'pstop': {'type': float, 'pstop': {'type': float,
'tooltip': 'end time [s] for calculating CF for P-picking', 'tooltip': 'end time [s] for calculating CF for P-picking',
'value': 60.0}, 'value': 60.0,
'namestring': 'P stop'},
'sstart': {'type': float, 'sstart': {'type': float,
'tooltip': 'start time [s] relative to P-onset for calculating CF for S-picking', 'tooltip': 'start time [s] relative to P-onset for calculating CF for S-picking',
'value': -1.0}, 'value': -1.0,
'namestring': 'S start'},
'sstop': {'type': float, 'sstop': {'type': float,
'tooltip': 'end time [s] after P-onset for calculating CF for S-picking', 'tooltip': 'end time [s] after P-onset for calculating CF for S-picking',
'value': 10.0}, 'value': 10.0,
'namestring': 'S stop'},
'bpz1': {'type': (float, float), 'bpz1': {'type': (float, float),
'tooltip': 'lower/upper corner freq. of first band pass filter Z-comp. [Hz]', 'tooltip': 'lower/upper corner freq. of first band pass filter Z-comp. [Hz]',
'value': (2, 20)}, 'value': (2, 20),
'namestring': ('Z-bandpass 1', 'Lower', 'Upper')},
'bpz2': {'type': (float, float), 'bpz2': {'type': (float, float),
'tooltip': 'lower/upper corner freq. of second band pass filter Z-comp. [Hz]', 'tooltip': 'lower/upper corner freq. of second band pass filter Z-comp. [Hz]',
'value': (2, 30)}, 'value': (2, 30),
'namestring': ('Z-bandpass 2', '', '')},
'bph1': {'type': (float, float), 'bph1': {'type': (float, float),
'tooltip': 'lower/upper corner freq. of first band pass filter H-comp. [Hz]', 'tooltip': 'lower/upper corner freq. of first band pass filter H-comp. [Hz]',
'value': (2, 15)}, 'value': (2, 15),
'namestring': ('H-bandpass 1', 'Lower', 'Upper')},
'bph2': {'type': (float, float), 'bph2': {'type': (float, float),
'tooltip': 'lower/upper corner freq. of second band pass filter z-comp. [Hz]', 'tooltip': 'lower/upper corner freq. of second band pass filter z-comp. [Hz]',
'value': (2, 20)}, 'value': (2, 20),
'namestring': ('H-bandpass 2', '', '')},
'algoP': {'type': str, 'algoP': {'type': str,
'tooltip': 'choose algorithm for P-onset determination (HOS, ARZ, or AR3)', 'tooltip': 'choose algorithm for P-onset determination (HOS, ARZ, or AR3)',
'value': 'HOS'}, 'value': 'HOS',
'namestring': 'P algorithm'},
'tlta': {'type': float, 'tlta': {'type': float,
'tooltip': 'for HOS-/AR-AIC-picker, length of LTA window [s]', 'tooltip': 'for HOS-/AR-AIC-picker, length of LTA window [s]',
'value': 7.0}, 'value': 7.0,
'namestring': 'LTA window'},
'hosorder': {'type': int, 'hosorder': {'type': int,
'tooltip': 'for HOS-picker, order of Higher Order Statistics', 'tooltip': 'for HOS-picker, order of Higher Order Statistics',
'value': 4}, 'value': 4,
'namestring': 'HOS order'},
'Parorder': {'type': int, 'Parorder': {'type': int,
'tooltip': 'for AR-picker, order of AR process of Z-component', 'tooltip': 'for AR-picker, order of AR process of Z-component',
'value': 2}, 'value': 2,
'namestring': 'AR order P'},
'tdet1z': {'type': float, 'tdet1z': {'type': float,
'tooltip': 'for AR-picker, length of AR determination window [s] for Z-component, 1st pick', 'tooltip': 'for AR-picker, length of AR determination window [s] for Z-component, 1st pick',
'value': 1.2}, 'value': 1.2,
'namestring': 'AR det. window Z 1'},
'tpred1z': {'type': float, 'tpred1z': {'type': float,
'tooltip': 'for AR-picker, length of AR prediction window [s] for Z-component, 1st pick', 'tooltip': 'for AR-picker, length of AR prediction window [s] for Z-component, 1st pick',
'value': 0.4}, 'value': 0.4,
'namestring': 'AR pred. window Z 1'},
'tdet2z': {'type': float, 'tdet2z': {'type': float,
'tooltip': 'for AR-picker, length of AR determination window [s] for Z-component, 2nd pick', 'tooltip': 'for AR-picker, length of AR determination window [s] for Z-component, 2nd pick',
'value': 0.6}, 'value': 0.6,
'namestring': 'AR det. window Z 2'},
'tpred2z': {'type': float, 'tpred2z': {'type': float,
'tooltip': 'for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick', 'tooltip': 'for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick',
'value': 0.2}, 'value': 0.2,
'namestring': 'AR pred. window Z 2'},
'addnoise': {'type': float, 'addnoise': {'type': float,
'tooltip': 'add noise to seismogram for stable AR prediction', 'tooltip': 'add noise to seismogram for stable AR prediction',
'value': 0.001}, 'value': 0.001,
'namestring': 'Add noise'},
'tsnrz': {'type': (float, float, float, float), 'tsnrz': {'type': (float, float, float, float),
'tooltip': 'for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]', 'tooltip': 'for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]',
'value': (3, 0.1, 0.5, 1.0)}, 'value': (3, 0.1, 0.5, 1.0),
'namestring': ('SNR windows P', 'Noise', 'Safety', 'Signal', 'Slope')},
'pickwinP': {'type': float, 'pickwinP': {'type': float,
'tooltip': 'for initial AIC pick, length of P-pick window [s]', 'tooltip': 'for initial AIC pick, length of P-pick window [s]',
'value': 3.0}, 'value': 3.0,
'namestring': 'AIC window P'},
'Precalcwin': {'type': float, 'Precalcwin': {'type': float,
'tooltip': 'for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)', 'tooltip': 'for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)',
'value': 6.0}, 'value': 6.0,
'namestring': 'Recal. window P'},
'aictsmooth': {'type': float, 'aictsmooth': {'type': float,
'tooltip': 'for HOS/AR, take average of samples for smoothing of AIC-function [s]', 'tooltip': 'for HOS/AR, take average of samples for smoothing of AIC-function [s]',
'value': 0.2}, 'value': 0.2,
'namestring': 'AIC smooth P'},
'tsmoothP': {'type': float, 'tsmoothP': {'type': float,
'tooltip': 'for HOS/AR, take average of samples for smoothing CF [s]', 'tooltip': 'for HOS/AR, take average of samples for smoothing CF [s]',
'value': 0.1}, 'value': 0.1,
'namestring': 'CF smooth P'},
'ausP': {'type': float, 'ausP': {'type': float,
'tooltip': 'for HOS/AR, artificial uplift of samples (aus) of CF (P)', 'tooltip': 'for HOS/AR, artificial uplift of samples (aus) of CF (P)',
'value': 0.001}, 'value': 0.001,
'namestring': 'Artificial uplift P'},
'nfacP': {'type': float, 'nfacP': {'type': float,
'tooltip': 'for HOS/AR, noise factor for noise level determination (P)', 'tooltip': 'for HOS/AR, noise factor for noise level determination (P)',
'value': 1.3}, 'value': 1.3,
'namestring': 'Noise factor P'},
'algoS': {'type': str, 'algoS': {'type': str,
'tooltip': 'choose algorithm for S-onset determination (ARH or AR3)', 'tooltip': 'choose algorithm for S-onset determination (ARH or AR3)',
'value': 'ARH'}, 'value': 'ARH',
'namestring': 'S algorithm'},
'tdet1h': {'type': float, 'tdet1h': {'type': float,
'tooltip': 'for HOS/AR, length of AR-determination window [s], H-components, 1st pick', 'tooltip': 'for HOS/AR, length of AR-determination window [s], H-components, 1st pick',
'value': 0.8}, 'value': 0.8,
'namestring': 'AR det. window H 1'},
'tpred1h': {'type': float, 'tpred1h': {'type': float,
'tooltip': 'for HOS/AR, length of AR-prediction window [s], H-components, 1st pick', 'tooltip': 'for HOS/AR, length of AR-prediction window [s], H-components, 1st pick',
'value': 0.4}, 'value': 0.4,
'namestring': 'AR pred. window H 1'},
'tdet2h': {'type': float, 'tdet2h': {'type': float,
'tooltip': 'for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick', 'tooltip': 'for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick',
'value': 0.6}, 'value': 0.6,
'namestring': 'AR det. window H 2'},
'tpred2h': {'type': float, 'tpred2h': {'type': float,
'tooltip': 'for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick', 'tooltip': 'for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick',
'value': 0.3}, 'value': 0.3,
'namestring': 'AR pred. window H 2'},
'Sarorder': {'type': int, 'Sarorder': {'type': int,
'tooltip': 'for AR-picker, order of AR process of H-components', 'tooltip': 'for AR-picker, order of AR process of H-components',
'value': 4}, 'value': 4,
'namestring': 'AR order S'},
'Srecalcwin': {'type': float, 'Srecalcwin': {'type': float,
'tooltip': 'for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)', 'tooltip': 'for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)',
'value': 5.0}, 'value': 5.0,
'namestring': 'Recal. window S'},
'pickwinS': {'type': float, 'pickwinS': {'type': float,
'tooltip': 'for initial AIC pick, length of S-pick window [s]', 'tooltip': 'for initial AIC pick, length of S-pick window [s]',
'value': 3.0}, 'value': 3.0,
'namestring': 'AIC window S'},
'tsnrh': {'type': (float, float, float, float), 'tsnrh': {'type': (float, float, float, float),
'tooltip': 'for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]', 'tooltip': 'for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]',
'value': (2, 0.2, 1.5, 0.5)}, 'value': (2, 0.2, 1.5, 0.5),
'namestring': ('SNR windows S', 'Noise', 'Safety', 'Signal', 'Slope')},
'aictsmoothS': {'type': float, 'aictsmoothS': {'type': float,
'tooltip': 'for AIC-picker, take average of samples for smoothing of AIC-function [s]', 'tooltip': 'for AIC-picker, take average of samples for smoothing of AIC-function [s]',
'value': 0.5}, 'value': 0.5,
'namestring': 'AIC smooth S'},
'tsmoothS': {'type': float, 'tsmoothS': {'type': float,
'tooltip': 'for AR-picker, take average of samples for smoothing CF [s] (S)', 'tooltip': 'for AR-picker, take average of samples for smoothing CF [s] (S)',
'value': 0.7}, 'value': 0.7,
'namestring': 'CF smooth S'},
'ausS': {'type': float, 'ausS': {'type': float,
'tooltip': 'for HOS/AR, artificial uplift of samples (aus) of CF (S)', 'tooltip': 'for HOS/AR, artificial uplift of samples (aus) of CF (S)',
'value': 0.9}, 'value': 0.9,
'namestring': 'Artificial uplift S'},
'nfacS': {'type': float, 'nfacS': {'type': float,
'tooltip': 'for AR-picker, noise factor for noise level determination (S)', 'tooltip': 'for AR-picker, noise factor for noise level determination (S)',
'value': 1.5}, 'value': 1.5,
'namestring': 'Noise factor S'},
'minfmweight': {'type': int, 'minfmweight': {'type': int,
'tooltip': 'minimum required P weight for first-motion determination', 'tooltip': 'minimum required P weight for first-motion determination',
'value': 1}, 'value': 1,
'namestring': 'Min. P weight'},
'minFMSNR': {'type': float, 'minFMSNR': {'type': float,
'tooltip': 'miniumum required SNR for first-motion determination', 'tooltip': 'miniumum required SNR for first-motion determination',
'value': 2.}, 'value': 2.,
'namestring': 'Min SNR'},
'fmpickwin': {'type': float, 'fmpickwin': {'type': float,
'tooltip': 'pick window around P onset for calculating zero crossings', 'tooltip': 'pick window around P onset for calculating zero crossings',
'value': 0.2}, 'value': 0.2,
'namestring': 'Zero crossings window'},
'timeerrorsP': {'type': (float, float, float, float), 'timeerrorsP': {'type': (float, float, float, float),
'tooltip': 'discrete time errors [s] corresponding to picking weights [0 1 2 3] for P', 'tooltip': 'discrete time errors [s] corresponding to picking weights [0 1 2 3] for P',
'value': (0.01, 0.02, 0.04, 0.08)}, 'value': (0.01, 0.02, 0.04, 0.08),
'namestring': ('Time errors P', '0', '1', '2', '3')},
'timeerrorsS': {'type': (float, float, float, float), 'timeerrorsS': {'type': (float, float, float, float),
'tooltip': 'discrete time errors [s] corresponding to picking weights [0 1 2 3] for S', 'tooltip': 'discrete time errors [s] corresponding to picking weights [0 1 2 3] for S',
'value': (0.04, 0.08, 0.16, 0.32)}, 'value': (0.04, 0.08, 0.16, 0.32),
'namestring': ('Time errors S', '0', '1', '2', '3')},
'minAICPslope': {'type': float, 'minAICPslope': {'type': float,
'tooltip': 'below this slope [counts/s] the initial P pick is rejected', 'tooltip': 'below this slope [counts/s] the initial P pick is rejected',
'value': 0.8}, 'value': 0.8,
'namestring': 'Min. slope P'},
'minAICPSNR': {'type': float, 'minAICPSNR': {'type': float,
'tooltip': 'below this SNR the initial P pick is rejected', 'tooltip': 'below this SNR the initial P pick is rejected',
'value': 1.1}, 'value': 1.1,
'namestring': 'Min. SNR P'},
'minAICSslope': {'type': float, 'minAICSslope': {'type': float,
'tooltip': 'below this slope [counts/s] the initial S pick is rejected', 'tooltip': 'below this slope [counts/s] the initial S pick is rejected',
'value': 1.}, 'value': 1.,
'namestring': 'Min. slope S'},
'minAICSSNR': {'type': float, 'minAICSSNR': {'type': float,
'tooltip': 'below this SNR the initial S pick is rejected', 'tooltip': 'below this SNR the initial S pick is rejected',
'value': 1.5}, 'value': 1.5,
'namestring': 'Min. SNR S'},
'minsiglength': {'type': float, 'minsiglength': {'type': float,
'tooltip': 'length of signal part for which amplitudes must exceed noiselevel [s]', 'tooltip': 'length of signal part for which amplitudes must exceed noiselevel [s]',
'value': 1.}, 'value': 1.,
'namestring': 'Min. signal length'},
'noisefactor': {'type': float, 'noisefactor': {'type': float,
'tooltip': 'noiselevel*noisefactor=threshold', 'tooltip': 'noiselevel*noisefactor=threshold',
'value': 1.0}, 'value': 1.0,
'namestring': 'Noise factor'},
'minpercent': {'type': float, 'minpercent': {'type': float,
'tooltip': 'required percentage of amplitudes exceeding threshold', 'tooltip': 'required percentage of amplitudes exceeding threshold',
'value': 10.}, 'value': 10.,
'namestring': 'Min amplitude [%]'},
'zfac': {'type': float, 'zfac': {'type': float,
'tooltip': 'P-amplitude must exceed at least zfac times RMS-S amplitude', 'tooltip': 'P-amplitude must exceed at least zfac times RMS-S amplitude',
'value': 1.5}, 'value': 1.5,
'namestring': 'Z factor'},
'mdttolerance': {'type': float, 'mdttolerance': {'type': float,
'tooltip': 'maximum allowed deviation of P picks from median [s]', 'tooltip': 'maximum allowed deviation of P picks from median [s]',
'value': 6.0}, 'value': 6.0,
'namestring': 'Median tolerance'},
'wdttolerance': {'type': float, 'wdttolerance': {'type': float,
'tooltip': 'maximum allowed deviation from Wadati-diagram', 'tooltip': 'maximum allowed deviation from Wadati-diagram',
'value': 1.0}, 'value': 1.0,
'namestring': 'Wadati tolerance'},
'WAscaling': {'type': (float, float, float), 'WAscaling': {'type': (float, float, float),
'tooltip': 'Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm] \ 'tooltip': 'Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm] \
If zeros are set, original Richter magnitude is calculated!', If zeros are set, original Richter magnitude is calculated!',
'value': (0., 0., 0.)}, 'value': (0., 0., 0.),
'namestring': ('Wood-Anderson scaling', '', '', '')},
'magscaling': {'type': (float, float), 'magscaling': {'type': (float, float),
'tooltip': 'Scaling relation for derived local magnitude [a*Ml+b]. \ 'tooltip': 'Scaling relation for derived local magnitude [a*Ml+b]. \
If zeros are set, no scaling of network magnitude is applied!', If zeros are set, no scaling of network magnitude is applied!',
'value': (0., 0.)} 'value': (0., 0.),
'namestring': ('Local mag. scaling', '', '')},
'minfreq': {'type': (float, float),
'tooltip': 'Lower filter frequency [P, S]',
'value': (1.0, 1.0),
'namestring': ('Lower freq.', 'P', 'S')},
'maxfreq': {'type': (float, float),
'tooltip': 'Upper filter frequency [P, S]',
'value': (10.0, 10.0),
'namestring': ('Upper freq.', '', '')},
'filter_order': {'type': (int, int),
'tooltip': 'filter order [P, S]',
'value': (2, 2),
'namestring': ('Order', '', '')},
'filter_type': {'type': (str, str),
'tooltip': 'filter type (bandpass, bandstop, lowpass, highpass) [P, S]',
'value': ('bandpass' , 'bandpass'),
'namestring': ('Type', '', '')}
} }
settings_main={ settings_main={
@ -311,6 +402,11 @@ settings_main={
'localmag':[ 'localmag':[
'WAscaling', 'WAscaling',
'magscaling'], 'magscaling'],
'filter':[
'minfreq',
'maxfreq',
'filter_order',
'filter_type'],
'pick':[ 'pick':[
'extent', 'extent',
'pstart', 'pstart',

14
pylot/core/io/inputs.py
View File

@ -141,7 +141,8 @@ class PylotParameter(object):
all_names += self.get_main_para_names()['nlloc'] all_names += self.get_main_para_names()['nlloc']
all_names += self.get_main_para_names()['smoment'] all_names += self.get_main_para_names()['smoment']
all_names += self.get_main_para_names()['localmag'] all_names += self.get_main_para_names()['localmag']
all_names += self.get_main_para_names()['pick'] all_names += self.get_main_para_names()['pick']
all_names += self.get_main_para_names()['filter']
all_names += self.get_special_para_names()['z'] all_names += self.get_special_para_names()['z']
all_names += self.get_special_para_names()['h'] all_names += self.get_special_para_names()['h']
all_names += self.get_special_para_names()['fm'] all_names += self.get_special_para_names()['fm']
@ -239,6 +240,8 @@ class PylotParameter(object):
'parameters for seismic moment estimation', separator) 'parameters for seismic moment estimation', separator)
self.write_section(fid_out, self.get_main_para_names()['localmag'], self.write_section(fid_out, self.get_main_para_names()['localmag'],
'settings local magnitude', separator) 'settings local magnitude', separator)
self.write_section(fid_out, self.get_main_para_names()['filter'],
'filter settings', separator)
self.write_section(fid_out, self.get_main_para_names()['pick'], self.write_section(fid_out, self.get_main_para_names()['pick'],
'common settings picker', separator) 'common settings picker', separator)
fid_out.write(('#special settings for calculating CF#\n'+ fid_out.write(('#special settings for calculating CF#\n'+
@ -338,12 +341,13 @@ class FilterOptions(object):
def parseFilterOptions(self): def parseFilterOptions(self):
if self: if self:
robject = {'type': self.getFilterType(), 'corners': self.getOrder()} robject = {'type': self.getFilterType(), 'corners': self.getOrder()}
if len(self.getFreq()) > 1: if not self.getFilterType() in ['highpass', 'lowpass']:
robject['freqmin'] = self.getFreq()[0] robject['freqmin'] = self.getFreq()[0]
robject['freqmax'] = self.getFreq()[1] robject['freqmax'] = self.getFreq()[1]
else: elif self.getFilterType() == 'highpass':
robject['freq'] = self.getFreq() if type(self.getFreq()) is \ robject['freq'] = self.getFreq()[0]
float else self.getFreq()[0] elif self.getFilterType() == 'lowpass':
robject['freq'] = self.getFreq()[1]
return robject return robject
return None return None

45
pylot/core/util/defaults.py
View File

@ -12,38 +12,27 @@ from pylot.core.loc import hyposat
from pylot.core.loc import hypo71 from pylot.core.loc import hypo71
from pylot.core.loc import hypodd from pylot.core.loc import hypodd
from pylot.core.loc import velest from pylot.core.loc import velest
from pylot.core.io.inputs import PylotParameter
def readDefaultFilterInformation(fname):
def readFilterInformation(fname): pparam = PylotParameter(fname)
def convert2FreqRange(*args): return readFilterInformation(pparam)
if len(args) > 1:
return [float(arg) for arg in args] def readFilterInformation(pylot_parameter):
elif len(args) == 1: p_filter = {'filtertype': pylot_parameter['filter_type'][0],
return float(args[0]) 'freq': [pylot_parameter['minfreq'][0], pylot_parameter['maxfreq'][0]],
return None 'order': int(pylot_parameter['filter_order'][0])}
s_filter = {'filtertype': pylot_parameter['filter_type'][1],
filter_file = open(fname, 'r') 'freq': [pylot_parameter['minfreq'][1], pylot_parameter['maxfreq'][1]],
filter_information = dict() 'order': int(pylot_parameter['filter_order'][1])}
for filter_line in filter_file.readlines(): filter_information = {'P': p_filter,
filter_line = filter_line.split(' ') 'S': s_filter}
for n, pos in enumerate(filter_line):
if pos == '\n':
filter_line[n] = ''
filter_information[filter_line[0]] = {'filtertype': filter_line[1]
if filter_line[1]
else None,
'order': int(filter_line[2])
if filter_line[1]
else None,
'freq': convert2FreqRange(*filter_line[3:])
if filter_line[1]
else None}
return filter_information return filter_information
FILTERDEFAULTS = readFilterInformation(os.path.join(os.path.expanduser('~'), FILTERDEFAULTS = readDefaultFilterInformation(os.path.join(os.path.expanduser('~'),
'.pylot', '.pylot',
'filter.in')) 'pylot.in'))
TIMEERROR_DEFAULTS = os.path.join(os.path.expanduser('~'), TIMEERROR_DEFAULTS = os.path.join(os.path.expanduser('~'),
'.pylot', '.pylot',

228
pylot/core/util/widgets.py
View File

@ -756,7 +756,10 @@ class PickDlg(QDialog):
else: else:
self.autopicks = {} self.autopicks = {}
self._init_autopicks = {} self._init_autopicks = {}
self.filteroptions = FILTERDEFAULTS if hasattr(self.parent(), 'filteroptions'):
self.filteroptions = self.parent().filteroptions
else:
self.filteroptions = FILTERDEFAULTS
self.pick_block = False self.pick_block = False
self.nextStation = QtGui.QCheckBox('Continue with next station.') self.nextStation = QtGui.QCheckBox('Continue with next station.')
@ -1230,7 +1233,10 @@ class PickDlg(QDialog):
def getFilterOptions(self, phase): def getFilterOptions(self, phase):
options = self.filteroptions[phase[0]] options = self.filteroptions[phase[0]]
return FilterOptions(**options) if type(options) == dict:
return FilterOptions(**options)
else:
return options
def getXLims(self): def getXLims(self):
return self.cur_xlim return self.cur_xlim
@ -2142,7 +2148,7 @@ class TuneAutopicker(QWidget):
return parameters return parameters
def set_stretch(self): def set_stretch(self):
self.tune_layout.setStretch(0, 3) self.tune_layout.setStretch(0, 2)
self.tune_layout.setStretch(1, 1) self.tune_layout.setStretch(1, 1)
def clear_all(self): def clear_all(self):
@ -2173,10 +2179,12 @@ class TuneAutopicker(QWidget):
self.qmb.show() self.qmb.show()
class PylotParaBox(QtGui.QWidget): class PylotParaBox(QtGui.QWidget):
accepted = QtCore.Signal(str)
rejected = QtCore.Signal(str)
def __init__(self, parameter, parent=None): def __init__(self, parameter, parent=None):
''' '''
Generate Widget containing parameters for automatic picking algorithm. Generate Widget containing parameters for PyLoT.
:param: parameter :param: parameter
:type: PylotParameter (object) :type: PylotParameter (object)
@ -2200,7 +2208,9 @@ class PylotParaBox(QtGui.QWidget):
self.params_to_gui() self.params_to_gui()
self._toggle_advanced_settings() self._toggle_advanced_settings()
self.resize(720, 1280) self.resize(720, 1280)
self.setWindowModality(QtCore.Qt.WindowModality.ApplicationModal) self.setWindowModality(QtCore.Qt.WindowModality.ApplicationModal)
self.accepted.connect(self.params_from_gui)
self.rejected.connect(self.params_to_gui)
def _init_sublayouts(self): def _init_sublayouts(self):
self._main_layout = QtGui.QVBoxLayout() self._main_layout = QtGui.QVBoxLayout()
@ -2231,10 +2241,9 @@ class PylotParaBox(QtGui.QWidget):
self._dialog_buttons.addWidget(self._okay) self._dialog_buttons.addWidget(self._okay)
self._dialog_buttons.addWidget(self._close) self._dialog_buttons.addWidget(self._close)
self._dialog_buttons.addWidget(self._apply) self._dialog_buttons.addWidget(self._apply)
self._okay.clicked.connect(self.params_from_gui) self._okay.clicked.connect(self.accept)
self._okay.clicked.connect(self.close) self._okay.clicked.connect(self.close)
self._apply.clicked.connect(self.params_from_gui) self._apply.clicked.connect(self.accept)
self._close.clicked.connect(self.params_to_gui)
self._close.clicked.connect(self.close) self._close.clicked.connect(self.close)
self.layout.addLayout(self._dialog_buttons) self.layout.addLayout(self._dialog_buttons)
@ -2277,8 +2286,6 @@ class PylotParaBox(QtGui.QWidget):
grid = QtGui.QGridLayout() grid = QtGui.QGridLayout()
for index1, name in enumerate(parameter_names): for index1, name in enumerate(parameter_names):
text = name + ' [?]'
label = QtGui.QLabel(text)
default_item = self.parameter.get_defaults()[name] default_item = self.parameter.get_defaults()[name]
tooltip = default_item['tooltip'] tooltip = default_item['tooltip']
tooltip += ' | type: {}'.format(default_item['type']) tooltip += ' | type: {}'.format(default_item['type'])
@ -2286,14 +2293,19 @@ class PylotParaBox(QtGui.QWidget):
typ = default_item['type'] typ = default_item['type']
box = self.create_box(typ, tooltip) box = self.create_box(typ, tooltip)
self.boxes[name] = box self.boxes[name] = box
namestring = default_item['namestring']
elif type(default_item['type']) == tuple: elif type(default_item['type']) == tuple:
boxes = [] boxes = []
values = self.parameter[name] values = self.parameter[name]
for index2, val in enumerate(values): for index2, val in enumerate(values):
typ = default_item['type'][index2] typ = default_item['type'][index2]
boxes.append(self.create_box(typ, tooltip)) boxes.append(self.create_box(typ, tooltip))
box = self.create_multi_box(boxes) headline = default_item['namestring'][1:]
box, lower = self.create_multi_box(boxes, headline)
self.boxes[name] = boxes self.boxes[name] = boxes
namestring = default_item['namestring'][0]
text = namestring + ' [?]'
label = QtGui.QLabel(text)
self.labels[name] = label self.labels[name] = label
label.setToolTip(tooltip) label.setToolTip(tooltip)
grid.addWidget(label, index1, 1) grid.addWidget(label, index1, 1)
@ -2305,8 +2317,8 @@ class PylotParaBox(QtGui.QWidget):
box = QtGui.QLineEdit() box = QtGui.QLineEdit()
elif typ == float: elif typ == float:
box = QtGui.QDoubleSpinBox() box = QtGui.QDoubleSpinBox()
box.setDecimals(5) box.setDecimals(4)
box.setRange(-10e5, 10e5) box.setRange(-10e4, 10e4)
elif typ == int: elif typ == int:
box = QtGui.QSpinBox() box = QtGui.QSpinBox()
elif typ == bool: elif typ == bool:
@ -2315,13 +2327,20 @@ class PylotParaBox(QtGui.QWidget):
raise TypeError('Unrecognized type {}'.format(typ)) raise TypeError('Unrecognized type {}'.format(typ))
return box return box
def create_multi_box(self, boxes): def create_multi_box(self, boxes, headline=None):
box = QtGui.QWidget() box = QtGui.QWidget()
hl = QtGui.QVBoxLayout() gl = QtGui.QGridLayout()
for b in boxes: row = 0
hl.addWidget(b) if headline:
box.setLayout(hl) for index, item in enumerate(headline):
return box if not item:
continue
gl.addWidget(QtGui.QLabel(item), 0, index, 4)
row = 1
for index, b in enumerate(boxes):
gl.addWidget(b, row, index)
box.setLayout(gl)
return box, row
def add_tab(self, layout, name): def add_tab(self, layout, name):
widget = QtGui.QWidget() widget = QtGui.QWidget()
@ -2340,8 +2359,10 @@ class PylotParaBox(QtGui.QWidget):
self.parameter.get_main_para_names()['smoment'], 2) self.parameter.get_main_para_names()['smoment'], 2)
self.add_to_layout(self._main_layout, 'Local Magnitude', self.add_to_layout(self._main_layout, 'Local Magnitude',
self.parameter.get_main_para_names()['localmag'], 3) self.parameter.get_main_para_names()['localmag'], 3)
self.add_to_layout(self._main_layout, 'Filter Settings',
self.parameter.get_main_para_names()['filter'], 4)
self.add_to_layout(self._main_layout, 'Common Settings Characteristic Function', self.add_to_layout(self._main_layout, 'Common Settings Characteristic Function',
self.parameter.get_main_para_names()['pick'], 4) self.parameter.get_main_para_names()['pick'], 5)
self.add_tab(self._main_layout, 'Main Settings') self.add_tab(self._main_layout, 'Main Settings')
def add_special_pick_parameters_tab(self): def add_special_pick_parameters_tab(self):
@ -2355,10 +2376,10 @@ class PylotParaBox(QtGui.QWidget):
self.parameter.get_special_para_names()['quality'], 4) self.parameter.get_special_para_names()['quality'], 4)
self.add_tab(self._advanced_layout, 'Advanced Settings') self.add_tab(self._advanced_layout, 'Advanced Settings')
# def gen_h_seperator(self): # def gen_h_separator(self):
# seperator = QtGui.QFrame() # separator = QtGui.QFrame()
# seperator.setFrameShape(QtGui.QFrame.HLine) # separator.setFrameShape(QtGui.QFrame.HLine)
# return seperator # return separator
# def gen_headline(self, text): # def gen_headline(self, text):
# label=QtGui.QLabel(text) # label=QtGui.QLabel(text)
@ -2559,7 +2580,14 @@ class PylotParaBox(QtGui.QWidget):
self._exclusive_dialog.close() self._exclusive_dialog.close()
self._exclusive_widgets = [] self._exclusive_widgets = []
QtGui.QWidget.show(self) QtGui.QWidget.show(self)
def close(self):
self.rejected.emit('reject')
QtGui.QWidget.close(self)
def accept(self):
self.accepted.emit('accept')
def _warn(self, message): def _warn(self, message):
self.qmb = QtGui.QMessageBox(QtGui.QMessageBox.Icon.Warning, self.qmb = QtGui.QMessageBox(QtGui.QMessageBox.Icon.Warning,
'Warning', message) 'Warning', message)
@ -3095,13 +3123,65 @@ class FilterOptionsDialog(QDialog):
adjust parameters for filtering seismic data. adjust parameters for filtering seismic data.
""" """
super(FilterOptionsDialog, self).__init__() super(FilterOptionsDialog, self).__init__()
if parent is not None and parent.getFilters():
if parent is not None and parent.getFilterOptions(): self.filterOptions = parent.getFilters()
self.filterOptions = parent.getFilterOptions() # elif filterOptions is not None:
elif filterOptions is not None: # self.filterOptions = filterOptions
self.filterOptions = FilterOptions(filterOptions)
else: else:
self.filterOptions = FilterOptions() self.filterOptions = {'P': FilterOptions(),
'S': FilterOptions()}
self.setWindowTitle(titleString)
self.filterOptionWidgets = {'P': FilterOptionsWidget(self.filterOptions['P']),
'S': FilterOptionsWidget(self.filterOptions['S'])}
self.setupUi()
self.updateUi()
self.connectButtons()
def setupUi(self):
self.main_layout = QtGui.QVBoxLayout()
self.filter_layout = QtGui.QHBoxLayout()
self.groupBoxes = {'P': QtGui.QGroupBox('P Filter'),
'S': QtGui.QGroupBox('S Filter')}
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok |
QDialogButtonBox.Cancel)
for key in ['P', 'S']:
groupbox = self.groupBoxes[key]
box_layout = QtGui.QVBoxLayout()
groupbox.setLayout(box_layout)
self.filter_layout.addWidget(groupbox)
box_layout.addWidget(self.filterOptionWidgets[key])
self.main_layout.addLayout(self.filter_layout)
self.main_layout.addWidget(self.buttonBox)
self.setLayout(self.main_layout)
def connectButtons(self):
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def accept(self):
self.updateUi()
QDialog.accept(self)
def updateUi(self):
returnvals = []
for foWidget in self.filterOptionWidgets.values():
foWidget.updateUi()
def getFilterOptions(self):
filteroptions = {'P': self.filterOptionWidgets['P'].getFilterOptions(),
'S': self.filterOptionWidgets['S'].getFilterOptions()}
return filteroptions
class FilterOptionsWidget(QWidget):
def __init__(self, filterOptions):
super(FilterOptionsWidget, self).__init__()
self.filterOptions = filterOptions
_enable = True _enable = True
if self.getFilterOptions().getFilterType() is None: if self.getFilterOptions().getFilterType() is None:
@ -3112,6 +3192,7 @@ class FilterOptionsDialog(QDialog):
self.freqminSpinBox = QDoubleSpinBox() self.freqminSpinBox = QDoubleSpinBox()
self.freqminSpinBox.setRange(5e-7, 1e6) self.freqminSpinBox.setRange(5e-7, 1e6)
self.freqminSpinBox.setDecimals(2) self.freqminSpinBox.setDecimals(2)
self.freqminSpinBox.setSingleStep(0.01)
self.freqminSpinBox.setSuffix(' Hz') self.freqminSpinBox.setSuffix(' Hz')
self.freqminSpinBox.setEnabled(_enable) self.freqminSpinBox.setEnabled(_enable)
@ -3120,22 +3201,23 @@ class FilterOptionsDialog(QDialog):
self.freqmaxSpinBox = QDoubleSpinBox() self.freqmaxSpinBox = QDoubleSpinBox()
self.freqmaxSpinBox.setRange(5e-7, 1e6) self.freqmaxSpinBox.setRange(5e-7, 1e6)
self.freqmaxSpinBox.setDecimals(2) self.freqmaxSpinBox.setDecimals(2)
self.freqmaxSpinBox.setSingleStep(0.01)
self.freqmaxSpinBox.setSuffix(' Hz') self.freqmaxSpinBox.setSuffix(' Hz')
if _enable: # if _enable:
# self.freqminSpinBox.setValue(self.getFilterOptions().getFreq()[0])
# if self.getFilterOptions().getFilterType() in ['bandpass',
# 'bandstop']:
# self.freqmaxSpinBox.setValue(
# self.getFilterOptions().getFreq()[1])
# else:
try:
self.freqminSpinBox.setValue(self.getFilterOptions().getFreq()[0]) self.freqminSpinBox.setValue(self.getFilterOptions().getFreq()[0])
if self.getFilterOptions().getFilterType() in ['bandpass', self.freqmaxSpinBox.setValue(self.getFilterOptions().getFreq()[1])
'bandstop']: except TypeError as e:
self.freqmaxSpinBox.setValue( print(e)
self.getFilterOptions().getFreq()[1]) self.freqmaxSpinBox.setValue(1.)
else: self.freqminSpinBox.setValue(.1)
try:
self.freqmaxSpinBox.setValue(self.getFilterOptions().getFreq())
self.freqminSpinBox.setValue(self.getFilterOptions().getFreq())
except TypeError as e:
print(e)
self.freqmaxSpinBox.setValue(1.)
self.freqminSpinBox.setValue(.1)
typeOptions = [None, "bandpass", "bandstop", "lowpass", "highpass"] typeOptions = [None, "bandpass", "bandstop", "lowpass", "highpass"]
@ -3165,44 +3247,60 @@ class FilterOptionsDialog(QDialog):
self.freqmaxSpinBox.setEnabled(_enable) self.freqmaxSpinBox.setEnabled(_enable)
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | try:
QDialogButtonBox.Cancel) self.orderSpinBox.setValue(self.getFilterOptions().getOrder())
except:
self.orderSpinBox.setValue(2)
grid = QGridLayout() grid = QGridLayout()
grid.addWidget(self.freqGroupBox, 0, 2, 1, 2) grid.addWidget(self.freqGroupBox, 0, 2, 1, 2)
grid.addLayout(self.selectTypeLayout, 1, 2, 1, 2) grid.addLayout(self.selectTypeLayout, 1, 2, 1, 2)
grid.addWidget(self.buttonBox, 2, 2, 1, 2)
self.setLayout(grid) self.setLayout(grid)
self.freqminSpinBox.valueChanged.connect(self.updateUi) self.freqminSpinBox.valueChanged.connect(self.checkMin)
self.freqmaxSpinBox.valueChanged.connect(self.updateUi) self.freqmaxSpinBox.valueChanged.connect(self.checkMax)
self.orderSpinBox.valueChanged.connect(self.updateUi) self.orderSpinBox.valueChanged.connect(self.updateUi)
self.selectTypeCombo.currentIndexChanged.connect(self.updateUi) self.selectTypeCombo.currentIndexChanged.connect(self.updateUi)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def checkMin(self):
if not self.freqminSpinBox.value() <= self.freqmaxSpinBox.value():
self.freqmaxSpinBox.setValue(self.freqminSpinBox.value())
def checkMax(self):
if not self.freqminSpinBox.value() <= self.freqmaxSpinBox.value():
self.freqminSpinBox.setValue(self.freqmaxSpinBox.value())
def updateUi(self): def updateUi(self):
type = self.selectTypeCombo.currentText() type = self.selectTypeCombo.currentText()
_enable = type in ['bandpass', 'bandstop'] _enable = type in ['bandpass', 'bandstop']
freq = [self.freqminSpinBox.value(), self.freqmaxSpinBox.value()] freq = [self.freqminSpinBox.value(), self.freqmaxSpinBox.value()]
self.freqmaxLabel.setEnabled(_enable) self.freqmaxLabel.setEnabled(True)
self.freqmaxSpinBox.setEnabled(_enable) self.freqmaxSpinBox.setEnabled(True)
self.freqminLabel.setEnabled(True)
self.freqminSpinBox.setEnabled(True)
self.freqminLabel.setText("minimum:")
self.freqmaxLabel.setText("maximum:")
if not _enable: if not _enable:
self.freqminLabel.setText("cutoff:") if type == 'highpass':
self.freqmaxSpinBox.setValue(freq[0]) self.freqminLabel.setText("cutoff:")
freq.remove(freq[1]) self.freqmaxLabel.setEnabled(False)
self.freqmaxSpinBox.setEnabled(False)
elif type == 'lowpass':
self.freqmaxLabel.setText("cutoff:")
self.freqminLabel.setEnabled(False)
self.freqminSpinBox.setEnabled(False)
else: else:
self.freqminLabel.setText("minimum:")
if not isSorted(freq): if not isSorted(freq):
QMessageBox.warning(self, "Value error", QMessageBox.warning(self, "Value error",
"Maximum frequency must be at least the " "Maximum frequency must be at least the "
"same value as minimum frequency (notch)!") "same value as minimum frequency (notch)! "
self.freqmaxSpinBox.setValue(freq[0]) "Adjusted maximum frequency automatically!")
freq[1] = freq[0]
self.freqmaxSpinBox.setValue(freq[1])
self.freqmaxSpinBox.selectAll() self.freqmaxSpinBox.selectAll()
self.freqmaxSpinBox.setFocus() self.freqmaxSpinBox.setFocus()
return
self.getFilterOptions().setFilterType(type) self.getFilterOptions().setFilterType(type)
self.getFilterOptions().setFreq(freq) self.getFilterOptions().setFreq(freq)
@ -3218,10 +3316,6 @@ class FilterOptionsDialog(QDialog):
return dlg.getFilterOptions() return dlg.getFilterOptions()
return None return None
def accept(self):
self.updateUi()
QDialog.accept(self)
class LoadDataDlg(QDialog): class LoadDataDlg(QDialog):
def __init__(self, parent=None): def __init__(self, parent=None):