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)