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

Merge branch 'develop' of ariadne.geophysik.ruhr-uni-bochum.de:/data/git/pylot into develop

Browse Source
This commit is contained in:
Sebastian Wehling-Benatelli 2015-10-20 12:02:01 +02:00
commit 0064ff1889
10 changed files with 656 additions and 980 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
pylot/core/active/activeSeismoPick.py
View File

@ -19,6 +19,7 @@ class Survey(object):
self.setParametersForShots() self.setParametersForShots()
self._removeAllEmptyTraces() self._removeAllEmptyTraces()
self._updateShots() self._updateShots()
self.setArtificialPick(0, 0) # artificial pick at source origin
def _generateSurvey(self): def _generateSurvey(self):
from obspy.core import read from obspy.core import read
@ -34,17 +35,23 @@ class Survey(object):
shot_dict[shotnumber] = seismicshot.SeismicShot(obsfile) shot_dict[shotnumber] = seismicshot.SeismicShot(obsfile)
shot_dict[shotnumber].setParameters('shotnumber', shotnumber) shot_dict[shotnumber].setParameters('shotnumber', shotnumber)
self.setArtificialPick(0, 0) # artificial pick at source origin
self.data = shot_dict self.data = shot_dict
print ("Generated Survey object for %d shots" % len(shotlist)) print ("Generated Survey object for %d shots" % len(shotlist))
print ("Total number of traces: %d \n" %self.countAllTraces()) print ("Total number of traces: %d \n" %self.countAllTraces())
def setArtificialPick(self, traceID, pick):
'''
Sets an artificial pick for a traceID of all shots in the survey object.
(This can be used to create a pick with t = 0 at the source origin)
'''
for shot in self.data.values():
shot.setPick(traceID, pick)
def setParametersForShots(self, cutwindow = (0, 0.2), tmovwind = 0.3, tsignal = 0.03, tgap = 0.0007): def setParametersForShots(self, cutwindow = (0, 0.2), tmovwind = 0.3, tsignal = 0.03, tgap = 0.0007):
if (cutwindow == (0, 0.2) and tmovwind == 0.3 and if (cutwindow == (0, 0.2) and tmovwind == 0.3 and
tsignal == 0.03 and tgap == 0.0007): tsignal == 0.03 and tgap == 0.0007):
print ("Warning: Standard values used for " print ("Warning: Standard values used for "
"setParamters. This may not be clever.") "setParamters. This might not be clever.")
# CHANGE this later. Parameters only needed for survey, not for each shot. # CHANGE this later. Parameters only needed for survey, not for each shot.
for shot in self.data.values(): for shot in self.data.values():
shot.setCut(cutwindow) shot.setCut(cutwindow)
@ -121,14 +128,13 @@ class Survey(object):
shot.setPickwindow(traceID, pickwin_used) shot.setPickwindow(traceID, pickwin_used)
shot.pickTraces(traceID, windowsize, folm, HosAic) # picker shot.pickTraces(traceID, windowsize, folm, HosAic) # picker
# ++ TEST: set and check SNR before adding to distance bin ############################
shot.setSNR(traceID) shot.setSNR(traceID)
#if shot.getSNR(traceID)[0] < snrthreshold: #if shot.getSNR(traceID)[0] < snrthreshold:
if shot.getSNR(traceID)[0] < shot.getSNRthreshold(traceID): if shot.getSNR(traceID)[0] < shot.getSNRthreshold(traceID):
shot.removePick(traceID) shot.removePick(traceID)
# -- TEST: set and check SNR before adding to distance bin ############################
if shot.getPick(traceID) is not None: # set epp and lpp if SNR > 1 (else earllatepicker cant set values)
if shot.getSNR(traceID)[0] > 1:
shot.setEarllatepick(traceID) shot.setEarllatepick(traceID)
tpicksum += (datetime.now() - tstartpick); tpick = tpicksum/count tpicksum += (datetime.now() - tstartpick); tpick = tpicksum/count
@ -138,6 +144,22 @@ class Survey(object):
self._update_progress(shot.getShotname(), tend, progress) self._update_progress(shot.getShotname(), tend, progress)
print('\npickAllShots: Finished\n') print('\npickAllShots: Finished\n')
def recover(self):
'''
Recovers all (accidently) removed picks. Still regards SNR threshold.
'''
print('Recovering survey...')
numpicks = 0
for shot in self.data.values():
for traceID in shot.getTraceIDlist():
if shot.getFlag(traceID) == 0:
shot.setFlag(traceID, 1)
if shot.getSNR(traceID)[0] < shot.getSNRthreshold(traceID):
shot.removePick(traceID)
else:
numpicks += 1
print('Recovered %d picks'%numpicks)
def setArtificialPick(self, traceID, pick): def setArtificialPick(self, traceID, pick):
for shot in self.data.values(): for shot in self.data.values():
shot.setPick(traceID, pick) shot.setPick(traceID, pick)
@ -195,7 +217,7 @@ class Survey(object):
for traceID in shot.getTraceIDlist(): for traceID in shot.getTraceIDlist():
snrlist.append(shot.getSNR(traceID)[0]) snrlist.append(shot.getSNR(traceID)[0])
dist.append(shot.getDistance(traceID)) dist.append(shot.getDistance(traceID))
if shot.getPick(traceID) is not None: if shot.getFlag(traceID) is not 0:
pickedTraces += 1 pickedTraces += 1
info_dict[shot.getShotnumber()] = {'numtraces': numtraces, info_dict[shot.getShotnumber()] = {'numtraces': numtraces,
'picked traces': [pickedTraces, 'picked traces': [pickedTraces,
@ -236,7 +258,7 @@ class Survey(object):
traceIDlist.sort() traceIDlist.sort()
ttfile.writelines(str(self.countPickedTraces(shot)) + '\n') ttfile.writelines(str(self.countPickedTraces(shot)) + '\n')
for traceID in traceIDlist: for traceID in traceIDlist:
if shot.getPick(traceID) is not None: if shot.getFlag(traceID) is not 0:
pick = shot.getPick(traceID) * fmtomo_factor pick = shot.getPick(traceID) * fmtomo_factor
delta = shot.getPickError(traceID) * fmtomo_factor delta = shot.getPickError(traceID) * fmtomo_factor
(x, y, z) = shot.getRecLoc(traceID) (x, y, z) = shot.getRecLoc(traceID)
@ -253,14 +275,87 @@ class Survey(object):
def countPickedTraces(self, shot): def countPickedTraces(self, shot):
count = 0 count = 0
for traceID in shot.getTraceIDlist(): for traceID in shot.getTraceIDlist():
if shot.getPick(traceID) is not None: if shot.getFlag(traceID) is not 0:
count += 1 count += 1
return count return count
def plotAllPicks(self, plotDeleted = False): def countAllPickedTraces(self):
count = 0
for shot in self.data.values():
for traceID in shot.getTraceIDlist():
if shot.getFlag(traceID) is not 0:
count += 1
return count
def plotAllShots(self, rows = 3, columns = 4):
''' '''
Plots all picks over the distance between source and receiver. Returns (ax, region) Plots all shots as Matrices with the color corresponding to the traveltime for each receiver.
IMPORTANT NOTE: Topography (z - coordinate) is not considered in the diagrams!
''' '''
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
plt.interactive(True)
fig = plt.figure()
ax = fig.add_subplot(111)
figPerSubplot = columns * rows
index = 1
#shotnames = []
#shotnumbers = []
# for shot in self.data.values():
# shotnames.append(shot.getShotname())
# shotnumbers.append(shot.getShotnumber())
# shotnumbers = [shotnumbers for (shotnumbers, shotnames) in sorted(zip(shotnumbers, shotnames))]
for shotnumber in self.getShotlist():
if index <= figPerSubplot:
#ax = fig.add_subplot(3,3,i, projection = '3d', title = 'shot:'
#+str(shot_dict[shotnumber].getShotnumber()), xlabel = 'X', ylabel = 'Y', zlabel = 'traveltime')
#shot_dict[shotnumber].plot3dttc(ax = ax, plotpicks = True)
ax = fig.add_subplot(3, 4, index)
self.getShot(shotnumber).matshow(ax = ax, colorbar = False, annotations = True)
index += 1
if index > figPerSubplot:
fig.subplots_adjust(left = 0, bottom = 0, right = 1, top = 1, wspace = 0, hspace = 0)
fig = plt.figure()
index = 1
fig.subplots_adjust(left = 0, bottom = 0, right = 1, top = 1, wspace = 0, hspace = 0)
def plotAllPicks(self, plotRemoved = False, colorByVal = 'log10SNR', ax = None, refreshPlot = False):
'''
Plots all picks over the distance between source and receiver. Returns (ax, region).
Picks can be checked and removed by using region class (pylot.core.active.surveyPlotTools.regions)
:param: plotRemoved, if True plots traces that were picked but removed from the survey (flag = 0)
:type: logical
:param: colorByVal, can be "log10SNR", "pickerror", or "spe"
:type: str
Examples:
regions.chooseRectangles():
- lets the user choose several rectangular regions in the plot
regions.plotTracesInRegions():
- creates plots (shot.plot_traces) for all traces in the active regions (i.e. chosen by e.g. chooseRectangles)
regions.setActiveRegionsForDeletion():
- highlights all shots in a the active regions for deletion
regions.deleteMarkedPicks():
- deletes the picks (pick flag set to 0) for all shots set for deletion
regions.deselectSelection(number):
- deselects the region of number = number
'''
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
import math import math
plt.interactive(True) plt.interactive(True)
@ -268,30 +363,40 @@ class Survey(object):
dist = [] dist = []
pick = [] pick = []
snrloglist = [] snrlog = []
pickerror = []
spe = []
for shot in self.data.values(): for shot in self.data.values():
for traceID in shot.getTraceIDlist(): for traceID in shot.getTraceIDlist():
if plotDeleted == False: if plotRemoved == False:
if shot.getPick(traceID) is not None: if shot.getFlag(traceID) is not 0 or plotRemoved == True:
dist.append(shot.getDistance(traceID)) dist.append(shot.getDistance(traceID))
pick.append(shot.getPick(traceID)) pick.append(shot.getPick(traceID))
snrloglist.append(math.log10(shot.getSNR(traceID)[0])) snrlog.append(math.log10(shot.getSNR(traceID)[0]))
elif plotDeleted == True: pickerror.append(shot.getPickError(traceID))
dist.append(shot.getDistance(traceID)) spe.append(shot.getSymmetricPickError(traceID))
pick.append(shot.getPick(traceID))
snrloglist.append(math.log10(shot.getSNR(traceID)[0]))
ax = self.createPlot(dist, pick, snrloglist, label = 'log10(SNR)') color = {'log10SNR': snrlog,
region = regions(ax, self.data) 'pickerror': pickerror,
'spe': spe}
if refreshPlot is False:
ax = self.createPlot(dist, pick, color[colorByVal], label = '%s'%colorByVal)
region = regions(ax, self)
ax.legend() ax.legend()
return ax, region return ax, region
elif refreshPlot is True:
ax = self.createPlot(dist, pick, color[colorByVal], label = '%s'%colorByVal, ax = ax)
ax.legend()
return ax
def createPlot(self, dist, pick, inkByVal, label): def createPlot(self, dist, pick, inkByVal, label, ax = None):
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
plt.interactive(True) plt.interactive(True)
cm = plt.cm.jet cm = plt.cm.jet
if ax is None:
print('Generating new plot...')
fig = plt.figure() fig = plt.figure()
ax = fig.add_subplot(111) ax = fig.add_subplot(111)
fig = ax.scatter(dist, pick, cmap = cm, c = inkByVal, s = 5, edgecolors = 'none', label = label) fig = ax.scatter(dist, pick, cmap = cm, c = inkByVal, s = 5, edgecolors = 'none', label = label)
@ -300,6 +405,8 @@ class Survey(object):
plt.title('Plot of all Picks') plt.title('Plot of all Picks')
plt.xlabel('Distance [m]') plt.xlabel('Distance [m]')
plt.ylabel('Time [s]') plt.ylabel('Time [s]')
else:
ax.scatter(dist, pick, cmap = cm, c = inkByVal, s = 5, edgecolors = 'none', label = label)
return ax return ax

5
pylot/core/active/fmtomo2vtk.py
View File

@ -128,7 +128,12 @@ def rays2VTK(fnin, fdirout = './vtk_files/', nthPoint = 50):
raynumber += 1 raynumber += 1
firstline = infile.readline() firstline = infile.readline()
if firstline == '': break # break at EOF if firstline == '': break # break at EOF
raynumber = int(firstline.split()[0])
shotnumber = int(firstline.split()[1]) shotnumber = int(firstline.split()[1])
rayValid = int(firstline.split()[4]) # is zero if the ray is invalid
if rayValid == 0:
print('Invalid ray number %d for shot number %d'%(raynumber, shotnumber))
continue
nRayPoints = int(infile.readline().split()[0]) nRayPoints = int(infile.readline().split()[0])
if not shotnumber in rays.keys(): if not shotnumber in rays.keys():
rays[shotnumber] = {} rays[shotnumber] = {}

107
pylot/core/active/picking_script.py
View File

@ -1,107 +0,0 @@
# -*- coding: utf-8 -*-
import sys
from obspy import read
from obspy import Stream
from obspy import Trace
from datetime import datetime
import numpy as np
from pylot.core.active import surveyUtils
from pylot.core.active import seismicshot
import activeSeismoPick
reload(seismicshot)
reload(surveyUtils)
#####################################################################################
# parameter definitions:#############################################################
#traceslist = list(np.arange(1, 49, 1)) # traces (1-48)
#shotlist = list(np.arange(302, 352, 1)) # shot-files(.dat) (Paffrath: 302-352) (Hauburg: 353-401) (arange+1!)
cutwindow = (0, 0.2) # cut out a part of the trace [seconds]
tmovwind = 0.3 # size of the moving window
windowsize = (5, 0) # windowsize for AIC picker (indices around HOS picks!!)
pickwindow = cutwindow # for local max and threshold picker: fraction of the seismogram used (0...1) TO BE DONE: depends on cutwindow!!!!
folm = 0.6
rockeskyll = False
if rockeskyll == True:
receiverfile = "Geophone_interpoliert_rockes"
sourcefile = "Schusspunkte_rockes"
obsdir = "/rscratch/minos22/marcel/flachseismik/rockeskyll_200615_270615/"
filename = 'survey_rockes.pickle'
else:
receiverfile = "Geophone_interpoliert_GZB"
sourcefile = "Schusspunkte_GZB"
obsdir = "/rscratch/minos22/marcel/flachseismik/GZB_26_06_15_01/"
filename = 'survey_GZB.pickle'
# SNR
tsignal = 0.03
tgap = 0.0007
snrthreshold = 1
######################################################################################
vmin = 333
vmax = 5500
distBinSize = 2
###########################################
############# Settings: ###################
thresholdpick=True
localmaxpick=False
if thresholdpick == True: pickmethod = "threshold"
if localmaxpick == True: pickmethod = "localmax"
HosAic = 'hos' # can be 'hos' or 'aic'
###########################################
starttime = datetime.now()
print '\n--------------------Starting Script at %s -------------------\n' %starttime.time()
if thresholdpick == True: print 'Using treshold pickmethod!\n'
elif localmaxpick == True: print 'Using local maximum pick method!\n'
if HosAic == 'aic': print 'picking with AIC\n'
if HosAic == 'hos': print 'picking with HOS\n'
survey = activeSeismoPick.Survey(obsdir, sourcefile, receiverfile, True)
surveyUtils.setFittedSNR(survey.getShotDict())
print '\nDone after %s seconds!\n------------------------------------------------------------------------------\n' % (datetime.now() - starttime).seconds
count = 0; tpicksum = starttime - starttime
for shot in survey.data.values():
tstartpick = datetime.now(); count += 1
for traceID in shot.getTraceIDlist():
distance = shot.getDistance(traceID) # receive distance
pickwin_used = pickwindow # use pickwindow set in the parameter section
# for higher distances use a linear vmin/vmax to cut out late/early regions with high noise
if distance > 5.:
pwleft = distance/vmax ################## TEST
pwright = distance/vmin
if pwright > cutwindow[1]:
pwright = cutwindow[1]
pickwin_used = (pwleft, pwright)
shot.setPickwindow(traceID, pickwin_used)
shot.pickTraces(traceID, windowsize, folm, HosAic) # picker
#shot.setManualPicks(traceID, picklist) # set manual picks if given (yet used on 2D only)
# ++ TEST: set and check SNR before adding to distance bin ############################
shot.setSNR(traceID)
#if shot.getSNR(traceID)[0] < snrthreshold:
if shot.getSNR(traceID)[0] < shot.getSNRthreshold(traceID):
shot.removePick(traceID)
# -- TEST: set and check SNR before adding to distance bin ############################
if shot.getPick(traceID) is not None:
shot.setEarllatepick(traceID)
tpicksum += (datetime.now() - tstartpick); tpick = tpicksum/count
tremain = (tpick * (len(survey.getShotDict()) - count))
tend = datetime.now() + tremain
print 'shot: %s, est. time to be finished is %s:%s:%s' % (shot.getShotname(), tend.hour, tend.minute, tend.second)
survey.saveSurvey(filename)
print '\n--- Finished script ---'
print 'Elapsed time:', datetime.now()-starttime

6
pylot/core/active/seismicArrayPreparation.py
View File

@ -491,7 +491,11 @@ class SeisArray(object):
plt.legend() plt.legend()
if annotations == True: if annotations == True:
for traceID in self.getReceiverCoordinates().keys(): for traceID in self.getReceiverCoordinates().keys():
plt.annotate(str(traceID), xy = (self._getXreceiver(traceID), self._getYreceiver(traceID)), fontsize = 'x-small') plt.annotate((' ' + str(traceID)), xy = (self._getXreceiver(traceID), self._getYreceiver(traceID)), fontsize = 'x-small', color = 'k')
for shotnumber in self.getSourceLocations().keys():
plt.annotate((' ' + str(shotnumber)), xy = (self._getXshot(shotnumber), self._getYshot(shotnumber)), fontsize = 'x-small', color = 'b')
def plotArray3D(self, ax = None): def plotArray3D(self, ax = None):
import matplotlib.pyplot as plt import matplotlib.pyplot as plt

666
pylot/core/active/seismicArrayPreperation.py
View File

@ -1,666 +0,0 @@
# -*- coding: utf-8 -*-
import sys
import numpy as np
from scipy.interpolate import griddata
class SeisArray(object):
'''
Can be used to interpolate missing values of a receiver grid, if only support points were measured.
Input file should contain in each line: ('traceID' 'receiverLineID' 'number of the geophone on recLine' 'X' 'Y' 'Z')
Can be used to generate a velocity grid file (vgrids.in) for FMTOMO with a topography adapting gradient.
Can be used to generate an interface file for FMTOMO (right now only interface.z used by grid3dg) for the topography.
Supports vtk output for sources and receivers.
Note: Source and Receiver files for FMTOMO will be generated by the Survey object (because traveltimes will be added directly).
'''
def __init__(self, recfile):
self._receiverlines = {}
self._receiverCoords = {}
self._measuredReceivers = {}
self._measuredTopo = {}
self._sourceLocs = {}
self._geophoneNumbers = {}
self._receiverlist = open(recfile, 'r').readlines()
self._generateReceiverlines()
self._setReceiverCoords()
self._setGeophoneNumbers()
def _generateReceiverlines(self):
'''
Connects the traceIDs to the lineIDs
for each receiverline in a dictionary.
'''
for receiver in self._receiverlist:
traceID = int(receiver.split()[0])
lineID = int(receiver.split()[1])
if not lineID in self._receiverlines.keys():
self._receiverlines[lineID] = []
self._receiverlines[lineID].append(traceID)
def _setReceiverCoords(self):
'''
Fills the three x, y, z dictionaries with measured coordinates
'''
for line in self._getReceiverlist():
traceID = int(line.split()[0])
x = float(line.split()[3])
y = float(line.split()[4])
z = float(line.split()[5])
self._receiverCoords[traceID] = (x, y, z)
self._measuredReceivers[traceID] = (x, y, z)
def _setGeophoneNumbers(self):
for line in self._getReceiverlist():
traceID = int(line.split()[0])
gphoneNum = float(line.split()[2])
self._geophoneNumbers[traceID] = gphoneNum
def _getReceiverlines(self):
return self._receiverlines
def _getReceiverlist(self):
return self._receiverlist
def getReceiverCoordinates(self):
return self._receiverCoords
def _getXreceiver(self, traceID):
return self._receiverCoords[traceID][0]
def _getYreceiver(self, traceID):
return self._receiverCoords[traceID][1]
def _getZreceiver(self, traceID):
return self._receiverCoords[traceID][2]
def _getXshot(self, shotnumber):
return self._sourceLocs[shotnumber][0]
def _getYshot(self, shotnumber):
return self._sourceLocs[shotnumber][1]
def _getZshot(self, shotnumber):
return self._sourceLocs[shotnumber][2]
def _getReceiverValue(self, traceID, coordinate):
setCoordinate = {'X': self._getXreceiver,
'Y': self._getYreceiver,
'Z': self._getZreceiver}
return setCoordinate[coordinate](traceID)
def _getGeophoneNumber(self, traceID):
return self._geophoneNumbers[traceID]
def getMeasuredReceivers(self):
return self._measuredReceivers
def getMeasuredTopo(self):
return self._measuredTopo
def getSourceLocations(self):
return self._sourceLocs
def _setXvalue(self, traceID, value):
self._checkKey(traceID)
self._receiverCoords[traceID][0] = value
def _setYvalue(self, traceID, value):
self._checkKey(traceID)
self._receiverCoords[traceID][1] = value
def _setZvalue(self, traceID, value):
self._checkKey(traceID)
self._receiverCoords[traceID][2] = value
def _setValue(self, traceID, coordinate, value):
setCoordinate = {'X': self._setXvalue,
'Y': self._setYvalue,
'Z': self._setZvalue}
setCoordinate[coordinate](traceID, value)
def _checkKey(self, traceID):
if not traceID in self._receiverCoords.keys():
self._receiverCoords[traceID] = [None, None, None]
def _checkTraceIDdirection(self, traceID1, traceID2):
if traceID2 > traceID1:
direction = +1
return direction
if traceID2 < traceID1:
direction = -1
return direction
print "Error: Same Value for traceID1 = %s and traceID2 = %s" %(traceID1, traceID2)
def _checkCoordDirection(self, traceID1, traceID2, coordinate):
'''
Checks whether the interpolation direction is positive or negative
'''
if self._getReceiverValue(traceID1, coordinate) < self._getReceiverValue(traceID2, coordinate):
direction = +1
return direction
if self._getReceiverValue(traceID1, coordinate) > self._getReceiverValue(traceID2, coordinate):
direction = -1
return direction
print "Error: Same Value for traceID1 = %s and traceID2 = %s" %(traceID1, traceID2)
def _interpolateMeanDistances(self, traceID1, traceID2, coordinate):
'''
Returns the mean distance between two traceID's depending on the number of geophones in between
'''
num_spaces = abs(self._getGeophoneNumber(traceID1) - self._getGeophoneNumber(traceID2))
mean_distance = abs(self._getReceiverValue(traceID1, coordinate) - self._getReceiverValue(traceID2, coordinate))/num_spaces
return mean_distance
def interpolateValues(self, coordinate):
'''
Interpolates and sets all values (linear) for coordinate = 'X', 'Y' or 'Z'
'''
for lineID in self._getReceiverlines().keys():
number_measured = len(self._getReceiverlines()[lineID])
for index, traceID1 in enumerate(self._getReceiverlines()[lineID]):
if index + 1 < number_measured:
traceID2 = self._getReceiverlines()[lineID][index + 1]
traceID_dir = self._checkTraceIDdirection(traceID1, traceID2)
traceID_interp = traceID1 + traceID_dir
coord_dir = self._checkCoordDirection(traceID1, traceID2, coordinate)
mean_distance = self._interpolateMeanDistances(traceID1, traceID2, coordinate)
while (traceID_dir * traceID_interp) < (traceID_dir * traceID2):
self._setValue(traceID_interp, coordinate,
(self._getReceiverValue(traceID_interp - traceID_dir, coordinate)
+ coord_dir * (mean_distance)))
traceID_interp += traceID_dir
def addMeasuredTopographyPoints(self, filename):
'''
Use more measured points for a higher precision of height interpolation.
Input file should contain in each line: ('point ID' 'X' 'Y' 'Z')
'''
topolist = open(filename, 'r').readlines()
for line in topolist:
line = line.split()
pointID = int(line[0])
x = float(line[1])
y = float(line[2])
z = float(line[3])
self._measuredTopo[pointID] = (x, y, z)
def addSourceLocations(self, filename):
'''
Use source locations for a higher precision of height interpolation.
Input file should contain in each line: ('point ID' 'X' 'Y' 'Z')
Source locations must be added before they can be written to vtk files.
'''
topolist = open(filename, 'r').readlines()
for line in topolist:
line = line.split()
pointID = int(line[0])
x = float(line[1])
y = float(line[2])
z = float(line[3])
self._sourceLocs[pointID] = (x, y, z)
def interpZcoords4rec(self, method = 'linear'):
'''
Interpolates z values for all receivers.
'''
measured_x, measured_y, measured_z = self.getAllMeasuredPointsLists()
for traceID in self.getReceiverCoordinates().keys():
if type(self.getReceiverCoordinates()[traceID]) is not tuple:
z = griddata((measured_x, measured_y), measured_z, (self._getXreceiver(traceID), self._getYreceiver(traceID)), method = method)
self._setZvalue(traceID, float(z))
def _getAngle(self, distance):
'''
Function returns the angle on a Sphere of the radius R = 6371 [km] for a distance [km].
'''
PI = np.pi
R = 6371.
angle = distance * 180 / (PI * R)
return angle
def _getDistance(self, angle):
'''
Function returns the distance [km] on a Sphere of the radius R = 6371 [km] for an angle.
'''
PI = np.pi
R = 6371.
distance = angle / 180 * (PI * R)
return distance
def getMeasuredReceiverLists(self):
'''
Returns a list of all measured receivers known to SeisArray.
'''
x = []; y = []; z = []
for traceID in self.getMeasuredReceivers().keys():
x.append(self.getMeasuredReceivers()[traceID][0])
y.append(self.getMeasuredReceivers()[traceID][1])
z.append(self.getMeasuredReceivers()[traceID][2])
return x, y, z
def getMeasuredTopoLists(self):
'''
Returns a list of all measured topography points known to the SeisArray.
'''
x = []; y = []; z = []
for pointID in self.getMeasuredTopo().keys():
x.append(self.getMeasuredTopo()[pointID][0])
y.append(self.getMeasuredTopo()[pointID][1])
z.append(self.getMeasuredTopo()[pointID][2])
return x, y, z
def getSourceLocsLists(self):
'''
Returns a list of all measured source locations known to SeisArray.
'''
x = []; y = []; z = []
for pointID in self.getSourceLocations().keys():
x.append(self.getSourceLocations()[pointID][0])
y.append(self.getSourceLocations()[pointID][1])
z.append(self.getSourceLocations()[pointID][2])
return x, y, z
def getAllMeasuredPointsLists(self):
'''
Returns a list of all measured points known to SeisArray.
'''
mtopo_x, mtopo_y, mtopo_z = self.getMeasuredTopoLists()
msource_x, msource_y, msource_z = self.getSourceLocsLists()
mrec_x, mrec_y, mrec_z = self.getMeasuredReceiverLists()
x = mtopo_x + mrec_x + msource_x
y = mtopo_y + mrec_y + msource_y
z = mtopo_z + mrec_z + msource_z
return x, y, z
def getReceiverLists(self):
'''
Returns a list of all receivers (measured and interpolated).
'''
x = []; y =[]; z = []
for traceID in self.getReceiverCoordinates().keys():
x.append(self.getReceiverCoordinates()[traceID][0])
y.append(self.getReceiverCoordinates()[traceID][1])
z.append(self.getReceiverCoordinates()[traceID][2])
return x, y, z
def _interpolateXY4rec(self):
'''
Interpolates the X and Y coordinates for all receivers.
'''
for coordinate in ('X', 'Y'):
self.interpolateValues(coordinate)
def interpolateAll(self):
self._interpolateXY4rec()
self.interpZcoords4rec()
def interpolateTopography(self, nTheta, nPhi, thetaSN, phiWE, method = 'linear', filename = 'interface1.in'):
'''
Interpolate Z values on a regular grid with cushion nodes to use it as FMTOMO topography interface.
Returns a surface in form of a list of points [[x1, y1, z1], [x2, y2, y2], ...] (cartesian).
:param: nTheta, number of points in theta (NS)
type: integer
:param: nPhi, number of points in phi (WE)
type: integer
:param: thetaSN (S, N) extensions of the model in degree
type: tuple
:param: phiWE (W, E) extensions of the model in degree
type: tuple
'''
surface = []
elevation = 0.25 # elevate topography so that no source lies above the surface
if filename is not None:
outfile = open(filename, 'w')
print "Interpolating topography on regular grid with the dimensions:"
print "nTheta = %s, nPhi = %s, thetaSN = %s, phiWE = %s"%(nTheta, nPhi, thetaSN, phiWE)
print "method = %s, filename = %s" %(method, filename)
thetaS, thetaN = thetaSN
phiW, phiE = phiWE
measured_x, measured_y, measured_z = self.getAllMeasuredPointsLists()
# need to determine the delta to add two cushion nodes around the min/max values
thetaDelta = (thetaN - thetaS) / (nTheta - 1)
phiDelta = (phiE - phiW) / (nPhi - 1)
thetaGrid = np.linspace(thetaS - thetaDelta, thetaN + thetaDelta, num = nTheta + 2) # +2 cushion nodes
phiGrid = np.linspace(phiW - phiDelta, phiE + phiDelta, num = nPhi + 2) # +2 cushion nodes
nTotal = len(thetaGrid) * len(phiGrid); count = 0
for theta in thetaGrid:
for phi in phiGrid:
xval = self._getDistance(phi)
yval = self._getDistance(theta)
z = griddata((measured_x, measured_y), measured_z, (xval, yval), method = method)
# in case the point lies outside, nan will be returned. Find nearest:
if np.isnan(z) == True:
z = griddata((measured_x, measured_y), measured_z, (xval, yval), method = 'nearest')
z = float(z)
surface.append((xval, yval, z))
count += 1
progress = float(count) / float(nTotal) * 100
self._update_progress(progress)
if filename is not None:
outfile.writelines('%10s\n'%(z + elevation))
return surface
def generateVgrid(self, nTheta = 80, nPhi = 80, nR = 120,
thetaSN = (-0.2, 1.2), phiWE = (-0.2, 1.2),
Rbt = (-62.0, 6.0), vbot = 5.5, filename = 'vgrids.in',
method = 'linear' ):
'''
Generate a velocity grid for fmtomo regarding topography with a linear gradient starting at the topography with 0.34 [km/s].
:param: nTheta, number of points in theta (NS)
type: integer
:param: nPhi, number of points in phi (WE)
type: integer
:param: nR, number of points in depth
type: integer
:param: thetaSN (S, N) extensions of the model in degree
type: tuple
:param: phiWE (W, E) extensions of the model in degree
type: tuple
:param: Rbt (bot, top) extensions of the model in km
type: tuple
:param: vbot, velocity at the bottom of the model
type: real
'''
def getRad(angle):
PI = np.pi
rad = angle / 180 * PI
return rad
def getZmax(surface):
z = []
for point in surface:
z.append(point[2])
return max(z)
R = 6371
vmin = 0.34
decm = 0.3 # diagonal elements of the covariance matrix (grid3dg's default value is 0.3)
outfile = open(filename, 'w')
thetaS, thetaN = thetaSN
phiW, phiE = phiWE
rbot = Rbt[0] + R
rtop = Rbt[1] + R
# need to determine the delta to add two cushion nodes around the min/max values
thetaDelta = abs(thetaN - thetaS) / (nTheta - 1)
phiDelta = abs(phiE - phiW) / (nPhi - 1)
rDelta = abs(rbot - rtop) / (nR - 1)
# create a regular grid including +2 cushion nodes in every direction
thetaGrid = np.linspace(thetaS - thetaDelta, thetaN + thetaDelta, num = nTheta + 2) # +2 cushion nodes
phiGrid = np.linspace(phiW - phiDelta, phiE + phiDelta, num = nPhi + 2) # +2 cushion nodes
rGrid = np.linspace(rbot - rDelta, rtop + rDelta, num = nR + 2) # +2 cushion nodes
nTotal = len(rGrid) * len(thetaGrid) * len(phiGrid)
print "Total number of grid nodes: %s"%nTotal
# write header for velocity grid file (in RADIANS)
outfile.writelines('%10s %10s \n' %(1, 1))
outfile.writelines('%10s %10s %10s\n' %(nR + 2, nTheta + 2, nPhi + 2))
outfile.writelines('%10s %10s %10s\n' %(rDelta, getRad(thetaDelta), getRad(phiDelta)))
outfile.writelines('%10s %10s %10s\n' %(rbot - rDelta, getRad(thetaS - thetaDelta), getRad(phiW - phiDelta)))
surface = self.interpolateTopography(nTheta, nPhi, thetaSN, phiWE, method = method, filename = None)
zmax = getZmax(surface)
print "\nGenerating velocity grid for FMTOMO. Output filename = %s, interpolation method = %s"%(filename, method)
print "nTheta = %s, nPhi = %s, nR = %s, thetaSN = %s, phiWE = %s, Rbt = %s"%(nTheta, nPhi, nR, thetaSN, phiWE, Rbt)
count = 0
for radius in rGrid:
for theta in thetaGrid:
for phi in phiGrid:
xval = self._getDistance(phi)
yval = self._getDistance(theta)
for point in surface:
if point[0] == xval and point[1] == yval:
z = point[2]
if radius > (R + z + 1):
vel = 0.0
# elif radius > (R + z - 15): ########### TESTING
# vel = (radius - z - R) / (Rbt[0] - rDelta - zmax) * 1.0 + vmin ##########################
else:
vel = (radius - z - R) / (Rbt[0] - rDelta - zmax) * vbot + vmin ##########################
count += 1
outfile.writelines('%10s %10s\n'%(vel, decm))
progress = float(count) / float(nTotal) * 100
self._update_progress(progress)
outfile.close()
def exportAll(self, filename = 'interpolated_receivers.out'):
recfile_out = open(filename, 'w')
count = 0
for traceID in self.getReceiverCoordinates().keys():
count += 1
x, y, z = self.getReceiverCoordinates()[traceID]
recfile_out.writelines('%5s %15s %15s %15s\n' %(traceID, x, y, z))
print "Exported coordinates for %s traces to file > %s" %(count, filename)
recfile_out.close()
def plotArray2D(self, plot_topo = False, highlight_measured = False, annotations = True):
import matplotlib.pyplot as plt
plt.interactive(True)
plt.figure()
xmt, ymt, zmt = self.getMeasuredTopoLists()
xsc, ysc, zsc = self.getSourceLocsLists()
xmr, ymr, zmr = self.getMeasuredReceiverLists()
xrc, yrc, zrc = self.getReceiverLists()
plt.plot(xrc, yrc, 'k.', markersize = 10, label = 'all receivers')
plt.plot(xsc, ysc, 'b*', markersize = 10, label = 'shot locations')
if plot_topo == True:
plt.plot(xmt, ymt, 'b', markersize = 10, label = 'measured topo points')
if highlight_measured == True:
plt.plot(xmr, ymr, 'ro', label = 'measured receivers')
plt.xlabel('X [m]')
plt.ylabel('Y [m]')
plt.legend()
if annotations == True:
for traceID in self.getReceiverCoordinates().keys():
plt.annotate(str(traceID), xy = (self._getXreceiver(traceID), self._getYreceiver(traceID)), fontsize = 'x-small')
def plotArray3D(self, ax = None):
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
plt.interactive(True)
if ax == None:
fig = plt.figure()
ax = plt.axes(projection = '3d')
xmt, ymt, zmt = self.getMeasuredTopoLists()
xmr, ymr, zmr = self.getMeasuredReceiverLists()
xin, yin, zin = self.getReceiverLists()
ax.plot(xmt, ymt, zmt, 'b*', markersize = 10, label = 'measured topo points')
ax.plot(xin, yin, zin, 'k.', markersize = 10, label = 'interpolated receivers')
ax.plot(xmr, ymr, zmr, 'ro', label = 'measured receivers')
ax.set_xlabel('X'); ax.set_ylabel('Y'); ax.set_zlabel('elevation')
ax.legend()
return ax
def plotSurface3D(self, ax = None, step = 0.5, method = 'linear'):
from matplotlib import cm
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
plt.interactive(True)
if ax == None:
fig = plt.figure()
ax = plt.axes(projection = '3d')
xmt, ymt, zmt = self.getMeasuredTopoLists()
xmr, ymr, zmr = self.getMeasuredReceiverLists()
x = xmt + xmr
y = ymt + ymr
z = zmt + zmr
xaxis = np.arange(min(x)+1, max(x), step)
yaxis = np.arange(min(y)+1, max(y), step)
xgrid, ygrid = np.meshgrid(xaxis, yaxis)
zgrid = griddata((x, y), z, (xgrid, ygrid), method = method)
ax.plot_surface(xgrid, ygrid, zgrid, linewidth = 0, cmap = cm.jet, vmin = min(z), vmax = max(z))
ax.set_zlim(-(max(x) - min(x)/2),(max(x) - min(x)/2))
ax.set_aspect('equal')
ax.set_xlabel('X'); ax.set_ylabel('Y'); ax.set_zlabel('elevation')
ax.legend()
return ax
def _update_progress(self, progress):
sys.stdout.write("%d%% done \r" % (progress) )
sys.stdout.flush()
def receivers2VTK(self, filename = 'receivers.vtk'):
'''
Generates vtk files from all receivers of the SeisArray object.
'''
outfile = open(filename, 'w')
traceIDs = []
for traceID in self.getReceiverCoordinates():
traceIDs.append(traceID)
nPoints = len(traceIDs)
# write header
print("Writing header for VTK file...")
outfile.writelines('# vtk DataFile Version 3.1\n')
outfile.writelines('Receivers with traceIDs\n')
outfile.writelines('ASCII\n')
outfile.writelines('DATASET POLYDATA\n')
outfile.writelines('POINTS %15d float\n' %(nPoints))
# write coordinates
print("Writing coordinates to VTK file...")
for traceID in traceIDs:
x = self._getXreceiver(traceID)
y = self._getYreceiver(traceID)
z = self._getZreceiver(traceID)
outfile.writelines('%10f %10f %10f \n' %(x, y, z))
outfile.writelines('VERTICES %15d %15d\n' %(nPoints, 2 * nPoints))
# write indices
print("Writing indices to VTK file...")
for index in range(nPoints):
outfile.writelines('%10d %10d\n' %(1, index))
outfile.writelines('POINT_DATA %15d\n' %(nPoints))
outfile.writelines('SCALARS traceIDs int %d\n' %(1))
outfile.writelines('LOOKUP_TABLE default\n')
# write traceIDs
print("Writing traceIDs to VTK file...")
for traceID in traceIDs:
outfile.writelines('%10d\n' %traceID)
outfile.close()
print("Wrote receiver grid for %d points to file: %s" %(nPoints, filename))
return
def sources2VTK(self, filename = 'sources.vtk'):
'''
Generates vtk-files for all source locations in the SeisArray object.
'''
outfile = open(filename, 'w')
shotnumbers = []
for shotnumber in self.getSourceLocations():
shotnumbers.append(shotnumber)
nPoints = len(shotnumbers)
# write header
print("Writing header for VTK file...")
outfile.writelines('# vtk DataFile Version 3.1\n')
outfile.writelines('Shots with shotnumbers\n')
outfile.writelines('ASCII\n')
outfile.writelines('DATASET POLYDATA\n')
outfile.writelines('POINTS %15d float\n' %(nPoints))
# write coordinates
print("Writing coordinates to VTK file...")
for shotnumber in shotnumbers:
x = self._getXshot(shotnumber)
y = self._getYshot(shotnumber)
z = self._getZshot(shotnumber)
outfile.writelines('%10f %10f %10f \n' %(x, y, z))
outfile.writelines('VERTICES %15d %15d\n' %(nPoints, 2 * nPoints))
# write indices
print("Writing indices to VTK file...")
for index in range(nPoints):
outfile.writelines('%10d %10d\n' %(1, index))
outfile.writelines('POINT_DATA %15d\n' %(nPoints))
outfile.writelines('SCALARS shotnumbers int %d\n' %(1))
outfile.writelines('LOOKUP_TABLE default\n')
# write shotnumber
print("Writing shotnumbers to VTK file...")
for shotnumber in shotnumbers:
outfile.writelines('%10d\n' %shotnumber)
outfile.close()
print("Wrote receiver grid for %d points to file: %s" %(nPoints, filename))
return
def saveSeisArray(self, filename = 'seisArray.pickle'):
import cPickle
outfile = open(filename, 'wb')
cPickle.dump(self, outfile, -1)
print('saved SeisArray to file %s'%(filename))
@staticmethod
def from_pickle(filename):
import cPickle
infile = open(filename, 'rb')
return cPickle.load(infile)

195
pylot/core/active/seismicshot.py
View File

@ -10,6 +10,8 @@ from pylot.core.pick.CharFuns import HOScf
from pylot.core.pick.CharFuns import AICcf from pylot.core.pick.CharFuns import AICcf
from pylot.core.pick.utils import getSNR from pylot.core.pick.utils import getSNR
from pylot.core.pick.utils import earllatepicker from pylot.core.pick.utils import earllatepicker
import matplotlib.pyplot as plt
plt.interactive('True')
class SeismicShot(object): class SeismicShot(object):
''' '''
@ -27,9 +29,6 @@ class SeismicShot(object):
self.srcCoordlist = None self.srcCoordlist = None
self.traceIDs = None self.traceIDs = None
self.pick = {} self.pick = {}
self.pick_backup = {}
self.earliest = {}
self.latest = {}
self.pickwindow= {} self.pickwindow= {}
self.manualpicks= {} self.manualpicks= {}
self.snr = {} self.snr = {}
@ -132,17 +131,27 @@ class SeismicShot(object):
def getSourcefile(self): def getSourcefile(self):
return self.paras['sourcefile'] return self.paras['sourcefile']
def getPick(self, traceID): def getPick(self, traceID, returnRemoved = False):
return self.pick[traceID] if not self.getFlag(traceID) == 0:
return self.pick[traceID]['mpp']
if returnRemoved == True:
#print('getPick: Returned removed pick for shot %d, traceID %d' %(self.getShotnumber(), traceID))
return self.pick[traceID]['mpp']
def getPick_backup(self, traceID): def getPickIncludeRemoved(self, traceID):
return self.pick_backup[traceID] return self.getPick(traceID, returnRemoved = True)
def getEarliest(self, traceID): def getEarliest(self, traceID):
return self.earliest[traceID] return self.pick[traceID]['epp']
def getLatest(self, traceID): def getLatest(self, traceID):
return self.latest[traceID] return self.pick[traceID]['lpp']
def getSymmetricPickError(self, traceID):
pickerror = self.pick[traceID]['spe']
if np.isnan(pickerror) == True:
print "SPE is NaN for shot %s, traceID %s"%(self.getShotnumber(), traceID)
return pickerror
def getPickError(self, traceID): def getPickError(self, traceID):
pickerror = abs(self.getEarliest(traceID) - self.getLatest(traceID)) pickerror = abs(self.getEarliest(traceID) - self.getLatest(traceID))
@ -217,7 +226,7 @@ class SeismicShot(object):
:type: int :type: int
''' '''
return HOScf(self.getSingleStream(traceID), self.getCut(), return HOScf(self.getSingleStream(traceID), self.getCut(),
self.getTmovwind(), self.getOrder()) self.getTmovwind(), self.getOrder(), stealthMode = True)
def getAICcf(self, traceID): def getAICcf(self, traceID):
''' '''
@ -240,7 +249,7 @@ class SeismicShot(object):
tr_cf = Trace() tr_cf = Trace()
tr_cf.data = self.getHOScf(traceID).getCF() tr_cf.data = self.getHOScf(traceID).getCF()
st_cf += tr_cf st_cf += tr_cf
return AICcf(st_cf, self.getCut(), self.getTmovwind()) return AICcf(st_cf, self.getCut(), self.getTmovwind(), stealthMode = True)
def getSingleStream(self, traceID): ########## SEG2 / SEGY ? ########## def getSingleStream(self, traceID): ########## SEG2 / SEGY ? ##########
''' '''
@ -305,16 +314,17 @@ class SeismicShot(object):
'aic': aiccftime} 'aic': aiccftime}
self.setPick(traceID, setHosAic[HosAic]) self.setPick(traceID, setHosAic[HosAic])
self.pick_backup[traceID] = setHosAic[HosAic] ### verbessern (vor allem weil ueberschrieben bei 2tem mal picken)
def setEarllatepick(self, traceID, nfac = 1.5): def setEarllatepick(self, traceID, nfac = 1.5):
tgap = self.getTgap() tgap = self.getTgap()
tsignal = self.getTsignal() tsignal = self.getTsignal()
tnoise = self.getPick(traceID) - tgap tnoise = self.getPickIncludeRemoved(traceID) - tgap
(self.earliest[traceID], self.latest[traceID], tmp) = earllatepicker(self.getSingleStream(traceID), (self.pick[traceID]['epp'], self.pick[traceID]['lpp'],
self.pick[traceID]['spe']) = earllatepicker(self.getSingleStream(traceID),
nfac, (tnoise, tgap, tsignal), nfac, (tnoise, tgap, tsignal),
self.getPick(traceID)) self.getPickIncludeRemoved(traceID),
stealthMode = True)
def threshold(self, hoscf, aiccf, windowsize, pickwindow, folm = 0.6): def threshold(self, hoscf, aiccf, windowsize, pickwindow, folm = 0.6):
''' '''
@ -464,7 +474,10 @@ class SeismicShot(object):
# raise KeyError('MANUAL pick to be set more than once for traceID %s' % traceID) # raise KeyError('MANUAL pick to be set more than once for traceID %s' % traceID)
def setPick(self, traceID, pick): ########## siehe Kommentar ########## def setPick(self, traceID, pick): ########## siehe Kommentar ##########
self.pick[traceID] = pick if not traceID in self.pick.keys():
self.pick[traceID] = {}
self.pick[traceID]['mpp'] = pick
self.pick[traceID]['flag'] = 1
# ++++++++++++++ Block raus genommen, da Error beim 2ten Mal picken! (Ueberschreiben von erstem Pick!) # ++++++++++++++ Block raus genommen, da Error beim 2ten Mal picken! (Ueberschreiben von erstem Pick!)
# if not self.pick.has_key(traceID): # if not self.pick.has_key(traceID):
# self.getPick(traceID) = picks # self.getPick(traceID) = picks
@ -475,7 +488,14 @@ class SeismicShot(object):
# parlist = open(parfile,'r').readlines() # parlist = open(parfile,'r').readlines()
def removePick(self, traceID): def removePick(self, traceID):
self.setPick(traceID, None) self.setFlag(traceID, 0)
def setFlag(self, traceID, flag):
'Set flag = 0 if pick is invalid, else flag = 1'
self.pick[traceID]['flag'] = flag
def getFlag(self, traceID):
return self.pick[traceID]['flag']
def setPickwindow(self, traceID, pickwindow): def setPickwindow(self, traceID, pickwindow):
self.pickwindow[traceID] = pickwindow self.pickwindow[traceID] = pickwindow
@ -580,7 +600,39 @@ class SeismicShot(object):
# plt.plot(self.getDistArray4ttcPlot(), pickwindowarray_upperb, ':k') # plt.plot(self.getDistArray4ttcPlot(), pickwindowarray_upperb, ':k')
def plot_traces(self, traceID, folm = 0.6): ########## 2D, muss noch mehr verbessert werden ########## def plot_traces(self, traceID, folm = 0.6): ########## 2D, muss noch mehr verbessert werden ##########
import matplotlib.pyplot as plt from matplotlib.widgets import Button
def onclick(event):
self.setPick(traceID, event.xdata)
self._drawStream(traceID, refresh = True)
self._drawCFs(traceID, folm, refresh = True)
fig.canvas.mpl_disconnect(self.traces4plot[traceID]['cid'])
plt.draw()
def connectButton(event = None):
cid = fig.canvas.mpl_connect('button_press_event', onclick)
self.traces4plot[traceID]['cid'] = cid
fig = plt.figure()
ax1 = fig.add_subplot(2,1,1)
ax2 = fig.add_subplot(2,1,2, sharex = ax1)
axb = fig.add_axes([0.15, 0.91, 0.05, 0.03])
button = Button(axb, 'repick', color = 'red', hovercolor = 'grey')
button.on_clicked(connectButton)
self.traces4plot = {}
if not traceID in self.traces4plot.keys():
self.traces4plot[traceID] = {'fig': fig,
'ax1': ax1,
'ax2': ax2,
'axb': axb,
'button': button,
'cid': None,}
self._drawStream(traceID)
self._drawCFs(traceID, folm)
def _drawStream(self, traceID, refresh = False):
from pylot.core.util.utils import getGlobalTimes from pylot.core.util.utils import getGlobalTimes
from pylot.core.util.utils import prepTimeAxis from pylot.core.util.utils import prepTimeAxis
@ -589,32 +641,47 @@ class SeismicShot(object):
timeaxis = prepTimeAxis(stime, stream[0]) timeaxis = prepTimeAxis(stime, stream[0])
timeaxis -= stime timeaxis -= stime
plt.interactive('True') ax = self.traces4plot[traceID]['ax1']
hoscf = self.getHOScf(traceID) if refresh == True:
aiccf = self.getAICcf(traceID) xlim, ylim = ax.get_xlim(), ax.get_ylim()
ax.clear()
if refresh == True:
ax.set_xlim(xlim)
ax.set_ylim(ylim)
fig = plt.figure() ax.set_title('Shot: %s, traceID: %s, pick: %s'
ax1 = plt.subplot(2,1,1) %(self.getShotnumber(), traceID, self.getPick(traceID)))
plt.title('Shot: %s, traceID: %s, pick: %s' %(self.getShotnumber(), traceID, self.getPick(traceID))) ax.plot(timeaxis, stream[0].data, 'k', label = 'trace')
ax1.plot(timeaxis, stream[0].data, 'k', label = 'trace') ax.plot([self.getPick(traceID), self.getPick(traceID)],
ax1.plot([self.getPick(traceID), self.getPick(traceID)],
[min(stream[0].data), [min(stream[0].data),
max(stream[0].data)], max(stream[0].data)],
'r', label = 'mostlikely') 'r', label = 'mostlikely')
plt.legend() ax.legend()
ax2 = plt.subplot(2,1,2, sharex = ax1)
ax2.plot(hoscf.getTimeArray(), hoscf.getCF(), 'b', label = 'HOS') def _drawCFs(self, traceID, folm, refresh = False):
ax2.plot(hoscf.getTimeArray(), aiccf.getCF(), 'g', label = 'AIC') hoscf = self.getHOScf(traceID)
ax2.plot([self.getPick(traceID), self.getPick(traceID)], aiccf = self.getAICcf(traceID)
ax = self.traces4plot[traceID]['ax2']
if refresh == True:
xlim, ylim = ax.get_xlim(), ax.get_ylim()
ax.clear()
if refresh == True:
ax.set_xlim(xlim)
ax.set_ylim(ylim)
ax.plot(hoscf.getTimeArray(), hoscf.getCF(), 'b', label = 'HOS')
ax.plot(hoscf.getTimeArray(), aiccf.getCF(), 'g', label = 'AIC')
ax.plot([self.getPick(traceID), self.getPick(traceID)],
[min(np.minimum(hoscf.getCF(), aiccf.getCF())), [min(np.minimum(hoscf.getCF(), aiccf.getCF())),
max(np.maximum(hoscf.getCF(), aiccf.getCF()))], max(np.maximum(hoscf.getCF(), aiccf.getCF()))],
'r', label = 'mostlikely') 'r', label = 'mostlikely')
ax2.plot([0, self.getPick(traceID)], ax.plot([0, self.getPick(traceID)],
[folm * max(hoscf.getCF()), folm * max(hoscf.getCF())], [folm * max(hoscf.getCF()), folm * max(hoscf.getCF())],
'm:', label = 'folm = %s' %folm) 'm:', label = 'folm = %s' %folm)
plt.xlabel('Time [s]') ax.set_xlabel('Time [s]')
plt.legend() ax.legend()
def plot3dttc(self, step = 0.5, contour = False, plotpicks = False, method = 'linear', ax = None): def plot3dttc(self, step = 0.5, contour = False, plotpicks = False, method = 'linear', ax = None):
''' '''
@ -632,7 +699,6 @@ class SeismicShot(object):
:param: method (optional), interpolation method; can be 'linear' (default) or 'cubic' :param: method (optional), interpolation method; can be 'linear' (default) or 'cubic'
:type: 'string' :type: 'string'
''' '''
import matplotlib.pyplot as plt
from scipy.interpolate import griddata from scipy.interpolate import griddata
from matplotlib import cm from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D from mpl_toolkits.mplot3d import Axes3D
@ -641,13 +707,13 @@ class SeismicShot(object):
y = [] y = []
z = [] z = []
for traceID in self.pick.keys(): for traceID in self.pick.keys():
if self.getPick(traceID) != None: if self.getFlag(traceID) != 0:
x.append(self.getRecLoc(traceID)[0]) x.append(self.getRecLoc(traceID)[0])
y.append(self.getRecLoc(traceID)[1]) y.append(self.getRecLoc(traceID)[1])
z.append(self.getPick(traceID)) z.append(self.getPick(traceID))
xaxis = np.arange(min(x)+1, max(x), step) xaxis = np.arange(min(x), max(x), step)
yaxis = np.arange(min(y)+1, max(y), step) yaxis = np.arange(min(y), max(y), step)
xgrid, ygrid = np.meshgrid(xaxis, yaxis) xgrid, ygrid = np.meshgrid(xaxis, yaxis)
zgrid = griddata((x, y), z, (xgrid, ygrid), method = method) zgrid = griddata((x, y), z, (xgrid, ygrid), method = method)
@ -672,7 +738,7 @@ class SeismicShot(object):
plotmethod[method](*args) plotmethod[method](*args)
def matshow(self, step = 0.5, method = 'linear', ax = None, plotRec = False, annotations = False): def matshow(self, ax = None, step = 0.5, method = 'linear', plotRec = True, annotations = True, colorbar = True):
''' '''
Plots a 2D matrix of the interpolated traveltimes. This needs less performance than plot3dttc Plots a 2D matrix of the interpolated traveltimes. This needs less performance than plot3dttc
@ -682,27 +748,32 @@ class SeismicShot(object):
:param: method (optional), interpolation method; can be 'linear' (default) or 'cubic' :param: method (optional), interpolation method; can be 'linear' (default) or 'cubic'
:type: 'string' :type: 'string'
:param: plotRec (optional), plot the receiver positions :param: plotRec (optional), plot the receiver positions (colored scatter plot, should not be
deactivated because there might be receivers that are not inside the interpolated area)
:type: 'logical' :type: 'logical'
:param: annotations (optional), displays traceIDs as annotations :param: annotations (optional), displays traceIDs as annotations
:type: 'logical' :type: 'logical'
''' '''
import matplotlib.pyplot as plt
from scipy.interpolate import griddata from scipy.interpolate import griddata
# plt.interactive('True')
x = [] x = []; xcut = []
y = [] y = []; ycut = []
z = [] z = []; zcut = []
tmin, tmax = self.getCut()
for traceID in self.pick.keys(): for traceID in self.pick.keys():
if self.getPick(traceID) != None: if self.getFlag(traceID) != 0:
x.append(self.getRecLoc(traceID)[0]) x.append(self.getRecLoc(traceID)[0])
y.append(self.getRecLoc(traceID)[1]) y.append(self.getRecLoc(traceID)[1])
z.append(self.getPick(traceID)) z.append(self.getPick(traceID))
if self.getFlag(traceID) == 0 and self.getPickIncludeRemoved(traceID) is not None:
xcut.append(self.getRecLoc(traceID)[0])
ycut.append(self.getRecLoc(traceID)[1])
zcut.append(self.getPickIncludeRemoved(traceID))
xaxis = np.arange(min(x)+1, max(x), step) xaxis = np.arange(min(x), max(x), step)
yaxis = np.arange(min(y)+1, max(y), step) yaxis = np.arange(min(y), max(y), step)
xgrid, ygrid = np.meshgrid(xaxis, yaxis) xgrid, ygrid = np.meshgrid(xaxis, yaxis)
zgrid = griddata((x, y), z, (xgrid, ygrid), method='linear') zgrid = griddata((x, y), z, (xgrid, ygrid), method='linear')
@ -710,14 +781,28 @@ class SeismicShot(object):
fig = plt.figure() fig = plt.figure()
ax = plt.axes() ax = plt.axes()
ax.imshow(zgrid, interpolation = 'none', extent = [min(x), max(x), min(y), max(y)]) ax.matshow(zgrid, extent = [min(x), max(x), min(y), max(y)], origin = 'lower')
plt.text(0.45, 0.9, 'shot: %s' %self.getShotnumber(), transform = ax.transAxes)
if annotations == True: sc = ax.scatter(x, y, c = z, s = 30, label = 'picked shots', vmin = tmin, vmax = tmax, linewidths = 1.5)
for i, traceID in enumerate(self.pick.keys()): sccut = ax.scatter(xcut, ycut, c = zcut, s = 30, edgecolor = 'm', label = 'cut out shots', vmin = tmin, vmax = tmax, linewidths = 1.5)
if shot.picks[traceID] != None: if colorbar == True:
ax.annotate('%s' % traceID, xy=(x[i], y[i]), fontsize = 'x-small') plt.colorbar(sc)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.plot(self.getSrcLoc()[0], self.getSrcLoc()[1],'*k', markersize = 15) # plot source location
if plotRec == True: if plotRec == True:
ax.plot(x, y, 'k.') ax.scatter(x, y, c = z, s = 30)
if annotations == True:
for traceID in self.getTraceIDlist():
if self.getFlag(traceID) is not 0:
ax.annotate(' %s' %traceID , xy = (self.getRecLoc(traceID)[0], self.getRecLoc(traceID)[1]),
fontsize = 'x-small', color = 'k')
else:
ax.annotate(' %s' %traceID , xy = (self.getRecLoc(traceID)[0], self.getRecLoc(traceID)[1]),
fontsize = 'x-small', color = 'r')
plt.show() plt.show()

421
pylot/core/active/surveyPlotTools.py
View File

@ -1,49 +1,191 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
import math
import numpy as np
plt.interactive(True) plt.interactive(True)
class regions(object): class regions(object):
def __init__(self, ax, shot_dict): '''
A class used for manual inspection and processing of all picks for the user.
Examples:
regions.chooseRectangles():
- lets the user choose several rectangular regions in the plot
regions.plotTracesInRegions():
- creates plots (shot.plot_traces) for all traces in the active regions (i.e. chosen by e.g. chooseRectangles)
regions.setActiveRegionsForDeletion():
- highlights all shots in a the active regions for deletion
regions.deleteMarkedPicks():
- deletes the picks (pick flag set to 0) for all shots set for deletion
regions.deselectSelection(number):
- deselects the region of number = number
'''
def __init__(self, ax, survey):
self.ax = ax self.ax = ax
self.shot_dict = shot_dict self.survey = survey
self.shot_dict = self.survey.getShotDict()
self._x0 = [] self._x0 = []
self._y0 = [] self._y0 = []
self._x1 = [] self._x1 = []
self._y1 = [] self._y1 = []
self._polyx = []
self._polyy = []
self._allpicks = None
self.shots_found = {} self.shots_found = {}
self.shots_for_deletion = {} self.shots_for_deletion = {}
self._generateList()
def _onselect(self, eclick, erelease): def _onselect_clicks(self, eclick, erelease):
'eclick and erelease are matplotlib events at press and release' #print ' startposition : (%f, %f)' % (eclick.xdata, eclick.ydata) 'eclick and erelease are matplotlib events at press and release'
#print ' startposition : (%f, %f)' % (eclick.xdata, eclick.ydata)
#print ' endposition : (%f, %f)' % (erelease.xdata, erelease.ydata) #print ' endposition : (%f, %f)' % (erelease.xdata, erelease.ydata)
print 'region selected x0, y0 = (%3s, %3s), x1, y1 = (%3s, %3s)'%(eclick.xdata, eclick.ydata, erelease.xdata, erelease.ydata) print 'region selected x0, y0 = (%3s, %3s), x1, y1 = (%3s, %3s)'%(eclick.xdata, eclick.ydata, erelease.xdata, erelease.ydata)
x0 = min(eclick.xdata, erelease.xdata) x0 = min(eclick.xdata, erelease.xdata)
x1 = max(eclick.xdata, erelease.xdata) x1 = max(eclick.xdata, erelease.xdata)
y0 = min(eclick.ydata, erelease.ydata) y0 = min(eclick.ydata, erelease.ydata)
y1 = max(eclick.ydata, erelease.ydata) y1 = max(eclick.ydata, erelease.ydata)
self._x0.append(x0)
self._x1.append(x1) shots, numtraces = self.findTracesInShotDict((x0, x1), (y0, y1))
self._y0.append(y0) print('Found %d traces in rectangle: %s' %(numtraces, shots))
self._y1.append(y1)
self.markCurrentRegion(x0, x1, y0, y1) key = self.getKey()
self.shots_found[key] = {'shots': shots,
'selection': 'rect',
'xvalues': (x0, x1),
'yvalues': (y0, y1)}
self.markRectangle((x0, x1), (y0, y1), key)
def _onselect_verts(self, verts):
x = verts[0][0]
y = verts[0][1]
self._polyx.append(x)
self._polyy.append(y)
self.drawPolyLine()
def _onpress(self, event):
if event.button == 3:
self.disconnectPoly()
def getKey(self):
if self.shots_found.keys() == []:
key = 1
else:
key = max(self.shots_found.keys()) + 1
return key
def drawPolyLine(self):
x = self._polyx
y = self._polyy
if len(x) >= 2 and len(y) >= 2:
plt.plot(x[-2:], y[-2:], 'k')
def drawLastPolyLine(self):
x = self._polyx
y = self._polyy
if len(x) >= 2 and len(y) >= 2:
plt.plot((x[-1], x[0]), (y[-1], y[0]), 'k')
def finishPolygon(self):
self.drawLastPolyLine()
x = self._polyx
y = self._polyy
self._polyx = []; self._polyy = []
key = self.getKey()
self.markPolygon(x, y, key = key)
shots, numtraces = self.findTracesInPoly(x, y)
self.shots_found[key] = {'shots': shots,
'selection': 'poly',
'xvalues': x,
'yvalues': y}
print('Found %d traces in polygon: %s' %(numtraces, shots))
def markPolygon(self, x, y, key = None, color = 'grey', alpha = 0.1, linewidth = 1):
from matplotlib.patches import Polygon
poly = Polygon(np.array(zip(x, y)), color = color, alpha = alpha, lw = linewidth)
self.ax.add_patch(poly)
if key is not None:
self.ax.text((min(x) + (max(x) - min(x)) / 2), (min(y) + (max(y) - min(y)) / 2), str(key))
self.drawFigure()
def disconnectPoly(self):
self.ax.figure.canvas.mpl_disconnect(self._cid)
del self._cid
self.finishPolygon()
self._lasso.disconnect_events()
print('disconnected poly selection\n')
def disconnectRect(self):
self.ax.figure.canvas.mpl_disconnect(self._cid)
del self._cid
self._rectangle.disconnect_events()
print('disconnected rectangle selection\n')
def chooseRectangles(self): def chooseRectangles(self):
'''
Activates matplotlib widget RectangleSelector.
'''
from matplotlib.widgets import RectangleSelector from matplotlib.widgets import RectangleSelector
print 'Select rectangle is active' print('Select rectangle is active')
return RectangleSelector(self.ax, self._onselect) self._cid = self.ax.figure.canvas.mpl_connect('button_press_event', self._onpress)
self._rectangle = RectangleSelector(self.ax, self._onselect_clicks)
return self._rectangle
def _getx0(self): def choosePolygon(self):
return self._x0 '''
Activates matplotlib widget LassoSelector.
'''
from matplotlib.widgets import LassoSelector
def _getx1(self): print('Select polygon is active')
return self._x1 self._cid = self.ax.figure.canvas.mpl_connect('button_press_event', self._onpress)
self._lasso = LassoSelector(self.ax, self._onselect_verts)
return self._lasso
def _gety0(self): def deselectLastSelection(self):
return self._y0 if self.shots_found.keys() == []:
print('No selection found.')
return
key = max(self.shots_found.keys())
self.deselectSelection(key)
def _gety1(self): def deselectSelection(self, key, color = 'green', alpha = 0.1):
return self._y1 if not key in self.shots_found.keys():
print('No selection found.')
return
if color is not None:
if self.shots_found[key]['selection'] == 'rect':
self.markRectangle(self.shots_found[key]['xvalues'],
self.shots_found[key]['yvalues'],
key = key, color = color, alpha = alpha,
linewidth = 1)
elif self.shots_found[key]['selection'] == 'poly':
self.markPolygon(self.shots_found[key]['xvalues'],
self.shots_found[key]['yvalues'],
key = key, color = color, alpha = alpha,
linewidth = 1)
value = self.shots_found.pop(key)
print('Deselected selection number %d'% key)
return
def _generateList(self):
allpicks = []
for shot in self.shot_dict.values():
for traceID in shot.getTraceIDlist():
allpicks.append((shot.getDistance(traceID), shot.getPickIncludeRemoved(traceID),
shot.getShotnumber(), traceID, shot.getFlag(traceID)))
allpicks.sort()
self._allpicks = allpicks
def getShotDict(self): def getShotDict(self):
return self.shot_dict return self.shot_dict
@ -51,119 +193,216 @@ class regions(object):
def getShotsForDeletion(self): def getShotsForDeletion(self):
return self.shots_for_deletion return self.shots_for_deletion
def findTracesInShotDict(self, picks = 'normal'): def findTracesInPoly(self, x, y, picks = 'normal', highlight = True):
''' def dotproduct(v1, v2):
Returns traces corresponding to a certain area in a plot with all picks over the distances. return sum((a*b) for a, b in zip(v1, v2))
'''
print "findTracesInShotDict: Searching for marked traces in the shot dictionary... "
for shot in self.shot_dict.values(): def getlength(v):
whichpicks = {'normal': shot.getPick, return math.sqrt(dotproduct(v, v))
'includeCutOut': shot.getPick_backup}
for index in range(len(self._getx1())): def getangle(v1, v2):
distancebin = (self._getx0()[index], self._getx1()[index]) return np.rad2deg(math.acos(dotproduct(v1, v2) / (getlength(v1) * getlength(v2))))
pickbin = (self._gety0()[index], self._gety1()[index])
if shot.getTraceIDs4Dist(distancebin = distancebin) is not None: def insidePoly(x, y, pickX, pickY):
for traceID in shot.getTraceIDs4Dist(distancebin = distancebin): angle = 0
if pickbin[0] < whichpicks[picks](traceID) < pickbin[1]: epsilon = 10e-8
for index in range(len(x)):
xval1 = x[index - 1]; yval1 = y[index - 1]
xval2 = x[index]; yval2 = y[index]
angle += getangle([xval1 - pickX, yval1 - pickY], [xval2 - pickX, yval2 - pickY])
if 360 - epsilon <= angle <= 360 + epsilon: ### IMPROVE THAT??
return True
if len(x) == 0 or len(y) == 0:
print('No polygon defined.')
return
shots_found = {}; numtraces = 0
x0 = min(x); x1 = max(x)
y0 = min(y); y1 = max(y)
shots, numtracesrect = self.findTracesInShotDict((x0, x1), (y0, y1), highlight = False)
for shotnumber in shots.keys():
shot = self.shot_dict[shotnumber]
for traceID in shots[shotnumber]:
if shot.getFlag(traceID) is not 0:
pickX = shot.getDistance(traceID)
pickY = shot.getPick(traceID)
if insidePoly(x, y, pickX, pickY):
if not shotnumber in shots_found.keys():
shots_found[shotnumber] = []
shots_found[shotnumber].append(traceID)
if highlight == True:
self.highlightPick(shot, traceID) self.highlightPick(shot, traceID)
if shot.getShotnumber() not in self.shots_found.keys(): numtraces += 1
self.shots_found[shot.getShotnumber()] = []
if traceID not in self.shots_found[shot.getShotnumber()]: self.drawFigure()
self.shots_found[shot.getShotnumber()].append(traceID) return shots_found, numtraces
self.refreshFigure()
print self.shots_found def findTracesInShotDict(self, (x0, x1), (y0, y1), picks = 'normal', highlight = True):
'''
Returns traces corresponding to a certain area in the plot with all picks over the distances.
'''
shots_found = {}; numtraces = 0
if picks == 'normal': pickflag = 0
elif picks == 'includeCutOut': pickflag = None
for line in self._allpicks:
dist, pick, shotnumber, traceID, flag = line
if flag == pickflag: continue ### IMPROVE THAT
if (x0 <= dist <= x1 and y0 <= pick <= y1):
if not shotnumber in shots_found.keys():
shots_found[shotnumber] = []
shots_found[shotnumber].append(traceID)
if highlight == True:
self.highlightPick(self.shot_dict[shotnumber], traceID)
numtraces += 1
self.drawFigure()
return shots_found, numtraces
def highlightPick(self, shot, traceID, annotations = True): def highlightPick(self, shot, traceID, annotations = True):
'''
Highlights a single pick for a shot(object)/shotnumber and traceID.
If annotations == True: Displays shotnumber and traceID in the plot.
'''
if type(shot) == int:
shot = self.survey.getShotDict()[shot]
self.ax.scatter(shot.getDistance(traceID), shot.getPick(traceID), s = 50, marker = 'o', facecolors = 'none', edgecolors = 'm', alpha = 1) self.ax.scatter(shot.getDistance(traceID), shot.getPick(traceID), s = 50, marker = 'o', facecolors = 'none', edgecolors = 'm', alpha = 1)
if annotations == True: if annotations == True:
self.ax.annotate(s = 's%s|t%s'%(shot.getShotnumber(), traceID), xy = (shot.getDistance(traceID), shot.getPick(traceID)), fontsize = 'xx-small') self.ax.annotate(s = 's%s|t%s'%(shot.getShotnumber(), traceID), xy = (shot.getDistance(traceID), shot.getPick(traceID)), fontsize = 'xx-small')
self.ax.set_ylim(shot.getCut()) self.ax.set_ylim(shot.getCut())
def plotTracesInRegion(self): def highlightAllRegions(self):
'''
Highlights all picks in all active regions.
'''
for key in self.shots_found.keys():
for shotnumber in self.shots_found[key]['shots'].keys():
for traceID in self.shots_found[key]['shots'][shotnumber]:
self.highlightPick(self.shot_dict[shotnumber], traceID)
self.drawFigure()
def plotTracesInRegions(self, keys = 'all', maxfigures = 20):
'''
Plots all traces in the active region or for all specified keys.
:param: keys
:type: int or list
:param: maxfigures, maximum value of figures opened
:type: int
'''
count = 0 count = 0
maxfigures = 20 if keys == 'all':
# if len(self.shots_found) == 0: keys = self.shots_found.keys()
self.findTracesInShotDict() elif type(keys) == int:
keys = [keys]
if len(self.shots_found) > 0: if len(self.shots_found) > 0:
for shot in self.shot_dict.values(): for shot in self.shot_dict.values():
for shotnumber in self.shots_found: for key in keys:
for shotnumber in self.shots_found[key]['shots']:
if shot.getShotnumber() == shotnumber: if shot.getShotnumber() == shotnumber:
for traceID in self.shots_found[shotnumber]: for traceID in self.shots_found[key]['shots'][shotnumber]:
count += 1 count += 1
if count > maxfigures: if count > maxfigures:
print 'Maximum number of figures (%s) reached. %sth figure was not opened.' %(maxfigures, count) print 'Maximum number of figures (%s) reached. %sth figure was not opened.' %(maxfigures, count)
break break
shot.plot_traces(traceID) shot.plot_traces(traceID)
else: else:
print 'No picks yet defined in the regions x = (%s, %s), y = (%s, %s)' %(self._x0, self._x1, self._y0, self._y1) print('No picks defined in that region(s)')
def plotTracesInRegion_withCutOutTraces(self): def setActiveRegionsForDeletion(self):
count = 0 keys = []
maxfigures = 20 for key in self.shots_found.keys():
# if len(self.shots_found) == 0: keys.append(key)
self.findTracesInShotDict(picks = 'includeCutOut') self.setRegionForDeletion(keys)
if len(self.shots_found) > 0: def setRegionForDeletion(self, keys):
for shot in self.shot_dict.values(): if type(keys) == int:
for shotnumber in self.shots_found: keys = [keys]
if shot.getShotnumber() == shotnumber:
for traceID in self.shots_found[shotnumber]:
count += 1
if count > maxfigures:
print 'Maximum number of figures (%s) reached. %sth figure was not opened.' %(maxfigures, count)
break
shot.plot_traces(traceID)
else:
print 'No picks yet defined in the regions x = (%s, %s), y = (%s, %s)' %(self._x0, self._x1, self._y0, self._y1)
for key in keys:
def setCurrentRegionsForDeletion(self): for shotnumber in self.shots_found[key]['shots'].keys():
# if len(self.shots_found) == 0:
self.findTracesInShotDict()
for shotnumber in self.shots_found:
if not shotnumber in self.shots_for_deletion: if not shotnumber in self.shots_for_deletion:
self.shots_for_deletion[shotnumber] = [] self.shots_for_deletion[shotnumber] = []
for traceID in self.shots_found[shotnumber]: for traceID in self.shots_found[key]['shots'][shotnumber]:
if not traceID in self.shots_for_deletion[shotnumber]: if not traceID in self.shots_for_deletion[shotnumber]:
self.shots_for_deletion[shotnumber].append(traceID) self.shots_for_deletion[shotnumber].append(traceID)
self.markAllRegions(color = 'red') self.deselectSelection(key, color = 'red', alpha = 0.2)
print 'Marked regions for deletion'
def markAllRegions(self, color = 'grey'): print 'Set region(s) %s for deletion'%keys
def markAllActiveRegions(self):
for key in self.shots_found.keys():
if self.shots_found[key]['selection'] == 'rect':
self.markRectangle(self.shots_found[key]['xvalues'],
self.shots_found[key]['yvalues'], key = key)
if self.shots_found[key]['selection'] == 'poly':
self.markPolygon(self.shots_found[key]['xvalues'],
self.shots_found[key]['yvalues'], key = key)
def markRectangle(self, (x0, x1), (y0, y1), key = None, color = 'grey', alpha = 0.1, linewidth = 1):
'''
Mark a rectangular region on the axes.
'''
from matplotlib.patches import Rectangle from matplotlib.patches import Rectangle
for index in range(len(self._getx0())): self.ax.add_patch(Rectangle((x0, y0), (x1 - x0), (y1 - y0),
x0 = self._getx0()[index] alpha = alpha, facecolor = color, linewidth = linewidth))
y0 = self._gety0()[index] if key is not None:
x1 = self._getx1()[index] self.ax.text((x0 + (x1 - x0) / 2), (y0 + (y1 - y0) / 2), str(key))
y1 = self._gety1()[index] self.drawFigure()
self.ax.add_patch(Rectangle((x0, y0), (x1 - x0), (y1 - y0), alpha=0.5, facecolor = color)) def refreshFigure(self):
self.refreshFigure() print('Refreshing figure...')
self.ax.clear()
self.ax = self.survey.plotAllPicks(ax = self.ax, refreshPlot = True)
self.markAllActiveRegions()
self.drawFigure()
print('Done!')
def markCurrentRegion(self, x0, x1, y0, y1, color = 'grey'): def clearShotsForDeletion(self):
from matplotlib.patches import Rectangle '''
Clears the list of shots marked for deletion.
'''
self.shots_for_deletion = {}
print('Cleared all shots that were set for deletion.')
self.ax.add_patch(Rectangle((x0, y0), (x1 - x0), (y1 - y0), alpha=0.1, facecolor = color)) def getShotsForDeletion(self):
self.refreshFigure() return self.shots_for_deletion
def deleteMarkedPicks(self): def deleteMarkedPicks(self):
'''
Deletes all shots set for deletion.
'''
if len(self.getShotsForDeletion()) is 0:
print('No shots set for deletion.')
return
for shot in self.getShotDict().values(): for shot in self.getShotDict().values():
for shotnumber in self.getShotsForDeletion(): for shotnumber in self.getShotsForDeletion():
if shot.getShotnumber() == shotnumber: if shot.getShotnumber() == shotnumber:
for traceID in self.getShotsForDeletion()[shotnumber]: for traceID in self.getShotsForDeletion()[shotnumber]:
shot.removePick(traceID) shot.removePick(traceID)
print "Deleted the pick for traceID %s on shot number %s" %(traceID, shotnumber) print "Deleted the pick for traceID %s on shot number %s" %(traceID, shotnumber)
self.shots_for_deletion = {} # clear dictionary self.clearShotsForDeletion()
def highlightPicksForShot(self, shot, annotations = False):
for traceID in shot.getTraceIDlist():
if shot.getPick(traceID) is not None:
self.highlightPick(shot, traceID, annotations)
self.refreshFigure() self.refreshFigure()
def refreshFigure(self): def highlightPicksForShot(self, shot, annotations = False):
'''
Highlight all picks for a given shot.
'''
if type(shot) is int:
shot = self.survey.getShotDict()[shotnumber]
for traceID in shot.getTraceIDlist():
if shot.getFlag(traceID) is not 0:
self.highlightPick(shot, traceID, annotations)
self.drawFigure()
def drawFigure(self):
plt.draw() plt.draw()

2
pylot/core/active/surveyUtils.py
View File

@ -73,7 +73,7 @@ def fitSNR4dist(shot_dict, shiftdist = 5):
for traceID in shot.getTraceIDlist(): for traceID in shot.getTraceIDlist():
if shot.getSNR(traceID)[0] >= 1: if shot.getSNR(traceID)[0] >= 1:
dists.append(shot.getDistance(traceID)) dists.append(shot.getDistance(traceID))
picks.append(shot.getPick_backup(traceID)) picks.append(shot.getPickIncludeRemoved(traceID))
snrs.append(shot.getSNR(traceID)[0]) snrs.append(shot.getSNR(traceID)[0])
snr_sqrt_inv.append(1/np.sqrt(shot.getSNR(traceID)[0])) snr_sqrt_inv.append(1/np.sqrt(shot.getSNR(traceID)[0]))
fit = np.polyfit(dists, snr_sqrt_inv, 1) fit = np.polyfit(dists, snr_sqrt_inv, 1)

15
pylot/core/pick/CharFuns.py
View File

@ -25,7 +25,7 @@ class CharacteristicFunction(object):
''' '''
SuperClass for different types of characteristic functions. SuperClass for different types of characteristic functions.
''' '''
def __init__(self, data, cut, t2=None, order=None, t1=None, fnoise=None): def __init__(self, data, cut, t2=None, order=None, t1=None, fnoise=None, stealthMode=False):
''' '''
Initialize data type object with information from the original Initialize data type object with information from the original
Seismogram. Seismogram.
@ -62,6 +62,7 @@ class CharacteristicFunction(object):
self.calcCF(self.getDataArray()) self.calcCF(self.getDataArray())
self.arpara = np.array([]) self.arpara = np.array([])
self.xpred = np.array([]) self.xpred = np.array([])
self._stealthMode = stealthMode
def __str__(self): def __str__(self):
return '''\n\t{name} object:\n return '''\n\t{name} object:\n
@ -135,6 +136,9 @@ class CharacteristicFunction(object):
def getXCF(self): def getXCF(self):
return self.xcf return self.xcf
def _getStealthMode(self):
return self._stealthMode()
def getDataArray(self, cut=None): def getDataArray(self, cut=None):
''' '''
If cut times are given, time series is cut from cut[0] (start time) If cut times are given, time series is cut from cut[0] (start time)
@ -219,7 +223,8 @@ class AICcf(CharacteristicFunction):
def calcCF(self, data): def calcCF(self, data):
#print 'Calculating AIC ...' ## MP MP output suppressed #if self._getStealthMode() is False:
# print 'Calculating AIC ...'
x = self.getDataArray() x = self.getDataArray()
xnp = x[0].data xnp = x[0].data
nn = np.isnan(xnp) nn = np.isnan(xnp)
@ -257,11 +262,13 @@ class HOScf(CharacteristicFunction):
if len(nn) > 1: if len(nn) > 1:
xnp[nn] = 0 xnp[nn] = 0
if self.getOrder() == 3: # this is skewness if self.getOrder() == 3: # this is skewness
print 'Calculating skewness ...' #if self._getStealthMode() is False:
# print 'Calculating skewness ...'
y = np.power(xnp, 3) y = np.power(xnp, 3)
y1 = np.power(xnp, 2) y1 = np.power(xnp, 2)
elif self.getOrder() == 4: # this is kurtosis elif self.getOrder() == 4: # this is kurtosis
#print 'Calculating kurtosis ...' ## MP MP output suppressed #if self._getStealthMode() is False:
# print 'Calculating kurtosis ...'
y = np.power(xnp, 4) y = np.power(xnp, 4)
y1 = np.power(xnp, 2) y1 = np.power(xnp, 2)

6
pylot/core/pick/utils.py
View File

@ -15,7 +15,7 @@ from obspy.core import Stream, UTCDateTime
import warnings import warnings
def earllatepicker(X, nfac, TSNR, Pick1, iplot=None): def earllatepicker(X, nfac, TSNR, Pick1, iplot=None, stealthMode = False):
''' '''
Function to derive earliest and latest possible pick after Diehl & Kissling (2009) Function to derive earliest and latest possible pick after Diehl & Kissling (2009)
as reasonable uncertainties. Latest possible pick is based on noise level, as reasonable uncertainties. Latest possible pick is based on noise level,
@ -44,7 +44,8 @@ def earllatepicker(X, nfac, TSNR, Pick1, iplot=None):
LPick = None LPick = None
EPick = None EPick = None
PickError = None PickError = None
#print 'earllatepicker: Get earliest and latest possible pick relative to most likely pick ...' if stealthMode is False:
print 'earllatepicker: Get earliest and latest possible pick relative to most likely pick ...'
x = X[0].data x = X[0].data
t = np.arange(0, X[0].stats.npts / X[0].stats.sampling_rate, t = np.arange(0, X[0].stats.npts / X[0].stats.sampling_rate,
@ -75,6 +76,7 @@ def earllatepicker(X, nfac, TSNR, Pick1, iplot=None):
# if EPick stays NaN the signal window size will be doubled # if EPick stays NaN the signal window size will be doubled
while np.isnan(EPick): while np.isnan(EPick):
if count > 0: if count > 0:
if stealthMode is False:
print("\nearllatepicker: Doubled signal window size %s time(s) " print("\nearllatepicker: Doubled signal window size %s time(s) "
"because of NaN for earliest pick." %count) "because of NaN for earliest pick." %count)
isigDoubleWinStart = pis[-1] + 1 isigDoubleWinStart = pis[-1] + 1