+
+
+
+
+
+
+
+
+
+
+
+
+R Notebook
+ +library(gridExtra)
+library(ggplot2)
+library(cowplot)
+library(grid)
+library(gridExtra)
+library(lubridate)
+library(leaflet)
+library(zoo)
+library(pracma)
+library(plotrix)
+library(signal)
+
+Tide Buoy and Seismometer Data from 2011 Japan Earthquake
+
+
+Read in csv data
+apia <- read.csv("C:/Users/kelsa/OneDrive/Desktop/Documents/GEOG490/apia.csv")
+iturup <- read.csv("C:/Users/kelsa/OneDrive/Desktop/Documents/GEOG490/iturup.csv")
+guadalcanal <- read.csv("C:/Users/kelsa/OneDrive/Desktop/Documents/GEOG490/guadalcanal.csv")The month column in the dataset is in the format ‘3’ instead of ‘03’ +so it needs to be converted.
+### Convert 'MM' column to numeric
+apia$MM <- as.numeric(apia$MM)
+### Convert month column '3' to '03' format
+apia$MM <- sprintf("%02d", apia$MM)
+### Drop values where height is 9999
+apia <- apia[apia$HEIGHT != 9999, , drop = FALSE]
+### Create combined date column as POSIXct format
+apia$Date <- as.POSIXct(paste(apia$X.YY, apia$MM, apia$DD, apia$hh, apia$mm, apia$ss, sep = " "), format='%Y %m %d %H %M %S')
+
+Same for itrup
+iturup$MM <- as.numeric(iturup$MM)
+iturup$MM <- sprintf("%02d", iturup$MM)
+iturup <- iturup[iturup$HEIGHT != 9999, ]
+iturup$Date <- as.POSIXct(paste(iturup$X.YY, iturup$MM, iturup$DD, iturup$hh, iturup$mm, iturup$ss, sep = " "), format='%Y %m %d %H %M %S')
+
+And for guadalcanal
+guadalcanal$MM <- as.numeric(guadalcanal$MM)
+guadalcanal$MM <- sprintf("%02d", guadalcanal$MM)
+guadalcanal <- guadalcanal[guadalcanal$HEIGHT != 9999, ]
+guadalcanal$Date <- as.POSIXct(paste(guadalcanal$X.YY, guadalcanal$MM, guadalcanal$DD, guadalcanal$hh, guadalcanal$mm, guadalcanal$ss, sep = " "), format='%Y %m %d %H %M %S')
+
+Normalize height against the average
+apia_height_avg <- mean(apia$HEIGHT)
+apia$height_norm <- apia$HEIGHT - apia_height_avg
+
+iturup_height_avg <- mean(iturup$HEIGHT)
+iturup$height_norm <- iturup$HEIGHT - iturup_height_avg
+
+guadalcanal_height_avg <- mean(guadalcanal$HEIGHT)
+guadalcanal$height_norm <- guadalcanal$HEIGHT - guadalcanal_height_avgThe data has 3 different sampling frequencies, denoted by values of +1, 2, or 3 in the ‘T’ column of the data. A value of 1 is a 15 minute +sampling frequency, 2 is a 1 minute frequency, and 3 is a 15 second +frequency. To look at the distribution of the different sampling rates +in the data, Apia is split into 3 sets by the value in the ‘T’ column, +then plotted.
+
+
+Separate data by sampling frequency
+apia1 <- subset(apia, T == 1)
+apia2 <- subset(apia, T == 2)
+apia3 <- subset(apia, T == 3)
+
+Reset the row names for each DataFrame
+rownames(apia1) <- NULL
+rownames(apia2) <- NULL
+rownames(apia3) <- NULL
+
+Extract time columns for each DataFrame
+time1 <- apia1$Date
+time2 <- apia2$Date
+time3 <- apia3$Date
+
+apia1$Date <- as.POSIXct(paste(apia1$X.YY, apia1$MM, apia1$DD, apia1$hh, apia1$mm, apia1$ss, sep = " "), format='%Y %m %d %H %M %S')
+apia2$Date <- as.POSIXct(paste(apia2$X.YY, apia2$MM, apia2$DD, apia2$hh, apia2$mm, apia2$ss, sep = " "), format='%Y %m %d %H %M %S')
+apia3$Date <- as.POSIXct(paste(apia3$X.YY, apia3$MM, apia3$DD, apia3$hh, apia3$mm, apia3$ss, sep = " "), format='%Y %m %d %H %M %S')
+
+Create three separate plots
+plot1 <- ggplot(apia1, aes(x = Date, y = height_norm)) +
+geom_point(size = 0.7) +
+labs(title = "Apia1 vs Date", x = "Date", y = "Height Norm")+
+scale_x_datetime(limits = c(min(apia1$Date), max(apia1$Date)))
+
+plot2 <- ggplot(apia2, aes(x = Date, y = height_norm)) +
+geom_point(size = 0.7) +
+labs(title = "Apia2 vs Date", x = "Date", y = "Height Norm")+
+scale_x_datetime(limits = c(min(apia1$Date), max(apia1$Date)))
+
+plot3 <- ggplot(apia3, aes(x = Date, y = height_norm)) +
+geom_point(size = 0.7) +
+labs(title = "Apia3 vs Date", x = "Date", y = "Height Norm")+
+scale_x_datetime(limits = c(min(apia1$Date), max(apia1$Date)))
+
+# Arrange the plots in a grid layout
+grid.arrange(plot1, plot2, plot3, ncol = 1)
+
+
+
+Plot 1
+Now plot the raw data for each station, and add scatter points that +are colored by the sampling frequency.
+
+
+Scatter plot for apia
+plot1 <- ggplot(data = apia, aes(x = Date, y = height_norm, color = T)) +
+geom_line() +
+#geom_point(size = 1) +
+labs(x = " ", y = " ") +
+ggtitle("Apia") +
+geom_vline(xintercept = as.numeric(as.POSIXct("2011-03-11 05:46:24")), color = "red")+
+theme_minimal()+
+ylim(-0.6, 0.6)+
+scale_x_datetime(limits = c(as.POSIXct("2011-03-11 3:00:00"), max(apia$Date)))
+
+Scatter plot for guadalcanal
+plot2 <- ggplot(data = guadalcanal, aes(x = Date, y = height_norm, color = T)) +
+geom_line() +
+#geom_point(size = 1) +
+labs(x = " ", y = "Normalized Height") +
+ggtitle("Guadalcanal") +
+geom_vline(xintercept = as.numeric(as.POSIXct("2011-03-11 05:46:24")), color = "red")+
+theme_minimal()+
+ylim(-0.6, 0.6)+
+scale_x_datetime(limits = c(as.POSIXct("2011-03-11 3:00:00"), max(guadalcanal$Date)))
+
+Scatter plot for iturup
+plot3 <- ggplot(data = iturup, aes(x = Date, y = height_norm, color = T)) +
+geom_line() +
+#geom_point(size = 1) +
+labs(x = " Date ", y = " ") +
+ggtitle("Iturup") +
+geom_vline(xintercept = as.numeric(as.POSIXct("2011-03-11 05:46:24")), color = "red")+
+theme_minimal()+
+ylim(-0.6, 0.6)+
+scale_x_datetime(limits = c(as.POSIXct("2011-03-11 3:00:00"), max(iturup$Date)))
+
+Create subplots
+grid.arrange(plot3, plot2, plot1, ncol = 1, nrow = 3,
+ top = textGrob("Subplots", gp = gpar(fontsize = 14)))
+
+
+
+Plot 2
+In order to compute the Fourier transform and apply a filter to the +data to remove the tidal signal, the data needs to be resampled to a +consistent frequency of 15 seconds.
+
+
+Now resample time series data to 15s sampling frequency
+new_freq = 15 #15 seconds
+
+### Create zoo object
+apia_data <- zoo(apia$height_norm, apia$Date)
+
+### Check for duplicate timestamps
+duplicated_timestamps <- duplicated(apia$Date)
+
+### Remove duplicates
+apia_unique <- apia[!duplicated_timestamps, ]
+### Set Date column as the index
+apia_zoo <- zoo(apia_unique$height_norm, order.by = apia_unique$Date)
+
+### Resample the time series data
+apia_resamp <- na.approx(merge(apia_zoo, zoo(, seq(start(apia_zoo), end(apia_zoo), by = new_freq))), xout = seq(start(apia_zoo), end(apia_zoo), by = new_freq))
+### Convert apia_resamp to numeric
+apia_resamp <- as.numeric(apia_resamp)The Fouerier Transform allows me to plot the frequency content of the +signal, which is necessary to choose what frequency I need to filter out +to remove the tide signal and leave the tsunami signal.
+
+
+Compute Fourier transform
+fft_apia <- fft(apia_resamp)
+fftshift_apia <- fftshift(fft_apia)
+
+### Compute amplitude spectrum
+amp_apia <- Mod(fftshift_apia)
+
+### Number of data points
+N <- length(amp_apia)
+
+### Sampling frequency
+sample_freq <- 4 # 4 samples per minute
+
+### Calculate the time step
+dt <- 1 / sample_freq
+
+### Compute the frequency values corresponding to the FFT result
+freq <- seq(-sample_freq / 2, sample_freq / 2, length.out = N)
+
+### Plot the frequency amplitude spectrum on a semilogx scale
+plot(freq, amp_apia, type = "l", log = 'x', xlab = "Frequency", ylab = "Amplitude")
+grid(lwd = 1)The filter I am applying to the signal is the Butterworth Filter.
+
+
+Now apply butterworth filter
+### Define the filter parameters
+poles <- 4 # Filter order
+fc <- 0.003 # Corner frequency in Hz to filter out tides
+fs <- 1/15 # Sampling frequency (1 sample every 15 seconds)
+
+### Calculate the normalized corner frequency
+fnyquist <- 0.5 * fs
+normalized_corner_freq <- fc / fnyquist
+
+### Design the Butterworth highpass filter
+b <- butter(poles, normalized_corner_freq, type = "high")
+
+### Filter the data using a two-pass Butterworth highpass filter
+apia_filt <- filter(b, filter(b, apia_resamp, sides = 1), sides = 1)
+
+now filter Guadalcanal
+guadalcanal_data <- zoo(guadalcanal$height_norm, guadalcanal$Date)
+
+duplicated_timestamps <- duplicated(guadalcanal$Date)
+
+guadalcanal_unique <- guadalcanal[!duplicated_timestamps, ]
+
+guadalcanal_zoo <- zoo(guadalcanal_unique$height_norm, order.by = guadalcanal_unique$Date)
+
+guadalcanal_resamp <- na.approx(merge(guadalcanal_zoo, zoo(, seq(start(guadalcanal_zoo), end(guadalcanal_zoo), by = new_freq))), xout = seq(start(guadalcanal_zoo), end(guadalcanal_zoo), by = new_freq))
+
+guadalcanal_resamp <- as.numeric(guadalcanal_resamp)
+
+fft_guadalcanal <- fft(guadalcanal_resamp)
+fftshift_guadalcanal <- fftshift(fft_guadalcanal)
+
+amp_guadalcanal <- Mod(fftshift_guadalcanal)
+
+N <- length(amp_guadalcanal)
+
+freq <- seq(-sample_freq / 2, sample_freq / 2, length.out = N)
+
+plot(freq, amp_guadalcanal, type = "l", log = 'x', xlab = "Frequency", ylab = "Amplitude")
+grid(lwd = 1)
+
+guadalcanal_filt <- filter(b, filter(b, guadalcanal_resamp, sides = 1), sides = 1)
+
+and Iturup
+iturup_data <- zoo(iturup$height_norm, iturup$Date)
+
+duplicated_timestamps <- duplicated(iturup$Date)
+
+iturup_unique <- iturup[!duplicated_timestamps, ]
+
+iturup_zoo <- zoo(iturup_unique$height_norm, order.by = iturup_unique$Date)
+
+iturup_resamp <- na.approx(merge(iturup_zoo, zoo(, seq(start(iturup_zoo), end(iturup_zoo), by = new_freq))), xout = seq(start(iturup_zoo), end(iturup_zoo), by = new_freq))
+
+iturup_resamp <- as.numeric(iturup_resamp)
+
+fft_iturup <- fft(iturup_resamp)
+fftshift_iturup <- fftshift(fft_iturup)
+
+amp_iturup <- Mod(fftshift_iturup)
+
+N <- length(amp_iturup)
+
+freq <- seq(-sample_freq / 2, sample_freq / 2, length.out = N)
+
+plot(freq, amp_iturup, type = "l", log = 'x', xlab = "Frequency", ylab = "Amplitude")
+grid(lwd = 1)
+
+iturup_filt <- filter(b, filter(b, iturup_resamp, sides = 1), sides = 1)
+
+
+
+Plot 3
+
+
+Now plot the filtered signals
+
+
+Set up plotting layout
+par(mfrow = c(3, 1), mar = c(4, 4, 2, 1))
+### Timestamp for earthquake on March 11, 2011 5:46pm UTC
+eq_timestamp <- as.POSIXct("2011-03-11 05:46:00", tz = "UTC")
+### Plot signals for iturup
+plot(iturup_resamp, type = "l", col = "blue", xlab = "Time", ylab = "Amplitude", main = "Iturup")
+lines(iturup_filt, col = "red")
+legend("topright", legend = c("Original", "Filtered"), col = c("blue", "red"), lty = 1)
+grid(lwd = 1)
+
+### Plot signals for guadalcanal
+plot(guadalcanal_resamp, type = "l", col = "blue", xlab = "Time", ylab = "Amplitude", main = "Guadalcanal")
+lines(guadalcanal_filt, col = "red")
+legend("topright", legend = c("Original", "Filtered"), col = c("blue", "red"), lty = 1)
+grid(lwd = 1)
+
+### Plot signals for apia
+plot(apia_resamp, type = "l", col = "blue", xlab = "Time", ylab = "Amplitude", main = "Apia")
+lines(apia_filt, col = "red")
+legend("topright", legend = c("Original", "Filtered"), col = c("blue", "red"), lty = 1)
+grid(lwd = 1)
+
+
+
+Plot 4
+
+
+
+Now plot seismic stations and buoys on a map
+
+
+Add the seismic data from Erimo (close to eq epicenter)
+japaneq <- read.csv("C:/Users/kelsa/OneDrive/Desktop/Documents/GEOG490/japaneq.csv")
+
+Data has no time values so we need to generate time values for +plotting
+sample_count <- 42000
+sampling_rate_hz <- 20
+start_time <- ymd_hms("2011-03-11T05:42:19.029500Z")
+
+Generate time values in seconds
+time_seconds <- seq(0, (sample_count - 1) / sampling_rate_hz, by = 1 / sampling_rate_hz)
+
+Add generated time values as a column
+japaneq$Time <- start_time + seconds(time_seconds)
+
+Plot acceleration data
+plot4 <- ggplot(japaneq, aes(x = Time, y = Z, color = "Z")) +
+geom_line() +
+labs(title = "Erimo Seismic Data",
+ x = " ", y = " ") +
+scale_y_continuous(labels = function(x) format(x / 1e7, scientific = FALSE),
+ breaks = scales::extended_breaks(n = 8),
+ limits = c(-20000000, 20000000)) +
+scale_color_manual(values = c("turquoise")) +
+theme_bw() +
+theme(panel.border = element_rect(color = "black", fill = NA, size = 1))
+
+plot5 <- ggplot(japaneq, aes(x = Time, y = N_S, color = "N/S")) +
+geom_line() +
+labs(title = "North/South ",
+ x = " ", y = "Acceleration (m/s/s*10^7)") +
+scale_y_continuous(labels = function(x) format(x / 1e7, scientific = FALSE),
+ breaks = scales::extended_breaks(n = 8),
+ limits = c(-20000000, 20000000)) +
+scale_color_manual(values = c("orange")) +
+theme_bw() +
+theme(panel.border = element_rect(color = "black", fill = NA, size = 1))
+
+
+plot6 <- ggplot(japaneq, aes(x = Time, y = E_W, color = "E/W")) +
+geom_line() +
+labs(title = "East/West ",
+ x = "Time", y = " ") +
+scale_y_continuous(labels = function(x) format(x / 1e7, scientific = FALSE),
+ breaks = scales::extended_breaks(n = 8),
+ limits = c(-20000000, 20000000)) +
+scale_color_manual(values = c("green")) +
+theme_bw() +
+theme(panel.border = element_rect(color = "black", fill = NA, size = 1))
+
+
+### Create subplots
+grid.arrange(plot4, plot5, plot6, ncol = 1, nrow = 3,
+ top = textGrob("Subplots", gp = gpar(fontsize = 14)))
+
+
+
+Plot 5
+
+
+Add the seismic data from Matsuhiro (SE Japan)
+matsushiro <- read.csv("C:/Users/kelsa/OneDrive/Desktop/Documents/GEOG490/matsushiro.csv")
+
+sample_count <- 42000
+sampling_rate_hz <- 20
+start_time <- ymd_hms("2011-03-11T05:42:19.029500Z")
+
+Generate time values in seconds
+time_seconds <- seq(0, (sample_count - 1) / sampling_rate_hz, by = 1 / sampling_rate_hz)
+
+Add generated time values as a column
+matsushiro$Time <- start_time + seconds(time_seconds)
+
+Plot acceleration data
+plot7 <- ggplot(matsushiro, aes(x = Time, y = Z, color = "Z")) +
+geom_line() +
+labs(title = "Matsuhiro Seismic Data",
+ x = " ", y = " ") +
+scale_y_continuous(labels = function(x) format(x / 1e7, scientific = FALSE),
+ breaks = scales::extended_breaks(n = 8),
+ limits = c(-40000000, 40000000)) +
+scale_color_manual(values = c("turquoise")) +
+theme_bw() +
+theme(panel.border = element_rect(color = "black", fill = NA, size = 1))
+
+plot8 <- ggplot(matsushiro, aes(x = Time, y = N_S, color = "N/S")) +
+geom_line() +
+labs(title = "North/South ",
+ x = " ", y = "Acceleration (m/s/s*10^7)") +
+scale_y_continuous(labels = function(x) format(x / 1e7, scientific = FALSE),
+ breaks = scales::extended_breaks(n = 8),
+ limits = c(-40000000, 40000000)) +
+scale_color_manual(values = c("orange")) +
+theme_bw() +
+theme(panel.border = element_rect(color = "black", fill = NA, size = 1))
+
+
+plot9 <- ggplot(matsushiro, aes(x = Time, y = E_W, color = "E/W")) +
+geom_line() +
+labs(title = "East/West ",
+ x = "Time", y = " ") +
+scale_y_continuous(labels = function(x) format(x / 1e7, scientific = FALSE),
+ breaks = scales::extended_breaks(n = 8),
+ limits = c(-40000000, 40000000)) +
+scale_color_manual(values = c("green")) +
+theme_bw() +
+theme(panel.border = element_rect(color = "black", fill = NA, size = 1))
+
+# Create subplots
+grid.arrange(plot7, plot8, plot9, ncol = 1, nrow = 3,
+ top = textGrob("Subplots", gp = gpar(fontsize = 14)))
+
+
+
+Plot 6
+
+
+Now add buoy, eq, and seismic stations to a map
+### buoy coordinates
+buoy_points <- data.frame(name = c("Guadalcanal", "Apia", "Iturup"),
+lon = c(164.99,176.26, 152.58),
+lat = c(5.37, 9.51, 42.62)
+)
+
+### EQ coordinates
+eq_point <- data.frame(name = "EQ",
+lon = 142.8600,
+lat = 38.1033
+)
+
+### Erimo seismic station coordinates
+erimo_point <- data.frame(name = "Erimo",
+lat = 42.02,
+lon = 143.16
+)
+
+### Matsushiro seismic station
+matsushiro_point <- data.frame(name = "Matsushiro",
+lat = 36.55,
+lon = 138.20
+)
+
+### Create a map centered around Japan
+m <- leaflet() %>%
+setView(lng = 140, lat = 35, zoom = 3) %>%
+addTiles()
+
+### Add buoys to map
+m <- m %>%
+addCircleMarkers(data = buoy_points, lng = ~lon, lat = ~lat, color = "red", radius = 5,popup = ~as.character(name))
+
+
+### Add eq to map with different symbology
+m <- addCircleMarkers(m, data = eq_point, lng = ~lon, lat = ~lat, color = "green", radius = 8, popup = ~as.character(name))
+
+
+### Add seismic stations to map
+m <- m %>%
+addCircleMarkers(data = erimo_point, lng = ~lon, lat = ~lat, color = "blue", radius = 5, popup = ~as.character(name))
+m <- m %>%
+addCircleMarkers(data = matsushiro_point, lng = ~lon, lat = ~lat, color = "darkblue", radius = 5, popup = ~as.character(name))
+
+# Display the map
+m
+
+
+
+
+Plot 7
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
+
+
+
+