Relationship of Avian Influenza Outbreaks to BWTE Residence Time

Joint modeling of duck telemetry and A.I. outbreaks across North America

Contact:
John: jmh09r@my.fsu.edu

date() 
## [1] "Sun Aug 19 21:24:07 2018"
library(knitr)
library(rgl)
opts_knit$set(verbose = FALSE)
knit_hooks$set(webgl = hook_webgl)
suppressMessages(library(INLA))
suppressMessages(library(rgdal))
suppressMessages(library(reshape2))
suppressMessages(library(raster))
suppressMessages(library(factoextra))
suppressMessages(library(corrplot))
suppressMessages(library(rasterVis))
suppressMessages(library(rgeos))
suppressMessages(library(maptools))
suppressMessages(library(mapproj))
suppressMessages(library(spdep))
suppressMessages(library(ggplot2))
suppressMessages(library(ggthemes))
suppressMessages(library(GISTools))
suppressMessages(library(lattice))
suppressMessages(library(gridExtra))
suppressMessages(library(dplyr))
suppressMessages(library(data.table))
suppressMessages(library(readr))
suppressMessages(library(stringr))
suppressMessages(library(lubridate))
suppressMessages(library(RcppRoll))
suppressMessages(library(changepoint))
suppressMessages(library(ecp))
suppressMessages(library(geosphere))
suppressMessages(library(moveHMM))
suppressMessages(library(adegenet))
suppressMessages(library(deldir))
suppressMessages(library(sp))
suppressMessages(library(spatstat))
suppressMessages(library(classInt))
suppressMessages(library(viridis))
suppressMessages(library(kableExtra))
source("RScripts.R")

Load and Prep Data

Removing “dead” locations.
Selecting “plausible” records from the DAF_Filter.
Formating date, adding local time (America/Chicago) and getting Hour, Day, Week, season.

Argos_sp = read.csv("C:/Users/humph173/Documents/LabWork/Patuxent/Douglas_080218/BWTeal_2013-2017_Ramey_argos_tabular_diag_gis_filtered.csv",
                    stringsAsFactors=FALSE,
                    header = TRUE, sep=",")[,1:35] %>% 
                    filter(Fate == "alive",
                           DAF_Filter == 0) %>%
                    mutate(ID = Animal_ID,
                           ObsDate = as.POSIXct(Location_Datetime_GMT, 
                                                tz = "GMT", 
                                                format = "%Y/%m/%d %H:%M:%S"),
                           ObsDateD = as.Date(Location_Datetime_GMT),
                           LocT = ymd_hms(format(ObsDate, tz="America/Chicago", usetz=TRUE)),
                           LocHR = hour(LocT),
                           LocDY = day(LocT),
                           LocWK = week(LocT),
                           LocMN = month(LocT))

Argos_sp$Season = ifelse(Argos_sp$LocMN == 12 | Argos_sp$LocMN == 1, "Winter",
                      ifelse(Argos_sp$LocMN == 3, "Spring",
                             ifelse(Argos_sp$LocMN >= 4 & Argos_sp$LocMN <= 8, "Breeding",
                                    ifelse(Argos_sp$LocMN >= 9 & Argos_sp$LocMN <= 11, "Fall",
                                           ifelse(Argos_sp$LocMN == 2 & Argos_sp$Day <= 15, "Winter",
                                                  ifelse(Argos_sp$LocMN == 2 & Argos_sp$Day >= 16, "Spring",
                                                         NA))))))

Get Boundaries of North America

NAmer.reg = readOGR(dsn = "./Arc/NAmer/States", 
                  layer = "NA_regions", 
                  stringsAsFactors = FALSE)
## OGR data source with driver: ESRI Shapefile 
## Source: "C:\Users\humph173\Documents\LabWork\Patuxent\Patux_level1\Arc\NAmer\States", layer: "NA_regions"
## with 127 features
## It has 36 fields
## Integer64 fields read as strings:  FID_NA_reg FID_Cuba FID_ FID_NA_r_1 FID_0 MEXST0_ MEXST0_ID TOTPOP MALE FEMALE FID_NA_sta FID_Bahama OBJECTID TOTPOP_CY
LL84 = "+proj=longlat +datum=WGS84 +no_defs +ellps=WGS84 +towgs84=0,0,0"

NAmer = gUnaryUnion(NAmer.reg)


tmp.ras = raster(res=0.5) #raster verion
extent(tmp.ras) = extent(NAmer)

Domain.r = rasterize(NAmer,
                     tmp.ras,
                     field = 0,
                     background = NA)

Grd.pnt = rasterToPoints(Domain.r, sp = TRUE)

Grd.pnt@data = Grd.pnt@data %>%
               mutate(Long = Grd.pnt@coords[,1],
                      Lat = Grd.pnt@coords[,2]) %>%
               select(-layer)

GLakes = readOGR(dsn = "./Arc/RedRast/GLake", 
                  layer = "GLakes", 
                  stringsAsFactors = FALSE)
## OGR data source with driver: ESRI Shapefile 
## Source: "C:\Users\humph173\Documents\LabWork\Patuxent\Patux_level1\Arc\RedRast\GLake", layer: "GLakes"
## with 5 features
## It has 6 fields
## Integer64 fields read as strings:  OBJECTID_1 ObjectID

Convert to Points

Locs = cbind(Argos_sp$Longitude, Argos_sp$Latitude)

Sp.pnts = SpatialPointsDataFrame(Locs, Argos_sp)
proj4string(Sp.pnts) = proj4string(NAmer.reg)

Grid Residence Time

Estimating duration of time (hours) spent in each grid cell. Individual birds are returned as layers in a raster stack. Birds are then combined to get the maximum duration any one bird spent in each cell. Time spent in grid cells lacking satellite fixes are interpolated assuming uniform movement between successful satellite captures.

Animal.IDs = levels(as.factor(Sp.pnts$Animal_ID))

for(i in 1:length(Animal.IDs)){
  
    Ani.tmp = subset(Sp.pnts, Animal_ID == Animal.IDs[i])
    
    tmp.res = ResidenceRaster(Ani.tmp, Domain.r)
    
    if(i == 1){Res.stk = tmp.res}
      else{Res.stk = stack(Res.stk, tmp.res)}
    
}

names(Res.stk) = Animal.IDs

Res.stk

ZZ = max(Res.stk)
ZZ

View Results

rng = seq(0, 105, 1)
mCols  = brewer.pal(9, "YlOrRd")[-c(1:2)]
cr0 = colorRampPalette(mCols)(n = 2000)
cr = colorRampPalette(c(cr0), 
         bias = 4)

#Removing background zeros for plotting
ZZ2 = ZZ
ZZ2[ZZ2 == 0] = NA


Plt.a = levelplot(ZZ2, 
             margin = FALSE,
             xlab =NULL, 
             ylab = NULL,
             main = "Residence Time (days)",
             maxpixels = 1e5,
             col.regions = cr, at =rng,
             colorkey = list(labels=list(at=c(0, 20, 40, 60, 80, 103),  
                             labels=c("0", "20", "40", "60", "80", "100 Days"), cex=1),
                             labels=list(cex=12),
                             space = "bottom"), 
                             par.strip.text = list(fontface='bold', cex=1),
             par.settings = list(axis.line = list(col = "black"),
                                 strip.background = list(col = 'transparent'), 
                                 strip.border = list(col = 'transparent')),
                                 scales = list(cex = 1)) + 
             latticeExtra::layer(sp.polygons(NAmer.reg, col = "darkgray", lwd = 0.5)) 

Plt.a

Construct Triangulated Mesh

NA.bf = gBuffer(NAmer, 
                width = 1, 
                byid = FALSE) 

NA.bnds = inla.sp2segment(NA.bf)

MaxEdge = 0.5

mesh0 = inla.mesh.2d(boundary = NA.bnds, 
                     cutoff = 1, 
                     max.edge = MaxEdge,
                     min.angle = 21) 

MeshLocs = cbind(mesh0$loc[,1], mesh0$loc[,2]) 

xyz = as.data.frame(                
          inla.mesh.map(MeshLocs, 
                        projection = "longlat", 
                        inverse = TRUE))

true.radius.of.earth = 6371 #km
radius.of.earth = 1

mesh.dom = inla.mesh.create(loc = xyz,
                     cutoff = 35/true.radius.of.earth, 
                     refine=list(max.edge = 1000/true.radius.of.earth, 
                                 min.angle = 26))

Click, drag, and zoom to view mesh

mesh.dom$n 
## [1] 9555
plot(mesh.dom, rgl = TRUE, main = " ")

You must enable Javascript to view this page properly.

Areal Exposure

Tessellation of mesh nodes.

dd = as.data.frame(cbind(mesh.dom$loc[,1], 
                         mesh.dom$loc[,2],
                         mesh.dom$loc[,3]))

dd = as.data.frame(
          inla.mesh.map(dd, 
                        projection = "longlat", 
                        inverse = FALSE))

names(dd) = c("Long", "Lat")

nProj = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0
         +x_0=0 +y_0=0 +k=1 +units=km +nadgrids=@null +no_defs"

dd.pnt = spTransform(
              SpatialPointsDataFrame(dd[,c("Long","Lat")], dd,
              proj4string = CRS(proj4string(NAmer))),
              nProj)

NA.unP = spTransform(NAmer, nProj)

Poly.msh = Mesh_tessellation(dd.pnt)

Poly.msh$Area = gArea(Poly.msh, byid=TRUE)
proj4string(Poly.msh) = proj4string(dd.pnt)

dd.pnt$Area = extract(Poly.msh, dd.pnt, 
                      method="simple")[,"Area"]

dd.pnt$Domain = is.na(over(dd.pnt, NA.unP))

dd.pnt$Exp = ifelse(dd.pnt$Domain == TRUE, 0, dd.pnt$Area)

Poly.in = spTransform(Poly.msh, proj4string(NAmer))
Poly.in = crop(Poly.in, NAmer)

Poly.msh$Zones = 1:nrow(Poly.msh@data)

Aggregate to Zones

Zones delineate each node’s area of influence.

#Poly.in$Dur = extract(ZZ, 
#                      spTransform(Poly.in, CRS(proj4string(ZZ))), 
#                      fun=max, sp=FALSE) 

#dd.pnt$Dur = as.numeric(extract(
#                          Poly.in, 
#                          spTransform(dd.pnt, proj4string(Poly.in)), 
#                          method = "simple")[,"Dur"])

Poly.in$IDx = 1:nrow(Poly.in@data)
Poly.in$IDx = Poly.in$IDx - 1

tmp.cov = read.csv("./Arc/RedRast/Dur_tab/Duration.csv",
                     stringsAsFactors=FALSE,
                     header = TRUE, sep=",")
  
Poly.in$Dur = as.numeric(with(tmp.cov ,
                            MAX[match(Poly.in$IDx, 
                                                 FID)]))

Poly.in$Dur[is.na(Poly.in$Dur)] = 0

Add Additional Variables

Pre-processed as above.

GetFiles = list.files(path = "./Arc/RedRast/CSV2", full.names = TRUE)

CovLabels = substr(GetFiles, 20, 24)

for(i in 1:length(CovLabels)){
  
  tmp.cov = read.csv(GetFiles[[i]],
                     stringsAsFactors=FALSE,
                     header = TRUE, sep=",")
  
  tmp.vec = as.numeric(with(tmp.cov ,
                              MEAN[match(Poly.in$IDx, 
                                                   FID)]))
  
  tmp.vec[is.na(tmp.vec)] = mean(tmp.vec, na.rm=T)
  
  
  if(i == 1){OutCov = tmp.vec}
      else{OutCov = as.data.frame(cbind(OutCov, tmp.vec))}
  
}
  
names(OutCov) = CovLabels

tmp.cov = read.csv("./Arc/RedRast/CSV2/WaterArea.csv",
                     stringsAsFactors=FALSE,
                     header = TRUE, sep=",")
  
OutCov$Water = as.numeric(with(tmp.cov ,
                            COUNT[match(Poly.in$IDx, 
                                                 FID)]))

OutCov$Water[is.na(OutCov$Water)] = median(OutCov$Water, na.rm=T)


##Chicken
tmp.cov = read.csv("./Arc/RedRast/CSV2/GChick.csv",
                     stringsAsFactors=FALSE,
                     header = TRUE, sep=",")
  
OutCov$GChic = as.numeric(with(tmp.cov ,
                            SUM[match(Poly.in$IDx, 
                                                 FID)]))

OutCov$GChic[is.na(OutCov$GChic)] = median(OutCov$GChic, na.rm=T)


##Ducks
tmp.cov = read.csv("./Arc/RedRast/CSV2/GDucks.csv",
                     stringsAsFactors=FALSE,
                     header = TRUE, sep=",")
  
OutCov$GDuck = as.numeric(with(tmp.cov ,
                            SUM[match(Poly.in$IDx, 
                                                 FID)]))

OutCov$GDuck[is.na(OutCov$GDuck)] = median(OutCov$GDuck, na.rm=T)

Cov.df = OutCov

for(i in 1:ncol(Cov.df)){
      Cov.df[,i] = as.numeric(scale(Cov.df[,i], scale = T, center = T))
}
  

names(Cov.df) = paste(names(OutCov), "_s", sep="")
  
Cov.df = cbind(OutCov, Cov.df)                     
             

ScCov.df = names(Cov.df)

Poly.in@data = cbind(Poly.in@data, Cov.df)

Poly.inP = spTransform(Poly.in, proj4string(dd.pnt))

TTTT = over(dd.pnt, Poly.inP)
TTTT[is.na(TTTT)] = 0

dd.pnt@data = cbind(dd.pnt@data, TTTT)

Avian Influenza Outbreaks

Load EMPRES Data

Loading global data then selecting years 2004-2017, domestic livestock outbreaks, and records for North America.

CleanEMPRES("C:/Users/humph173/Documents/LabWork/Patuxent/EMPRES", "EMPRES.cln")
EMPRES.cln = as.data.frame(EMPRES.cln)

#Observations
dim(EMPRES.cln)[1]
## [1] 7937
str(EMPRES.cln)
## 'data.frame':    7937 obs. of  13 variables:
##  $ Id       : int  234352 234350 234330 234310 234302 234301 234300 234299 234298 234295 ...
##  $ Spp      : Factor w/ 495 levels "","captive, amur tiger",..: 30 183 183 183 183 183 30 30 140 183 ...
##  $ Long     : num  120.22 25.45 6.33 19.4 44.21 ...
##  $ Lat      : num  23.8 42.2 53.2 -34.3 33.5 ...
##  $ AI       : chr  "H5N2 HPAI" "H5N8 HPAI" "H5N6 HPAI" "H5N8 HPAI" ...
##  $ ObsDate  : Date, format: "2018-02-15" "2017-11-20" ...
##  $ Year     : int  2018 2017 2018 2018 2018 2018 2018 2018 2018 2018 ...
##  $ Month    : int  2 11 2 1 2 2 2 2 2 2 ...
##  $ Week     : int  7 47 8 5 7 7 7 7 7 6 ...
##  $ Day      : int  15 20 24 29 14 13 12 12 12 11 ...
##  $ Cntry    : chr  "Taiwan (Province of China)" "Bulgaria" "Netherlands" "South Africa" ...
##  $ sumAtRisk: int  28451 2981 37866 14 130500 39500 15767 12807 1985 2058 ...
##  $ sumDeaths: int  250 19 230 4 77850 13500 482 800 29 10 ...
EMPRES.cln %>% 
   group_by(Year) %>%
   summarise(no_rows = length(Year))
## # A tibble: 15 x 2
##     Year no_rows
##    <int>   <int>
##  1  2004     981
##  2  2005     369
##  3  2006     757
##  4  2007     378
##  5  2008     509
##  6  2009     115
##  7  2010     109
##  8  2011     419
##  9  2012     210
## 10  2013     248
## 11  2014     193
## 12  2015     911
## 13  2016    1239
## 14  2017    1401
## 15  2018      98
EMPRES.cln$Dom = grepl("domestic", EMPRES.cln$Spp)

EMPRES.cln %>% 
   group_by(Dom) %>%
   summarise(no_rows = length(Dom))
## # A tibble: 2 x 2
##   Dom   no_rows
##   <lgl>   <int>
## 1 FALSE     374
## 2 TRUE     7563
E.df = EMPRES.cln %>%
          mutate(OBS = 1) %>%
          filter(Year >= 2004 & Year <= 2017,
                 Dom == "TRUE") %>%
          select(Long, Lat, OBS, AI, Spp, ObsDate, Year, sumAtRisk, sumDeaths)


O.pnts = SpatialPointsDataFrame(E.df[,c("Long","Lat")], E.df)
proj4string(O.pnts) = proj4string(NAmer)

O.pnts$Domain = is.na(over(O.pnts, NAmer))
O.pnts = subset(O.pnts, Domain == "FALSE")

Get Additional Outbreak (2015)

F1.df = read.csv("./US_AI_2015/ai_022718A.csv",
                    stringsAsFactors=FALSE,
                    header = TRUE, sep=",") %>%
                select(Long, Lat, Confirmation_Date)

F2.df = read.csv("./US_AI_2015/ai_022718B.csv",
                    stringsAsFactors=FALSE,
                    header = TRUE, sep=",") %>%
                select(Long, Lat, Confirmation_Date)

AI_1415.pnt = rbind(F1.df, F2.df)


AI_1415.pnt = AI_1415.pnt %>%
                mutate(IDs = 1:nrow(AI_1415.pnt),
                       Source = "US")

AI_1415.pnt = SpatialPointsDataFrame(AI_1415.pnt[,c("Long","Lat")], AI_1415.pnt)
proj4string(AI_1415.pnt) = proj4string(NAmer)

Combine with EMPRES

Also, removing duplicates.

All.ai = rbind(
          O.pnts@data %>%
            mutate(Source = "EMPRES",
                   IDs = 1:nrow(O.pnts@data)) %>%
            select(Long, Lat, IDs, Source),
          AI_1415.pnt@data[, c("Long", "Lat", "IDs", "Source")])

All.ai$dups = duplicated(All.ai[, c("Long","Lat")])

All.ai %>%
  group_by(dups) %>%
  summarise(Cnt = length(dups))
## # A tibble: 2 x 2
##   dups    Cnt
##   <lgl> <int>
## 1 FALSE   395
## 2 TRUE     42
All.ai = All.ai %>% filter(dups == "FALSE")

All.ai.pnt = SpatialPointsDataFrame(All.ai[,c("Long","Lat")], All.ai)
proj4string(All.ai.pnt) = proj4string(NAmer)

View Outbreak Locations

wmap_df = fortify(NAmer.reg)
## Regions defined for each Polygons
tmp.df = All.ai.pnt@data %>% 
            select(Long, Lat)

ggplot(wmap_df, aes(long,lat, group=group)) + 
        geom_polygon(fill = "tan", col="black") + 
        geom_point(data=tmp.df, 
                   aes(Long, Lat, 
                       group=NULL, fill=NULL),
                       col = "red", size=1) +
        xlab("Longitude") +
        ylab("Latitude") +
        ggtitle("A.I. Outbreaks (2004-2017)") +
        guides(color=guide_legend(title = "Year")) +
        scale_x_longitude(xmin=-110, xmax=80, step=10) +
        scale_y_latitude(ymin=20, ymax=60, step=10) +
        coord_equal() + 
        theme(panel.grid.minor = element_blank(),
              panel.grid.major = element_blank(),
              panel.background = element_blank(),
              plot.background = element_blank(),
              panel.border = element_blank(),
              legend.title = element_blank(),
              axis.title.x = element_text(size=16, face="bold"),
              axis.title.y = element_text(size=16, face="bold"),
              plot.title = element_text(size=20, face="bold", hjust = 0.5))

Point Covariates

Pnt.mod = All.ai.pnt@data %>% mutate(OBS = 1) %>% select(Long, Lat, OBS)

Pntdd = spTransform(dd.pnt, proj4string(All.ai.pnt))
Pntdd = Pntdd@data %>% mutate(OBS = 0) %>% select(Long, Lat, OBS)

Pnt.mod = rbind(Pnt.mod, Pntdd)
Pnt.mod = SpatialPointsDataFrame(Pnt.mod[,c("Long", "Lat")], Pnt.mod)
proj4string(Pnt.mod) = proj4string(NAmer)

SoilPH = raster("C:/Users/humph173/Documents/Soils/SoilGrids/PHIHOX_M_sl3_250m.tif")
SoilAWC = raster("C:/Users/humph173/Documents/Soils/SoilGrids/AWCh1_M_sl3_250m.tif")
SoilOrg = raster("C:/Users/humph173/Documents/Soils/SoilGrids/ORCDRC_M_sl3_250m.tif")
SoilBD = raster("C:/Users/humph173/Documents/Soils/SoilGrids/BLDFIE_M_sl3_250m.tif")
Pop = raster("C:/Users/humph173/Documents/LabWork/PopDens/gpw_v4_population_density_rev10_2015_30_sec.tif")
Slope = raster("./Arc/RedRast/Slope.tif")
DEM = raster("./Arc/NA_DEM/NA_dem.tif")
GlobChkn = raster("C:/Users/humph173/Documents/LabWork/Patuxent/GlobPoultry/livestock_CHICKENS/Glb_chkAD_2006_paper.tif")
GlobDuck = raster("C:/Users/humph173/Documents/LabWork/Patuxent/GlobPoultry/DUCKS_global/GLb_Ducks_CC2006_AD.tif")


Pnt.mod$SoilPH = extract(SoilPH, 
                          spTransform(Pnt.mod, 
                          CRS(proj4string(SoilPH))), 
                          method = "simple")

Pnt.mod$SoilPH[is.na(Pnt.mod$SoilPH)] = mean(Pnt.mod$SoilPH, na.rm=T)


Pnt.mod$SoilAWC = extract(SoilAWC, 
                          spTransform(Pnt.mod, 
                          CRS(proj4string(SoilAWC))), 
                          method = "simple")

Pnt.mod$SoilAWC[is.na(Pnt.mod$SoilAWC)] = mean(Pnt.mod$SoilAWC, na.rm=T)

Pnt.mod$SoilOrg = extract(SoilOrg, 
                          spTransform(Pnt.mod, 
                          CRS(proj4string(SoilOrg))), 
                          method = "simple")

Pnt.mod$SoilOrg[is.na(Pnt.mod$SoilOrg)] = mean(Pnt.mod$SoilOrg, na.rm=T)

Pnt.mod$SoilBD = extract(SoilBD, 
                          spTransform(Pnt.mod, 
                          CRS(proj4string(SoilBD))), 
                          method = "simple")

Pnt.mod$SoilBD[is.na(Pnt.mod$SoilBD)] = mean(Pnt.mod$SoilBD, na.rm=T)






Pnt.mod$Slope = extract(Slope, 
                          spTransform(Pnt.mod, 
                          CRS(proj4string(Slope))), 
                          method = "simple")

Pnt.mod$Slope[is.na(Pnt.mod$Slope)] = mean(Pnt.mod$Slope, na.rm=T)

Pnt.mod$GlobChkn = extract(GlobChkn, 
                            spTransform(Pnt.mod, 
                            CRS(proj4string(GlobChkn))), 
                            method = "simple")

Pnt.mod$GlobChkn[is.na(Pnt.mod$GlobChkn)] = mean(Pnt.mod$GlobChkn, na.rm=T)
Pnt.mod$GlobChkn = Pnt.mod$GlobChkn/1000

Pnt.mod$GlobDuck = extract(GlobDuck, 
                            spTransform(Pnt.mod, 
                            CRS(proj4string(GlobDuck))), 
                            method = "simple")

Pnt.mod$GlobDuck[is.na(Pnt.mod$GlobDuck)] = mean(Pnt.mod$GlobDuck, na.rm=T)
Pnt.mod$GlobDuck = Pnt.mod$GlobDuck/100


Pnt.mod$Pop = extract(Pop, 
                      spTransform(Pnt.mod, 
                      CRS(proj4string(Pop))), 
                      method = "simple")

Pnt.mod$Pop[is.na(Pnt.mod$Pop)] = mean(Pnt.mod$Pop, na.rm=T)
Pnt.mod$Pop = Pnt.mod$Pop/100
Grd.pnt$SoilPH = extract(SoilPH, 
                          spTransform(Grd.pnt, 
                          CRS(proj4string(SoilPH))), 
                          method = "simple")

Grd.pnt$SoilPH[is.na(Grd.pnt$SoilPH)] = mean(Grd.pnt$SoilPH, na.rm=T)


Grd.pnt$SoilAWC = extract(SoilAWC, 
                          spTransform(Grd.pnt, 
                          CRS(proj4string(SoilAWC))), 
                          method = "simple")

Grd.pnt$SoilAWC[is.na(Grd.pnt$SoilAWC)] = mean(Grd.pnt$SoilAWC, na.rm=T)

Grd.pnt$SoilOrg = extract(SoilOrg, 
                          spTransform(Grd.pnt, 
                          CRS(proj4string(SoilOrg))), 
                          method = "simple")

Grd.pnt$SoilOrg[is.na(Grd.pnt$SoilOrg)] = mean(Grd.pnt$SoilOrg, na.rm=T)

Grd.pnt$SoilBD = extract(SoilBD, 
                          spTransform(Grd.pnt, 
                          CRS(proj4string(SoilBD))), 
                          method = "simple")

Grd.pnt$SoilBD[is.na(Grd.pnt$SoilBD)] = mean(Grd.pnt$SoilBD, na.rm=T)



Grd.pnt$Slope = extract(Slope, 
                          spTransform(Grd.pnt, 
                          CRS(proj4string(Slope))), 
                          method = "simple")

Grd.pnt$Slope[is.na(Grd.pnt$Slope)] = mean(Grd.pnt$Slope, na.rm=T)

Grd.pnt$GlobChkn = extract(GlobChkn, 
                            spTransform(Grd.pnt, 
                            CRS(proj4string(GlobChkn))), 
                            method = "simple")

Grd.pnt$GlobChkn[is.na(Grd.pnt$GlobChkn)] = mean(Grd.pnt$GlobChkn, na.rm=T)
Grd.pnt$GlobChkn = Grd.pnt$GlobChkn/1000

Grd.pnt$GlobDuck = extract(GlobDuck, 
                            spTransform(Grd.pnt, 
                            CRS(proj4string(GlobDuck))), 
                            method = "simple")

Grd.pnt$GlobDuck[is.na(Grd.pnt$GlobDuck)] = mean(Grd.pnt$GlobDuck, na.rm=T)
Grd.pnt$GlobDuck = Grd.pnt$GlobDuck/100


Grd.pnt$Pop = extract(Pop, 
                      spTransform(Grd.pnt, 
                      CRS(proj4string(Pop))), 
                      method = "simple")

Grd.pnt$Pop[is.na(Grd.pnt$Pop)] = mean(Grd.pnt$Pop, na.rm=T)
Grd.pnt$Pop = Grd.pnt$Pop/100
GlobCover = raster("C:/Users/humph173/Documents/Michigan_State/Marten/Marten_SDM/Env/Globcover2009_V2.3_Global_/GLOBCOVER_L4_200901_200912_V2.3.tif")

GLCcdm = raster("./Arc/LC/WetDist/GLCcdm.tif") 

Pnt.mod$LC = as.character(
                extract(GlobCover, 
                spTransform(Pnt.mod, 
                CRS(proj4string(GlobCover))), 
                method = "simple"))

Pnt.mod$LC[is.na(Pnt.mod$LC)] = "200" 
levels(as.factor(Pnt.mod$LC))


Pnt.mod$wDs = as.numeric(
                     extract(GLCcdm, 
                     spTransform(Pnt.mod, 
                     CRS(proj4string(GLCcdm))), 
                     method = "simple"))

range(Pnt.mod$wDs, na.rm=T)

Pnt.mod$wDs[is.na(Pnt.mod$wDs)] = mean(Pnt.mod$wDs, na.rm=T)
Pnt.mod$wDsR = round(Pnt.mod$wDs, 0) #rounding to whole km
range(Pnt.mod$wDsR)

Pnt.mod$wDsR[Pnt.mod$wDsR>400] = 400
range(Pnt.mod$wDsR)


#Prediction Grid
Grd.pnt$LC = as.character(
                  extract(GlobCover, 
                  spTransform(Grd.pnt, 
                  CRS(proj4string(GlobCover))), 
                  method = "simple"))

Grd.pnt$LC[is.na(Grd.pnt$LC)] = "200" 
levels(as.factor(Grd.pnt$LC))


Grd.pnt$wDs = as.numeric(
                     extract(GLCcdm, 
                     spTransform(Grd.pnt, 
                     CRS(proj4string(GLCcdm))), 
                     method = "simple"))

range(Grd.pnt$wDs, na.rm=T)

Grd.pnt$wDs[is.na(Grd.pnt$wDs)] = mean(Grd.pnt$wDs, na.rm=T)
Grd.pnt$wDsR = round(Grd.pnt$wDs, 0) #rounding to whole km
Grd.pnt$wDsR[Grd.pnt$wDsR>400] = 400
range(Grd.pnt$wDsR)

Nearest Neighbor

Pred.locs = Grd.pnt@data %>%
            mutate(Spp = "PG",
                   OBS = 0) %>%
            select(Long, Lat, Spp, OBS)

OutB.locs = Pnt.mod@data %>%
            mutate(Spp = "OutB") %>%
            select(Long, Lat, Spp, OBS)
            
NN.pnt = rbind(Pred.locs, OutB.locs)
NN.pnt = SpatialPointsDataFrame(NN.pnt[, c("Long","Lat")], NN.pnt)
proj4string(NN.pnt) = proj4string(NAmer)

NN.pnt = spTransform(NN.pnt, nProj)

By = as.factor(NN.pnt$OBS)
P.pp = as.ppp(NN.pnt)
NN = as.data.frame(nndist(P.pp, by=By, k = 1))

NN.pnt$nOutBrk = round(NN[,"1"]/100, 2)

Grd.pnt$nOutBrk = (NN.pnt@data %>% filter(Spp == "PG"))[,"nOutBrk"]
Pnt.mod$nOutBrk = (NN.pnt@data %>% filter(Spp == "OutB"))[,"nOutBrk"]

Scale and Center

Cov.df = Pnt.mod@data[,4:11]

for(i in 1:ncol(Cov.df)){
      Cov.df[,i] = as.numeric(scale(Cov.df[,i], scale = T, center = T))
}

Cov.df = as.data.frame(Cov.df)
names(Cov.df) = paste(names(Pnt.mod[,4:11]), "s", sep="_")

Pnt.mod@data = cbind(Pnt.mod@data, Cov.df)

##Grd locs
Cov.df = Grd.pnt@data[,3:10]

for(i in 1:ncol(Cov.df)){
      Cov.df[,i] = as.numeric(scale(Cov.df[,i], scale = T, center = T))
}

Cov.df = as.data.frame(Cov.df)
names(Cov.df) = paste(names(Grd.pnt@data[,3:10]), "s", sep="_")

Grd.pnt@data = cbind(Grd.pnt@data, Cov.df)
#save.image("~/LabWork/Patuxent/Patux_level1/Tri_prepro_081118.RData")

Spatial Modeling

Convert to 3D Cartesian Coordinates

dd.pntLL = spTransform(dd.pnt, proj4string(NAmer))

locs = cbind(dd.pntLL@coords[,1], dd.pntLL@coords[,2])

locs = inla.mesh.map(locs, 
                     projection = "longlat", 
                     inverse = TRUE)

A.bwte = inla.spde.make.A(mesh.dom, 
                          alpha = 2,
                          loc=locs)

A.bwte2 = A.bwte

#Points
locs = cbind(Pnt.mod$Long, Pnt.mod$Lat)

locs = inla.mesh.map(locs, 
                     projection = "longlat", 
                     inverse = TRUE)

A.em = inla.spde.make.A(mesh.dom, 
                          alpha = 2,
                          loc=locs)

Sptial Prior for Models and Spatial Indicies

spde0 = inla.spde2.pcmatern(mesh.dom, alpha = 2,
                                    prior.range=c(3, 0.01),
                                    prior.sigma=c(1, 0.01),
                                    constr = TRUE)

field.bwte1 = inla.spde.make.index("field.bwte1", spde0$n.spde) 

field.bwte2 = inla.spde.make.index("field.bwte2", spde0$n.spde)

field.bwte3 = inla.spde.make.index("field.bwte3", spde0$n.spde) 

field.bwteX = inla.spde.make.index("field.bwteX", spde0$n.spde) 

field.bwteXX = inla.spde.make.index("field.bwteXX", spde0$n.spde) 

field.bwteXXX = inla.spde.make.index("field.bwteXXX", spde0$n.spde) 

Orginizing Model Data

FE.df = dd.pnt@data

#BWTE1 
FE.lst.1 = list(c(field.bwte1,
                list(intercept1 = 1)),
                list(DEMX = FE.df[,"DEMms_s"]))

FE.df$DurOBS = ifelse(FE.df$Dur > 0.5, 1, 0)

BWTE.stk1 = inla.stack(data = list(Dur = FE.df$DurOBS),
                                   A = list(A.bwte, 1), 
                             effects = FE.lst.1,   
                                 tag = "bwte.1")


JBWTE.stk1 = inla.stack(data = list(Y = cbind(FE.df$DurOBS, NA)),
                                   A = list(A.bwte, 1), 
                             effects = FE.lst.1,   
                                 tag = "bwte.1")

TBWTE.stk1 = inla.stack(data = list(Y = cbind(FE.df$DurOBS, NA, NA)),
                                   A = list(A.bwte, 1), 
                             effects = FE.lst.1,   
                                 tag = "bwte.1")


#BWTE2 
FE.lst.2 = list(c(field.bwte2, field.bwteX,
                list(intercept2 = 1)),
                list(DEMX = FE.df[,"DEMms_s"]))

FE.df$Dur2 = FE.df$Dur
FE.df$Dur2[FE.df$Dur2 == 0 ] = NA


FE.df$Exp = FE.df$Exp/true.radius.of.earth
FE.df$Exp2 = ifelse(is.na(FE.df$Dur2), NA, FE.df$Exp)

BWTE.stk = inla.stack(data = list(Dur = FE.df$Dur2, e = FE.df$Exp2),
                                   A = list(A.bwte, 1), 
                             effects = FE.lst.2,   
                                 tag = "bwte.0")

JBWTE.stk2 = inla.stack(data = list(Y = cbind(NA, FE.df$Dur2), e = FE.df$Exp2),
                                   A = list(A.bwte2, 1), 
                             effects = FE.lst.2,   
                                 tag = "bwte.2")

TBWTE.stk2 = inla.stack(data = list(Y = cbind(NA, FE.df$Dur2, NA), e = FE.df$Exp2),
                                   A = list(A.bwte2, 1), 
                             effects = FE.lst.2,   
                                 tag = "bwte.2")



##OutB Points
FE.df = Pnt.mod@data
FE.df$Glob_pltry = (FE.df$GlobChkn + FE.df$GlobDuck)

FE.lst.3 = list(c(field.bwte3, 
                  field.bwteXX, 
                  field.bwteXXX,
                list(intercept3 = 1)),
                list(IDD = 1:dim(FE.df)[1],
                     hPop = FE.df[,"Pop_s"],
                     Slope = FE.df[,"Slope_s"],
                     SoilBD = FE.df[,"SoilBD_s"],
                     SoilOrg = FE.df[,"SoilOrg_s"],
                     SoilAWC = FE.df[,"SoilAWC_s"],
                     SoilPH = FE.df[,"SoilPH_s"],
                     wDsR = FE.df[,"wDsR"],
                     Glob_pltry = FE.df[,"Glob_pltry"],
                     GlobChkn = FE.df[,"GlobChkn_s"],
                     GlobDuck = FE.df[,"GlobDuck_s"],
                     nOutBrk = FE.df[,"nOutBrk"],
                     LC = FE.df[,"LC"]))

OutBrk.stkp = inla.stack(data = list(Event = FE.df$OBS),
                                   A = list(A.em, 1), 
                             effects = FE.lst.3,   
                                 tag = "outbrkp.0")

JOutBrk.stkp = inla.stack(data = list(Y = cbind(NA, NA, FE.df$OBS)),
                             A = list(A.em, 1), 
                       effects = FE.lst.3,   
                           tag = "outbrkp.3")


Joint.stk = inla.stack(TBWTE.stk1, TBWTE.stk2, JOutBrk.stkp)

Base Spatial Model for Outbreaks

Frm0 = Event ~ -1 + intercept3 + 
                  f(field.bwte3, 
                    model=spde0)

  
#theta0 = Model0$internal.summary.hyperpar$mean
theta0 = c(-0.9765993, 1.9968117)


Model0 = inla(Frm0, 
               data = inla.stack.data(OutBrk.stkp, 
                                      spde=spde0), 
               family = "binomial", 
               verbose = FALSE,
               control.fixed = list(prec = 0.001, 
                                    prec.intercept = 0.0001), 
               control.predictor = list(
                                      A = inla.stack.A(OutBrk.stkp), 
                                      compute = TRUE, 
                                      link = 1), 
               control.mode = list(restart = TRUE, theta = theta0),
               control.inla = list(strategy="gaussian", 
                                   int.strategy = "eb"),
               control.results = list(return.marginals.random = TRUE,
                                      return.marginals.predictor = TRUE),
               control.compute=list(dic = TRUE, cpo = TRUE, waic = TRUE)) 
GetMets(Model0)[2,2]
## [1] 1684.672

Mapping Random Field and Standard Deviation for Later Comparison

Pred.pnts = Grd.pnt
ModResult = Model0
ModMesh = mesh.dom

pLoc = cbind(Pred.pnts$Long, Pred.pnts$Lat)

pLoc = inla.mesh.map(pLoc, 
                     projection = "longlat", 
                     inverse = TRUE)

Ap = inla.spde.make.A(ModMesh, loc=pLoc)

Pred.pnts$RF3 = drop(Ap %*% ModResult$summary.random$field.bwte3$mean)
Pred.pnts$RF3sd = drop(Ap %*% ModResult$summary.random$field.bwte3$sd)

Mod0RF = rasterize(Pred.pnts, 
                  Domain.r, 
                  "RF3", 
                  background = NA)

Mod0sd = rasterize(Pred.pnts, 
                  Domain.r, 
                  "RF3sd", 
                  background = NA)

Model for Outbreaks with Clustering

pcprior = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
pcprior2 = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
mod.prec = list(hyper=list(theta=list(prior='pc.prec', param=c(1, 0.01))))

Frm1 = Event ~ -1 + intercept3 + 
                  f(field.bwte3, 
                    model=spde0) +
                  f(nOutBrk,
                    model = "rw1",
                    scale.model = TRUE,
                    hyper = pcprior) 

  

theta1 = c(2.943513, -1.758147, -3.344915)

Model1 = inla(Frm1, 
               data = inla.stack.data(OutBrk.stkp, 
                                      spde=spde0), 
               family = "binomial", 
               verbose = FALSE,
               control.fixed = list(prec = 0.001, 
                                    prec.intercept = 0.0001), 
               control.predictor = list(
                                      A = inla.stack.A(OutBrk.stkp), 
                                      compute = TRUE, 
                                      link = 1), 
               control.mode = list(restart = TRUE, theta = theta1),
               control.inla = list(strategy="gaussian", 
                                   int.strategy = "eb"),
               control.results = list(return.marginals.random = TRUE,
                                      return.marginals.predictor = TRUE),
               control.compute=list(dic = TRUE, cpo = TRUE, waic = TRUE)) 
GetMets(Model1)[2,2]
## [1] 945.3396
Model1$mode$mode.status 
## [1] 0
idat = inla.stack.index(OutBrk.stkp, "outbrkp.0")$data
cor(Pnt.mod$OBS, plogis(Model1$summary.linear.predictor$mean[idat]), use = "complete.obs")
## [1] 0.8522379

Model with Covariates (No Clustering)

pcprior = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
pcprior2 = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
mod.prec = list(hyper=list(theta=list(prior='pc.prec', param=c(1, 0.01))))

Frm1b = Event ~ -1 + intercept3 + 
                  f(field.bwte3, 
                    model=spde0) +
                  f(LC,
                    model = "iid",
                    hyper= LC.prior) +
                  Glob_pltry + hPop + Slope + wDsR 

  
#theta1 = Model1b$internal.summary.hyperpar$mean
theta1b = c(-0.8418032, 1.8683961, 0.1874032)

Model1b = inla(Frm1b, 
               data = inla.stack.data(OutBrk.stkp, 
                                      spde=spde0), 
               family = "binomial", 
               verbose = FALSE,
               control.fixed = list(prec = 0.001, 
                                    prec.intercept = 0.0001), 
               control.predictor = list(
                                      A = inla.stack.A(OutBrk.stkp), 
                                      compute = TRUE, 
                                      link = 1), 
               control.mode = list(restart = TRUE, theta = theta1b),
               control.inla = list(strategy="gaussian", 
                                   int.strategy = "eb"),
               control.results = list(return.marginals.random = TRUE,
                                      return.marginals.predictor = TRUE),
               control.compute=list(dic = TRUE, cpo = TRUE, waic = TRUE)) 
GetMets(Model1b)[2,2]
## [1] 1490.543

Mapping estimate for later comparison

Pred.pnts = Grd.pnt
ModResult = Model1b
ModMesh = mesh.dom
Pred.pnts$Glob_pltry = Pred.pnts$GlobChkn+Pred.pnts$GlobDuck

pLoc = cbind(Pred.pnts$Long, Pred.pnts$Lat)

pLoc = inla.mesh.map(pLoc, 
                     projection = "longlat", 
                     inverse = TRUE)

Ap = inla.spde.make.A(ModMesh, loc=pLoc)

Pred.pnts$RF3 = drop(Ap %*% ModResult$summary.random$field.bwte3$mean)

mydf = ModResult$summary.fix

Pred.pnts$Int1 = ModResult$summary.fix[1,1]

                      #LC Effect
           LuTable = as.data.frame(ModResult$summary.random$LC)  
           LuTable$ID = as.factor(LuTable$ID)
                    
           Pred.pnts$Z.ef = with(LuTable,
                                 mean[match(Pred.pnts$LC,
                                                      ID)])
           
           Pred.pnts$Z.ef[is.na(Pred.pnts$Z.ef)] = 0
           
           
Pred.pnts@data = Pred.pnts@data %>%
            mutate(LP = Int1 + RF3 + Z.ef +  
                        Glob_pltry*mydf[2,1] +
                        Pop_s*mydf[3,1] +
                        Slope_s*mydf[4,1] +
                        wDsR*mydf[5,1],
                   LP = ifelse(is.na(LP), 0, LP),
                  Mod1b = plogis(LP)) 

Mod1bp = rasterize(Pred.pnts, 
                  Domain.r, 
                  "Mod1b", 
                  background = NA)

Mod1brf = rasterize(Pred.pnts, 
                  Domain.r, 
                  "RF3", 
                  background = NA)

Model for Outbreaks with Clustering and Covariates

pcprior = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
pcprior2 = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
LC.prior = list(theta=list(prior = "normal", param=c(0, 3)))
mod.prec = list(hyper=list(theta=list(prior='pc.prec', param=c(1, 0.01))))

Frm2 = Event ~ -1 + intercept3 + 
                  f(field.bwte3, 
                    model=spde0) +
                   f(LC,
                    model = "iid",
                    hyper= LC.prior) +
                  f(nOutBrk,
                    model = "rw1",
                    scale.model = TRUE,
                    hyper = pcprior) +
                  Glob_pltry + hPop + Slope + wDsR
                  
  
#theta2 = Model2$internal.summary.hyperpar$mean
theta2 = c(3.0830519, -1.9996869, 0.5241344, -3.2908515)

Model2 = inla(Frm2, 
               data = inla.stack.data(OutBrk.stkp, 
                                      spde=spde0), 
               family = "binomial", 
               verbose = FALSE,
               control.fixed = list(prec = 0.001, 
                                    prec.intercept = 0.0001), 
               control.predictor = list(
                                      A = inla.stack.A(OutBrk.stkp), 
                                      compute = TRUE, 
                                      link = 1), 
               control.mode = list(restart = TRUE, theta = theta2),
               control.inla = list(strategy="gaussian", 
                                   int.strategy = "eb"),
               control.results = list(return.marginals.random = TRUE,
                                      return.marginals.predictor = TRUE),
               control.compute=list(dic = TRUE, cpo = TRUE, waic = TRUE)) 
GetMets(Model2)[2,2]
## [1] 888.9858
Model2$mode$mode.status 
## [1] 0

Mapping estimate for later comparison

Pred.pnts = Grd.pnt
ModResult = Model2
ModMesh = mesh.dom
Pred.pnts$Glob_pltry = Pred.pnts$GlobChkn+Pred.pnts$GlobDuck

pLoc = cbind(Pred.pnts$Long, Pred.pnts$Lat)

pLoc = inla.mesh.map(pLoc, 
                     projection = "longlat", 
                     inverse = TRUE)

Ap = inla.spde.make.A(ModMesh, loc=pLoc)

Pred.pnts$RF3 = drop(Ap %*% ModResult$summary.random$field.bwte3$mean)

mydf = ModResult$summary.fix

Pred.pnts$Int1 = ModResult$summary.fix[1,1]

           #Clustering
            LuTable = ModResult$summary.random$nOutBrk
            LuTable$POS = 1:dim(LuTable)[1]
                      
            Pred.pnts$RW = sapply(Pred.pnts$nOutBrk, function(x)which.min(abs(x - LuTable$ID)))
            
            Pred.pnts$nObrk.ef = as.numeric(with(LuTable,
                                          mean[match(Pred.pnts$RW, 
                                                               POS)]))
            
           #LC Effect
           LuTable = as.data.frame(ModResult$summary.random$LC)  
           LuTable$ID = as.factor(LuTable$ID)
                    
           Pred.pnts$Z.ef = with(LuTable,
                                 mean[match(Pred.pnts$LC,
                                                      ID)])
           
           Pred.pnts$Z.ef[is.na(Pred.pnts$Z.ef)] = 0
           
           
Pred.pnts@data = Pred.pnts@data %>%
            mutate(LP = Z.ef +
                        Glob_pltry*mydf[2,1] +
                        Pop_s*mydf[3,1] +
                        Slope_s*mydf[4,1] +
                        wDsR*mydf[5,1],
                   LP = ifelse(is.na(LP), 0, LP),
                  Mod2 = plogis(LP)) 

Mod2p = rasterize(Pred.pnts, 
                  Domain.r, 
                  "Mod2", 
                  background = NA)

Mod2rf = rasterize(Pred.pnts, 
                  Domain.r, 
                  "RF3", 
                  background = NA)

clustComp.stk = stack(Mod1bp, Mod2p, Mod1brf, Mod2rf)
names(clustComp.stk) = c("A", "B", "C", "D")

Joint Models

Including BWTE Occurence and Residence Time

Joint Model (CoRegion)

No linear covariates.

pcprior = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
pcprior2 = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
LC.prior = list(theta=list(prior = "normal", param=c(0, 3)))
mod.prec = list(hyper=list(theta=list(prior='pc.prec', param=c(1, 0.01))))

Frm.J = Y ~ -1 +  intercept1 + 
                  intercept2 + 
                  intercept3 +
              f(field.bwte1, 
                model = spde0) +
              f(field.bwte2, 
                model = spde0) +
              f(field.bwte3, 
                model = spde0) +
              f(field.bwteX, 
                copy = "field.bwte1", 
                fixed = FALSE) +
              f(field.bwteXX, 
                copy = "field.bwte1", 
                fixed = FALSE) +
              f(field.bwteXXX, 
                copy = "field.bwte2", 
                fixed = FALSE) +
              f(LC,
                model = "iid",
                hyper= LC.prior) +
              f(nOutBrk,
                model = "rw1",
                scale.model = TRUE,
                hyper = pcprior) 

#theta.jnc  = Model.Jnc$internal.summary.hyperpar$mean
theta.jnc = c(5.0480804, 0.4370231, -3.6808626, -1.8458792, -0.4246105,  1.4141917,  2.8572157,
            -1.7047687, 0.2033466, -3.3181406, 5.8388172, 0.7143663, 0.1829404)

Model.Jnc = inla(Frm.J, 
             data = inla.stack.data(Joint.stk, spde=spde0), 
             family = c("gaussian", "gamma", "binomial"), 
             verbose = FALSE,
             E = inla.stack.data(Joint.stk)$e,
             control.fixed = list(prec = 0.001, 
                                  prec.intercept = 0.0001), 
             control.predictor = list(
                                    A = inla.stack.A(Joint.stk), 
                                    compute = TRUE, 
                                    link = 1), 
             control.mode = list(restart = TRUE, theta = theta.jnc),
             control.inla = list(strategy="gaussian", 
                                 int.strategy = "eb"),
             control.results = list(return.marginals.random = TRUE,
                                    return.marginals.predictor = TRUE),
             control.compute=list(dic = TRUE, cpo = TRUE, waic = TRUE)) 
GetMets(Model.Jnc)[2,4]
## [1] 915.674

Joint Model (CoRegion)

Including linear covariates.

pcprior = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
pcprior2 = list(prec = list(prior="pc.prec", param = c(1, 0.001))) 
LC.prior = list(theta=list(prior = "normal", param=c(0, 3)))
mod.prec = list(hyper=list(theta=list(prior='pc.prec', param=c(1, 0.01))))

Frm.J = Y ~ -1 +  intercept1 + 
                  intercept2 + 
                  intercept3 +
              f(field.bwte1, 
                model = spde0) +
              f(field.bwte2, 
                model = spde0) +
              f(field.bwte3, 
                model = spde0) +
              f(field.bwteX, 
                copy = "field.bwte1", 
                fixed = FALSE) +
              f(field.bwteXX, 
                copy = "field.bwte1", 
                fixed = FALSE) +
              f(field.bwteXXX, 
                copy = "field.bwte2", 
                fixed = FALSE) +
              f(LC,
                model = "iid",
                hyper= LC.prior) +
              f(nOutBrk,
                model = "rw1",
                scale.model = TRUE,
                hyper = pcprior) +
              Glob_pltry + hPop + Slope + wDsR

theta.j3 = c(4.70995465, -0.03843521, -2.86767794, -1.23844535, -1.47810977, 2.31949778, 3.01255369, -2.04213365, 0.50720186,
             -3.31754205, 0.5, 1.30978091, 0.04042024)

Model.J3C = inla(Frm.J3, 
             data = inla.stack.data(Joint.stk, spde=spde0), 
             family = c("gaussian", "gamma", "binomial"), 
             verbose = FALSE,
             E = inla.stack.data(Joint.stk)$e,
             control.fixed = list(prec = 0.001, 
                                  prec.intercept = 0.0001), 
             control.predictor = list(
                                    A = inla.stack.A(Joint.stk), 
                                    compute = TRUE, 
                                    link = 1), 
             control.mode = list(restart = TRUE, theta = theta.j3),
             control.inla = list(strategy="gaussian", 
                                 int.strategy = "eb"),
             control.results = list(return.marginals.random = TRUE,
                                    return.marginals.predictor = TRUE),
             control.compute=list(dic = TRUE, cpo = TRUE, waic = TRUE)) 
GetMets(Model.J3C)[2,4]
## [1] 888.692

Simple Linear Regression

Frm.lr = Event ~ -1 + intercept3 + 
                    Glob_pltry + hPop + Slope + wDsR

  
#theta0 = Model0$internal.summary.hyperpar$mean
theta0 = c(-0.9765993, 1.9968117)


Model.lr = inla(Frm.lr, 
               data = inla.stack.data(OutBrk.stkp), 
               family = "binomial", 
               verbose = FALSE,
               control.fixed = list(prec = 0.001, 
                                    prec.intercept = 0.0001), 
               control.predictor = list(
                                      A = inla.stack.A(OutBrk.stkp), 
                                      compute = TRUE, 
                                      link = 1), 
               control.inla = list(strategy="gaussian", 
                                   int.strategy = "eb"),
               control.results = list(return.marginals.random = TRUE,
                                      return.marginals.predictor = TRUE),
               control.compute=list(dic = TRUE, cpo = TRUE, waic = TRUE)) 
GetMets(Model.lr)[2,2]
## [1] 2888.466

Compare Models

Models = c("Model0", "Model1",
           "Model2", "Model3", 
           "Model4", "Model5",
           "Model6")

Type = c("Base spatial model",
         "Spatial + cluster term",
         "Spatial + environment",
         "Spatial + cluster + environment",
         "Joint BWTE model",
         "Joint BWTE model + environment",
         "Non-spatial model")

#Watanabe-Akaike information criteria
WAICs = c(GetMets(Model0)[2,2], GetMets(Model1)[2,2], GetMets(Model1b)[2,2], 
         GetMets(Model2)[2,2], GetMets(Model.Jnc)[2,4],
         GetMets(Model.J3C)[2,4],GetMets(Model.lr)[2,2])

lCPOs = c(GetMets(Model0)[3,2], GetMets(Model1)[3,2], GetMets(Model1b)[3,2], 
         GetMets(Model2)[3,2], GetMets(Model.Jnc)[3,4],
         GetMets(Model.J3C)[3,4],GetMets(Model.lr)[3,2])

Model_mets = as.data.frame(cbind(Model = Models,
                                 WAICs = round(WAICs, 2),
                                 lCPOs = round(lCPOs, 2),
                                 Type = Type))

rownames(Model_mets) = 1:nrow(Model_mets)

kable(Model_mets) %>%
      kable_styling("striped", full_width = F) %>%
      row_spec(0, font_size = 20) 
Model WAICs lCPOs Type
Model0 1684.67 0.89 Base spatial model
Model1 945.34 0.09 Spatial + cluster term
Model2 1490.54 0.36 Spatial + environment
Model3 888.99 0.08 Spatial + cluster + environment
Model4 915.67 0.08 Joint BWTE model
Model5 888.69 0.08 Joint BWTE model + environment
Model6 2888.47 0.15 Non-spatial model
library(xtable)
## 
## Attaching package: 'xtable'
## The following object is masked from 'package:maptools':
## 
##     label
Table2 = xtable(Model_mets)
print(Table2, include.rownames = FALSE)
## % latex table generated in R 3.5.1 by xtable 1.8-2 package
## % Sun Aug 19 21:25:37 2018
## \begin{table}[ht]
## \centering
## \begin{tabular}{llll}
##   \hline
## Model & WAICs & lCPOs & Type \\ 
##   \hline
## Model0 & 1684.67 & 0.89 & Base spatial model \\ 
##   Model1 & 945.34 & 0.09 & Spatial + cluster term \\ 
##   Model2 & 1490.54 & 0.36 & Spatial + environment \\ 
##   Model3 & 888.99 & 0.08 & Spatial + cluster + environment \\ 
##   Model4 & 915.67 & 0.08 & Joint BWTE model \\ 
##   Model5 & 888.69 & 0.08 & Joint BWTE model + environment \\ 
##   Model6 & 2888.47 & 0.15 & Non-spatial model \\ 
##    \hline
## \end{tabular}
## \end{table}

Summing all Components

Pred.pnts = Grd.pnt
ModResult = Model.J3C
ModMesh = mesh.dom
Pred.pnts$Glob_pltry = Pred.pnts$GlobChkn+Pred.pnts$GlobDuck

pLoc = cbind(Pred.pnts$Long, Pred.pnts$Lat)

pLoc = inla.mesh.map(pLoc, 
                     projection = "longlat", 
                     inverse = TRUE)

Ap = inla.spde.make.A(ModMesh, loc=pLoc)

Pred.pnts$RF1 = drop(Ap %*% ModResult$summary.random$field.bwte1$mean)
Pred.pnts$RF2 = drop(Ap %*% ModResult$summary.random$field.bwte2$mean)
Pred.pnts$RF3 = drop(Ap %*% ModResult$summary.random$field.bwte3$mean)
Pred.pnts$RFX = drop(Ap %*% ModResult$summary.random$field.bwteX$mean)
Pred.pnts$RFXX = drop(Ap %*% ModResult$summary.random$field.bwteXX$mean)
Pred.pnts$RFXXX = drop(Ap %*% ModResult$summary.random$field.bwteXXX$mean)

Pred.pnts$RF3sd = drop(Ap %*% ModResult$summary.random$field.bwte3$sd)

mydf = ModResult$summary.fix

Pred.pnts$Int1 = ModResult$summary.fix[1,1]
Pred.pnts$Int2 = ModResult$summary.fix[2,1]
Pred.pnts$Int3 = ModResult$summary.fix[3,1]

           #Clustering
            LuTable = ModResult$summary.random$nOutBrk
            LuTable$POS = 1:dim(LuTable)[1]
                      
            Pred.pnts$RW = sapply(Pred.pnts$nOutBrk, function(x)which.min(abs(x - LuTable$ID)))
            
            Pred.pnts$nObrk.ef = as.numeric(with(LuTable,
                                          mean[match(Pred.pnts$RW, 
                                                               POS)]))
            
            Con.clust = quantile(Pred.pnts$nObrk.ef, probs = 0.90, na.rm=T)
            
           #LC Effect
           LuTable = as.data.frame(ModResult$summary.random$LC)  
           LuTable$ID = as.factor(LuTable$ID)
                    
           Pred.pnts$Z.ef = with(LuTable,
                                 mean[match(Pred.pnts$LC,
                                                      ID)])
           
           Pred.pnts$Z.ef[is.na(Pred.pnts$Z.ef)] = 0
           
           
Pred.pnts@data = Pred.pnts@data %>%
            mutate(LP = Int3 + Int2 + Int1 +
                        RF1 + RFX + RF2 +
                        RF3 + RFXX + RFXXX +
                        Z.ef +  nObrk.ef +  
                        Glob_pltry*mydf[4,1] +
                        Pop_s*mydf[5,1] +
                        Slope_s*mydf[6,1] +
                        wDsR*mydf[7,1],
                   LP = ifelse(is.na(LP), 0, LP),
                   bst.fit = plogis(LP)) 
           

Pred.pnts@data = Pred.pnts@data %>%
                  mutate(LP =  Z.ef + RFXXX + #RFXX +
                              Glob_pltry*mydf[4,1] +
                              Pop_s*mydf[5,1] +
                              Slope_s*mydf[6,1] +
                              wDsR*mydf[7,1],
                         LP = ifelse(is.na(LP), 0, LP),
                         true.pred = plogis(LP)) 
  
Best.fit = rasterize(Pred.pnts, 
                  Domain.r, 
                  "bst.fit", 
                  background = NA)

True.pred = rasterize(Pred.pnts, 
                  Domain.r, 
                  "true.pred", 
                  background = NA)

Pred.pnts@data = Pred.pnts@data %>%
        mutate(LP = Int2 + RF2 + RFX,
               LP = ifelse(is.na(LP), 0, LP),
               pDur = exp(LP))  

Dur.bwte = rasterize(Pred.pnts, 
                     Domain.r, 
                     "pDur", 
                     background = NA)

Pred.pnts@data = Pred.pnts@data %>%
        mutate(LP = Int1 + RF1, 
               LP = ifelse(is.na(LP), 0, LP),
               pOcc = (LP))  

Occur.bwte = rasterize(Pred.pnts, 
                     Domain.r, 
                     "pOcc", 
                     background = NA)


Best.RF = rasterize(Pred.pnts, 
                   Domain.r, 
                   "RF3", 
                   background = NA)

Best.sd = rasterize(Pred.pnts, 
                   Domain.r, 
                   "RF3sd", 
                   background = NA)

CompRF.stk = stack(Mod0RF, Best.RF)
names(CompRF.stk) = c("Base", "Joint")

CompSD.stk = stack(Mod0sd, Best.sd)
names(CompSD.stk) = c("Base", "Joint")

From Linear Regression

Pred.pnts = Grd.pnt
mydf = Model.lr$summary.fixed
Pred.pnts$Glob_pltry = Pred.pnts$GlobChkn+Pred.pnts$GlobDuck

Pred.pnts@data = Pred.pnts@data %>%
                  mutate(LP = mydf[1,1] +
                              Glob_pltry*mydf[2,1] +
                              Pop_s*mydf[3,1] +
                              Slope_s*mydf[4,1] +
                              wDsR*mydf[5,1],
                         LP = ifelse(is.na(LP), 0, LP),
                         Pred.lr = plogis(LP)) 

lr.rast = rasterize(Pred.pnts, 
                   Domain.r, 
                   "Pred.lr", 
                   background = NA)

Distance to Outbreak

Plt.df = as.data.frame(Model.J3C$summary.random$nOutBrk)
names(Plt.df) = c("ID", "Mean", "sd", "Q025", "Q50", "Q975")

ggplot(Plt.df, aes(ID*100, Mean)) +
        geom_smooth(col = "black", 
                  linetype= "solid",
                  method = "loess",
                  span = 1,
                  se = FALSE,
                  lwd = 1) +
        geom_smooth(data = Plt.df, aes(ID*100, Q025), 
                    col = "grey", 
                    method = "loess",
                    span = 1,
                    se = FALSE,
                    linetype= "dashed") +
        geom_smooth(data = Plt.df, aes(ID*100, Q975), 
                    col = "grey", 
                    method = "loess",
                    span = 1,
                    se = FALSE,
                    linetype= "dashed") +
        geom_hline(yintercept = 0, 
                   linetype = "dotted",
                   col = "red",
                   size = 0.5) +  
        geom_vline(xintercept = 0, 
                   linetype = "dotted",
                   col = "red",
                   size = 0.5) +
        xlim(0, 1500) +
        xlab("Distance to Outbreak (km)") +
        ylab("Effect (logit)") +  
        theme_classic() +
        theme(axis.text=element_text(size=16),
              strip.text = element_text(face="bold", size = 20),
              axis.title.y = element_text(face="bold", size = 20),
              axis.title.x = element_text(face="bold", size = 20, vjust=-2))

##Zoom in
Plt.df = as.data.frame(Model.J3C$summary.random$nOutBrk)
names(Plt.df) = c("ID", "Mean", "sd", "Q025", "Q50", "Q975")

ggplot(Plt.df, aes(ID*100, Mean)) +
        geom_smooth(col = "black", 
                  linetype= "solid",
                  method = "loess",
                  span = 1,
                  se = FALSE,
                  lwd = 1) +
        geom_smooth(data = Plt.df, aes(ID*100, Q025), 
                    col = "grey", 
                    method = "loess",
                    span = 1,
                    se = FALSE,
                    linetype= "dashed") +
        geom_smooth(data = Plt.df, aes(ID*100, Q975), 
                    col = "grey", 
                    method = "loess",
                    span = 1,
                    se = FALSE,
                    linetype= "dashed") +
        geom_hline(yintercept = 0, 
                   linetype = "dotted",
                   col = "red",
                   size = 0.5) +  
        geom_vline(xintercept = 0, 
                   linetype = "dotted",
                   col = "red",
                   size = 0.5) +
        xlim(0, 150) +
        xlab("Distance to Outbreak (km)") +
        ylab("Effect (logit)") +  
        theme_classic() +
        theme(axis.text=element_text(size=16),
              strip.text = element_text(face="bold", size = 20),
              axis.title.y = element_text(face="bold", size = 20),
              axis.title.x = element_text(face="bold", size = 20, vjust=-2))

Land Cover Effect

IDD.df = as.data.frame(Model.J3C$summary.random$LC)

names(IDD.df) = c("ID", "Mean", "sd", "Q025", "Q50", "Q975", "mode", "kld")

IDD.df$PSigL = ifelse(IDD.df$Q025>0 & IDD.df$Q975>0, 1, 0)
IDD.df$PSigH = ifelse(IDD.df$Q025<0 & IDD.df$Q975<0, 1, 0)

IDD.df2 = IDD.df %>%
              filter(PSigL == 1 | PSigH == 1)

RM.m3 = ggplot(IDD.df, aes(x=ID, y=Mean)) + 
    geom_point(size=2, pch=1, col = "gray75") +
    geom_linerange(aes(ymin=Q025, ymax=Q975), colour="gray75", size = 0.5) +
    geom_point(data=IDD.df2, aes(x=ID, y=Mean), 
               size=2, pch=19, col = "red") +
     geom_text(aes(x=6, y=1.5, label= "Grassland"), size=5) +
    geom_linerange(data=IDD.df2, 
                   aes(ymin=Q025, ymax=Q975), colour="black") +
    geom_hline(yintercept = 0, 
                linetype = "dotted",
                   colour = "red",
                   size = 0.75) +
        theme_classic() +
               xlab("Land Cover (class)") +
               ylab("Effect (logit)") + 
               theme(axis.title.y = element_text(face="bold", size=14),
                     axis.title.x = element_text(face="bold", size=14),
                     axis.text.y = element_text(face="bold", size=12),
                     axis.ticks.x=element_blank(),
                     axis.text.x =element_text(face="bold", size=12,vjust=1, hjust=1, angle=45))

RM.m3

Compare Random Field Density

rng = seq(-2.2, 10.2, 0.001)
mCols  = c("#A50026", "#D73027", "#F46D43", "#FDAE61", "#E0F3F8", "#ABD9E9", "#74ADD1", "#4575B4","#313695")
cr0 = rev(colorRampPalette(mCols)(n = 2000))
cr = colorRampPalette(c(cr0), 
         bias = 2.6)

Plt.a = levelplot(CompRF.stk, 
             layout=c(2, 1),
             margin = FALSE,
             xlab =NULL, 
             ylab = NULL,
             main = "Random Field Density",
             maxpixels = 1e5,
             col.regions = cr, at =rng,
             colorkey = list(space = "bottom"), 
                             par.strip.text = list(fontface='bold', cex=1),
             par.settings = list(axis.line = list(col = "black"),
                                 strip.background = list(col = 'transparent'), 
                                 strip.border = list(col = 'transparent')),
                                 scales = list(cex = 1)) + 
             latticeExtra::layer(sp.polygons(NAmer.reg, col = "darkgray", lwd = 1)) +
             latticeExtra::layer(sp.polygons(GLakes, fill = "darkgray", col = "darkgray", lwd = 0.25)) 
         

Plt.a

Compare Standard Deviation

rng = seq(0, 6, 0.001)
mCols  = c("white", "lightblue", "blue")
cr0 = (colorRampPalette(mCols)(n = 2000))
cr = colorRampPalette(c(cr0), 
         bias = 1)

Plt.a = levelplot(CompSD.stk, 
             layout=c(2, 1),
             margin = FALSE,
             xlab =NULL, 
             ylab = NULL,
             main = "Standard Deviation",
             maxpixels = 1e5,
             col.regions = cr, at =rng,
             colorkey = list(space = "bottom"), 
                             par.strip.text = list(fontface='bold', cex=1),
             par.settings = list(axis.line = list(col = "black"),
                                 strip.background = list(col = 'transparent'), 
                                 strip.border = list(col = 'transparent')),
                                 scales = list(cex = 1)) + 
             latticeExtra::layer(sp.polygons(NAmer.reg, col = "darkgray", lwd = 1)) +
             latticeExtra::layer(sp.polygons(GLakes, fill = "darkgray", col = "darkgray", lwd = 0.25)) 
             #latticeExtra::layer(sp.polygons(All.ai.pnt, col = "red", cex=0.5)) 
             #latticeExtra::layer(sp.polygons(GLakes, col = "red", pch=19, cex=1))

Plt.a

Estimated Duration

rng = seq(0, 42, 1)
mCols  = brewer.pal(9, "YlOrRd")[-c(1:2)]
cr0 = colorRampPalette(mCols)(n = 2000)
cr = colorRampPalette(c(cr0), 
         bias = 2.5)

Dur.bwte2 = Dur.bwte
Dur.bwte2[Dur.bwte2 <1] = NA

Plt.a = levelplot(Dur.bwte2, 
             margin = FALSE,
             xlab =NULL, 
             ylab = NULL,
             main = "Residence Time \n (1 or more days)",
             maxpixels = 1e5,
             col.regions = cr, at =rng,
             colorkey = list(labels=list(at=c(0, 10, 20, 30, 41),  
                             labels=c("1", "10", "20", "30", "40 Days"), cex=1),
                             labels=list(cex=12),
                             space = "bottom"), 
                             par.strip.text = list(fontface='bold', cex=1),
             par.settings = list(axis.line = list(col = "black"),
                                 strip.background = list(col = 'transparent'), 
                                 strip.border = list(col = 'transparent')),
                                 scales = list(cex = 1)) + 
             latticeExtra::layer(sp.polygons(NAmer.reg, col = "darkgray", lwd = 0.5)) 

Plt.a

Potential Stopover Locations

If a stopover is arbitrarily defined as 12hrs or more.

CC = Occur.bwte
CC[CC<0] = 0

rng = seq(0, 1, 0.5)
cr  = c("tan", "green")

Plt.a = levelplot(CC, 
             margin = FALSE,
             xlab =NULL, 
             ylab = NULL,
             main = "Stopover vs. Flyover \n (12hr threshold)",
             maxpixels = 1e5,
             col.regions = cr, at =rng,
             colorkey = list(labels=list(at=c(0.25, 0.75),  
                             labels=c("Fly Over", "Stop Over"), cex=1),
                             labels=list(cex=12),
                             space = "right"), 
                             par.strip.text = list(fontface='bold', cex=1),
             par.settings = list(axis.line = list(col = "black"),
                                 strip.background = list(col = 'transparent'), 
                                 strip.border = list(col = 'transparent')),
                                 scales = list(cex = 1)) + 
             latticeExtra::layer(sp.polygons(NAmer.reg, col = "darkgray", lwd = 0.5)) 

Plt.a

Formal Prediction

rng = seq(0, 1, 0.01)
mCols  = rev(brewer.pal(11, "RdYlBu")[-6])
cr0 = colorRampPalette(mCols)(n = 2000)
cr = colorRampPalette(c(cr0), 
         bias = 1)

Qk.stk =stack(Mod2p, True.pred)
names(Qk.stk) = c("No.BWTE", "BWTE")

Plt.a = levelplot(Qk.stk , #True.pred, 
             margin = FALSE,
             xlab =NULL, 
             ylab = NULL,
             layout=c(2, 1),
             main = " ",
             maxpixels = 1e5,
             col.regions = cr, at =rng,
             colorkey = list(labels=list(at=c(0, 0.25, 0.50, 0.75, 1),  
                             labels=c("0%", "25%", "50%", "75%", "100%"), cex=1),
                             labels=list(cex=12),
                             space = "bottom"), 
                             par.strip.text = list(fontface='bold', cex=1),
             par.settings = list(axis.line = list(col = "black"),
                                 strip.background = list(col = 'transparent'), 
                                 strip.border = list(col = 'transparent')),
                                 scales = list(cex = 1)) + 
             latticeExtra::layer(sp.polygons(NAmer.reg, col = "darkgray", lwd = 0.5)) 

Plt.a

Risk (Classified Suitabilty)

rng = seq(0, 1, 0.01)
#mCols  = rev(brewer.pal(11, "YlOrRd")[-6])
mCols  = c("#BF812D", "#FFEDA0", "red")
cr0 = colorRampPalette(mCols)(n = 2000)
cr = colorRampPalette(c(cr0), 
         bias = 1)

rng = as.numeric(c(0, quantile(values(True.pred), probs = c(0.20, 0.80, 1), na.rm=T)))
rng
## [1] 0.0000000 0.2040601 0.5134336 1.0000000
True.pred2 = CleanRas(True.pred2, Domain.r)

Plt.a = levelplot(True.pred, 
             margin = FALSE,
             xlab =NULL, 
             ylab = NULL,
             main = "A.I. Outbreak Risk",
             maxpixels = 1e5,
             col.regions = cr, at =rng,
             colorkey = list(labels=list(at=c(0.10, 0.35, 0.74),  
                             labels=c("Low", "Medium", "High"), cex=1),
                             labels=list(cex=12),
                             space = "right"), 
                             par.strip.text = list(fontface='bold', cex=1),
             par.settings = list(axis.line = list(col = "black"),
                                 strip.background = list(col = 'transparent'), 
                                 strip.border = list(col = 'transparent')),
                                 scales = list(cex = 1)) + 
             latticeExtra::layer(sp.polygons(NAmer.reg, col = "darkgray", lwd = 1)) +
             latticeExtra::layer(sp.polygons(GLakes, fill = "darkgray", col = "darkgray", lwd = 0.25)) 
            

Plt.a

Best Model vs. Linear Regression

rng = seq(0, 1, 0.01)
mCols  = rev(brewer.pal(11, "RdYlBu")[-6])
cr0 = colorRampPalette(mCols)(n = 2000)
cr = colorRampPalette(c(cr0), 
         bias = 1)

lrComp.stk = stack(True.pred, lr.rast)
names(lrComp.stk) = c("Full", "Regression")

Plt.a = levelplot(lrComp.stk, 
             layout=c(2, 1),
             margin = FALSE,
             xlab =NULL, 
             ylab = NULL,
             main = " ",
             maxpixels = 1e5,
             col.regions = cr, at =rng,
             colorkey = list(labels=list(at=c(0, 0.25, 0.50, 0.75, 1),  
                             labels=c("0%", "25%", "50%", "75%", "100%"), cex=1),
                             labels=list(cex=12),
                             space = "bottom"), 
                             par.strip.text = list(fontface='bold', cex=1),
             par.settings = list(axis.line = list(col = "black"),
                                 strip.background = list(col = 'transparent'), 
                                 strip.border = list(col = 'transparent')),
                                 scales = list(cex = 1)) + 
             latticeExtra::layer(sp.polygons(NAmer.reg, col = "darkgray", lwd = 0.5)) 

Plt.a

sessionInfo()
## R version 3.5.1 (2018-07-02)
## Platform: x86_64-w64-mingw32/x64 (64-bit)
## Running under: Windows 10 x64 (build 17134)
## 
## Matrix products: default
## 
## locale:
## [1] LC_COLLATE=English_United States.1252 
## [2] LC_CTYPE=English_United States.1252   
## [3] LC_MONETARY=English_United States.1252
## [4] LC_NUMERIC=C                          
## [5] LC_TIME=English_United States.1252    
## 
## attached base packages:
## [1] stats     graphics  grDevices utils     datasets  methods   base     
## 
## other attached packages:
##  [1] xtable_1.8-2        bindrcpp_0.2.2      trip_1.5.0         
##  [4] kableExtra_0.9.0    viridis_0.5.1       viridisLite_0.3.0  
##  [7] classInt_0.2-3      spatstat_1.56-0     rpart_4.1-13       
## [10] nlme_3.1-137        spatstat.data_1.3-1 deldir_0.1-15      
## [13] adegenet_2.1.1      ade4_1.7-11         moveHMM_1.6        
## [16] CircStats_0.2-6     boot_1.3-20         geosphere_1.5-7    
## [19] ecp_3.1.0           Rcpp_0.12.17        changepoint_2.2.2  
## [22] zoo_1.8-3           RcppRoll_0.3.0      lubridate_1.7.4    
## [25] stringr_1.3.1       readr_1.1.1         data.table_1.11.4  
## [28] dplyr_0.7.6         gridExtra_2.3       GISTools_0.7-4     
## [31] MASS_7.3-50         ggthemes_4.0.0      spdep_0.7-7        
## [34] spData_0.2.9.3      mapproj_1.2.6       maps_3.3.0         
## [37] maptools_0.9-2      rgeos_0.3-28        rasterVis_0.45     
## [40] latticeExtra_0.6-28 RColorBrewer_1.1-2  lattice_0.20-35    
## [43] corrplot_0.84       factoextra_1.0.5    ggplot2_3.0.0      
## [46] raster_2.6-7        reshape2_1.4.3      rgdal_1.3-3        
## [49] INLA_18.07.12       sp_1.3-1            Matrix_1.2-14      
## [52] rgl_0.99.16         knitr_1.20         
## 
## loaded via a namespace (and not attached):
##  [1] colorspace_1.3-2        seqinr_3.4-5           
##  [3] rjson_0.2.20            class_7.3-14           
##  [5] rprojroot_1.3-2         markdown_0.8           
##  [7] rstudioapi_0.7          hexbin_1.27.2          
##  [9] ggrepel_0.8.0           fansi_0.2.3            
## [11] xml2_1.2.0              splines_3.5.1          
## [13] polyclip_1.9-0          jsonlite_1.5           
## [15] cluster_2.0.7-1         png_0.1-7              
## [17] shiny_1.1.0             httr_1.3.1             
## [19] compiler_3.5.1          backports_1.1.2        
## [21] assertthat_0.2.0        lazyeval_0.2.1         
## [23] cli_1.0.0               later_0.7.3            
## [25] htmltools_0.3.6         tools_3.5.1            
## [27] ggmap_2.6.1             igraph_1.2.1           
## [29] coda_0.19-1             gtable_0.2.0           
## [31] glue_1.3.0              gmodels_2.18.1         
## [33] gdata_2.18.0            ape_5.1                
## [35] crosstalk_1.0.0         proto_1.0.0            
## [37] rvest_0.3.2             mime_0.5               
## [39] miniUI_0.1.1.1          gtools_3.8.1           
## [41] goftest_1.1-1           LearnBayes_2.15.1      
## [43] scales_0.5.0            hms_0.4.2              
## [45] promises_1.0.1          spatstat.utils_1.8-2   
## [47] parallel_3.5.1          expm_0.999-2           
## [49] stringi_1.1.7           highr_0.7              
## [51] e1071_1.6-8             permute_0.9-4          
## [53] manipulateWidget_0.10.0 RgoogleMaps_1.4.2      
## [55] rlang_0.2.1             pkgconfig_2.0.1        
## [57] evaluate_0.11           tensor_1.5             
## [59] purrr_0.2.5             bindr_0.1.1            
## [61] labeling_0.3            htmlwidgets_1.2        
## [63] tidyselect_0.2.4        plyr_1.8.4             
## [65] magrittr_1.5            R6_2.2.2               
## [67] pillar_1.3.0            foreign_0.8-71         
## [69] withr_2.1.2             mgcv_1.8-24            
## [71] abind_1.4-5             tibble_1.4.2           
## [73] crayon_1.3.4            utf8_1.1.4             
## [75] rmarkdown_1.10          jpeg_0.1-8             
## [77] grid_3.5.1              vegan_2.5-2            
## [79] digest_0.6.15           webshot_0.5.0          
## [81] httpuv_1.4.5            numDeriv_2016.8-1      
## [83] munsell_0.5.0