def filterClusterStationMinimumNumber(CentroidList, StationClusterList,
Config):
newCentroidList = []
newStationClusterList = []
for i in CentroidList:
counter = 0
for j in StationClusterList:
if i.rank == j.member:
counter += 1
streamID = j.net + '.' + j.sta + '.' + j.loc + '.' + j.comp
delta = loc2degrees(i, j)
#print i.lat,i.lon,': ',streamID,j.lat,j.lon,delta
if counter < int(Config['minclusterstation']): s1 = 'OUT'
else:
s1 = 'IN '
newCentroidList.append(i)
Logfile.red('Centroid %s %d %s %5.2f %5.2f' %
(i.rank, counter, s1, i.lat, i.lon))
for i in newCentroidList:
for j in StationClusterList:
if i.rank == j.member:
newStationClusterList.append(j)
return newStationClusterList, newCentroidList
def compareClusterCentre(oldCluster, newCluster, Config):
counter = 0
for i in range(int(Config['maxcluster'])):
if newCluster[i].rank == -1: continue #hs-1
delta = loc2degrees(oldCluster[i], newCluster[i])
#print i,' OLD: ',oldCluster[i].lat,oldCluster[i].lon,' NEW: ',newCluster[i].lat,newCluster[i].lon,' DELTA: ',delta
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)
s = 'NO'
if delta < float(Config['comparedelta']):
s = 'JO'
counter += 1
Logfile.add(s)
#endfor
return counter
def filterStations(StationList, Config, Origin, network):
F = []
cfg = ConfigObj(dict=Config)
minDist, maxDist = cfg.FloatRange('mindist', 'maxdist')
origin = Location(Origin['lat'], Origin['lon'])
Logfile.red('Filter stations with configured parameters...')
print 'nr networks = ', len(network)
print 'nr stations = ', len(StationList)
for j in network:
#print j
for i in StationList:
if fnmatch.fnmatch(i.getcmpName(), 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 calctakeoff(Station, Event, Config):
de = loc2degrees(Event, Station)
Phase = cake.PhaseDef('P')
model = cake.load_model()
arrivals = model.arrivals([de, de], phases=Phase, zstart=Event.depth * km)
return arrivals[0].takeoff_angle()
def traveltimes(self, phase):
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')
model = cake.load_model('../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 = self.readWaveformsCross_pyrocko(i, tw, ptime)
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 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, 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 traveltimes(self):
Logfile.red('Enter AUTOMATIC CROSSCORRELATION ')
Logfile.red(
'\n\n+++++++++++++++++++++++++++++++++++++++++++++++++++\n ')
T = []
Wdict = {}
SNR = {}
for i in self.StationMeta:
Logfile.red('read in %s ' % (i))
de = loc2degrees(self.Origin, i)
tt = obs_TravelTimes(de, self.Origin.depth)
ptime = 0
phasename = ('%sphase') % (os.path.basename(self.AF))
for j in tt:
if j['phase_name'] == self.Config[phasename] or j[
'phase_name'] == ('%sdiff') % (self.Config[phasename]):
ptime = j['time']
T.append(ptime)
Logfile.add('%sdiff' % (self.Config[phasename]))
Logfile.add('j = ' + str(j))
if ptime == 0:
Logfile.red(
'Available phases for station %s in range %f deegree' %
(i, de))
# print '\033[31m'+'|'.join([str(item['phase_name']) for item in tt])+'' ???
Logfile.red('you tried phase %s' % (self.Config[phasename]))
raise Exception("ILLEGAL: phase definition")
tw = self.calculateTimeWindows(ptime)
try:
w, snr = self.readWaveformsCross(i, tw, ptime)
Wdict[i.getName()] = w
SNR[i.getName()] = snr
except:
continue
Logfile.red(
'\n\n+++++++++++++++++++++++++++++++++++++++++++++++++++ ')
Logfile.red('Exit AUTOMATIC FILTER ')
return Wdict, SNR
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):
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
#endfor
for index, k in enumerate(StationClusterList):
if k.member == -1: del StationClusterList[index]
return StationClusterList
def kmean(Config, inputCentroid, FilterMeta, counter, Folder, Origin, flag):
counter += 1
Logfile.add('COUNTER ' + str(counter) + ' CUTOFF ' + Config['cutoff'])
cfg = ConfigObj(dict=Config)
if counter == cfg.UInt('cutoff'):
endcheck(inputCentroid, FilterMeta, Config, Folder, Origin, flag)
sys.exit()
scl = stationBelongToCluster(Config, inputCentroid, FilterMeta)
#sys.exit()
#print scl,len(scl)
acounter = 1
for a in inputCentroid:
#print a
for i in scl:
if acounter == i.member:
delta = loc2degrees(i, a)
if delta > cfg.Float('initialstationdistance'):
i.member = -1
#print 'delete ',a,i,i.member,delta
#b=scl.index(i)
#del scl[b]
#else:
# print a,i,i.member,delta
acounter += 1
#endfor
#sys.exit()
nsc = calculateClusterCentre(Config, scl)
t = compareClusterCentre(inputCentroid, nsc, Config)
Logfile.add('ITERATIONSTEP: ---> ' + str(counter) +
' <-----------------------------')
while t != cfg.UInt('maxcluster'):
Logfile.add('ANZAHL DER JO in KMEAN: ' + str(t))
kmean(Config, nsc, FilterMeta, counter, Folder, Origin, flag)
endcheck(inputCentroid, FilterMeta, Config, Folder, Origin, flag)
sys.exit()
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 traveltimes(self):
Logfile.red('Enter AUTOMATIC FILTER')
T = []
Wdict = {}
for i in self.StationMeta:
de = loc2degrees(self.Origin, i)
tt = obs_TravelTimes(de, self.Origin.depth)
if tt[0]['phase_name'] == 'P':
time = tt[0]['time']
T.append(time)
tw = self.calculateTimeWindows(time)
w = self.readWaveformsCross(i, tw)
Wdict[i.getName()] = w
Logfile.red('Exit AUTOMATIC FILTER')
return Wdict
def calctakeoff(Station, Event, Config):
de = loc2degrees(Event, Station)
tt = obs_TravelTimes(de, Event.depth)
cfgPhase = Config['phasename']
for k in tt:
phase_name = k['phase_name']
if phase_name == cfgPhase or phase_name == ('%sdiff') % (cfgPhase):
ttime = k['time']
if tt[0]['phase_name'] == Config['ttphase']:
takeoff = tt[0]['take-off angle']
#for r in tt:
# if r['phase_name'] is Config [phasename]:
# takeoff = r['take-off angle']
return takeoff
def traveltimes(MetaDict, Config, Event, Folder, evpath):
Logfile.red('Enter AUTOMATIC FILTER')
T = []
for i in MetaDict:
delta = loc2degrees(Event, i)
tt = obs_TravelTimes(delta, Event.depth)
if tt[0]['phase_name'] == Config['ttphase']:
time = tt[0]['time']
T.append(time)
mint = min(T)
maxt = max(T)
tw = times.calculateTimeWindows(mint, maxt, Config, Event, switch)
readWaveformsCross(i, tw, evpath, Event)
#endfor
Logfile.red('Exit AUTOMATIC FILTER')
def stationBelongToCluster(Config, CentroidList, StationMetaList):
ClusterList = []
for i in StationMetaList:
mind = 100000
c = 0
for j in CentroidList:
delta = loc2degrees(j, i)
c += 1
if mind > delta:
mind = delta
i.member = c
#endfor
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))
#endfor
return ClusterList
def addOK(station, stationList, Config, MetaList):
cfg = ConfigObj(dict=Config)
minDist = cfg.Distance('centroidmindistance')
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 traveltimes(self):
logger.info('\033[31m Enter AUTOMATIC FILTER \033[0m')
T = []
Wdict = {}
SNR = {}
for i in self.StationMeta:
#de = locations2degrees (float(self.Origin.lat), float(self.Origin.lon), float(i.lat), float(i.lon))
de = loc2degrees(self.Origin, i)
tt = getTravelTimes(delta=de,
depth=float(self.Origin.depth),
model='ak135')
if tt[0]['phase_name'] == 'P':
ptime = tt[0]['time']
T.append(ptime)
logger.info(
'\033[31m \n\n+++++++++++++++++++++++++++++++++++++++++++++++++++ \033[0m'
)
print i.getName(), i.lat, i.lon, ptime
ttime = ptime
tw = self.calculateTimeWindows(ptime)
try:
w, snr = self.readWaveformsCross(i, tw, ttime)
Wdict[i.getName()] = w
SNR[i.getName()] = snr
except:
continue
logger.info('\033[31m Exit AUTOMATIC FILTER \033[0m')
return Wdict, SNR
def createRandomInitialCentroids(Config, StationMetaList):
Logfile.red('Begin initial centroid search')
initialCentroids = []
usedIndexes = []
random.seed(time.clock())
if len(StationMetaList) == 0:
Logfile.red('Empty station list')
return initialCentroids
MAX_TIME_ALLOWED = 50
start = time.time()
while len(initialCentroids) < int(Config['maxcluster']):
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:
Logfile.red('found initial cluster %d' % (len(initialCentroids)))
Logfile.red('centroid %s with %d stations around %s deegree' %
(StationMetaList[randomIndex], around,
Config['centroidmindistance']))
Logfile.red('Initial centroid search finished')
return initialCentroids
def calcTTTAdv(Config, station, Origin, flag, arrayname, Xcorrshift, Refshift,
phase):
cfg = ConfigObj(dict=Config)
if cfg.Bool('correct_shifts_empirical') is True:
dimX = cfg.Int('dimx_emp')
dimY = cfg.Int('dimy_emp')
else:
dimX = cfg.Int('dimx')
dimY = cfg.Int('dimy')
gridspacing = cfg.Float('gridspacing')
traveltime_model = cfg.Str('traveltime_model')
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)
model = cake.load_model('../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)
GridArray[(i, j)] = GridElem(oLatul, oLonul, o_depth, 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)
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)
Basic.dumpToFile(str(flag) + '-ttt.pkl', TTTGridMap)
Basic.dumpToFile('minmax-' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-' + str(flag) + '.pkl', station)
def calcTTTAdv(Config,
station,
Origin,
flag,
arrayname,
Xcorrshift=None,
Refshift=None):
phasename = ('%sphase') % (os.path.basename(arrayname))
cfg = ConfigObj(dict=Config)
dimX = cfg.Int('dimx')
dimY = cfg.Int('dimy')
gridspacing = cfg.Float('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
#mint= 100000 #maxt=-100000
TTTGridMap = {}
LMINMAX = []
GridArray = {}
locStation = Location(station.lat, station.lon)
sdelta = loc2degrees(Location(o_lat, o_lon), locStation)
tt = obs_TravelTimes(sdelta, o_depth)
for r in tt:
if r['phase_name'] is Config[phasename] or r['phase_name'] == (
'%sdiff') % (Config[phasename]):
station.takeoff = r['take-off angle']
ph = r['phase_name']
#endfor
#15.12.2015 : rauskommentiert
#Logfile.add ('STATIONINFO ' + str(station) + ' ' + str(station.takeoff) + ' ' + str(ph),
# 'PROCESS %d STATION: %s --> DELTA: %f' % (flag,station,sdelta), ' ')
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):
ttime = 0
oLonul = o_lon - ((dimY - 1) / 2) * gridspacing + j * gridspacing
if o == 0 and j == 0: Lonul = oLonul
de = loc2degrees(Location(oLatul, oLonul), locStation)
tt = obs_TravelTimes(de, o_depth)
for k in tt:
if k['phase_name'] == Config[phasename] or k['phase_name'] == (
'%sdiff') % (Config[phasename]):
ttime = k['time']
if int(Config['xcorr']) == 1:
ttime = ttime - float(
Xcorrshift[station.getName()].shift) - Refshift
GridArray[(i, j)] = GridElem(oLatul, oLonul, o_depth,
ttime, de)
LMINMAX.append(ttime)
#endfor
if ttime == 0:
print '\033[31mAvailable phases for station %s in range %f deegree\033[0m' % (
station, de)
print '\033[31m' + '|'.join(
[str(item['phase_name']) for item in tt]) + '\033[0m'
print '\033[31myou tried phase %s\033[0m' % (Config[phasename])
raise Exception("\033[31mILLEGAL: phase definition\033[0m")
#endif
#endfor
#endfor
mint = min(LMINMAX)
maxt = max(LMINMAX) # maxt = time
TTTGridMap[station.getName()] = TTTGrid(o_depth, mint, maxt, Latul, Lonul,
oLator, oLonor, GridArray)
k = MinTMaxT(mint, maxt)
Basic.dumpToFile(str(flag) + '-ttt.pkl', TTTGridMap)
Basic.dumpToFile('minmax-' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-' + str(flag) + '.pkl', station)
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)
print 'DD2: ', durationpath
trigger.semblancestalta(sembmaxvaluev, sembmaxlatv, sembmaxlonv)
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
#endfor
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
print i, i.member, ' <--> ', k, k.member, ' delta: ', delta, ' allowed ', kd
if delta < kd: counter += 1
#endif
#endif
#endfor
print i, 'less then allowd ', counter
#endfor
print 'masxdist ', maxdist
def refTrigger(self, RefWaveform):
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('P')
model = cake.load_model()
if cfg.colesseo_input() == 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:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=o_depth * km - 0.1)
ptime = arrivals[0].t
phasename = ('%sphase') % (os.path.basename(self.AF))
if ptime == 0:
print '\033[31mAvailable phases for reference station %s in range %f deegree\033[0m' % (
i, de)
print '\033[31m' + '|'.join(
[str(item['phase_name']) for item in tt]) + '\033[0m'
print '\033[31myou tried phase %s\033[0m' % (
self.Config[phasename])
raise Exception("\033[31mILLEGAL: phase definition\033[0m")
tw = self.calculateTimeWindows(ptime)
if cfg.pyrocko_download() == True:
stP = self.readWaveformsPicker_pyrocko(i, tw, self.Origin, ptime)
elif cfg.colesseo_input() == True:
stP = self.readWaveformsPicker_colos(i, tw, self.Origin, ptime)
else:
stP = self.readWaveformsPicker(i, tw, self.Origin, ptime)
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(self.Config['refstationfreqmin']),
freqmax=float(self.Config['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(self.Config['refsta'])
lta = float(self.Config['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
print 'ONSET ', onset
except:
onset = self.mintforerun
trigger = trP.stats.starttime + onset
print 'TRIGGER ', trigger
print 'THEORETICAL: ', UTCDateTime(3600) + self.mintforerun
tdiff = (trP.stats.starttime + onset) - (UTCDateTime(3600) +
self.mintforerun)
print 'TDIFF: ', tdiff
refp = UTCDateTime(self.Origin.time) + ptime
reftriggeronset = refp + onset - self.mintforerun
if int(self.Config['autoxcorrcorrectur']) == 1:
try:
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']) # 4
thrOff = float(self.Config['refsta']) # 0.7
plotTrigger(trP, cft, thrOn, thrOff)
selection = float(
raw_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')
except:
selection = 0.
refname = os.path.basename(self.AF) + '-shift.mseed'
trP.stats.starttime = trP.stats.starttime - selection - self.mintforerun
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 calcTTTAdv(Config,
station,
Origin,
flag,
arrayname,
Xcorrshift=None,
Refshift=None):
phasename = ('%sphase') % (os.path.basename(arrayname))
cfg = ConfigObj(dict=Config)
dimX = cfg.Int('dimx')
dimY = cfg.Int('dimy')
gridspacing = cfg.Float('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(Config[phasename])
model = cake.load_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:
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:
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 int(Config['xcorr']) == 1:
ttime = ttime-float(Xcorrshift[station.getName()].shift)\
- Refshift
GridArray[(i, j)] = GridElem(oLatul, oLonul, o_depth, ttime,
de)
LMINMAX.append(ttime)
if ttime == 0:
print '\033[31mAvailable phases for station %s in range %f deegree\033[0m' % (
station, de)
print '\033[31m' + '|'.join(
[str(item['phase_name']) for item in tt]) + '\033[0m'
print '\033[31myou tried phase %s\033[0m' % (
Config[phasename])
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 - 2.5,
zstop=o_depth * km - 2.5,
refine=True)
ttime = arrivals[0].t
except:
arrivals = model.arrivals([de, de],
phases=Phase,
zstart=o_depth * km - 2.5,
zstop=0.,
refine=True)
ttime = arrivals[0].t
GridArray[(i, j)] = GridElem(oLatul, oLonul, o_depth, ttime,
de)
LMINMAX.append(ttime)
if int(Config['xcorr']) == 1:
ttime = ttime-float(Xcorrshift[station.getName()].shift)\
- Refshift
GridArray[(i, j)] = GridElem(oLatul, oLonul, o_depth, ttime,
de)
LMINMAX.append(ttime)
if ttime == 0:
print '\033[31mAvailable phases for station %s in range %f deegree\033[0m' % (
station, de)
print '\033[31m' + '|'.join(
[str(item['phase_name']) for item in tt]) + '\033[0m'
print '\033[31myou tried phase %s\033[0m' % (
Config[phasename])
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)
Basic.dumpToFile(str(flag) + '-ttt.pkl', TTTGridMap)
Basic.dumpToFile('minmax-' + str(flag) + '.pkl', k)
Basic.dumpToFile('station-' + str(flag) + '.pkl', station)
def calcTTTAdvTauP(Config,
station,
Origin,
flag,
Xcorrshift=None,
Refshift=None):
cfg = ConfigObj(dict=Config)
dimX = cfg.Int('dimx')
dimY = cfg.Int('dimy')
gridspacing = cfg.Float('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
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)
#os.system(cmd)
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)
#endfor
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)
#endfor
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)
try:
os.remove(inputpath)
os.remove(outputpath)
os.remove(errorpath)
except:
Logfile.exception('cannot delete files')
