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')