geanders/stormwindmodel

Model Hurricane Wind Speeds

Overview

The stormwindmodel package was created to allow users to model wind speeds at grid points in the United States based on “best tracks” hurricane tracking data, using a model for wind speed developed by Willoughby and coauthors (2006). The package includes functions for interpolating hurricane tracks and for modeling and mapping wind speeds during the storm. It includes population mean center locations for all U.S. counties, which can be used to map winds by county; however, other grid point locations can also be input for modeling. Full details on how this model is fit are provided in the “Details” vignette of the stormwindmodel package.

This package is currently in development on GitHub. You can install it using the install_github function from the devtools package using:

devtools::install_github("geanders/stormwindmodel", build_vignettes = TRUE)

Package example data

For examples, the package includes data on the tracks of Hurricane Floyd in 1999 and Hurricane Katrina in 2005. You can load these example best tracks data sets using:

library(stormwindmodel)
data("floyd_tracks")
head(floyd_tracks)
#> # A tibble: 6 x 4
#>   date         latitude longitude  wind
#>   <chr>           <dbl>     <dbl> <dbl>
#> 1 199909071800     14.6     -45.6    25
#> 2 199909080000     15       -46.9    30
#> 3 199909080600     15.3     -48.2    35
#> 4 199909081200     15.8     -49.6    40
#> 5 199909081800     16.3     -51.1    45
#> 6 199909090000     16.7     -52.6    45
data("katrina_tracks")
head(katrina_tracks)
#> # A tibble: 6 x 4
#>   date         latitude longitude  wind
#>   <chr>           <dbl>     <dbl> <dbl>
#> 1 200508231800     23.1     -75.1    30
#> 2 200508240000     23.4     -75.7    30
#> 3 200508240600     23.8     -76.2    30
#> 4 200508241200     24.5     -76.5    35
#> 5 200508241800     25.4     -76.9    40
#> 6 200508250000     26       -77.7    45

This example data includes the following columns:

• date: Date and time of the observation (in UTC)
• latitude, longitude: Location of the storm at that time
• wind: Maximum wind speed at that time (knots)

You can input other storm tracks into the wind modeling functions in the stormwindmodel package, but you must have your storm tracks in the same format as these example dataframes and with these columns names to input the tracks to the functions in stormwindmodel. If necessary, use rename from dplyr to rename columns and convert_wind_speed from weathermetrics to convert windspeed into knots.

The stormwindmodel package also includes a dataset with the location of the population mean center of each U.S. county (county_points). This dataset can be used as the grid point inputs if you want to model storm-related winds for counties. These counties are listed by Federal Information Processing Standard (FIPS) number, which uniquely identifies each U.S. county. This dataset comes from the US Census file of county population mean center locations, as of the 2010 Census.

data(county_points)
head(county_points)
#>   gridid     glat      glon
#> 1  01001 32.50039 -86.49416
#> 2  01003 30.54892 -87.76238
#> 3  01005 31.84404 -85.31004
#> 4  01007 33.03092 -87.12766
#> 5  01009 33.95524 -86.59149
#> 6  01011 32.11633 -85.70119

You can use a different dataset of grid points to model winds at other U.S. locations, including across evenly spaced grid points. However, you will need to include these grid points in a dataframe with a similar format to this example dataframe, with columns for each grid point id (gridid— these IDs can be random but should be unique across grid points), and glat and glon for latitude and longitude of each grid point.

Basic example

The main function of this package is get_grid_winds. It inputs storm tracks for a tropical cyclone (hurr_track) and a dataframe with grid point locations (grid_df). It models winds during the tropical storm at each grid point and outputs summaries of wind during the storm at each grid point from the storm. The wind measurements generated for each grid point are:

• vmax_gust: Maximum 10-m 1-minute gust wind experienced at the grid point during the storm
• vmax_sust: Maximum 10-m 1-minute sustained wind experienced at the grid point during the storm
• gust_dur: Duration gust wind was at or above a specified speed (default is 20 m/s), in minutes
• sust_dur: Duration sustained wind was at or above a specified speed (default is 20 m/s), in minutes

To get modeled winds for Hurricane Floyd at U.S. county centers, you can run:

floyd_winds <- get_grid_winds(hurr_track = floyd_tracks,
                              grid_df = county_points)
#> Warning: `mutate_()` is deprecated as of dplyr 0.7.0.
#> Please use `mutate()` instead.
#> See vignette('programming') for more help
#> This warning is displayed once every 8 hours.
#> Call `lifecycle::last_warnings()` to see where this warning was generated.
#> Warning: `select_()` is deprecated as of dplyr 0.7.0.
#> Please use `select()` instead.
#> This warning is displayed once every 8 hours.
#> Call `lifecycle::last_warnings()` to see where this warning was generated.
#> Warning: `summarise_()` is deprecated as of dplyr 0.7.0.
#> Please use `summarise()` instead.
#> This warning is displayed once every 8 hours.
#> Call `lifecycle::last_warnings()` to see where this warning was generated.
floyd_winds %>%
  dplyr::select(gridid, vmax_gust, vmax_sust, gust_dur, sust_dur) %>%
  slice(1:6)
#>   gridid vmax_gust vmax_sust gust_dur sust_dur
#> 1  01001  2.971364  1.994204        0        0
#> 2  01003  1.958180  1.314215        0        0
#> 3  01005  4.806562  3.225880        0        0
#> 4  01007  2.309274  1.549848        0        0
#> 5  01009  2.600039  1.744992        0        0
#> 6  01011  4.077514  2.736587        0        0

If you use the coutny_points data that comes with the package for the grid_df argument, you will model winds for county centers. In this case, the gridid is a county FIPS, and the stormwindmodel package has a function called map_wind for mapping the estimated winds for each county. By default, it maps the maximum sustained wind in each county during the storm in meters per second.

map_wind(floyd_winds)

Further functionality

Options for modeling winds

You can input the track for any Atlantic Basin tropical storm into get_grid_winds, as long as you convert it to meet the following format requirements:

• Is a dataframe of class tbl_df (you can use the tbl_df function from dplyr to do this)
• Has the following columns:
  • date: A character vector with date and time (in UTC), expressed as YYYYMMDDHHMM.
  • latitude: A numeric vector with latitude in decimal degrees.
  • longitude: A numeric vector with longitude in decimal degrees.
  • wind: A numeric vector with maximum storm wind speed in knots

For the grid point locations at which to model, you can input a dataframe with grid points anywhere in the eastern half of the United States. For example, you may want to map wind speeds for Hurricane Katrina by census tract in Orleans Parish, LA. The following code shows how a user could do that with the stormwindmodel package.

First, the tigris package can be used to pull US Census tract shapefiles for a county. You can use the following code to pull these census tract file shapefiles for Orleans Parish in Louisiana:

library(tigris)
new_orleans <- tracts(state = "LA", county = c("Orleans"), 
                      class = "sp") 

This shapefile gives the polygon for each census tract. You can use the gCentroid function from the rgeos package to determine the location of the center of each census tract:

library(rgeos)
new_orleans_tract_centers <- gCentroid(new_orleans, byid = TRUE)@coords
head(new_orleans_tract_centers)
#>            x        y
#> 1  -89.95393 30.04011
#> 2  -89.91693 30.03769
#> 30 -90.01988 29.95959
#> 31 -90.07362 29.97811
#> 32 -90.12008 29.91933
#> 46 -90.08967 29.94482

With some cleaning, you can get this data to the format required for the get_grid_winds function. In particular, you should add the tract id from the original shapefiles as the grid id, as this will help you map the modeled wind results:

new_orleans_tract_centers <- new_orleans_tract_centers %>%
  tbl_df() %>%
  mutate(gridid = unique(new_orleans@data$TRACTCE)) %>%
  dplyr::rename(glat = y, 
                glon = x)
#> Warning: `tbl_df()` is deprecated as of dplyr 1.0.0.
#> Please use `tibble::as_tibble()` instead.
#> This warning is displayed once every 8 hours.
#> Call `lifecycle::last_warnings()` to see where this warning was generated.
head(new_orleans_tract_centers)
#> # A tibble: 6 x 3
#>    glon  glat gridid
#>   <dbl> <dbl> <chr> 
#> 1 -90.0  30.0 001747
#> 2 -89.9  30.0 001750
#> 3 -90.0  30.0 000800
#> 4 -90.1  30.0 003600
#> 5 -90.1  29.9 011400
#> 6 -90.1  29.9 008600

Here is a map of the census tracts, with the center point of each shown with a red dot (note that an area over water is also included– this is included as one of the census tract shapefiles pulled by tigris for Orleans Parish):

library(sf)
new_orleans <- new_orleans %>% 
  st_as_sf()
new_orleans_centers <- new_orleans_tract_centers %>% 
  st_as_sf(coords = c("glon", "glat")) %>% 
  st_set_crs(4269)

library(ggplot2)
ggplot() + 
  geom_sf(data = new_orleans) + 
  geom_sf(data = new_orleans_centers, color = "red", size = 0.6)

Since the new_orleans_tract_centers is now in the appropriate format to use with the stormwindmodel functions, you can input it directly into get_grid_winds to model the winds from Hurricane Katrina at each census tract center:

new_orleans_tracts_katrina <- get_grid_winds(hurr_track = katrina_tracks, 
                                             grid_df = new_orleans_tract_centers)
head(new_orleans_tracts_katrina)
#>        glon     glat gridid vmax_gust vmax_sust gust_dur sust_dur
#> 1 -89.95393 30.04011 001747  62.91971  42.22799     1110      690
#> 2 -89.91693 30.03769 001750  65.34514  43.85580     1110      690
#> 3 -90.01988 29.95959 000800  59.41499  39.87583     1110      675
#> 4 -90.07362 29.97811 003600  56.61081  37.99383     1110      675
#> 5 -90.12008 29.91933 011400  54.80164  36.77962     1110      690
#> 6 -90.08967 29.94482 008600  55.98677  37.57502     1095      675

To plot these modeled winds, you can merge this modeled data back into the “sf” version of the census tract shapefile data, joining by census tract identification, and then add to the map. You can show wind speed in this map with color.

new_orleans <- new_orleans %>% 
  left_join(new_orleans_tracts_katrina, by = c("TRACTCE" = "gridid"))

library(viridis)
ggplot() + 
  geom_sf(data = new_orleans, aes(fill = vmax_sust)) + 
  geom_sf(data = new_orleans_centers, color = "red", size = 0.6) + 
  scale_fill_viridis(name = "Maximum\nsustained\nwinds (m/s)")

There are also functions in this package that you can use to create a time series of all modeled winds at a specific grid point throughout the storm. For example, here is the code to calculate modeled wind at the population mean center of Dare County, NC (FIPS: 37055) throughout Hurricane Floyd:

dare_county <- county_points %>% # Get grid point information for Dare County
  filter(gridid == "37055")

with_wind_radii <- floyd_tracks %>%
  create_full_track() %>% # Interpolate tracks to every 15 minutes
  add_wind_radii()        # Calculate required inputs for Willoughby wind model

dare_winds <- calc_grid_wind(grid_point = dare_county,          # Model winds at one grid point
                             with_wind_radii = with_wind_radii)

ggplot(dare_winds, aes(x = date, y = windspeed)) + 
  geom_line() + 
  xlab("Observation time (UTC)") + 
  ylab("Modeled surface wind (m / s)") 

For more details, see the “Details” vignette, which walks through all steps of the modeling process.

Options for mapping county-level winds

There are a number of options when mapping wind speeds using map_wind.

First, you can use the add_storm_track function to add the storm track to the map. This function inputs one dataframe with tracking data (the floyd_tracks example data that comes with the package in this case) as well as the plot object created using map_wind, which is input using the plot_object argument. In this example code, we’ve first created the base map of winds by county using map_wind and then input that, along with Floyd’s track data, into add_storm_track to create a map with both winds and the storm tracks:

floyd_map <- map_wind(floyd_winds)
add_storm_track(floyd_tracks, plot_object = floyd_map)

You can also choose whether to map sustained or gust winds (value, which can take “vmax_gust” or “vmax_sust”), as well as the unit to use for wind speed (wind_metric, which can take values of “mps” [the default] or “knots”).

map_wind(floyd_winds, value = "vmax_gust", wind_metric = "knots")

Finally, you can map a binary classification of counties with winds at or above a certain break point. For example, to map counties with sustained wind at or above 34 knots during the storm, you can run:

map_wind(floyd_winds, value = "vmax_sust", wind_metric = "knots",
         break_point = 34)

Tracks data

You can get an R version of best tracks data for Atlantic basin storms from 1988 to 2015 through the hurricaneexposuredata package (also in development on GitHub):

devtools::install_github("geanders/hurricaneexposuredata")

Here are all the storms currently included in that dataset:

library(hurricaneexposuredata)
data("hurr_tracks")
hurr_tracks %>% 
  tidyr::separate(storm_id, c("storm", "year")) %>%
  dplyr::select(storm, year) %>%
  dplyr::distinct() %>%
  dplyr::group_by(year) %>% 
  dplyr::summarize(storms = paste(storm, collapse = ", ")) %>% 
  knitr::kable()
#> Warning: Expected 2 pieces. Additional pieces discarded in 27 rows [3313, 3314,
#> 3315, 3316, 3317, 3318, 3319, 3320, 3321, 3322, 3323, 3324, 3325, 3326, 3327,
#> 3328, 3329, 3330, 3331, 3332, ...].
#> `summarise()` ungrouping output (override with `.groups` argument)

year	storms
1988	Alberto, Beryl, Chris, Florence, Gilbert, Keith, AL13, AL14, AL17
1989	Allison, Chantal, Hugo, Jerry
1990	AL01, Bertha, Marco
1991	Ana, Bob, Fabian, AL12
1992	AL02, Andrew, Danielle, Earl
1993	AL01, Arlene, Emily
1994	Alberto, AL02, Beryl, Gordon
1995	Allison, Dean, Erin, Gabrielle, Jerry, Opal
1996	Arthur, Bertha, Edouard, Fran, Josephine
1997	AL01, Ana, Danny
1998	Bonnie, Charley, Earl, Frances, Georges, Hermine, Mitch
1999	Bret, Dennis, AL07, Floyd, Harvey, Irene
2000	AL04, Beryl, AL09, Gordon, Helene, Leslie
2001	Allison, Barry, Gabrielle, Karen, Michelle
2002	Arthur, Bertha, Cristobal, Edouard, Fay, Gustav, Hanna, Isidore, Kyle, Lili
2003	Bill, Claudette, AL07, Erika, Grace, Henri, Isabel
2004	Alex, Bonnie, Charley, Frances, Gaston, Hermine, Ivan, Jeanne, Matthew
2005	Arlene, Cindy, Dennis, Emily, Katrina, Ophelia, Rita, Tammy, Wilma
2006	Alberto, Beryl, Chris, Ernesto
2007	Andrea, Barry, Erin, Gabrielle, Humberto, Ten, Noel
2008	Cristobal, Dolly, Edouard, Fay, Gustav, Hanna, Ike, Kyle, Paloma
2009	One, Claudette, Ida
2010	Alex, Two, Bonnie, Five, Earl, Hermine, Nicole, Paula
2011	Bret, Don, Emily, Irene, Lee
2012	Alberto, Beryl, Debby, Isaac, Sandy
2013	Andrea, Dorian, Karen
2014	Arthur
2015	Ana, Bill, Claudette
2016	Bonnie, Colin, Eight, Hermine, Julia, Matthew
2017	Cindy, Emily, Harvey, Irma, Jose, Nate, Philippe
2018	Alberto, Chris, Florence, Gordon, Michael
Two	Twenty

References

Willoughby, HE, RWR Darling, and ME Rahn. 2006. “Parametric Representation of the Primary Hurricane Vortex. Part II: A New Family of Sectionally Continuous Profiles.” Monthly Weather Review 134 (4): 1102–20.

stormwindmodel's Issues

Consider function to check that latitude / longitude inputs are in correct range

There are different ways to list latitudes and longitudes. Differences in conventions for longitudes may be particularly likely to cause potential problems.

It may be worth adding a check on these inputs. This would apply to:

• Grid points (e.g., county centers) that are input to the wind model
• Storm tracks that are input to the wind model

Both inputs should have longitude values within the range of 0 (prime meridian) to about -110 (west Texas).

ggplot() + 
  geom_point(data = county_points, aes(x = glon, y = glat)) + 
  geom_point(data = floyd_tracks, aes(x = longitude, y = latitude), color = "red")

The model will work best when the storm tracks are within the range of the landmask, with longitude between -60 and -100 and latitude between 15 and 50.

ggplot() + 
  geom_point(data = landmask, aes(x = longitude - 360, y = latitude, color = land), alpha = 0.2)+ 
  geom_point(data = county_points, aes(x = glon, y = glat)) 

Check processes to submit to CRAN post-removal

Change all the functions that use `calc_grid_winds2`, now that it returns a list

Previously, this function returned a matrix with just the sustained wind. Now, it returns a list where that matrix is the first element (i.e., what was grid_winds will now be stored in grid_winds[[1]], aka grid_winds[["vmax_sust"]].

We need to change all the functions that use calc_grid_winds2 so that they extract this element from the list.

Landmasks for each basin

Currently, the landmask is for the North Atlantic basin, focusing on the US.

It may be worthwhile to include a landmask for each basin? The basins are:

(Image source: https://rammb.cira.colostate.edu/projects/gparm/description.asp)

Replace mapping functions with ones with more basic dependencies

Check longitude conventions in common tracking data

Check for all basins in IBTrACS and in HURDAT.

Update dependencies to current versions

Add tips on using parallel processing

See example from Daniel's code

Clarify in documentation that storm track input should use USA winds

Make CRAN notes

Do final proof of help files

Explain polar versus geographic coordinates in documentation

In some of our functions, we convert to use polar coordinate conventions rather than geographical ones, to align with using u- and v-components of forward distance of the storm. It would be helpful to explain this somewhere in the documentation, including with pictures. Also, we should check that, if we output something like the surface wind direction, that we move it back to a geographical direction that would make sense with mapping functions.

There are nice write-ups on differences in these coordinate systems at:

• https://vvvv.org/blog/polar-spherical-and-geographic-coordinates
• https://kartoweb.itc.nl/geometrics/Coordinate%20systems/coordsys.html
• https://www.skillsyouneed.com/num/polar-cylindrical-spherical-coordinates.html

Use `pkgdown` for documentation

As an alternative to current vignettes

Details Vignette Format

Reformat Details.RMD to run easier

Fix warnings about deprecated `dplyr` functions

These include:

• select_
• mutate_
• summarise_

Change mapping functions to use simple features (`sf` package)

Now that the sf package is well-developed, I think our mapping functions would work better in that system. One idea might be a function that creates an sf object from the grid winds output. This would input a dataset with the latitude and longitude of the grid points (could be an sf object with the gridpoint id as the first column and then the geometry column with the latitude and longitude), then merge in the wind speed and surface wind direction data by gridpoint id so that those pieces of data could easily be mapped.

We could also create a function that takes the storm track info and creates an sf object, so that could be added as a layer to the maps.

There's an excellent book on the sf package and related functions here: https://geocompr.robinlovelace.net/

Consider separating main output and summarizing functions

From the main function (get_grid_winds), output an array with the wind at each grid point at each time step. Then have separate functions to summarize or slice, to get out (for example), the wind field at a time point or to get the maximum winds at each grid point over the storm.

interpolate_line() crashes R

interpolate_line() crashes R. (interporlate_spline() works fine.)

stormwindmodel Version: 0.1.5.9

platform x86_64-apple-darwin17.0
arch x86_64
os darwin17.0
system x86_64, darwin17.0
status
major 4
minor 1.0
year 2021
month 05
day 18
svn rev 80317
language R
version.string R version 4.1.0 (2021-05-18)
nickname Camp Pontanezen

How to use surface roughness length and LULC to generate windfield footprints

How to use surface roughness length and LULC to generate Windfield footprints. I am trying to interpolate windspeed to generate wind footprint using LULC and topo data.

can you please tell me how to that? Is there any R code do that?

Thanks.

Consider using modulo operation in converting longitudes

Currently, there is some code in create_full_tracks that handles different longitude conventions. Consider changing to use modulo operations.

Currently:

tclon = ifelse(.data$tclon > -180, .data$tclon, .data$tclon + 360)

instead?

tclon = .data$tclon %% 360

Make vignettes file small enough for CRAN

create subdirectory of website only vignettes to be used w/ pkgdown

r-lib/pkgdown#823

Fix CRAN error with vignette code

Possibly this will be fixed automatically with using pkgdown? (Does CRAN check code in pkgdown documentation?

May have something to do with using sf for mapping in the vignettes. When sf is loaded, there is a message that it is:

Linking to GEOS 3.8.1, GDAL 3.1.4, PROJ 6.3.1

Miles Per Hour?

This may be hurricane meteorological heresy, but how would you feel about adding "mph" to map_wind as a valid wind_metric?

if (wind_metric == "mps") {
      breaks <- c(0, seq(15, 45, 5))
      exposure_palette <- c("#FEE5D9", "#FCBBA1", "#FC9272", 
                            "#FB6A4A", "#DE2D26", "#A50F15")
    }
    else if (wind_metric == "knots") {
      breaks <- c(0, 34, 50, 64, 100)
      exposure_palette <- c("#FEE0D2", "#FC9272", "#DE2D26")
    }
    else if (wind_metric == "mph") {
      breaks <- c(0, 40, 60, 75, 115)
      exposure_palette <- c("#FEE0D2", "#FC9272", "#DE2D26")
    }

Update metadata for new release

Date, authors info (any new emails?)

Make vignettes self-sufficient

Keep the README's running from scratch, but the vignettes for CRAN need to run more quickly than they currently do. The need to be more self-sufficient:

• Create and save the modeled winds for examples
• Load those, but then use mapping functions "in real time"

Account for different wind averaging periods for different basins

This is a good resource for addressing this:

https://library.wmo.int/doc_num.php?explnum_id=290

Ensure only required packages are included in Imports and Suggests

Speed up the check_over_land function

It might be running a bit slow now that the landmask is global. There's probably a way to limit difference comparisons only to parts of the landmask close to the storm to start with.

Make `check_over_land` more efficient for large landmask

As first step, pull landmask within range of hurricane track?

In the global version, the landmask is much longer---no point comparing all points to find closest, without first limiting to only a subset of the landmask (although perhaps the code is already efficient in terms of this?)

Check on correct earth radius to use in distance calculations

Currently, our default is 6378.14, but it looks like we get answers that are more in-line with online calculators (e.g., https://www.nhc.noaa.gov/gccalc.shtml) if we use 6,371 km, which it sounds like may be the median radius (whereas the other is closer to the maximum radius).

Should we change the default earth radius to 6,371 km throughout? (Likely this will only be ~1 km difference in distance estimates).

Add testing suite

Some things to add tests for:

• Calculating distance between two storm locations
• Calculating forward speed of the storm between two locations
• Calculating bearing between two storm locations
• Calculating distance between grid point location and storm track location
• Determining if point is over land or over sea

Do final proof of "Details" vignette

Check for hemisphere-crossing issues

The version with global functionality doesn't work when tracks cross between hemispheres. To what extent will this be a practical problem?

Here are all tracks in 2006 (image source: NASA):

change `latlon_to_meters` name

Change latlon_to_meters function name to something resembling latlon_to_kilometers. Currently, latlon_to_meters function converts to kilometers.

Do final proof of main vignette / README

Consider separating conversions and interpolation steps in track interpolation

This is in create_full_track.

Currently, it includes some parts that are to convert track data to a common standard before running the wind model:

• Convert the max. winds from knots to meters per second (this one will depend on the units the track data start in---always knots in different basins?)
• Add 360 to longitude if it's below -180, then to all longitudes multiple -1 (this one will depend on the conventions used for longitude in the input tracking data)

create_full_track <- function(hurr_track = stormwindmodel::floyd_tracks,
                              tint = 0.25){
  hurr_track <- dplyr::select(hurr_track, .data$date, .data$latitude,
                               .data$longitude, .data$wind) %>%
    dplyr::rename(vmax = .data$wind,
                  tclat = .data$latitude,
                  tclon = .data$longitude) %>%
    dplyr::mutate(date = lubridate::ymd_hm(.data$date),
                  tclat = abs(as.numeric(.data$tclat)),
                  tclon = as.numeric(.data$tclon),
                  tclon = ifelse(.data$tclon > -180, .data$tclon, .data$tclon + 360), # Stuff with longitude conventions here and next line
                  tclon = -1 * .data$tclon,
                  vmax = weathermetrics::convert_wind_speed(.data$vmax, "knots",  # Unit conversion here
                                                            "mps", round = 3),
                  track_time_simple = difftime(.data$date, dplyr::first(.data$date),
                                               units = "hour"),
                  track_time_simple = as.numeric(.data$track_time_simple))

  full_track <- hurr_track %>%
    tidyr::nest(data = tidyr::everything()) %>%
    # Create times to interpolate to
    dplyr::mutate(interp_time = purrr::map(.data$data,
                                           .f = ~ seq(from = dplyr::first(.x$track_time_simple),
                                                      to = dplyr::last(.x$track_time_simple),
                                                      by = tint))) %>%
    # Interpolate latitude and longitude using natural cubic splines
    dplyr::mutate(tclat = purrr::map2(.data$data, .data$interp_time,
                                      .f = ~ spline(x = .x$track_time_simple,
                                                    y = .x$tclat,
                                                    xout = .y,
                                                    method = "natural")$y)) %>%
    dplyr::mutate(tclon = purrr::map2(.data$data, .data$interp_time,
                                      .f = ~ spline(x = .x$track_time_simple,
                                                    y = .x$tclon,
                                                    xout = .y,
                                                    method = "natural")$y)) %>%
    # Interpolate max wind using linear interpolation
    dplyr::mutate(vmax = purrr::map2(.data$data, .data$interp_time,
                                     .f = ~ approx(x = .x$track_time_simple,
                                                   y = .x$vmax,
                                                   xout = .y)$y)) %>%
    dplyr::mutate(date = purrr::map2(.data$data, .data$interp_time,
                                    .f = ~ dplyr::first(.x$date) +
                                      lubridate::seconds(3600 * .y))) %>%
    dplyr::select(.data$date, .data$tclat, .data$tclon, .data$vmax) %>%
    tidyr::unnest(.data$date:.data$vmax)

  return(full_track)
}

Finalize DESCRIPTION

• Date
• Version number

Fix Travis build

Check if there are any interpolation issues when crossing international date line

Check this for the code where we interpolate storm tracks to a finer resolution.

Check that conversions between polar coordinates and geographic bearing work in North and South hemispheres

This may be an issue in some of the calc_bearing functions, if they're converting between geographic and polar coordinate systems. Check if geographic bearing is interpreted the same in the two hemispheres, and if the calc_bearing functions (which use trig) work the same in both hemispheres.

Find alternatives to Travis CI for checking package on Linux

Can GitHub Actions be used for CI testing for R packages?

Clarify in documentation that all inputs (grid points, storm tracks) should be in degrees East

Adapt wind direction and inflow for Northern vs Southern hemisphere

When calculating gwd in calc_grid_winds, should subtract 90 degrees in Southern hemisphere (add 90 in Northern). When adding inflow, should also be opposite in Northern and Southern hemispheres.

Create function to plot wind field of the storm at specific times along the storm's track

Let's see if we can make a function that will generate the wind field of the storm over one or more time points---for example, a set of panels that show the wind field as the storm makes landfall.

Fix deprecated call in mapping

We're getting the following message when mapping:

Warning: `panel.margin` is deprecated. Please use `panel.spacing` property 
instead

Use absolute latitude, rather than latitude, for will7a, will10a, will10b, and will10c

Check Windows build