structure-stability.Rmd

---
title: "structure-stability"
author: "Iara Diamela Rodriguez"
editor_options: 
  chunk_output_type: console
---

## Setup ##

```{r setup, eval=T, echo=FALSE}

knitr::opts_chunk$set(echo=TRUE)

load(".RData")

require(igraph)
require(NetIndices)
require(multiweb)

require(devtools)
require(dplyr)
require(future.apply)
require(knitr)
require(purrr)
require(stringr)
require(cowplot)

require(ggplot2)
require(RColorBrewer)

```


### Read Potter Cove and Beagle Channel food webs ###

```{r fw, echo=FALSE, message=FALSE, results='asis'}

# Read food webs
# .txt format: predator -> prey

p <- readNetwork("Data/Potter_FW.txt", edgeListFormat=1)
b <- readNetwork("Data/Beagle_FW.txt", edgeListFormat=1)

# Remove loops and repeated interactions

p <- igraph::simplify(p)
b <- igraph::simplify(b)

# Check that loops and repeated interactions were removed.
# If Cannib = 0 loops were removed.

calc_topological_indices(p)
calc_topological_indices(b)

```


### Calculate empirical structure and stability metrics and perfome Strona Curveball randomizations ###

```{r ti, eval=T, echo=F, message=T, warning=T}

# Calculate empirical structure and stability metrics

if(!file.exists("Data/ti.rds")){
  
  nc <-  detectCores()

  tip <- bind_cols(calc_topological_indices(p), calc_modularity(p), calc_QSS(p, nsim=1000, ncores=nc)) %>% mutate(Name="Potter")
  tib <- bind_cols(calc_topological_indices(b), calc_modularity(b), calc_QSS(b, nsim=1000, ncores=nc)) %>% mutate(Name="Beagle")
  
  ti <- bind_rows(tip, tib) %>% rename(Network=Name)

  saveRDS(ti, "Data/ti.rds")
  write.csv(ti, file="Results/ti.csv")
  rm(tip, tib)
  
} else {
  
  ti <- readRDS("Data/ti.rds")

}

# Calculate species trophic level and omnivory index

adj_matrix <- get.adjacency(p, sparse=FALSE)
p_tl <- TrophInd(adj_matrix)

adj_matrix1 <- get.adjacency(b, sparse=FALSE)
b_tl <- TrophInd(adj_matrix1)

# Calculate Strona Curveball randomizations structure and stability metrics

pCB <- curveBall(p, nsim=1000)
bCB <- curveBall(b, nsim=1000)

if(!file.exists("Data/tiIC95.rds")){
  
    require(parallel)
    nc <-  detectCores()
    cl <- makeCluster(rep("localhost", nc))
    
    ptiIC <- bind_cols(calc_topological_indices(pCB)) %>% mutate(Name="Potter") 
    btiIC <- bind_cols(calc_topological_indices(bCB)) %>% mutate(Name="Beagle") 
    tiIC <- bind_rows(ptiIC, btiIC) %>% rename(Network=Name)
   
    ptiQSS <- calc_QSS(pCB, nsim=10000, ncores=nc) %>% mutate(Name="Potter")
    btiQSS <- calc_QSS(bCB, nsim=10000, ncores=nc) %>% mutate(Name="Beagle")
    QSSIC <- bind_rows(ptiQSS, btiQSS) %>% rename(Network=Name)
    
    pM <- calc_modularity(pCB) %>% mutate(Name="Potter")
    bM <- calc_modularity(bCB) %>% mutate(Name="Beagle") 
    ModularityIC <- bind_rows(pM, bM) %>% rename(Network=Name)
    
    tiMIC <- cbind(tiIC, QSSIC, ModularityIC)
    
    stop2Cluster(cl) 
    saveRDS(tiMIC,"Data/tiIC95.rds")
    rm(ptiIC,btiIC,tiIC,ptiQSS,btiQSS,QSSIC,pM,bM,ModularityIC,nc,cl)
  
} else {
  
    tiMIC <- readRDS("Data/tiIC95.rds")

}

```


### Statistical analysis of structure and stability metrics ###

```{r stat, eval=T, echo=F, message=T, warning=T}

# Two-sided Kolmogorov-Smirnov test

#(change metric name wanting to test: TLmean, Omnivory, Modularity, MEing (QSS))
tiMIC_pc <- filter((tiMIC %>% select(TLmean, Network)), Network=="Potter")
tiMIC_bc <- filter((tiMIC %>% select(TLmean, Network)), Network=="Beagle")
ks.test(tiMIC_pc$TLmean, tiMIC_bc$TLmean)

#rm(tiMIC_pc, tiMIC_bc)

```


### Calculate and classify species by topological roles ###

```{r topoRol, echo=FALSE, message=FALSE, results='asis'}

source("R/network_fun.r")

mod_by_red <- vector(mode="list", length=2)
set.seed(123)

modulos <- cluster_spinglass(p)
mti <- data_frame(Name="Potter", Groups=length(modulos$csize), Modularity=modulos$modularity)
mod_by_red[[1]] <- modulos

modulos <- cluster_spinglass(b)
mti <- mti %>% add_row(Name="Beagle", Groups=length(modulos$csize), Modularity=modulos$modularity)
mod_by_red[[2]] <- modulos

# Topological roles

if(!file.exists("Data/rolesTopologicos.rds")){
  
  nc <-  detectCores()

  # POTTER
  tR1 <- calc_topological_roles(p, nsim=100, ncores=nc)
  tR  <- tR1 %>% group_by(node) %>% summarize(wtmLowCI=quantile(within_module_degree, 0.005, na.rm=TRUE),
                                          wtmHiCI=quantile(within_module_degree, 0.995, na.rm=TRUE),
                                          amcLowCI=quantile(among_module_conn, 0.005, na.rm=TRUE),
                                          amcHiCI=quantile(among_module_conn, 0.995, na.rm=TRUE),
                                          within_module_degree=mean(within_module_degree, na.rm=TRUE),
                                          among_module_conn=mean(among_module_conn, na.rm=TRUE))
  
  topoRoles <- tR %>% mutate(Name="Potter")
  
  # BEAGLE
  tR1 <- calc_topological_roles(b, nsim=100, ncores=nc)
  tR  <- tR1 %>% group_by(node) %>% summarize(wtmLowCI=quantile(within_module_degree, 0.005, na.rm=TRUE),
                                          wtmHiCI=quantile(within_module_degree, 0.995, na.rm=TRUE),
                                          amcLowCI=quantile(among_module_conn, 0.005, na.rm=TRUE),
                                          amcHiCI=quantile(among_module_conn, 0.995, na.rm=TRUE),
                                          within_module_degree=mean(within_module_degree, na.rm=TRUE),
                                          among_module_conn=mean(among_module_conn, na.rm=TRUE))
  
  topoRoles <- bind_rows(topoRoles, tR %>% mutate(Name="Beagle"))
  
  saveRDS(topoRoles,"Data/rolesTopologicos.rds")
  rm(nc)
  
} else {
  
  topoRoles <- readRDS("Data/rolesTopologicos.rds")

}

# Classify species by topological roles

hub_conn <- data.frame()

hc <- plot_topological_roles(filter(topoRoles, Name=="Potter"), p, mod_by_red[[1]])
hub_connp <- hc %>% mutate(Name="Potter", modulo=mod_by_red[[1]]$membership[node])
hc <- hc %>% mutate(Name="Potter", modulo=mod_by_red[[1]]$membership[node])
hub_conn <- bind_rows(hub_conn, hc)

hc <- plot_topological_roles(filter(topoRoles, Name=="Beagle"), b, mod_by_red[[2]]) 
hub_connb <- hc %>% mutate(Name="Beagle", modulo=mod_by_red[[2]]$membership[node])
hc <- hc %>% mutate(Name="Beagle", modulo=mod_by_red[[2]]$membership[node])
hub_conn <- bind_rows(hub_conn, hc)

hub_conn <- rename(hub_conn, Network=Name)

write.csv(hub_conn, file="Results/rolestop.csv") 

#rm(hc,hub_connb,hub_connp,mod_by_red,plot_topological_roles,mti,modulos,topoRoles)

```


### Habitat and functional group vs modules ###

```{r traits, echo=FALSE, message=FALSE, results='asis'}

# Read habitat and functional group data in each module
# format .txt

cp <- read.delim(file="Data/Potter_ModHabFG.txt")
cb <- read.delim(file="Data/Beagle_ModHabFG.txt")

cp <- lapply(cp, factor)
cb <- lapply(cb, factor)

# Calculate trait levels frequency in each module 

cpH <- as.data.frame(table(cp$Mod, cp$Hab))
colnames(cpH) <- c("Mod", "Habitat", "Freq")

cpFG <- as.data.frame(table(cp$Mod, cp$FG))
colnames(cpFG) <- c("Mod", "FG", "Freq")

cbH <- as.data.frame(table(cb$Mod, cb$Hab))
colnames(cbH) <- c("Mod", "Habitat", "Freq")

cbFG <- as.data.frame(table(cb$Mod, cb$FG))
colnames(cbFG) <- c("Mod", "FG", "Freq")

# Chi-square test

require(tidyr)

#--Chi-square test: Trait's levels vs FW
# Potter-Beagle Habitat
cpH_t <- cpH %>% group_by(Habitat) %>% summarise(Total=(sum(Freq)/110)*100) %>% mutate(Name="Potter")
cbH_t <- cbH %>% group_by(Habitat) %>% summarise(Total=(sum(Freq)/145)*100) %>% mutate(Name="Beagle")
H_t <- bind_rows(cpH_t, cbH_t) %>% rename(Network=Name)

H_t <- spread(H_t, Habitat, Total)
H_t <- data.matrix(H_t)
chisq.test(H_t[,3]) #(change habitat level of interest to test: [,2]=benthic, [,3]=benthopelagic, [,4]=pelagic)

# Potter-Beagle Functional Group
cpFG_t <- cpFG %>% group_by(FG) %>% summarise(Total=(sum(Freq)/110)*100) %>% mutate(Name="Potter")
cbFG_t <- cbFG %>% group_by(FG) %>% summarise(Total=(sum(Freq)/145)*100) %>% mutate(Name="Beagle")
FG_t <- bind_rows(cpFG_t, cbFG_t) %>% rename(Network=Name)

FG_t <- spread(FG_t, FG, Total)
chisq.test(FG_t$fish) #(change function group of interest to test: basal taxa, zooplankton, non-living, benthos, fish)

#--Chi-square test: Modules vs traits
# Potter-Habitat
cpH <- spread(cpH, Habitat, Freq)
cpH$Mod <- as.integer(cpH$Mod)
cpH <- data.matrix(cpH)
chisq.test(cpH)

# Potter-Functional group
cpFG <- spread(cpFG, FG, Freq)
cpFG$Mod <- as.integer(cpFG$Mod)
cpFG <- data.matrix(cpFG)
chisq.test(cpFG)

# Beagle-Habitat
cbH <- spread(cbH, Habitat, Freq)
cbH$Mod <- as.integer(cbH$Mod)
cbH <- data.matrix(cbH)
chisq.test(cbH)

# Beagle-Functional group
cbFG <- spread(cbFG, FG, Freq)
cbFG$Mod <- as.integer(cbFG$Mod)
cbFG <- data.matrix(cbFG)
chisq.test(cbFG)

rm(cp,cb,cpH_t,cbH_t,cpFG_t,cbFG_t,cbFG,cbH,cpFG,cpH,H_t,FG_t)

```


### Setup degree distribution analysis ### 

```{r setupDegree, eval=T, echo=F, message=T, warning=T}

require(pander)
require(plyr)
require(dplyr)
panderOptions('table.split.table', Inf)
panderOptions('table.style', 'multiline')
options("scipen"=6, "digits"=4)

library(poweRlaw)
source("R/dist_fun.r")

# Upload continuous distributions functions

source("R/powerlaw/discpowerexp.R")
source("R/powerlaw/discexp.R")
source("R/powerlaw/zeta.R")
source("R/powerlaw/powerexp.R")
source("R/powerlaw/exp.R")
source("R/powerlaw/pareto.R")

```


### Fit degree distributions ###

```{r fitDegree, eval=T, echo=F, message=T, warning=T}

# Total-degree
dgp <- data.frame(degree(p)) %>% mutate(Name="Potter")
colnames(dgp) <- c("Degree", "Network")

dgb <- data.frame(degree(b)) %>% mutate(Name="Beagle")
colnames(dgb) <- c("Degree", "Network")

dg <- bind_rows(dgp, dgb)

# Test for differences in degree distribution 

ks.test(dgp$Degree, dgb$Degree)
kSamples::ad.test(dgp$Degree, dgb$Degree, method="simulated", Nsim=10000)

#rm(dgp,dgb)

# Fit distributions

opt.output <- vector("list", length=0)
opt.output$GOF <- 0
opt.output$ploting <- 1

fit <- dg %>% group_by(Network) %>% do(fit_ht_dplyr_helper(.))
fitML <- fit

# Correct negative uniform parameter

fitML <- fitML %>% mutate(par1=ifelse(ModelNames=="Uniform", abs(par1), par1))

fitML1 <- filter(fitML, Delta_AICc==0) %>% mutate_if(is.numeric, round, digits=4) 

write.csv(fitML, file="Results/NetworksFit.csv")
write.csv(fitML1, file="Results/NetworksLowerAICc.csv")

```