def calctakeoff(Station, Event, Config):
de = loc2degrees(Event, Station)
Phase = cake.PhaseDef('P')
arrivals = model.arrivals([de, de], phases=Phase, zstart=Event.depth * km)
return arrivals[0].takeoff_angle()
def kmean(Config, inputCentroid, FilterMeta, counter, Folder, Origin, flag):
counter += 1
Logfile.add('COUNTER ' + str(counter) + ' CUTOFF ' + Config['cutoff'])
cfg = ConfigObj(dict=Config)
scl = stationBelongTocluster(Config, inputCentroid, FilterMeta)
acounter = 1
for a in inputCentroid:
for i in scl:
if acounter == i.member:
delta = loc2degrees(i, a)
if delta > cfg.Float('initialstationdistance'):
i.member = -1
acounter += 1
if counter == cfg.UInt('cutoff'):
endcheck(inputCentroid, FilterMeta, Config, Folder, Origin, flag)
sys.exit()
nsc = calculateclusterCentre(Config, scl)
t = compareclusterCentre(inputCentroid, nsc, Config)
Logfile.add('ITERATIONSTEP: ---> ' + str(counter) +
' <-----------------------------')
while t < cfg.UInt('maxcluster'):
Logfile.add('number of arrays in KMEAN: ' + str(t))
kmean(Config, nsc, FilterMeta, counter, Folder, Origin, flag)
endcheck(inputCentroid, FilterMeta, Config, Folder, Origin, flag)
sys.exit()
def traveltimes(self, phase, traces):
Logfile.red('Enter AUTOMATIC CROSSCORRELATION ')
Logfile.red('\n\n+++++++++++++++++++++++++++++++++++++++++++++++\n ')
T = []
Wdict = OrderedDict()
SNR = OrderedDict()
Config = self.Config
cfg = ConfigObj(dict=Config)
for i in self.StationMeta:
Logfile.red('read in %s ' % (i))
de = loc2degrees(self.Origin, i)
Phase = cake.PhaseDef(phase)
traveltime_model = cfg.Str('traveltime_model')
path = palantiri.__path__
model = cake.load_model(path[0] + '/data/' + traveltime_model)
if cfg.colesseo_input() is True:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=self.Origin.depth,
zstop=0.)
else:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=self.Origin.depth * km,
zstop=0.)
try:
ptime = arrivals[0].t
except Exception:
try:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=self.Origin.depth * km -
2.1)
ptime = arrivals[0].t
except Exception:
ptime = 0
T.append(ptime)
if ptime == 0:
Logfile.red('Available phases for station %s in\
range %f deegree' % (i, de))
Logfile.red('you tried phase %s' % (phase))
raise Exception("ILLEGAL: phase definition")
else:
tw = self.calculateTimeWindows(ptime)
if cfg.pyrocko_download() is True:
w, snr, found = self.readWaveformsCross_pyrocko(
i, tw, ptime, traces)
elif cfg.colesseo_input() is True:
w, snr = self.readWaveformsCross_colesseo(i, tw, ptime)
else:
w, snr = self.readWaveformsCross(i, tw, ptime)
Wdict[i.getName()] = w
SNR[i.getName()] = snr
Logfile.red('\n\n+++++++++++++++++++++++++++++++++++++++++++++++ ')
Logfile.red('Exit AUTOMATIC FILTER ')
return Wdict, SNR
def filterBestSolution(solution):
evp = os.path.join('/',*solution.path.split('/')[:-2])
C= Config(evp)
Conf = C.parseConfig('config')
cfg = ConfigObj(dict=Conf)
SL = []
M= []
fobj = open(os.path.join(solution.path, 'event.stations'),'r')
for s in fobj:
try:
line = s.split()
net,sta,loc,comp = line[0].split('.')
slat= line[1]
slon= line[2]
smember = line[3]
M.append(smember)
SL.append(Station(net,sta,loc,comp,lat=slat,lon=slon,member=smember))
except:
Logfile.exception('filterBestSolution', '<' + s + '>')
continue
fobj.close()
M = list(set(M))
Logfile.add('number of clusters ' + str(len(M)),
'number of stations ' + str(len(SL)))
kd = obs_kilometer2degrees(cfg.Distance('intraclusterdistance'))
Logfile.add('icd ' + str(kd))
maxdist = -1
for i in SL:
counter = 0
for k in SL:
if i.member == '8' and k.member == '8':
if i.getName() != k.getName():
delta = loc2degrees(i, k)
if delta > maxdist:
maxdist = delta
if delta < kd:
counter +=1
print(i, 'less then allowd ', counter)
print('masxdist ', maxdist)
def calcMeanCentroidDistance(CentroidList):
sumdelta = 0
for i in CentroidList:
for j in CentroidList:
sumdelta += loc2degrees(i, j)
meanCentroidDistance = sumdelta / len(CentroidList)
return meanCentroidDistance
def checkStationAroundInitialCentroid(station, cfg, StationMetaList):
initDist = cfg.config_cluster.initialstationdistance
counter = 0
for i in StationMetaList:
sdelta = loc2degrees(station, i)
if sdelta < initDist:
counter += 1
return counter
def checkStationAroundInitialCentroid(station, Config, StationMetaList):
cfg = ConfigObj(dict=Config)
initDist = cfg.Float('initialstationdistance')
counter = 0
for i in StationMetaList:
sdelta = loc2degrees(station, i)
if sdelta < initDist:
counter += 1
return counter
def calcMinValue(CentroidList):
mCD = calcMeanCentroidDistance(CentroidList)
sumdelta = 0
for i in CentroidList:
for j in CentroidList:
delta = loc2degrees(i, j)
x = (delta - mCD)
sumdelta += math.pow(x, 2)
minval = sumdelta / len(CentroidList)
return minval
def deleteFarStations(CentroidList, StationclusterList, Config):
stationdistance = int(Config.config_cluster.stationdistance)
for i in CentroidList:
for j in StationclusterList:
if i.rank == j.member:
if loc2degrees(i, j) > stationdistance:
j.member = -1
for index, k in enumerate(StationclusterList):
if k.member == -1:
del StationclusterList[index]
return StationclusterList
def deleteFarStations(CentroidList, StationclusterList, Config):
cfg = ConfigObj(dict=Config)
stationdistance = int(cfg.Distance('stationdistance'))
for i in CentroidList:
for j in StationclusterList:
if i.rank == j.member:
if loc2degrees(i, j) > stationdistance:
j.member = -1
for index, k in enumerate(StationclusterList):
if k.member == -1:
del StationclusterList[index]
return StationclusterList
def filterStations(StationList, Config, Origin):
F = []
cfg = ConfigObj(dict=Config)
minDist, maxDist = cfg.FloatRange('mindist', 'maxdist')
origin = DataTypes.dictToLocation(Origin)
Logfile.red('Filter stations with configured parameters')
for i in StationList:
sdelta = loc2degrees(origin, i)
if sdelta > minDist and sdelta < maxDist:
F.append(
Station(i.net, i.sta, i.loc, i.comp, i.lat, i.lon, i.ele,
i.dip, i.azi, i.gain))
Logfile.red('%d STATIONS LEFT IN LIST' % len(F))
return F
def compareclusterCentre(oldcluster, newcluster, Config):
counter = 0
for i in range(int(Config['maxcluster'])):
if newcluster[i].rank == -1:
continue
delta = loc2degrees(oldcluster[i], newcluster[i])
msg = str(i) + ' OLD: ' + str(oldcluster[i].lat) + ' ' + str(
oldcluster[i].lon)
msg += ' NEW: ' + str(newcluster[i].lat) + ' ' + str(
newcluster[i].lon) + ' DELTA: ' + str(delta)
Logfile.add(msg)
if delta < float(Config['centroidmindistance']):
counter += 1
return counter
def filterStations(StationList, cfg, Origin):
F = []
minDist = cfg.config_cluster.minDist
maxDist = cfg.config_cluster.maxDist
origin = DataTypes.dictToLocation(Origin)
Logfile.red('Filter stations with configured parameters')
for i in StationList:
sdelta = loc2degrees(origin, i)
if sdelta > minDist and sdelta < maxDist:
F.append(
Station(i.net, i.sta, i.loc, i.comp, i.lat, i.lon, i.ele,
i.dip, i.azi, i.gain))
Logfile.red('%d STATIONS LEFT IN LIST' % len(F))
return F
def addOK(station, stationList, cfg, MetaList):
minDist = 0
minAround = cfg.config_cluster.minStationAroundInitialcluster
t = 0
for i in stationList:
sdelta = loc2degrees(station, i)
if sdelta > minDist:
aroundcounter = checkStationAroundInitialCentroid(
station, cfg, MetaList)
if aroundcounter >= minAround:
t = 1
else:
t = 0
return t
else:
t = 0
return t
return t
def filterStations(StationList, Config, Origin, network, cfg_yaml):
F = []
cfg = ConfigObj(dict=Config)
minDist = cfg_yaml.config_cluster.minDist
maxDist = cfg_yaml.config_cluster.maxDist
origin = Location(Origin['lat'], Origin['lon'])
Logfile.red('Filter stations with configured parameters...')
for j in network:
for i in StationList:
if str(i.getcmpName()[:-2]) == str(j) or str(
i.getcmpName()[:]) == str(j):
pos = Location(i.lat, i.lon)
sdelta = loc2degrees(origin, pos)
if sdelta > minDist and sdelta < maxDist:
s = Station(i.net, i.sta, i.loc, i.comp, i.lat, i.lon,
i.ele, i.dip, i.azi, i.gain)
if s not in F:
F.append(s)
Logfile.red('%d STATIONS LEFT IN LIST' % len(F))
return F
def stationBelongTocluster(Config, CentroidList, StationMetaList):
clusterList = []
for i in StationMetaList:
mind = 0
c = 0
for j in CentroidList:
delta = abs(loc2degrees(j, i))
c += 1
if mind == 0:
mind = delta
i.member = c
else:
if delta < mind:
mind = delta
i.member = c
clusterList.append(
Station(i.net, i.sta, i.loc, i.comp, i.lat, i.lon, i.ele, i.dip,
i.azi, i.gain, i.member))
return clusterList
def addOK(station, stationList, Config, MetaList):
cfg = ConfigObj(dict=Config)
minDist = 0
minAround = cfg.UInt('minstationaroundinitialcluster')
t = 0
for i in stationList:
sdelta = loc2degrees(station, i)
if sdelta > minDist:
aroundcounter = checkStationAroundInitialCentroid(
station, Config, MetaList)
if aroundcounter >= minAround:
t = 1
else:
t = 0
return t
else:
t = 0
return t
return t
def refTrigger(self, RefWaveform, phase, cfg_yaml):
Config = self.Config
cfg = ConfigObj(dict=Config)
name = ('%s.%s.%s.%s') % (RefWaveform[0].stats.network,
RefWaveform[0].stats.station,
RefWaveform[0].stats.location,
RefWaveform[0].stats.channel)
i = self.searchMeta(name, self.StationMeta)
de = loc2degrees(self.Origin, i)
ptime = 0
Phase = cake.PhaseDef(phase)
model = cake.load_model()
if cfg_yaml.config_data.colesseo_input is True:
arrivals = model.arrivals([de, de], phases=Phase,
zstart=self.Origin.depth, zstop=0.)
else:
arrivals = model.arrivals([de, de], phases=Phase,
zstart=self.Origin.depth*km, zstop=0.)
try:
ptime = arrivals[0].t
except Exception:
arrivals = model.arrivals([de, de], phases=Phase,
zstart=self.Origin.depth*km-0.1)
ptime = arrivals[0].t
if ptime == 0:
raise Exception("\033[31mILLEGAL: phase definition\033[0m")
tw = self.calculateTimeWindows(ptime)
if cfg_yaml.config_data.pyrocko_download is True:
stP = self.readWaveformsPicker_pyrocko(i, tw, self.Origin, ptime,
cfg_yaml)
elif cfg_yaml.config_data.colesseo_input is True:
stP = self.readWaveformsPicker_colos(i, tw, self.Origin, ptime,
cfg_yaml)
else:
stP = self.readWaveformsPicker(i, tw, self.Origin, ptime, cfg_yaml)
refuntouchname = os.path.basename(self.AF)+'-refstation-raw.mseed'
stP.write(os.path.join(self.EventPath, refuntouchname), format='MSEED',
byteorder='>')
stP.filter("bandpass",
freqmin=float(cfg_yaml.config_xcorr.refstationfreqmin),
freqmax=float(cfg_yaml.config_xcorr.refstationfreqmax))
stP.trim(tw['xcorrstart'], tw['xcorrend'])
trP = stP[0]
trP.stats.starttime = UTCDateTime(3600)
refname = os.path.basename(self.AF)+'-refstation-filtered.mseed'
trP.write(os.path.join(self.EventPath, refname), format='MSEED',
byteorder='>')
sta = float(cfg_yaml.config_xcorr.refsta)
lta = float(cfg_yaml.config_xcorr.reflta)
cft = recSTALTA(trP.data, int(sta * trP.stats.sampling_rate),
int(lta * trP.stats.sampling_rate))
t = triggerOnset(cft, lta, sta)
try:
onset = t[0][0] / trP.stats.sampling_rate
except Exception:
onset = self.mintforerun
trigger = trP.stats.starttime+onset
tdiff = (trP.stats.starttime + onset)-(UTCDateTime(3600)
+ self.mintforerun)
refp = UTCDateTime(self.Origin.time)+ptime
reftriggeronset = refp+onset-self.mintforerun
if cfg_yaml.config_xcorr.autoxcorrcorrectur is True:
refmarkername = os.path.join(self.EventPath,
('%s-marker') % (os.path.basename(
self.AF)))
fobjrefmarkername = open(refmarkername, 'w')
fobjrefmarkername.write('# Snuffler Markers File Version\
0.2\n')
fobjrefmarkername.write(('phase: %s 0 %s None None None XWStart None False\n') % (tw['xcorrstart'].strftime('%Y-%m-%d %H:%M:%S.%f'), name))
fobjrefmarkername.write(('phase: %s 0 %s None None None XWEnd None False\n') % (tw['xcorrend'].strftime('%Y-%m-%d %H:%M:%S.%f'), name))
fobjrefmarkername.write(('phase: %s 1 %s None None None TheoP None False\n') % (refp.strftime('%Y-%m-%d %H:%M:%S.%f'), name))
fobjrefmarkername.write(('phase: %s 3 %s None None None XTrig None False') % (reftriggeronset.strftime('%Y-%m-%d %H:%M:%S.%f'), name))
fobjrefmarkername.close()
cmd = 'snuffler %s --markers=%s&' % (os.path.join(
self.EventPath,
refuntouchname),
refmarkername)
os.system(cmd)
thrOn = float(self.Config['reflta'])
thrOff = float(self.Config['refsta'])
plotTrigger(trP, cft, thrOn, thrOff)
selection = float(input('Enter self picked phase in seconds: '))
tdiff = selection-self.mintforerun
refname = os.path.basename(self.AF)+'-shift.mseed'
trP.stats.starttime = trP.stats.starttime - selection
trP.write(os.path.join(self.EventPath, refname),
format='MSEED')
'''
tdiff = 0
trigger = trP.stats.starttime
'''
To = Trigger(name, trigger, os.path.basename(self.AF), tdiff)
return tdiff, To
def collectSembweighted(SembList,Config,Origin,Folder,ntimes,arrays,switch, weights):
'''
method to collect semblance matrizes from all processes and write them to file for each timestep
'''
Logfile.add ('start collect in collectSemb')
cfg= ConfigObj (dict=Config)
origin = ConfigObj (dict=Origin)
dimX = cfg.dimX() # ('dimx')
dimY = cfg.dimY() # ('dimy')
winlen = cfg.winlen () # ('winlen')
step = cfg.step() # ('step')
latv= []
lonv= []
gridspacing = cfg.Float ('gridspacing')
migpoints = dimX * dimY
o_lat = origin.lat() # float (Origin['lat'])
o_lon = origin.lon() # float (Origin['lon'])
oLatul = 0
oLonul = 0
z=0
for i in xrange(dimX):
oLatul = o_lat - ((dimX-1)/2) * gridspacing + i*gridspacing
if z == 0 and i == 0 :
Latul = oLatul
o=0
for j in xrange (dimY):
oLonul = o_lon - ((dimY-1)/2) * gridspacing + j*gridspacing
if o==0 and j==0:
Lonul = oLonul
latv.append (oLatul)
lonv.append (oLonul)
tmp=1
for a, w in zip(SembList, weights):
tmp *= a
#sys.exit()
sembmaxvaluev = num.ndarray (ntimes,dtype=float)
sembmaxlatv = num.ndarray (ntimes,dtype=float)
sembmaxlonv = num.ndarray (ntimes,dtype=float)
rc= UTCDateTime(Origin['time'])
rcs= '%s-%s-%s_%02d:%02d:%02d'% (rc.day,rc.month,rc.year, rc.hour,rc.minute,rc.second)
d = rc.timestamp
usedarrays = 5
folder = Folder['semb']
fobjsembmax = open (os.path.join (folder,'sembmax_%s.txt' % (switch)),'w')
for a, i in enumerate(tmp):
logger.info('timestep %d' % a)
fobj = open (os.path.join (folder,'%s-%s_%03d._weighted_semblance.ASC' % (switch,Origin['depth'],a)),'w')
#fobj = open (os.path.join (folder, '%03d.ASC' % a),'w')
fobj.write ('# %s , %s\n' % (d,rcs))
fobj.write ('# step %ds| ntimes %d| winlen: %ds\n' % (step,ntimes,winlen))
fobj.write ('# \n')
fobj.write ('# southwestlat: %.2f dlat: %f nlat: %f \n'%(Latul,gridspacing,dimX))
fobj.write ('# southwestlon: %.2f dlon: %f nlon: %f \n'%(Lonul,gridspacing,dimY))
fobj.write ('# ddepth: 0 ndepth: 1 \n')
sembmax = 0
sembmaxX = 0
sembmaxY = 0
origin = DataTypes.dictToLocation (Origin)
uncert = num.std(i) #maybe not std?
for j in range(migpoints):
x= latv[j]
y= lonv[j]
semb = i[j]
fobj.write ('%.2f %.2f %.20f\n' % (x,y,semb))
if semb > sembmax:
sembmax = semb;# search for maximum and position of maximum on semblance grid for given time step
sembmaxX = x;
sembmaxY = y;
delta = loc2degrees (Location (sembmaxX, sembmaxY), origin)
azi = toAzimuth (float(Origin['lat']), float(Origin['lon']),float(sembmaxX), float(sembmaxY))
sembmaxvaluev[a] = sembmax
sembmaxlatv[a] = sembmaxX
sembmaxlonv[a] = sembmaxY
fobjsembmax.write ('%d %.2f %.2f %.20f %.20f %d %03f %f %03f\n' % (a*step,sembmaxX,sembmaxY,sembmax,uncert,usedarrays,delta,float(azi),delta*119.19))
fobj.close()
fobjsembmax.close()
durationpath = os.path.join (folder, "duration.txt")
trigger.writeSembMaxValue (sembmaxvaluev,sembmaxlatv,sembmaxlonv,ntimes,Config,Folder)
trigger.semblancestalta (sembmaxvaluev,sembmaxlatv,sembmaxlonv)
def createRandomInitialCentroids(Config, StationMetaList):
Logfile.red('Begin initial centroid search')
cfg = ConfigObj(dict=Config)
initialCentroids = []
usedIndexes = []
random.seed(time.clock())
if len(StationMetaList) == 0:
Logfile.red('Empty station list')
return initialCentroids
MAX_TIME_ALLOWED = 350
start = time.time()
if int(Config['maxcluster']) == 0:
to = len(StationMetaList) - 1
else:
to = int(Config['maxcluster'])
while len(initialCentroids) < to:
dist_centroids = float(Config['centroidmindistance'])
randomIndex = random.randint(0, len(StationMetaList) - 1)
redraw = True
while redraw is True:
if randomIndex in usedIndexes:
randomIndex = random.randint(0, len(StationMetaList) - 1)
else:
if len(usedIndexes) > 2:
for rdx in usedIndexes:
s1 = StationMetaList[randomIndex]
s2 = StationMetaList[rdx]
delta = loc2degrees(s1, s2)
if delta >= dist_centroids:
redraw = False
else:
redraw = False
usedIndexes.append(randomIndex)
around = checkStationAroundInitialCentroid(
StationMetaList[randomIndex], Config, StationMetaList)
found = False
if len(initialCentroids) == 0:
initialCentroids.append(StationMetaList[randomIndex])
found = True
start = time.time()
else:
t = addOK(StationMetaList[randomIndex], initialCentroids, Config,
StationMetaList)
if (time.time() - start) > MAX_TIME_ALLOWED:
break
if t == 1:
if len(usedIndexes) > 1:
for rdx in usedIndexes:
s1 = StationMetaList[randomIndex]
s2 = StationMetaList[rdx]
delta = loc2degrees(s1, s2)
if delta >= dist_centroids:
initialCentroids.append(
StationMetaList[randomIndex])
found = True
else:
initialCentroids.append(StationMetaList[randomIndex])
found = True
else:
continue
if found:
initDist = cfg.Float('initialstationdistance')
Logfile.red('found initial cluster %d' % (len(initialCentroids)))
Logfile.red('centroid %s with %d stations around %s deegree' %
(StationMetaList[randomIndex], around, initDist))
Logfile.red('Initial centroid search finished')
return initialCentroids
def calcTTTAdvTauP(Config,
station,
Origin,
flag,
Xcorrshift=None,
Refshift=None,
flag_rpe=False):
cfg = ConfigObj(dict=Config)
if flag_rpe is False:
dimX = cfg.Int('dimx')
dimY = cfg.Int('dimy')
else:
dimX = cfg.Int('dimx_emp')
dimY = cfg.Int('dimy_emp')
gridspacing = cfg.config_geometry.gridspacing
print('done this')
o_lat = float(Origin['lat'])
o_lon = float(Origin['lon'])
o_depth = float(Origin['depth'])
oLator = o_lat + dimX / 2
oLonor = o_lon + dimY / 2
oLatul = 0
oLonul = 0
TTTGridMap = {}
LMINMAX = []
GridArray = {}
locStation = Location(station.lat, station.lon)
sdelta = loc2degrees(Location(o_lat, o_lon), locStation)
Logfile.add('TTT PROCESS %d STATION: %s --> DELTA: %f' %
(flag, station.getName(), sdelta))
inputpath = str(flag) + '-' + station.getName() + ".input"
outputpath = str(flag) + '-' + station.getName() + ".output"
errorpath = str(flag) + '-' + station.getName() + '.error'
fobjinput = open(inputpath, 'w')
fobjinput.write('s\n')
fobjinput.write(('%s %s\n') % (station.lat, station.lon))
fobjinput.write('h\n')
fobjinput.write(('%s\n') % (o_depth))
for i in xrange(dimX):
oLatul = o_lat - ((dimX - 1) / 2) * gridspacing + i * gridspacing
for j in xrange(dimY):
oLonul = o_lon - ((dimY - 1) / 2) * gridspacing + j * gridspacing
fobjinput.write('e\n')
fobjinput.write(('%s %s\n') % (oLatul, oLonul))
# endfor
fobjinput.close()
cmd = ('taup_time -ph P -mod ak135 -time -o %s < %s > %s') % (
outputpath, inputpath, errorpath)
p = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
p.wait()
L = []
output = open(outputpath, 'r')
'OUTPUT: ', outputpath
for k in output:
k = k.split()
if len(k) == 1:
tt = k[0].replace('\n', '')
tt = float(tt) - float(Xcorrshift[station.getName()].shift)
L.append(tt)
output.close()
z = 0
for i in xrange(dimX):
oLatul = o_lat - ((dimX - 1) / 2) * gridspacing + i * gridspacing
if z == 0 and i == 0:
Latul = oLatul
o = 0
for j in xrange(dimY):
oLonul = o_lon - ((dimY - 1) / 2) * gridspacing + j * gridspacing
if o == 0 and j == 0:
Lonul = oLonul
de = loc2degrees(Location(oLatul, oLonul), locStation)
time = L[i * dimX + j]
GridArray[(i, j)] = GridElem(oLatul, oLonul, o_depth, time, de)
LMINMAX.append(time)
mint = float(min(LMINMAX))
maxt = float(max(LMINMAX))
k = MinTMaxT(mint, maxt)
TTTGridMap[station.getName()] = TTTGrid(o_depth, mint, maxt, Latul, Lonul,
oLator, oLonor, GridArray)
#tttname = str(flag)+'-ttt.pkl'
#Basic.dumpToFile(tttname, TTTGridMap)
#Basic.dumpToFile('minmax-'+str(flag)+'.pkl', k)
if flag_rpe is True:
Basic.dumpToFile(str(flag) + '-ttt_emp.pkl', TTTGridMap)
Basic.dumpToFile('minmax-emp' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-emp' + str(flag) + '.pkl', station)
else:
Basic.dumpToFile(str(flag) + '-ttt.pkl', TTTGridMap)
Basic.dumpToFile('minmax-' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-' + str(flag) + '.pkl', station)
try:
os.remove(inputpath)
os.remove(outputpath)
os.remove(errorpath)
except:
Logfile.exception('cannot delete files')
def calcTTTAdv_cube(Config,
station,
Origin,
flag,
arrayname,
Xcorrshift,
Refshift,
phase,
flag_rpe=False):
cfg = ConfigObj(dict=Config)
if flag_rpe is True:
dimX = cfg.Int('dimx_emp')
dimY = cfg.Int('dimy_emp')
dimZ = cfg.Int('dimz_emp')
else:
dimX = cfg.Int('dimx')
dimY = cfg.Int('dimy')
dimZ = cfg.Int('dimz')
orig_depth = float(Origin['depth'])
start, stop, step = cfg.String('depths').split(',')
start = orig_depth + float(start)
stop = orig_depth + float(stop)
depths = np.linspace(start, stop, num=dimZ)
gridspacing = cfg.config_geometry.gridspacing
traveltime_model = cfg_yaml.config.traveltime_model
o_lat = float(Origin['lat'])
o_lon = float(Origin['lon'])
oLator = o_lat + dimX / 2
oLonor = o_lon + dimY / 2
oLatul = 0
oLonul = 0
o_dip = 80.
plane = False
TTTGridMap = {}
LMINMAX = []
GridArray = {}
locStation = Location(station.lat, station.lon)
sdelta = loc2degrees(Location(o_lat, o_lon), locStation)
Phase = cake.PhaseDef(phase)
path = palantiri.__path__
model = cake.load_model(path[0] + '/data/' + traveltime_model)
for depth in depths:
o_depth = depth
for i in xrange(dimX):
oLatul = o_lat - ((dimX - 1) / 2) * gridspacing + i * gridspacing
if i == 0:
Latul = oLatul
o = 0
for j in xrange(dimY):
oLonul = o_lon - (
(dimY - 1) / 2) * gridspacing + j * gridspacing
if o == 0 and j == 0:
Lonul = oLonul
de = loc2degrees(Location(oLatul, oLonul), locStation)
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=o_depth * km)
try:
ttime = arrivals[0].t
except Exception:
try:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=o_depth * km,
zstop=o_depth * km,
refine=True)
ttime = arrivals[0].t
except Exception:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=o_depth * km - 2.5,
zstop=o_depth * km + 2.5,
refine=True)
ttime = arrivals[0].t
GridArray[(i, j, depth)] = GridElem(oLatul, oLonul, o_depth,
ttime, de)
LMINMAX.append(ttime)
if ttime == 0:
raise Exception("\033[31mILLEGAL: phase definition\033[0m")
mint = min(LMINMAX)
maxt = max(LMINMAX)
TTTGridMap[station.getName()] = TTTGrid(o_depth, mint, maxt, Latul, Lonul,
oLator, oLonor, GridArray)
k = MinTMaxT(mint, maxt)
if flag_rpe is True:
Basic.dumpToFile(str(flag) + '-ttt_emp.pkl', TTTGridMap)
Basic.dumpToFile('minmax-emp' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-emp' + str(flag) + '.pkl', station)
else:
Basic.dumpToFile(str(flag) + '-ttt.pkl', TTTGridMap)
Basic.dumpToFile('minmax-' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-' + str(flag) + '.pkl', station)
def calcTTTAdv(cfg,
station,
Origin,
flag,
arrayname,
Xcorrshift,
Refshift,
phase,
flag_rpe=False):
if flag_rpe is True:
dimX = cfg.config_geometry.dimx_emp
dimY = cfg.config_geometry.dimy_emp
else:
dimX = cfg.config_geometry.dimx
dimY = cfg.config_geometry.dimy
gridspacing = cfg.config_geometry.gridspacing
o_lat = float(Origin['lat'])
o_lon = float(Origin['lon'])
o_depth = float(Origin['depth'])
oLator = o_lat + dimX / 2
oLonor = o_lon + dimY / 2
oLatul = 0
oLonul = 0
o_dip = 80.
plane = False
TTTGridMap = {}
LMINMAX = []
GridArray = {}
locStation = Location(station.lat, station.lon)
sdelta = loc2degrees(Location(o_lat, o_lon), locStation)
Phase = cake.PhaseDef(phase)
path = palantiri.__path__
traveltime_model = cfg.config.traveltime_model
model = cake.load_model(path[0] + '/data/' + traveltime_model)
z = 0
if plane is True:
depth = np.linspace(0., 40., num=dimY)
for i in xrange(70):
oLatul = o_lat - ((dimX - 1) / 2) * gridspacing + i * gridspacing
if z == 0 and i == 0:
Latul = oLatul
o = 0
start_time = time.clock()
for j in xrange(40):
oLonul = o_lon - (
(dimY - 1) /
2) * gridspacing + j * gridspacing / np.cos(o_dip)
if o == 0 and j == 0:
Lonul = oLonul
de = loc2degrees(Location(oLatul, oLonul), locStation)
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=depth[j] * km,
zstop=0.)
try:
ttime = arrivals[0].t
except Exception:
try:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=depth[j] * km - 2.5,
zstop=depth[j] * km + 2.5,
refine=True)
ttime = arrivals[0].t
except Exception:
tt = obs_TravelTimes(de, o_depth)
for k in tt:
if k['phase_name'] == 'P' or k['phase_name'] == (
'%sdiff') % (Config[phasename]):
ttime = k['time']
print("Something wrong with phase arrival, too large\
distances choosen?")
GridArray[(i, j)] = GridElem(oLatul, oLonul, depth[j], ttime,
de)
LMINMAX.append(ttime)
if ttime == 0:
raise Exception("\033[31mILLEGAL: phase definition\033[0m")
else:
for i in xrange(dimX):
oLatul = o_lat - ((dimX - 1) / 2) * gridspacing + i * gridspacing
if z == 0 and i == 0:
Latul = oLatul
o = 0
for j in xrange(dimY):
oLonul = o_lon - (
(dimY - 1) / 2) * gridspacing + j * gridspacing
if o == 0 and j == 0:
Lonul = oLonul
de = loc2degrees(Location(oLatul, oLonul), locStation)
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=o_depth * km)
try:
ttime = arrivals[0].t
except:
try:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=o_depth * km,
zstop=o_depth * km,
refine=True)
ttime = arrivals[0].t
except:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=o_depth * km - 2.5,
zstop=o_depth * km + 2.5,
refine=True)
ttime = arrivals[0].t
GridArray[(i, j)] = GridElem(oLatul, oLonul, o_depth, ttime,
de)
LMINMAX.append(ttime)
if ttime == 0:
raise Exception("\033[31mILLEGAL: phase definition\033[0m")
mint = min(LMINMAX)
maxt = max(LMINMAX)
TTTGridMap[station.getName()] = TTTGrid(o_depth, mint, maxt, Latul, Lonul,
oLator, oLonor, GridArray)
k = MinTMaxT(mint, maxt)
if flag_rpe is True:
Basic.dumpToFile(str(flag) + '-ttt_emp.pkl', TTTGridMap)
Basic.dumpToFile('minmax-emp' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-emp' + str(flag) + '.pkl', station)
else:
Basic.dumpToFile(str(flag) + '-ttt.pkl', TTTGridMap)
Basic.dumpToFile('minmax-' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-' + str(flag) + '.pkl', station)
