#!/usr/bin/env python

# coding: utf-8

# In[1]:

from __future__ import division, absolute_import

from __future__ import print_function, unicode_literals

import glob

import numpy as np

import obspy

from obspy.geodetics import calc_vincenty_inverse

# from IPython.display import HTML

import matplotlib.pyplot as plt

import matplotlib.patches as mpatches

from matplotlib.collections import PatchCollection

from matplotlib import animation, rc

from mpl_toolkits.mplot3d import Axes3D

import mpl_toolkits.mplot3d.art3d as art3d

import cartopy.crs as ccrs

import cartopy.feature as cfeature

from tqdm import tqdm as tqdm

import re

import datetime

import pandas as pd

import seaborn as sns

sns.set_style("white")

sns.set_context("talk")

#rc('animation', html='jshtml')

# In[2]:

def plot_map():

return fig, ax

# In[3]:

def get_point_from(lat, lon, dist, az):

return np.degrees(lat2), np.degrees(lon2)

def get_dist_circle(lat, lon, dist):

return cx, cy

def notebook_anim(fig, anim_func, *args, **kwargs):

anim = animation.FuncAnimation(fig, anim_func, *args, **kwargs)

return anim

def write_anim_avi(anim, fps, filename):

Writer = animation.writers['ffmpeg']

writer = Writer(fps=fps, metadata=dict(artist='DerJeofizik'), bitrate=1800)

anim.save(filename, writer=writer)

# In[4]:

# First set up the figure, the axis, and the plot element we want to animate

fig, ax = plot_map()

# lat = 40.70

# lon = 29.91

evlo = 29.9870

evla = 40.7250

vp = 8.0

vs = 5.0

ax.set_extent([25, 33, 39, 42])

ax.scatter(evlo, evla, 200, marker="*", color="magenta", zorder=10)

cx, cy = get_dist_circle(evla, evlo, 0)

pline, = ax.plot(

cy, cx, color="b", transform=ccrs.Geodetic(), label="P dalgasi", zorder=10

)

sline, = ax.plot(

cy, cx, color="r", transform=ccrs.Geodetic(), label="S dalgasi", zorder=10

)

ax.legend()

fig.tight_layout()

lons = [29.88152, 29.66667, 29.063448, 30.435763, 31.15654, 28.7214, 28.9774, 29.1936]

lats = [40.85327, 40.65000, 40.266864, 40.693997, 40.843849, 40.9792, 41.0371, 40.8999]

labels = [

]

ax.scatter(lons, lats, 10, marker="o", color="k", zorder=10, transform=ccrs.Geodetic())

for label, lat, lon in zip(labels, lats, lons):

ax.text(

lon,

lat,

label,

fontsize=12,

verticalalignment="bottom",

horizontalalignment="center",

transform=ccrs.Geodetic(),

)

fault_lons = [

]

fault_lats = [

]

for lons, lats in zip(fault_lons, fault_lats):

ax.plot(lons, lats, "-k", lw=5, zorder=8, transform=ccrs.Geodetic())

size_t = 100

size_amp = 0.1

stations = []

for filename in glob.glob("./seismic_data/*.HGZ.SAC"):

tr = obspy.read(filename, format="SAC")[0]

for _ in range(2):

tr.detrend("demean")

tr.detrend("linear")

tr.taper(0.05)

tr.integrate()

tr_len = len(tr.data)

tr_plot, = ax.plot([], [], "r", zorder=100, transform=ccrs.Geodetic())

dist_m, _, _ = calc_vincenty_inverse(

evla, evlo, tr.stats.sac.stla, tr.stats.sac.stlo

)

p_arrival = dist_m / 1000 / vp

stations.append(

{

"name": tr.id,

"lat": tr.stats.sac.stla,

"lon": tr.stats.sac.stlo,

"trace": tr,

"length": tr_len,

"plot": tr_plot,

"amp_scale": size_amp / np.abs(tr.data).max(),

"time_scale": size_t / tr_len,

"t_offset": p_arrival - tr.stats.sac.a,

}

)

ax.scatter(

[s["lon"] for s in stations],

[s["lat"] for s in stations],

50,

marker="v",

color="r",

zorder=20,

)

def init():

return (pline,)

fps = 1

frames = 30 * fps

pbar = None

def animate(i):

return pline, sline

anim = notebook_anim(

)

write_anim_avi(anim, fps, "wave_propagation.avi")

#anim

# In[5]:

def ramp_value(rise_time, rupture_time, t):

return 1.0/rise_time*rt

# In[6]:

data_started = False

xs = []

ys = []

zs = []

slips = []

was_here = False

pp = None

offsetX = 0

offsetY = 0

read_top_center_next = False

read_len_wid_next = False

source_lat = 0.0

source_lon = 0.0

source_depth = 0.0

center_lat = 0.0

center_lon = 0.0

segment_width = 0

segment_length = 0

rises = []

trups = []

loc = re.compile(

r"""^% Loc\s+:\s+LAT\s+=\s+(?P<lat>[\.\d]+)\s+LON\s+=\s+(?P<lon>[\.\d]+)\s+DEP\s+=\s+(?P<depth>[\.\d]+)"""

)

segment = re.compile(

".*STRIKE\s+=\s+(?P<strike>[\.\d]+)\s+deg\s+DIP\s+=\s+(?P<dip>[\.\d]+)\s+deg.*"

)

segment2 = re.compile(

".*LEN\s+=\s+(?P<len>[\.\d]+)\s+km\s+WID\s+=\s+(?P<wid>[\.\d]+)\s+km.*"

)

fig, ax = plt.subplots(figsize=(7, 5), subplot_kw={"projection": "3d"})

patches = []

with open("s1999IZMITT01BOUC.fsp") as f:

for line in tqdm(f):

if line.startswith("%"):

if line.startswith("% Loc"):

m = loc.match(line)

if m:

vals = m.groupdict()

source_lat = float(vals["lat"])

source_lon = float(vals["lon"])

source_depth = float(vals["depth"])

else:

raise Exception("Couldn't read Location line")

elif read_top_center_next:

center_lat, center_lon = [

float(x.split("=")[1]) for x in line.split(",")

]

read_top_center_next = False

dist_m, az, baz = calc_vincenty_inverse(

source_lat, source_lon, center_lat, center_lon

)

dist_km = dist_m / 1000.0

offsetX = dist_km * np.sin(np.deg2rad(az))

offsetY = dist_km * np.cos(np.deg2rad(az))

proj_dist_km = np.dot(np.array((offsetX, offsetY, 0)), strike_v)

elif "coordinates of top-center:" in line:

read_top_center_next = True

elif "SEGMENT # " in line:

read_len_wid_next = True

m = segment.match(line)

if m:

vals = m.groupdict()

strike_r = np.deg2rad(float(vals["strike"]))

dip_r = np.deg2rad(float(vals["dip"]))

strike_v = np.array((np.sin(strike_r), np.cos(strike_r), 0))

strike_v /= np.linalg.norm(strike_v)

dip_v = np.array((0, 0, np.sin(dip_r)))

dip_v /= np.linalg.norm(dip_v)

else:

raise Exception("Couldn't read segment line: \n {}".format(line))

elif read_len_wid_next:

read_len_wid_next = False

m = segment2.match(line)

if m:

vals = m.groupdict()

segment_length = float(vals["len"])

segment_width = float(vals["wid"])

else:

raise Exception("Couldn't read second segment line.")

else:

data_started = True

lat, lon, x, y, z, slip, rise, trup = [float(x) for x in line.split()]

xs.append(x)

ys.append(y)

zs.append(z)

v = np.array((x, y, z))

strike_end = v + strike_v

dip_end = v+dip_v

far_end = v+strike_v+dip_v

patches.append((np.array([[x, strike_end[0]], [dip_end[0], far_end[0]]]),

np.array([[y, strike_end[1]], [dip_end[1], far_end[1]]]),

np.array([[z, strike_end[2]], [dip_end[2], far_end[2]]])))

trups.append(trup)

rises.append(rise)

slips.append(slip)

slips = np.array(slips)

ax.get_proj = lambda: np.dot(Axes3D.get_proj(ax), np.diag([2.0, 0.1, 1.0, 1]))

ax.view_init(30, -120)

ax.set_zlim([18, 0])

# animation function. This is called sequentially

fps = 1

frames = 30 * fps

max_slip = np.max(slips)

def init():

return plots

def animate(i):

return plots

norm = plt.Normalize(0, 7)

colors = plt.cm.jet(norm(slips))

cmap = plt.cm.get_cmap("jet")

plots = []

anim = notebook_anim(

fig, animate, init_func=init, frames=frames, interval=1000.0 / fps, blit=True, save_count=frames

)

write_anim_avi(anim, fps, "bouc_fault_plane.avi")

#anim

# In[7]:

events = []

lats = []

lons = []

mags = []

dates = []

with open("./depremler.txt") as f:

f.readline() # Header

for line in f:

data = line.split()

lats.append(float(data[4]))

lons.append(float(data[5]))

mags.append(float(data[7]))

dates.append(

datetime.datetime.strptime(" ".join(data[2:4])[:-3], "%Y.%m.%d %H:%M:%S")

)

events.append(

{

"date": datetime.datetime.strptime(

" ".join(data[2:4])[:-3], "%Y.%m.%d %H:%M:%S"

),

"lat": float(data[4]),

"lon": float(data[5]),

"mag": float(data[7]),

}

)

mags = np.array(mags)

start = min(dates)

stop = max(dates)

length = max(dates) - min(dates)

df = pd.DataFrame(events)

steps = np.logspace(-2, 0, frames)

inv_steps = 1.0 // steps

pbar = None

sc = None

def increments(start, end, x_after_a_day=2):

i += 1

incs = list(increments(start, stop))

frames = len(incs)

fps = 10

def init():

return (sc,)

def animate(i):

return (sc,)

fig, ax = plot_map()

ax.set_extent([25, 33, 39, 42])

mags = [3.5, 4.5, 5.5, 6.5, 7.4]

mag_labels = ["3.0-3.9", "4.0-4.9", "5.0-5.9", "6.0-6.9", "> 7.0"]

cmap = plt.cm.get_cmap("jet")

for mag, label in zip(mags, mag_labels):

ax.scatter(

0,

0,

c=cmap((mag - 3.0) / 4.4),

s=mag ** 3,

alpha=0.5,

cmap="jet",

zorder=0,

label=label,

)

ax.legend()

anim = notebook_anim(

)

write_anim_avi(anim, fps, "aftershocks.avi")

# anim

# End.