---
title: "Analysis"
author: "Steven L. Peck and Andrew Heiss"
date: "Last run: `r format(Sys.time(), '%B %e, %Y')`"
output: 
  html_document:
    code_folding: hide
editor_options: 
  chunk_output_type: console
---

```{r load-libraries-data, warning=FALSE, message=FALSE}
library(tidyverse)
library(patchwork)
library(here)

constraints <- read_rds(here("data", "derived_data", "constraints.rds")) 

constraint_levels <- constraints %>% 
  mutate(constraint_clean = fct_inorder(constraint_clean)) %>% 
  mutate(levels = map(levels_clean, names)) %>% 
  unnest(levels) %>% 
  mutate(levels = fct_inorder(levels))

# TODO: Switch back to full BLS.rds and BHL.rds
BHL <- read_rds(here("data", "derived_data", "BHL_small.rds"))
bhl_long <- BHL %>% 
  gather(constraint, value, one_of(constraints$constraint)) %>% 
  left_join(constraints, by = "constraint") %>% 
  mutate(value = fct_relevel(value, levels(constraint_levels$levels)),
         constraint_clean = fct_relevel(constraint_clean, 
                                        levels(constraint_levels$constraint_clean)))

BLS <- read_rds(here("data", "derived_data", "BLS_small.rds"))
bls_long <- BLS %>% 
  gather(constraint, value, one_of(constraints$constraint)) %>% 
  left_join(constraints, by = "constraint") %>% 
  mutate(value = fct_relevel(value, levels(constraint_levels$levels)),
         constraint_clean = fct_relevel(constraint_clean, 
                                        levels(constraint_levels$constraint_clean)))
```


# Single conditions, no nested interactions

## Landscape fitness

### High-low

```{r landscape-fitness-linked-bhl-single, fig.width=8, fig.height=4.5}
ggplot(bhl_long, aes(x = value, y = landscape_fitness_linked, fill = repp)) +
  geom_violin(size = 0.25, position = position_dodge(width = 0.75)) +
  stat_summary(geom = "point", fun.y = "mean", 
               aes(group = repp), position = position_dodge(width = 0.75),
               size = 2, pch = 21, fill = "black", color = "white") +
  scale_y_reverse(breaks = seq(0, 0.4, 0.2)) +
  coord_cartesian(ylim = c(0, 0.5)) +
  scale_fill_viridis_d(option = "plasma", begin = 0.1, end = 0.9) +
  labs(x = NULL, y = "Landscape fitness, linked", fill = NULL, 
       caption = "Point = mean value") +
  facet_wrap(~ constraint_clean, scales = "free_x") +
  theme_bw() +
  theme(legend.position = "top",
        legend.key.size = unit(0.65, "lines"))
```

### Latin squares

```{r landscape-fitness-linked-bls-single, fig.width=8, fig.height=4}
ggplot(bls_long, 
       aes(x = value, y = landscape_fitness_linked, fill = constraint_clean)) +
  geom_violin(size = 0.25) +
  stat_summary(geom = "point", fun.y = "mean", 
               size = 2, pch = 21, fill = "black", color = "white") +
  scale_y_reverse(breaks = seq(0, 0.4, 0.2)) +
  coord_cartesian(ylim = c(0, 0.5)) +
  scale_fill_viridis_d(option = "plasma", begin = 0.1, end = 0.9) +
  guides(fill = FALSE) +
  labs(x = NULL, y = "Landscape fitness, linked",
       caption = "Point = mean value") +
  facet_wrap(~ constraint_clean, scales = "free_x") +
  theme_bw()
```


# Nested interactions

## Landscape fitness, linked

### High-low

```{r landscape-fitness-linked-bhl, fig.width=10, fig.height=7.5}
ggplot(BHL, aes(x = compete, y = landscape_fitness_linked)) +
  geom_violin(aes(fill = repp), size = 0.1, width = 1,
              position = position_dodge(width = 1)) +
  stat_summary(aes(group = repp), geom = "point", fun.y = "mean", 
               position = position_dodge(width = 1),
               size = 2, pch = 21, fill = "black", color = "white") +
  scale_y_reverse(breaks = c(0, 0.2, 0.4)) +
  coord_cartesian(ylim = c(0, 0.5)) +
  labs(x = NULL, y = "Landscape fitness, linked", 
       fill = NULL, caption = "Point = mean value") +
  facet_grid(selectfor_d + create_network ~ disperse + catastrophe) +
  theme_bw() +
  theme(legend.position = "top",
        legend.key.size = unit(0.65, "lines"))
```

### Latin squares

```{r landscape-fitness-linked-bls, fig.width=10, fig.height=7}
ggplot(BLS, aes(x = compete, y = landscape_fitness_linked)) +
  geom_violin(fill = "#FE7F2D", size = 0.25) +
  stat_summary(geom = "point", fun.y = "mean", 
               size = 2, pch = 21, fill = "black", color = "white") +
  scale_y_reverse(breaks = c(0, 0.2, 0.4)) +
  coord_cartesian(ylim = c(0, 0.5)) +
  labs(x = NULL, y = "Landscape fitness, linked",
       caption = "Point = mean value") +
  facet_grid(selectfor_d + create_network ~ disperse + catastrophe) +
  theme_bw()
```
