Function to process coordinates

# Set up parallel processing
plan(multicore(workers = 16))

# Set the global timeout
options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes


# Function to process each location
process_location <- function(loc) {

    print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))

    # Set parameters
    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    coords <- c(loc$lon, loc$lat)

    ERR <- 1.5  # Adjusting ERR based on the locations (locations with snow sometimes need a higher value)

    micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, dstart = dstart, dfinish = dfinish, scenario = 0,
            minshade = 85, maxshade = 90, Usrhyt = 0.01, cap = 1, ERR = ERR, spatial = "data/NCEP")
    }, timeout = 600, onTimeout = "warning")

    # If the process takes longer than 10 minutes, break.

    if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon,
            "lat =", loc$lat))
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "micro_ncep exceeded time limit"))
    } else {
        micro <- micro_result
    }

    # When the first micro_ncep fails, try again with different ERR
    if (max(micro$metout[, 1] == 0)) {
        while (max(micro$metout[, 1] == 0)) {
            ERR <- ERR + 0.5

            # Use withTimeout() for the micro_ncep() function inside the while
            # loop as well
            micro_result <- withTimeout({
                NicheMapR::micro_ncep(loc = coords, dstart = dstart, dfinish = dfinish,
                  scenario = 0, minshade = 85, maxshade = 90, Usrhyt = 0.01, cap = 1,
                  ERR = ERR, spatial = "data/NCEP")
            }, timeout = 600, onTimeout = "warning")

            if (inherits(micro_result, "try-error") || is.null(micro_result)) {
                print(paste("micro_ncep inside while loop exceeded time limit for location with lon =",
                  loc$lon, "lat =", loc$lat))
                return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat),
                  error_message = "micro_ncep inside while loop exceeded time limit"))
            } else {
                micro <- micro_result
            }

            # If ERR exceeds 5, break the loop regardless of the value of
            # micro$metout[,1]
            if (ERR >= 5) {
                break
            }
        }
    }

    # If even after adjusting ERR micro_ncep fails, return an error message
    if (max(micro$metout[, 1] == 0)) {
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "Failed on micro_ncep call"))
    }

    # Another explicit check
    if (!max(micro$metout[, 1] == 0)) {
        assign("micro", micro, envir = globalenv())
    } else {
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "Failed on micro_ncep call"))
    }

    success <- FALSE
    result <- NULL

    # Use withTimeout() for the ectotherm() function as well
    ecto_result <- withTimeout({
        tryCatch({
            ecto <- NicheMapR::ectotherm(live = 0, Ww_g = loc$median_mass, shape = 4,
                pct_wet = 80)
            list(success = TRUE, ecto = ecto)
        }, error = function(e) {
            list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = paste("Failed on ectotherm call:",
                as.character(conditionMessage(e))))
        })
    }, timeout = 200, onTimeout = "warning")

    if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
        print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon,
            "lat =", loc$lat))
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "ectotherm() exceeded time limit"))
    }

    if (!ecto_result$success) {
        return(ecto_result)
    }

    gc()

    # Assign the successful ecto result to the global environment
    ecto <- ecto_result$ecto
    assign("ecto", ecto, envir = globalenv())
    environ <- as.data.frame(ecto$environ)

    # Max and mean daily temperatures
    daily_temp <- environ %>%
        dplyr::mutate(YEAR = YEAR + 2004, ERR = ERR) %>%
        dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat = paste(loc$lat)) %>%
        dplyr::summarize(max_temp = max(TC), mean_temp = mean(TC), .groups = "drop")

    # Create a function to calculate the rolling weekly temperature
    calc_yearly_rolling_mean <- function(data) {
        data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean,
            align = "right", partial = TRUE, fill = NA)
        data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean,
            align = "right", partial = TRUE, fill = NA)
        return(data)
    }

    # Calculate the rolling mean for each year and location
    daily_temp <- daily_temp %>%
        dplyr::group_by(YEAR, lon, lat) %>%
        dplyr::group_modify(~calc_yearly_rolling_mean(.))

    # Identify the warmest 91 days (3 months) of each year
    daily_temp_warmest_days <- daily_temp %>%
        dplyr::group_by(YEAR, lon, lat) %>%
        dplyr::top_n(91, max_temp)

    # Calculate the mean overall maximum temperature for the warmest days of
    # each year
    overall_temp_warmest_days <- daily_temp_warmest_days %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
            0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
            0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
            max = max(max_temp), .groups = "drop")

    result <- list(daily_temp, daily_temp_warmest_days, overall_temp_warmest_days)

    return(list(success = ecto_result$success, result = result))  # Return a list with a success flag and the result.

}

Function to process coordinates in chunks

Processing the coordinates in chunks is very useful for debugging.

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

    data_for_imp <- readRDS(file = "RData/General_data/pre_data_for_imputation.rds")

    presence_body_mass <- merge(presence, dplyr::select(data_for_imp, tip.label,
        body_mass), by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Substrate/current/results/1st_batch/results_biophysical_modelling_substrate_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 14092

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "4th_batch", "5th_batch")

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Substrate/current/results",
        folder, sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Substrate/current/results",
        folder, "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Substrate/current/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)



#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")

# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Substrate/current/daily_temp_substrate.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Substrate/current/daily_temp_warmest_days_substrate.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Substrate/current/overall_temp_warmest_days_substrate.rds")

####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Substrate/current/missing_coordinates.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Substrate/current/missing_coordinates_row_n.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Substrate/current/row_n_duplicated_coordinates.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Substrate/current/duplicated_coordinates.rds")

Function to process coordinates

# Set up parallel processing
plan(multicore(workers = 16))

# Set the global timeout
options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes


# Function to process each location
process_location <- function(loc) {

    print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))

    # Set parameters
    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    coords <- c(loc$lon, loc$lat)

    # Check if current index falls within any of the problematic ranges
    ERR <- 1.5

    micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, dstart = dstart, dfinish = dfinish, scenario = 2,
            minshade = 85, maxshade = 90, Usrhyt = 0.01, cap = 1, ERR = ERR, spatial = "data/NCEP",
            terra_source = "data/TerraClimate/data")
    }, timeout = 600, onTimeout = "warning")

    if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon,
            "lat =", loc$lat))
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "micro_ncep exceeded time limit"))
    } else {
        micro <- micro_result
    }

    # When the first micro_ncep fails, try again with different ERR
    if (max(micro$metout[, 1] == 0)) {
        while (max(micro$metout[, 1] == 0)) {
            ERR <- ERR + 0.5

            # Use withTimeout() for the micro_ncep() function inside the while
            # loop as well
            micro_result <- withTimeout({
                NicheMapR::micro_ncep(loc = coords, dstart = dstart, dfinish = dfinish,
                  scenario = 2, minshade = 85, maxshade = 90, Usrhyt = 0.01, cap = 1,
                  ERR = ERR, spatial = "data/NCEP", terra_source = "data/TerraClimate/data")
            }, timeout = 600, onTimeout = "warning")

            if (inherits(micro_result, "try-error") || is.null(micro_result)) {
                print(paste("micro_ncep inside while loop exceeded time limit for location with lon =",
                  loc$lon, "lat =", loc$lat))
                return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat),
                  error_message = "micro_ncep inside while loop exceeded time limit"))
            } else {
                micro <- micro_result
            }

            # If ERR exceeds 5, break the loop regardless of the value of
            # micro$metout[,1]
            if (ERR >= 5) {
                break
            }
        }
    }

    # If even after adjusting ERR micro_ncep fails, return an error message
    if (max(micro$metout[, 1] == 0)) {
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "Failed on micro_ncep call"))
    }

    # Another explicit check
    if (!max(micro$metout[, 1] == 0)) {
        assign("micro", micro, envir = globalenv())
    } else {
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "Failed on micro_ncep call"))
    }

    success <- FALSE
    result <- NULL

    # Use withTimeout() for the ectotherm() function as well
    ecto_result <- withTimeout({
        tryCatch({
            ecto <- NicheMapR::ectotherm(live = 0, Ww_g = loc$median_mass, shape = 4,
                pct_wet = 80)
            list(success = TRUE, ecto = ecto)
        }, error = function(e) {
            list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = paste("Failed on ectotherm call:",
                as.character(conditionMessage(e))))
        })
    }, timeout = 300, onTimeout = "warning")

    if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
        print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon,
            "lat =", loc$lat))
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "ectotherm() exceeded time limit"))
    }

    if (!ecto_result$success) {
        return(ecto_result)
    }

    gc()

    # Assign the successful ecto result to the global environment
    ecto <- ecto_result$ecto
    assign("ecto", ecto, envir = globalenv())
    environ <- as.data.frame(ecto$environ)

    # Max and mean daily temperatures
    daily_temp <- environ %>%
        dplyr::mutate(YEAR = YEAR + 2004, ERR = ERR) %>%
        dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat = paste(loc$lat)) %>%
        dplyr::summarize(max_temp = max(TC), mean_temp = mean(TC), .groups = "drop")

    # Create a function to calculate the rolling weekly temperature
    calc_yearly_rolling_mean <- function(data) {
        data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean,
            align = "right", partial = TRUE, fill = NA)
        data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean,
            align = "right", partial = TRUE, fill = NA)
        return(data)
    }

    # Calculate the rolling mean for each year and location
    daily_temp <- daily_temp %>%
        dplyr::group_by(YEAR, lon, lat) %>%
        dplyr::group_modify(~calc_yearly_rolling_mean(.))

    # Identify the warmest 91 days (3 months) of each year
    daily_temp_warmest_days <- daily_temp %>%
        dplyr::group_by(YEAR, lon, lat) %>%
        dplyr::top_n(91, max_temp)

    # Calculate the mean overall maximum temperature for the warmest days of
    # each year
    overall_temp_warmest_days <- daily_temp_warmest_days %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
            0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
            0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
            max = max(max_temp), .groups = "drop")

    result <- list(daily_temp, daily_temp_warmest_days, overall_temp_warmest_days)

    return(list(success = ecto_result$success, result = result))  # Return a list with a success flag and the result.

}

Function to process coordinates in chunks

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

    data_for_imp <- readRDS(file = "RData/General_data/pre_data_for_imputation.rds")

    presence_body_mass <- merge(presence, dplyr::select(data_for_imp, tip.label,
        body_mass), by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 1800)  # Set a global timeout for 50 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Substrate/2C/results/1st_batch/results_biophysical_modelling_substrate_future2C_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 14092

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "4th_batch", "5th_batch", "6th_batch",
    "7th_batch", "8th_batch", "9th_batch", "10th_batch", "11th_batch", "12th_batch",
    "13th_batch", "14th_batch")

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Substrate/2C/results", folder,
        sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Substrate/2C/results",
        folder, "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Substrate/2C/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)

#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")

# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Substrate/2C/daily_temp_substrate_2C.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Substrate/2C/daily_temp_warmest_days_substrate_2C.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Substrate/2C/overall_temp_warmest_days_substrate_2C.rds")


####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Substrate/2C/missing_coordinates.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Substrate/2C/missing_coordinates_row_n.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Substrate/2C/row_n_duplicated_coordinates.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Substrate/2C/duplicated_coordinates.rds")

Function to process coordinates

# # Set up parallel processing
plan(multicore(workers = 16))

# Set the global timeout
options(future.globals.timeout = 2700)  # Set a global timeout for 45 minutes


# Function to process each location
process_location <- function(loc) {

    print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))

    # Set parameters
    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    coords <- c(loc$lon, loc$lat)

    # Check if current index falls within any of the problematic ranges
    ERR <- 1.5

    micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, dstart = dstart, dfinish = dfinish, scenario = 4,
            minshade = 85, maxshade = 90, Usrhyt = 0.01, cap = 1, ERR = ERR, spatial = "data/NCEP",
            terra_source = "data/TerraClimate/data")
    }, timeout = 600, onTimeout = "warning")

    if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon,
            "lat =", loc$lat))
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "micro_ncep exceeded time limit"))
    } else {
        micro <- micro_result
    }

    # When the first micro_ncep fails, try again with different ERR
    if (max(micro$metout[, 1] == 0)) {
        while (max(micro$metout[, 1] == 0)) {
            ERR <- ERR + 0.5

            # Use withTimeout() for the micro_ncep() function inside the while
            # loop as well
            micro_result <- withTimeout({
                NicheMapR::micro_ncep(loc = coords, dstart = dstart, dfinish = dfinish,
                  scenario = 4, minshade = 85, maxshade = 90, Usrhyt = 0.01, cap = 1,
                  ERR = ERR, spatial = "data/NCEP", terra_source = "data/TerraClimate/data")
            }, timeout = 600, onTimeout = "warning")

            if (inherits(micro_result, "try-error") || is.null(micro_result)) {
                print(paste("micro_ncep inside while loop exceeded time limit for location with lon =",
                  loc$lon, "lat =", loc$lat))
                return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat),
                  error_message = "micro_ncep inside while loop exceeded time limit"))
            } else {
                micro <- micro_result
            }

            # If ERR exceeds 5, break the loop regardless of the value of
            # micro$metout[,1]
            if (ERR >= 5) {
                break
            }
        }
    }

    # If even after adjusting ERR micro_ncep fails, return an error message
    if (max(micro$metout[, 1] == 0)) {
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "Failed on micro_ncep call"))
    }

    # Another explicit check
    if (!max(micro$metout[, 1] == 0)) {
        assign("micro", micro, envir = globalenv())
    } else {
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "Failed on micro_ncep call"))
    }

    success <- FALSE
    result <- NULL

    # Use withTimeout() for the ectotherm() function as well
    ecto_result <- withTimeout({
        tryCatch({
            ecto <- NicheMapR::ectotherm(live = 0, Ww_g = loc$median_mass, shape = 4,
                pct_wet = 80)
            list(success = TRUE, ecto = ecto)
        }, error = function(e) {
            list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = paste("Failed on ectotherm call:",
                as.character(conditionMessage(e))))
        })
    }, timeout = 300, onTimeout = "warning")

    if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
        print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon,
            "lat =", loc$lat))
        return(list(success = FALSE, loc = c(lon = loc$lon, lat = loc$lat), error_message = "ectotherm() exceeded time limit"))
    }

    if (!ecto_result$success) {
        return(ecto_result)
    }

    gc()

    # Assign the successful ecto result to the global environment
    ecto <- ecto_result$ecto
    assign("ecto", ecto, envir = globalenv())
    environ <- as.data.frame(ecto$environ)

    # Max and mean daily temperatures
    daily_temp <- environ %>%
        dplyr::mutate(YEAR = YEAR + 2004, ERR = ERR) %>%
        dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat = paste(loc$lat)) %>%
        dplyr::summarize(max_temp = max(TC), mean_temp = mean(TC), .groups = "drop")

    # Create a function to calculate the rolling weekly temperature
    calc_yearly_rolling_mean <- function(data) {
        data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean,
            align = "right", partial = TRUE, fill = NA)
        data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean,
            align = "right", partial = TRUE, fill = NA)
        return(data)
    }

    # Calculate the rolling mean for each year and location
    daily_temp <- daily_temp %>%
        dplyr::group_by(YEAR, lon, lat) %>%
        dplyr::group_modify(~calc_yearly_rolling_mean(.))

    # Identify the warmest 91 days (3 months) of each year
    daily_temp_warmest_days <- daily_temp %>%
        dplyr::group_by(YEAR, lon, lat) %>%
        dplyr::top_n(91, max_temp)

    # Calculate the mean overall maximum temperature for the warmest days of
    # each year
    overall_temp_warmest_days <- daily_temp_warmest_days %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
            0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
            0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
            max = max(max_temp), .groups = "drop")

    result <- list(daily_temp, daily_temp_warmest_days, overall_temp_warmest_days)

    return(list(success = ecto_result$success, result = result))  # Return a list with a success flag and the result.

}

Function to process coordinates in chunks

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

    data_for_imp <- readRDS(file = "RData/General_data/pre_data_for_imputation.rds")

    presence_body_mass <- merge(presence, dplyr::select(data_for_imp, tip.label,
        body_mass), by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 2700)  # Set a global timeout for 45 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Substrate/4C/results/1st_batch/results_biophysical_modelling_substrate_future4C_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 14092

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "4th_batch", "5th_batch", "6th_batch",
    "7th_batch", "8th_batch", "9th_batch", "10th_batch", "11th_batch", "12th_batch",
    "13th_batch", "14th_batch")

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Substrate/4C/results", folder,
        sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Substrate/4C/results",
        folder, "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Substrate/4C/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)


#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")
# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Substrate/4C/daily_temp_substrate_4C.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Substrate/4C/daily_temp_warmest_days_substrate_4C.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Substrate/4C/overall_temp_warmest_days_substrate_4C.rds")


####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Substrate/4C/missing_coordinates.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Substrate/4C/missing_coordinates_row_n.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Substrate/4C/row_n_duplicated_coordinates.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Substrate/4C/duplicated_coordinates.rds")

Function to process coordinates

# Set up parallel processing
plan(multicore(workers=16))

# Set the global timeout
options(future.globals.timeout = 3600)  # Set a global timeout for 1 hour


# Function to process each location
process_location <- function(loc) {
  
  print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))
  
  # Set parameters
  dstart <- "01/01/2005"
  dfinish <- "31/12/2015"
  
  coords<- c(loc$lon, loc$lat)
  
  ERR <- 1.5  # Adjusting ERR based on the locations (locations with snow sometimes need a higher value)
  
  micro_result <- withTimeout({
    NicheMapR::micro_ncep(loc = coords, 
                          dstart = dstart, 
                          dfinish = dfinish, 
                          scenario=0,
                          minshade=85,
                          maxshade=90,
                          Usrhyt = 0.01,
                          cap = 1,
                          ERR = ERR, 
                          spatial = 'data/NCEP')
  }, timeout = 600, onTimeout = "warning")
  
  # If the process takes longer than 10 minutes, break.
  
  if (inherits(micro_result, "try-error") || is.null(micro_result)) {
    print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "micro_ncep exceeded time limit"))
  } else {
    micro <- micro_result
    micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
  }
  
  
  # When the first micro_ncep fails, try again with different ERR
  if (max(micro$metout[,1] == 0)) {
    while(max(micro$metout[,1] == 0)){
      ERR <- ERR + 0.5
      
      # Use withTimeout() for the micro_ncep() function inside the while loop as well
      micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, 
                              dstart = dstart, 
                              dfinish = dfinish, 
                              scenario=0,
                              minshade=85,
                              maxshade=90,
                              Usrhyt = 0.01,
                              cap = 1,
                              ERR = ERR, 
                              spatial = 'data/NCEP')
      }, timeout = 600, onTimeout = "warning")
      
      if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep inside while loop exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
        return(list(success = FALSE, 
                    loc = c(lon = loc$lon, lat = loc$lat), 
                    error_message = "micro_ncep inside while loop exceeded time limit"))
      } else {
        micro <- micro_result
        micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
      }
      
      # If ERR exceeds 5, break the loop regardless of the value of micro$metout[,1]
      if(ERR >= 5){
        break
      }
    }
  }
  
  # If even after adjusting ERR micro_ncep fails, return an error message
  if (max(micro$metout[,1] == 0)) {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  # Another explicit check
  if (!max(micro$metout[,1] == 0)) {
    assign("micro", micro, envir = globalenv())
  } else {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  success <- FALSE
  result <- NULL
  
  micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
  
  # Use withTimeout() for the ectotherm() function as well
  ecto_result <- withTimeout({
    tryCatch({
      ecto <- NicheMapR::ectotherm(
        container=1, # container model
        conth=1500, # shallow pond of 1.5m depth
        contw=12000,# pond of 12m width
        contype=1, # container sunk into the ground like a pond
        rainmult = 1000000000, # rainfall multiplier, to keep the pond wet
        continit = 1500, # Initial container water level (1.5m)
        conthole = 0, # Daily loss of height (mm) due to hole in container (e.g. infiltration)
        contwet=100, # 100% of container surface area acting as free water exchanger
        contonly=1)
      
      list(success = TRUE, ecto = ecto)
    }, error = function(e) {
      list(success = FALSE,
           loc = c(lon = loc$lon, lat = loc$lat),
           error_message = paste("Failed on ectotherm call:", as.character(conditionMessage(e))))
    })
  }, timeout = 2000, onTimeout = "warning")
  
  if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
    print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "ectotherm() exceeded time limit"))
  }
  
  if(!ecto_result$success){
    return(ecto_result)
  }
  
  gc()
  
  # Assign the successful ecto result to the global environment
  ecto <- ecto_result$ecto
  assign("ecto", ecto, envir = globalenv())
  environ <- as.data.frame(ecto$environ)
  
  # Max and mean daily temperatures
  daily_temp <- environ %>%
    dplyr::mutate(YEAR = YEAR + 2004,
                  ERR = ERR) %>%
    dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat=paste(loc$lat)) %>%
    dplyr::summarize(max_temp = max(TC),
                     mean_temp = mean(TC), .groups = 'drop')
  
  # Create a function to calculate the rolling weekly temperature
  calc_yearly_rolling_mean <- function(data) {
    data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    return(data)
  }
  
  # Calculate the rolling mean for each year and location
  daily_temp <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::group_modify(~calc_yearly_rolling_mean(.))
  
  # Identify the warmest 91 days (3 months) of each year
  daily_temp_warmest_days <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::top_n(91, max_temp)
  
  # Calculate the mean overall maximum temperature for the warmest days of each year
  overall_temp_warmest_days <- daily_temp_warmest_days %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp),
                     median = median(max_temp),
                     fifth_percentile = quantile(max_temp, 0.05),
                     first_quartile = quantile(max_temp, 0.25),
                     third_quartile = quantile(max_temp, 0.75),
                     ninetyfifth_percentile = quantile(max_temp, 0.95),
                     min = min(max_temp),
                     max = max(max_temp), .groups = 'drop')
  
  result <- list(daily_temp, 
                 daily_temp_warmest_days, 
                 overall_temp_warmest_days)
  
  return(list(success = ecto_result$success, result = result)) # Return a list with a success flag and the result.
  
}

Function to process coordinates in chunks

Processing the coordinates in chunks is very useful for debugging.

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

    data_for_imp <- readRDS(file = "RData/General_data/pre_data_for_imputation.rds")

    presence_body_mass <- merge(presence, dplyr::select(data_for_imp, tip.label,
        body_mass), by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 3600)  # Set a global timeout for 60 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Pond/current/results/1st_batch/results_biophysical_modelling_pond_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 14092

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "21st_batch", "22nd_batch", "23rd_batch",
    "31st_batch", "32nd_batch", "33rd_batch")
folders2 <- paste0(4:20, "th_batch")
folders3 <- paste0(24:30, "th_batch")
folders4 <- paste0(34:36, "th_batch")

folders <- c(folders, folders2, folders3, folders4)

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Pond/current/results", folder,
        sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Pond/current/results",
        folder, "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Pond/current/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)

#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")
# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Pond/current/daily_temp_pond.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Pond/current/daily_temp_warmest_days_pond.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Pond/current/overall_temp_warmest_days_pond.rds")


####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Pond/current/missing_coordinates.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Pond/current/missing_coordinates_row_n.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Pond/current/row_n_duplicated_coordinates.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Pond/current/duplicated_coordinates.rds")

Function to process coordinates

# Set up parallel processing
plan(multicore(workers=16))

# Set the global timeout
options(future.globals.timeout = 3600)  # Set a global timeout for 60 minutes


# Function to process each location
process_location <- function(loc) {
  
  print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))
  
  # Set parameters
  dstart <- "01/01/2005"
  dfinish <- "31/12/2015"
  
  coords<- c(loc$lon, loc$lat)
  
  ERR <- 1.5  # Adjusting ERR based on the locations (locations with snow sometimes need a higher value)
  
  micro_result <- withTimeout({
    NicheMapR::micro_ncep(loc = coords, 
                          dstart = dstart, 
                          dfinish = dfinish, 
                          scenario=2,
                          minshade=85,
                          maxshade=90,
                          Usrhyt = 0.01,
                          cap = 1,
                          ERR = ERR, 
                          spatial = 'data/NCEP',
                          terra_source = 'data/TerraClimate/data')
  }, timeout = 600, onTimeout = "warning")
  
  # If the process takes longer than 10 minutes, break.
  
  if (inherits(micro_result, "try-error") || is.null(micro_result)) {
    print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "micro_ncep exceeded time limit"))
  } else {
    micro <- micro_result
    micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
  }
  
  
  # When the first micro_ncep fails, try again with different ERR
  if (max(micro$metout[,1] == 0)) {
    while(max(micro$metout[,1] == 0)){
      ERR <- ERR + 0.5
      
      # Use withTimeout() for the micro_ncep() function inside the while loop as well
      micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, 
                              dstart = dstart, 
                              dfinish = dfinish, 
                              scenario=2,
                              minshade=85,
                              maxshade=90,
                              Usrhyt = 0.01,
                              cap = 1,
                              ERR = ERR, 
                              spatial = 'data/NCEP',
                              terra_source = 'data/TerraClimate/data')
      }, timeout = 600, onTimeout = "warning")
      
      if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep inside while loop exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
        return(list(success = FALSE, 
                    loc = c(lon = loc$lon, lat = loc$lat), 
                    error_message = "micro_ncep inside while loop exceeded time limit"))
      } else {
        micro <- micro_result
        micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
      }
      
      # If ERR exceeds 5, break the loop regardless of the value of micro$metout[,1]
      if(ERR >= 5){
        break
      }
    }
  }
  
  # If even after adjusting ERR micro_ncep fails, return an error message
  if (max(micro$metout[,1] == 0)) {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  # Another explicit check
  if (!max(micro$metout[,1] == 0)) {
    assign("micro", micro, envir = globalenv())
  } else {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  success <- FALSE
  result <- NULL
  
  micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
  
  # Use withTimeout() for the ectotherm() function as well
  ecto_result <- withTimeout({
    tryCatch({
      ecto <- NicheMapR::ectotherm(
        container=1, # container model
        conth=1500, # shallow pond of 1.5m depth
        contw=12000,# pond of 12m width
        contype=1, # container sunk into the ground like a pond
        rainmult = 1000000000, # rainfall multiplier, to keep the pond wet
        continit = 1500, # Initial container water level (1.5m)
        conthole = 0, # Daily loss of height (mm) due to hole in container (e.g. infiltration)
        contwet=100, # 100% of container surface area acting as free water exchanger
        contonly=1)
      
      list(success = TRUE, ecto = ecto)
    }, error = function(e) {
      list(success = FALSE,
           loc = c(lon = loc$lon, lat = loc$lat),
           error_message = paste("Failed on ectotherm call:", as.character(conditionMessage(e))))
    })
  }, timeout = 2000, onTimeout = "warning")
  
  if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
    print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "ectotherm() exceeded time limit"))
  }
  
  if(!ecto_result$success){
    return(ecto_result)
  }
  
  gc()
  
  # Assign the successful ecto result to the global environment
  ecto <- ecto_result$ecto
  assign("ecto", ecto, envir = globalenv())
  environ <- as.data.frame(ecto$environ)
  
  # Max and mean daily temperatures
  daily_temp <- environ %>%
    dplyr::mutate(YEAR = YEAR + 2004,
                  ERR = ERR) %>%
    dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat=paste(loc$lat)) %>%
    dplyr::summarize(max_temp = max(TC),
                     mean_temp = mean(TC), .groups = 'drop')
  
  # Create a function to calculate the rolling weekly temperature
  calc_yearly_rolling_mean <- function(data) {
    data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    return(data)
  }
  
  # Calculate the rolling mean for each year and location
  daily_temp <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::group_modify(~calc_yearly_rolling_mean(.))
  
  # Identify the warmest 91 days (3 months) of each year
  daily_temp_warmest_days <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::top_n(91, max_temp)
  
  # Calculate the mean overall maximum temperature for the warmest days of each year
  overall_temp_warmest_days <- daily_temp_warmest_days %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp),
                     median = median(max_temp),
                     fifth_percentile = quantile(max_temp, 0.05),
                     first_quartile = quantile(max_temp, 0.25),
                     third_quartile = quantile(max_temp, 0.75),
                     ninetyfifth_percentile = quantile(max_temp, 0.95),
                     min = min(max_temp),
                     max = max(max_temp), .groups = 'drop')
  
  result <- list(daily_temp, 
                 daily_temp_warmest_days, 
                 overall_temp_warmest_days)
  
  return(list(success = ecto_result$success, result = result)) # Return a list with a success flag and the result.
  
}

Function to process coordinates in chunks

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

    data_for_imp <- readRDS(file = "RData/General_data/pre_data_for_imputation.rds")

    presence_body_mass <- merge(presence, dplyr::select(data_for_imp, tip.label,
        body_mass), by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 3600)  # Set a global timeout for 30 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Pond/2C/results/1st_batch/results_biophysical_modelling_pond_future2C_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 14092

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "21st_batch", "22nd_batch", "23rd_batch",
    "31st_batch", "32nd_batch", "33rd_batch")
folders2 <- paste0(4:20, "th_batch")
folders3 <- paste0(24:30, "th_batch")
folders4 <- paste0(34:36, "th_batch")

folders <- c(folders, folders2, folders3, folders4)

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {

    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Pond/2C/results", folder, sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {

    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Pond/2C/results", folder,
        "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Pond/2C/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)

#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")

# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Pond/2C/daily_temp_pond_2C.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Pond/2C/daily_temp_warmest_days_pond_2C.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Pond/2C/overall_temp_warmest_days_pond_2C.rds")


####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Pond/2C/missing_coordinates_2C.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Pond/2C/missing_coordinates_row_n_2C.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Pond/2C/row_n_duplicated_coordinates_2C.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Pond/2C/duplicated_coordinates_2C.rds")

Function to process coordinates

# Set up parallel processing
plan(multicore(workers=16))

# Set the global timeout
options(future.globals.timeout = 3600)  # Set a global timeout for 60 minutes


# Function to process each location
process_location <- function(loc) {
  
  print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))
  
  # Set parameters
  dstart <- "01/01/2005"
  dfinish <- "31/12/2015"
  
  coords<- c(loc$lon, loc$lat)
  
  ERR <- 1.5  # Adjusting ERR based on the locations (locations with snow sometimes need a higher value)
  
  micro_result <- withTimeout({
    NicheMapR::micro_ncep(loc = coords, 
                          dstart = dstart, 
                          dfinish = dfinish, 
                          scenario=4,
                          minshade=85,
                          maxshade=90,
                          Usrhyt = 0.01,
                          cap = 1,
                          ERR = ERR, 
                          spatial = 'data/NCEP',
                          terra_source = 'data/TerraClimate/data')
  }, timeout = 600, onTimeout = "warning")
  
  # If the process takes longer than 10 minutes, break.
  
  if (inherits(micro_result, "try-error") || is.null(micro_result)) {
    print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "micro_ncep exceeded time limit"))
  } else {
    micro <- micro_result
    micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
  }
  
  
  # When the first micro_ncep fails, try again with different ERR
  if (max(micro$metout[,1] == 0)) {
    while(max(micro$metout[,1] == 0)){
      ERR <- ERR + 0.5
      
      # Use withTimeout() for the micro_ncep() function inside the while loop as well
      micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, 
                              dstart = dstart, 
                              dfinish = dfinish, 
                              scenario=4,
                              minshade=85,
                              maxshade=90,
                              Usrhyt = 0.01,
                              cap = 1,
                              ERR = ERR, 
                              spatial = 'data/NCEP',
                              terra_source = 'data/TerraClimate/data')
      }, timeout = 600, onTimeout = "warning")
      
      if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep inside while loop exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
        return(list(success = FALSE, 
                    loc = c(lon = loc$lon, lat = loc$lat), 
                    error_message = "micro_ncep inside while loop exceeded time limit"))
      } else {
        micro <- micro_result
        micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
      }
      
      # If ERR exceeds 5, break the loop regardless of the value of micro$metout[,1]
      if(ERR >= 5){
        break
      }
    }
  }
  
  # If even after adjusting ERR micro_ncep fails, return an error message
  if (max(micro$metout[,1] == 0)) {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  # Another explicit check
  if (!max(micro$metout[,1] == 0)) {
    assign("micro", micro, envir = globalenv())
  } else {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  success <- FALSE
  result <- NULL
  
  micro$metout[, 13] <- 0 # Make sure the pond stays in the shade
  
  # Use withTimeout() for the ectotherm() function as well
  ecto_result <- withTimeout({
    tryCatch({
      ecto <- NicheMapR::ectotherm(
        container=1, # container model
        conth=1500, # shallow pond of 1.5m depth
        contw=12000,# pond of 12m width
        contype=1, # container sunk into the ground like a pond
        rainmult = 1000000000, # rainfall multiplier, to keep the pond wet
        continit = 1500, # Initial container water level (1.5m)
        conthole = 0, # Daily loss of height (mm) due to hole in container (e.g. infiltration)
        contwet=100, # 100% of container surface area acting as free water exchanger
        contonly=1)
      
      list(success = TRUE, ecto = ecto)
    }, error = function(e) {
      list(success = FALSE,
           loc = c(lon = loc$lon, lat = loc$lat),
           error_message = paste("Failed on ectotherm call:", as.character(conditionMessage(e))))
    })
  }, timeout = 2000, onTimeout = "warning")
  
  if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
    print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "ectotherm() exceeded time limit"))
  }
  
  if(!ecto_result$success){
    return(ecto_result)
  }
  
  gc()
  
  # Assign the successful ecto result to the global environment
  ecto <- ecto_result$ecto
  assign("ecto", ecto, envir = globalenv())
  environ <- as.data.frame(ecto$environ)
  
  
  # Max and mean daily temperatures
  daily_temp <- environ %>%
    dplyr::mutate(YEAR = YEAR + 2004,
                  ERR = ERR) %>%
    dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat=paste(loc$lat)) %>%
    dplyr::summarize(max_temp = max(TC),
                     mean_temp = mean(TC), .groups = 'drop')
  
  # Create a function to calculate the rolling weekly temperature
  calc_yearly_rolling_mean <- function(data) {
    data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    return(data)
  }
  
  # Calculate the rolling mean for each year and location
  daily_temp <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::group_modify(~calc_yearly_rolling_mean(.))
  
  # Identify the warmest 91 days (3 months) of each year
  daily_temp_warmest_days <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::top_n(91, max_temp)
  
  # Calculate the mean overall maximum temperature for the warmest days of each year
  overall_temp_warmest_days <- daily_temp_warmest_days %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp),
                     median = median(max_temp),
                     fifth_percentile = quantile(max_temp, 0.05),
                     first_quartile = quantile(max_temp, 0.25),
                     third_quartile = quantile(max_temp, 0.75),
                     ninetyfifth_percentile = quantile(max_temp, 0.95),
                     min = min(max_temp),
                     max = max(max_temp), .groups = 'drop')
  
  result <- list(daily_temp, 
                 daily_temp_warmest_days, 
                 overall_temp_warmest_days)
  
  return(list(success = ecto_result$success, result = result)) # Return a list with a success flag and the result.
  
}

Function to process coordinates in chunks

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

    data_for_imp <- readRDS(file = "RData/General_data/pre_data_for_imputation.rds")

    presence_body_mass <- merge(presence, dplyr::select(data_for_imp, tip.label,
        body_mass), by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 3600)  # Set a global timeout for 30 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Pond/4C/results/1st_batch/results_biophysical_modelling_pond_future4C_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 14092

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "21st_batch", "22nd_batch", "23rd_batch",
    "31st_batch", "32nd_batch", "33rd_batch")
folders2 <- paste0(4:20, "th_batch")
folders3 <- paste0(24:30, "th_batch")
folders4 <- paste0(34:36, "th_batch")

folders <- c(folders, folders2, folders3, folders4)

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {

    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Pond/4C/results", folder, sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {

    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Pond/4C/results", folder,
        "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Pond/4C/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)

#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")
# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Pond/4C/daily_temp_pond_4C.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Pond/4C/daily_temp_warmest_days_pond_4C.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Pond/4C/overall_temp_warmest_days_pond_4C.rds")


####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Pond/4C/missing_coordinates_4C.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Pond/4C/missing_coordinates_row_n_4C.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Pond/4C/row_n_duplicated_coordinates_4C.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Pond/4C/duplicated_coordinates_4C.rds")

Function to process coordinates

# Set up parallel processing
plan(multicore(workers=16))

# Set the global timeout
options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes


# Function to process each location
process_location <- function(loc) {
  
  print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))
  
  # Set parameters
  dstart <- "01/01/2005"
  dfinish <- "31/12/2015"
  
  coords<- c(loc$lon, loc$lat)
  
  ERR <- 1.5  # Adjusting ERR based on the locations (locations with snow sometimes need a higher value)
  
  micro_result <- withTimeout({
    NicheMapR::micro_ncep(loc = coords, 
                          dstart = dstart, 
                          dfinish = dfinish, 
                          scenario=0,
                          minshade=85,
                          maxshade=90,
                          Usrhyt = 2, # 2 meters above ground
                          windfac = 0.2, # Reduce wind speed by 80% in dense vegetation
                          microclima.LAI = 0.9, # 90% of the radiation is diffused because of vegetation
                          cap = 1,
                          ERR = ERR, 
                          spatial = 'data/NCEP')
  }, timeout = 600, onTimeout = "warning")
  
  # If the process takes longer than 10 minutes, break.
  
  if (inherits(micro_result, "try-error") || is.null(micro_result)) {
    print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "micro_ncep exceeded time limit"))
  } else {
    micro <- micro_result
  }
  
  
  # When the first micro_ncep fails, try again with different ERR
  if (max(micro$metout[,1] == 0)) {
    while(max(micro$metout[,1] == 0)){
      ERR <- ERR + 0.5
      
      # Use withTimeout() for the micro_ncep() function inside the while loop as well
      micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, 
                              dstart = dstart, 
                              dfinish = dfinish, 
                              scenario=0,
                              minshade=85,
                              maxshade=90,
                              Usrhyt = 2, # 2 meters above ground
                              windfac = 0.2, # Reduce wind speed by 80% in dense vegetation
                              microclima.LAI = 0.9, # 90% of the radiation is diffused because of vegetation
                              cap = 1,
                              ERR = ERR, 
                              spatial = 'data/NCEP')
      }, timeout = 600, onTimeout = "warning")
      
      if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep inside while loop exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
        return(list(success = FALSE, 
                    loc = c(lon = loc$lon, lat = loc$lat), 
                    error_message = "micro_ncep inside while loop exceeded time limit"))
      } else {
        micro <- micro_result
      }
      
      # If ERR exceeds 5, break the loop regardless of the value of micro$metout[,1]
      if(ERR >= 5){
        break
      }
    }
  }
  
  # If even after adjusting ERR micro_ncep fails, return an error message
  if (max(micro$metout[,1] == 0)) {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  # Another explicit check
  if (!max(micro$metout[,1] == 0)) {
    assign("micro", micro, envir = globalenv())
  } else {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  success <- FALSE
  result <- NULL
  
  micro$metout[, 3] <- micro$metout[, 4] # Make the local height equal to reference height (2m)
  micro$metout[, 5] <- micro$metout[, 6] # Make the local height equal to reference height (2m)
  micro$metout[, 7] <- micro$metout[, 8] # Make the local height equal to reference height (2m)
  
  # Use withTimeout() for the ectotherm() function as well
  ecto_result <- withTimeout({
    tryCatch({
      ecto <- NicheMapR::ectotherm(live=0, 
                                   Ww_g = loc$median_mass, 
                                   shape = 4, 
                                   pct_wet = 80)
      list(success = TRUE, ecto = ecto)
    }, error = function(e) {
      list(success = FALSE,
           loc = c(lon = loc$lon, lat = loc$lat),
           error_message = paste("Failed on ectotherm call:", as.character(conditionMessage(e))))
    })
  }, timeout = 200, onTimeout = "warning")
  
  if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
    print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "ectotherm() exceeded time limit"))
  }
  
  if(!ecto_result$success){
    return(ecto_result)
  }
  
  gc()
  
  # Assign the successful ecto result to the global environment
  ecto <- ecto_result$ecto
  assign("ecto", ecto, envir = globalenv())
  environ <- as.data.frame(ecto$environ)
  
  # Max and mean daily temperatures
  daily_temp <- environ %>%
    dplyr::mutate(YEAR = YEAR + 2004,
                  ERR = ERR) %>%
    dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat=paste(loc$lat)) %>%
    dplyr::summarize(max_temp = max(TC),
                     mean_temp = mean(TC), .groups = 'drop')
  
  # Create a function to calculate the rolling weekly temperature
  calc_yearly_rolling_mean <- function(data) {
    data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    return(data)
  }
  
  # Calculate the rolling mean for each year and location
  daily_temp <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::group_modify(~calc_yearly_rolling_mean(.))
  
  # Identify the warmest 91 days (3 months) of each year
  daily_temp_warmest_days <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::top_n(91, max_temp)
  
  # Calculate the mean overall maximum temperature for the warmest days of each year
  overall_temp_warmest_days <- daily_temp_warmest_days %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp),
                     median = median(max_temp),
                     fifth_percentile = quantile(max_temp, 0.05),
                     first_quartile = quantile(max_temp, 0.25),
                     third_quartile = quantile(max_temp, 0.75),
                     ninetyfifth_percentile = quantile(max_temp, 0.95),
                     min = min(max_temp),
                     max = max(max_temp), .groups = 'drop')
  
  result <- list(daily_temp, 
                 daily_temp_warmest_days, 
                 overall_temp_warmest_days)
  
  return(list(success = ecto_result$success, result = result)) # Return a list with a success flag and the result.
  
}

Function to process coordinates in chunks

Processing the coordinates in chunks is very useful for debugging.

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted_arboreal.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted_arboreal.rds")

    data <- readRDS(file = "RData/General_data/data_arboreal_sp.rds")

    presence_body_mass <- merge(presence, dplyr::select(data, tip.label, body_mass),
        by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Arboreal/current/results/1st_batch/results_biophysical_modelling_arboreal_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 6614

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "4th_batch", "5th_batch", "6th_batch",
    "7th_batch")

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Arboreal/current/results",
        folder, sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Arboreal/current/results",
        folder, "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Arboreal/current/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)

#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")

# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Arboreal/current/daily_temp_arboreal.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Arboreal/current/daily_temp_warmest_days_arboreal.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Arboreal/current/overall_temp_warmest_days_arboreal.rds")


####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted_arboreal.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Arboreal/current/missing_coordinates.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Arboreal/current/missing_coordinates_row_n.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Arboreal/current/row_n_duplicated_coordinates.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Arboreal/current/duplicated_coordinates.rds")

Function to process coordinates

# Set up parallel processing
plan(multicore(workers=16))

# Set the global timeout
options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes


# Function to process each location
process_location <- function(loc) {
  
  print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))
  
  # Set parameters
  dstart <- "01/01/2005"
  dfinish <- "31/12/2015"
  
  coords<- c(loc$lon, loc$lat)
  
  ERR <- 1.5  # Adjusting ERR based on the locations (locations with snow sometimes need a higher value)
  
  micro_result <- withTimeout({
    NicheMapR::micro_ncep(loc = coords, 
                          dstart = dstart, 
                          dfinish = dfinish, 
                          scenario=2,
                          minshade=85,
                          maxshade=90,
                          Usrhyt = 2, # 2 meters above ground
                          windfac = 0.2, # Reduce wind speed by 80% in dense vegetation
                          microclima.LAI = 0.9, # 90% of the radiation is diffused because of vegetation
                          cap = 1,
                          ERR = ERR, 
                          spatial = 'data/NCEP',
                          terra_source = 'data/TerraClimate/data')
  }, timeout = 600, onTimeout = "warning")
  
  # If the process takes longer than 10 minutes, break.
  
  if (inherits(micro_result, "try-error") || is.null(micro_result)) {
    print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "micro_ncep exceeded time limit"))
  } else {
    micro <- micro_result
  }
  
  
  # When the first micro_ncep fails, try again with different ERR
  if (max(micro$metout[,1] == 0)) {
    while(max(micro$metout[,1] == 0)){
      ERR <- ERR + 0.5
      
      # Use withTimeout() for the micro_ncep() function inside the while loop as well
      micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, 
                              dstart = dstart, 
                              dfinish = dfinish, 
                              scenario=2,
                              minshade=85,
                              maxshade=90,
                              Usrhyt = 2, # 2 meters above ground
                              windfac = 0.2, # Reduce wind speed by 80% in dense vegetation
                              microclima.LAI = 0.9, # 90% of the radiation is diffused because of vegetation
                              cap = 1,
                              ERR = ERR, 
                              spatial = 'data/NCEP',
                              terra_source = 'data/TerraClimate/data')
      }, timeout = 600, onTimeout = "warning")
      
      if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep inside while loop exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
        return(list(success = FALSE, 
                    loc = c(lon = loc$lon, lat = loc$lat), 
                    error_message = "micro_ncep inside while loop exceeded time limit"))
      } else {
        micro <- micro_result
      }
      
      # If ERR exceeds 5, break the loop regardless of the value of micro$metout[,1]
      if(ERR >= 5){
        break
      }
    }
  }
  
  # If even after adjusting ERR micro_ncep fails, return an error message
  if (max(micro$metout[,1] == 0)) {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  # Another explicit check
  if (!max(micro$metout[,1] == 0)) {
    assign("micro", micro, envir = globalenv())
  } else {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  success <- FALSE
  result <- NULL
  
  micro$metout[, 3] <- micro$metout[, 4] # Make the local height equal to reference height (2m)
  micro$metout[, 5] <- micro$metout[, 6] # Make the local height equal to reference height (2m)
  micro$metout[, 7] <- micro$metout[, 8] # Make the local height equal to reference height (2m)
  
  # Use withTimeout() for the ectotherm() function as well
  ecto_result <- withTimeout({
    tryCatch({
      ecto <- NicheMapR::ectotherm(live=0, 
                                   Ww_g = loc$median_mass, 
                                   shape = 4, 
                                   pct_wet = 80)
      list(success = TRUE, ecto = ecto)
    }, error = function(e) {
      list(success = FALSE,
           loc = c(lon = loc$lon, lat = loc$lat),
           error_message = paste("Failed on ectotherm call:", as.character(conditionMessage(e))))
    })
  }, timeout = 200, onTimeout = "warning")
  
  if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
    print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "ectotherm() exceeded time limit"))
  }
  
  if(!ecto_result$success){
    return(ecto_result)
  }
  
  gc()
  
  # Assign the successful ecto result to the global environment
  ecto <- ecto_result$ecto
  assign("ecto", ecto, envir = globalenv())
  environ <- as.data.frame(ecto$environ)
  
  
  # Max and mean daily temperatures
  daily_temp <- environ %>%
    dplyr::mutate(YEAR = YEAR + 2004,
                  ERR = ERR) %>%
    dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat=paste(loc$lat)) %>%
    dplyr::summarize(max_temp = max(TC),
                     mean_temp = mean(TC), .groups = 'drop')
  
  # Create a function to calculate the rolling weekly temperature
  calc_yearly_rolling_mean <- function(data) {
    data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    return(data)
  }
  
  # Calculate the rolling mean for each year and location
  daily_temp <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::group_modify(~calc_yearly_rolling_mean(.))
  
  # Identify the warmest 91 days (3 months) of each year
  daily_temp_warmest_days <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::top_n(91, max_temp)
  
  # Calculate the mean overall maximum temperature for the warmest days of each year
  overall_temp_warmest_days <- daily_temp_warmest_days %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp),
                     median = median(max_temp),
                     fifth_percentile = quantile(max_temp, 0.05),
                     first_quartile = quantile(max_temp, 0.25),
                     third_quartile = quantile(max_temp, 0.75),
                     ninetyfifth_percentile = quantile(max_temp, 0.95),
                     min = min(max_temp),
                     max = max(max_temp), .groups = 'drop')
  
  result <- list(daily_temp, 
                 daily_temp_warmest_days, 
                 overall_temp_warmest_days)
  
  return(list(success = ecto_result$success, result = result)) # Return a list with a success flag and the result.
  
}

Function to process coordinates in chunks

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted_arboreal.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted_arboreal.rds")

    data <- readRDS(file = "RData/General_data/data_arboreal_sp.rds")

    presence_body_mass <- merge(presence, dplyr::select(data, tip.label, body_mass),
        by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Arboreal/2C/results/1st_batch/results_biophysical_modelling_arboreal_future2C_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 6614

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "4th_batch", "5th_batch", "6th_batch",
    "7th_batch")

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Arboreal/2C/results", folder,
        sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Arboreal/2C/results",
        folder, "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Arboreal/2C/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)

#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")

# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Arboreal/2C/daily_temp_arboreal_2C.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Arboreal/2C/daily_temp_warmest_days_arboreal_2C.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Arboreal/2C/overall_temp_warmest_days_arboreal_2C.rds")


####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted_arboreal.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Arboreal/2C/missing_coordinates_2C.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Arboreal/2C/missing_coordinates_row_n_2C.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Arboreal/2C/row_n_duplicated_coordinates_2C.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Arboreal/2C/duplicated_coordinates_2C.rds")

Function to process coordinates

# Set up parallel processing
plan(multicore(workers=16))

# Set the global timeout
options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes


# Function to process each location
process_location <- function(loc) {
  
  print(paste("Processing location with lon =", loc$lon, "lat =", loc$lat))
  
  # Set parameters
  dstart <- "01/01/2005"
  dfinish <- "31/12/2015"
  
  coords<- c(loc$lon, loc$lat)
  
  ERR <- 1.5  # Adjusting ERR based on the locations (locations with snow sometimes need a higher value)
  
  micro_result <- withTimeout({
    NicheMapR::micro_ncep(loc = coords, 
                          dstart = dstart, 
                          dfinish = dfinish, 
                          scenario=4,
                          minshade=85,
                          maxshade=90,
                          Usrhyt = 2, # 2 meters above ground
                          windfac = 0.2, # Reduce wind speed by 80% in dense vegetation
                          microclima.LAI = 0.9, # 90% of the radiation is diffused because of vegetation
                          cap = 1,
                          ERR = ERR, 
                          spatial = 'data/NCEP',
                          terra_source = 'data/TerraClimate/data')
  }, timeout = 600, onTimeout = "warning")
  
  # If the process takes longer than 10 minutes, break.
  
  if (inherits(micro_result, "try-error") || is.null(micro_result)) {
    print(paste("micro_ncep exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "micro_ncep exceeded time limit"))
  } else {
    micro <- micro_result
  }
  
  
  # When the first micro_ncep fails, try again with different ERR
  if (max(micro$metout[,1] == 0)) {
    while(max(micro$metout[,1] == 0)){
      ERR <- ERR + 0.5
      
      # Use withTimeout() for the micro_ncep() function inside the while loop as well
      micro_result <- withTimeout({
        NicheMapR::micro_ncep(loc = coords, 
                              dstart = dstart, 
                              dfinish = dfinish, 
                              scenario=4,
                              minshade=85,
                              maxshade=90,
                              Usrhyt = 2, # 2 meters above ground
                              windfac = 0.2, # Reduce wind speed by 80% in dense vegetation
                              microclima.LAI = 0.9, # 90% of the radiation is diffused because of vegetation
                              cap = 1,
                              ERR = ERR, 
                              spatial = 'data/NCEP',
                              terra_source = 'data/TerraClimate/data')
      }, timeout = 600, onTimeout = "warning")
      
      if (inherits(micro_result, "try-error") || is.null(micro_result)) {
        print(paste("micro_ncep inside while loop exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
        return(list(success = FALSE, 
                    loc = c(lon = loc$lon, lat = loc$lat), 
                    error_message = "micro_ncep inside while loop exceeded time limit"))
      } else {
        micro <- micro_result
      }
      
      # If ERR exceeds 5, break the loop regardless of the value of micro$metout[,1]
      if(ERR >= 5){
        break
      }
    }
  }
  
  # If even after adjusting ERR micro_ncep fails, return an error message
  if (max(micro$metout[,1] == 0)) {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  # Another explicit check
  if (!max(micro$metout[,1] == 0)) {
    assign("micro", micro, envir = globalenv())
  } else {
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "Failed on micro_ncep call"))
  }
  
  success <- FALSE
  result <- NULL
  
  micro$metout[, 3] <- micro$metout[, 4] # Make the local height equal to reference height (2m)
  micro$metout[, 5] <- micro$metout[, 6] # Make the local height equal to reference height (2m)
  micro$metout[, 7] <- micro$metout[, 8] # Make the local height equal to reference height (2m)
  
  # Use withTimeout() for the ectotherm() function as well
  ecto_result <- withTimeout({
    tryCatch({
      ecto <- NicheMapR::ectotherm(live=0, 
                                   Ww_g = loc$median_mass, 
                                   shape = 4, 
                                   pct_wet = 80)
      list(success = TRUE, ecto = ecto)
    }, error = function(e) {
      list(success = FALSE,
           loc = c(lon = loc$lon, lat = loc$lat),
           error_message = paste("Failed on ectotherm call:", as.character(conditionMessage(e))))
    })
  }, timeout = 200, onTimeout = "warning")
  
  if (inherits(ecto_result, "try-error") || is.null(ecto_result)) {
    print(paste("ectotherm() exceeded time limit for location with lon =", loc$lon, "lat =", loc$lat))
    return(list(success = FALSE, 
                loc = c(lon = loc$lon, lat = loc$lat), 
                error_message = "ectotherm() exceeded time limit"))
  }
  
  if(!ecto_result$success){
    return(ecto_result)
  }
  
  gc()
  
  # Assign the successful ecto result to the global environment
  ecto <- ecto_result$ecto
  assign("ecto", ecto, envir = globalenv())
  environ <- as.data.frame(ecto$environ)
  
  # Max and mean daily temperatures
  daily_temp <- environ %>%
    dplyr::mutate(YEAR = YEAR + 2004,
                  ERR = ERR) %>%
    dplyr::group_by(ERR, YEAR, DOY, lon = paste(loc$lon), lat=paste(loc$lat)) %>%
    dplyr::summarize(max_temp = max(TC),
                     mean_temp = mean(TC), .groups = 'drop')
  
  # Create a function to calculate the rolling weekly temperature
  calc_yearly_rolling_mean <- function(data) {
    data$mean_weekly_temp <- zoo::rollapply(data$mean_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    data$max_weekly_temp <- zoo::rollapply(data$max_temp, width = 7, FUN = mean, align = "right", partial = TRUE, fill = NA)
    return(data)
  }
  
  # Calculate the rolling mean for each year and location
  daily_temp <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::group_modify(~calc_yearly_rolling_mean(.))
  
  # Identify the warmest 91 days (3 months) of each year
  daily_temp_warmest_days <- daily_temp %>%
    dplyr::group_by(YEAR, lon, lat) %>%
    dplyr::top_n(91, max_temp)
  
  # Calculate the mean overall maximum temperature for the warmest days of each year
  overall_temp_warmest_days <- daily_temp_warmest_days %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp),
                     median = median(max_temp),
                     fifth_percentile = quantile(max_temp, 0.05),
                     first_quartile = quantile(max_temp, 0.25),
                     third_quartile = quantile(max_temp, 0.75),
                     ninetyfifth_percentile = quantile(max_temp, 0.95),
                     min = min(max_temp),
                     max = max(max_temp), .groups = 'drop')
  
  result <- list(daily_temp, 
                 daily_temp_warmest_days, 
                 overall_temp_warmest_days)
  
  return(list(success = ecto_result$success, result = result)) # Return a list with a success flag and the result.
  
}

Function to process coordinates in chunks

# Function to process a chunk of locations
process_chunk <- function(start_index, end_index) {
    # Read in distinct coordinates
    distinct_coord <- readRDS(file = "RData/General_data/distinct_coordinates_adjusted_arboreal.rds")

    distinct_coord <- distinct_coord[, 3:4]
    distinct_coord <- rename(distinct_coord, x = lon, y = lat)

    # Adjust the range of locations
    distinct_coord <- distinct_coord[start_index:end_index, ]
    loc_list <- split(distinct_coord, seq(nrow(distinct_coord)))
    loc_list <- lapply(loc_list, unlist)

    # Match body mass data to coordinates
    presence <- readRDS(file = "RData/General_data/species_coordinates_adjusted_arboreal.rds")

    data <- readRDS(file = "RData/General_data/data_arboreal_sp.rds")

    presence_body_mass <- merge(presence, dplyr::select(data, tip.label, body_mass),
        by = "tip.label")
    median_body_mass <- presence_body_mass %>%
        dplyr::group_by(lon, lat) %>%
        dplyr::summarise(median_mass = median(body_mass, na.rm = TRUE)) %>%
        dplyr::ungroup()

    median_body_mass <- mutate(median_body_mass, median_mass = ifelse(is.na(median_mass) ==
        TRUE, 8.4, median_mass))

    # Convert loc_list back into a data frame
    loc_df <- do.call("rbind", loc_list)
    loc_df <- as.data.frame(loc_df)
    names(loc_df) <- c("lon", "lat")

    # Join loc_df and median_body_mass
    loc_df <- dplyr::left_join(loc_df, median_body_mass, by = c("lon", "lat"))

    # Convert loc_df back into a list
    loc_list <- split(loc_df, seq(nrow(loc_df)))

    # # Set up parallel processing
    plan(multicore(workers = 16))

    # Set the global timeout
    options(future.globals.timeout = 1800)  # Set a global timeout for 30 minutes

    dstart <- "01/01/2005"
    dfinish <- "31/12/2015"

    Sys.time()

    results <- future.apply::future_lapply(loc_list, process_location, future.packages = c("NicheMapR",
        "microclima", "dplyr", "zoo", "R.utils"))

    Sys.time()

    saveRDS(results, file = paste0("RData/Biophysical_modelling/Arboreal/4C/results/1st_batch/results_biophysical_modelling_arboreal_future4C_",
        start_index, "-", end_index, ".rds"))

}

Process all locations

dstart <- "01/01/2005"
dfinish <- "31/12/2015"

Sys.time()

chunk_size <- 16

# Define start and end row numbers in distinct_coord
start_row <- 1
end_row <- 6614

# Calculate total chunks for the specified range
total_chunks <- ceiling((end_row - start_row + 1)/chunk_size)

# Loop through each chunk
for (i in seq(total_chunks)) {
    # Calculate start and end indices for the current chunk
    start_index <- ((i - 1) * chunk_size) + start_row
    end_index <- min(i * chunk_size + start_row - 1, end_row)

    # Call the process_chunk function with a timeout of 600 seconds
    result <- process_chunk(start_index, end_index)
}

Sys.time()

Combine outputs

Note that some coordinates failed to run with the code provided above, and hence ran using slightly different parameters (higher error tolerance for calculating soil temperatures; not in parallel session). See details [HERE] Note also that the year 2005 was taken out as a burn in to allow the models to fully converge.

# List of folders for each type of file
folders <- c("1st_batch", "2nd_batch", "3rd_batch", "4th_batch", "5th_batch", "6th_batch",
    "7th_batch")

# Initialize empty lists to store the combined dataframes
combined_daily_temp <- list()
combined_daily_temp_warmest_days <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the folder
    path_to_rds <- paste("RData/Biophysical_modelling/Arboreal/4C/results", folder,
        sep = "/")

    # Get the list of all rds files in the folder
    rds_files <- list.files(path = path_to_rds, pattern = "*.rds", full.names = TRUE)

    # Read all the files into a list
    nested_list_results <- lapply(rds_files, readRDS)

    # Extract 'result' from each sublist in nested_list_results
    nested_list_results <- lapply(nested_list_results, function(x) lapply(x, function(y) y[["result"]]))

    # Flatten the list
    flattened_list <- do.call("c", nested_list_results)

    # Combine all dataframes for each metric and store them in the respective
    # lists
    combined_daily_temp[[folder]] <- do.call("rbind", lapply(flattened_list, function(x) x[[1]]))
    combined_daily_temp_warmest_days[[folder]] <- do.call("rbind", lapply(flattened_list,
        function(x) x[[2]]))
}

# Combine the dataframes from all folders
combined_daily_temp <- do.call("rbind", combined_daily_temp)
combined_daily_temp_warmest_days <- do.call("rbind", combined_daily_temp_warmest_days)

# Convert to numeric values
combined_daily_temp$lon <- as.numeric(combined_daily_temp$lon)
combined_daily_temp$lat <- as.numeric(combined_daily_temp$lat)

combined_daily_temp_warmest_days$lon <- as.numeric(combined_daily_temp_warmest_days$lon)
combined_daily_temp_warmest_days$lat <- as.numeric(combined_daily_temp_warmest_days$lat)

######################################################################################################

# Initialize empty lists to store the combined dataframes
combined_daily_temp_problematic <- list()
combined_daily_temp_warmest_days_problematic <- list()

# Loop over each folder
for (folder in folders) {
    # Get the path to the subfolder 'problematic_locations'
    path_to_subfolder <- paste("RData/Biophysical_modelling/Arboreal/4C/results",
        folder, "problematic_locations", sep = "/")

    # Check if the subfolder exists
    if (dir.exists(path_to_subfolder)) {
        # Get the list of all rds files in the subfolder
        rds_files <- list.files(path = path_to_subfolder, pattern = "*.rds", full.names = TRUE)

        # Read all the files into a list
        nested_list_results <- lapply(rds_files, readRDS)

        # Extract the four dataframes from each list and unlist 'lat' and 'lon'
        # columns
        combined_daily_temp_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[1]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))
        combined_daily_temp_warmest_days_subfolder <- do.call("rbind", lapply(nested_list_results,
            function(x) {
                df <- x[[2]]
                if (is.list(df$lat))
                  df$lat <- unlist(df$lat)
                if (is.list(df$lon))
                  df$lon <- unlist(df$lon)
                df
            }))

        # Store the combined dataframes in the respective lists
        combined_daily_temp_problematic[[folder]] <- combined_daily_temp_subfolder
        combined_daily_temp_warmest_days_problematic[[folder]] <- combined_daily_temp_warmest_days_subfolder
    }
}

# Combine the dataframes from all subfolders
combined_daily_temp_problematic <- do.call("rbind", combined_daily_temp_problematic)
combined_daily_temp_warmest_days_problematic <- do.call("rbind", combined_daily_temp_warmest_days_problematic)

#################################################################################################################

# Get the path to the 'failed_locations' folder
path_to_failed_locations <- "RData/Biophysical_modelling/Arboreal/4C/results/failed_locations"

# Initialize empty lists to store the combined dataframes
combined_daily_temp_failed <- list()
combined_daily_temp_warmest_days_failed <- list()

# Get the list of .rds files in the 'failed_locations' folder
rds_files_failed <- list.files(path = path_to_failed_locations, pattern = "*.rds",
    full.names = TRUE)

# Loop over each .rds file
for (file_failed in rds_files_failed) {
    # Read the .rds file into a list
    nested_list_results_failed <- readRDS(file_failed)

    # Extract the four dataframes from the list
    combined_daily_temp_failed_subfolder <- nested_list_results_failed[["result"]][[1]]
    combined_daily_temp_warmest_days_failed_subfolder <- nested_list_results_failed[["result"]][[2]]

    # Store the combined dataframes in the respective lists
    combined_daily_temp_failed[[file_failed]] <- combined_daily_temp_failed_subfolder
    combined_daily_temp_warmest_days_failed[[file_failed]] <- combined_daily_temp_warmest_days_failed_subfolder
}

# Combine the dataframes from all files in the 'failed_locations' folder
combined_daily_temp_failed <- do.call("rbind", combined_daily_temp_failed)
combined_daily_temp_warmest_days_failed <- do.call("rbind", combined_daily_temp_warmest_days_failed)

#####################################################################################################

# Combine files
combined_daily_temp_all <- rbind(combined_daily_temp, combined_daily_temp_problematic,
    combined_daily_temp_failed)
combined_daily_temp_warmest_days_all <- rbind(combined_daily_temp_warmest_days, combined_daily_temp_warmest_days_problematic,
    combined_daily_temp_warmest_days_failed)

# Remove the first year (burn-in)
combined_daily_temp_all <- filter(combined_daily_temp_all, YEAR != "2005")
combined_daily_temp_warmest_days_all <- filter(combined_daily_temp_warmest_days_all,
    YEAR != "2005")

# Calculate the overall temperature across coordinates
combined_overall_temp_all <- combined_daily_temp_warmest_days_all %>%
    dplyr::group_by(lon, lat) %>%
    dplyr::summarize(mean = mean(max_temp), median = median(max_temp), fifth_percentile = quantile(max_temp,
        0.05), first_quartile = quantile(max_temp, 0.25), third_quartile = quantile(max_temp,
        0.75), ninetyfifth_percentile = quantile(max_temp, 0.95), min = min(max_temp),
        max = max(max_temp), .groups = "drop")

# Save files
saveRDS(combined_daily_temp_all, file = "RData/Biophysical_modelling/Arboreal/4C/daily_temp_arboreal_4C.rds")
saveRDS(combined_daily_temp_warmest_days_all, file = "RData/Biophysical_modelling/Arboreal/4C/daily_temp_warmest_days_arboreal_4C.rds")
saveRDS(combined_overall_temp_all, file = "RData/Biophysical_modelling/Arboreal/4C/overall_temp_warmest_days_arboreal_4C.rds")


####################################################################################################

## Check for missing coordinates again

distinct_coord <- readRDS("RData/General_data/distinct_coordinates_adjusted_arboreal.rds")
distinct_coord <- mutate(distinct_coord, lon_lat = paste(lon, lat))

combined_daily_temp_warmest_days_all <- mutate(combined_daily_temp_warmest_days_all,
    lon_lat = paste(lon, lat))

# Function opposite of %in%
"%!in%" <- function(x, y) !(x %in% y)

missing_coord <- distinct_coord[distinct_coord$lon_lat %!in% combined_daily_temp_warmest_days_all$lon_lat,
    ]
missing_coord
missing_coord_row_numbers <- data.frame(row_n = which(distinct_coord$lon_lat %!in%
    combined_daily_temp_warmest_days_all$lon_lat))
missing_coord_row_numbers

###
check_dup <- group_by(combined_daily_temp_all, lon, lat, YEAR, DOY) %>%
    summarise(n = n())
loc_with_more_than_one <- filter(check_dup, n > 1)
loc_with_more_than_one <- mutate(loc_with_more_than_one, lon_lat = paste(lon, lat))
row_n_dup <- data.frame(row_n = which(distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat))
row_n_dup
dup_coord <- distinct_coord[distinct_coord$lon_lat %in% loc_with_more_than_one$lon_lat,
    ]
dup_coord

# Save the combined data
saveRDS(missing_coord, file = "RData/Biophysical_modelling/Arboreal/4C/missing_coordinates_4C.rds")
saveRDS(missing_coord_row_numbers, file = "RData/Biophysical_modelling/Arboreal/4C/missing_coordinates_row_n_4C.rds")
saveRDS(row_n_dup, file = "RData/Biophysical_modelling/Arboreal/4C/row_n_duplicated_coordinates_4C.rds")
saveRDS(dup_coord, file = "RData/Biophysical_modelling/Arboreal/4C/duplicated_coordinates_4C.rds")

Current climate

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Substrate/current/daily_temp_warmest_days_substrate.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

### Remove species that are paedomorphic as they live exclusively in water
pre_data_for_imputation <- readRDS("RData/General_data/pre_data_for_imputation.rds")
pre_data_for_imputation <- dplyr::select(pre_data_for_imputation, tip.label, strategy)
paedomorphic_species <- filter(pre_data_for_imputation, strategy == "Paedomorphic")

species_occurrence <- anti_join(species_occurrence, paedomorphic_species, by = "tip.label")

### Combine datasets
species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Substrate/current/species_daily_temp_warmest_days_substrate_current.rds")

Future climate (+2C)

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Substrate/2C/daily_temp_warmest_days_substrate_2C.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

### Remove species that are paedomorphic as they live exclusively in water
pre_data_for_imputation <- readRDS("RData/General_data/pre_data_for_imputation.rds")
pre_data_for_imputation <- dplyr::select(pre_data_for_imputation, tip.label, strategy)
paedomorphic_species <- filter(pre_data_for_imputation, strategy == "Paedomorphic")

species_occurrence <- anti_join(species_occurrence, paedomorphic_species, by = "tip.label")

### Combine datasets
species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Substrate/2C/species_daily_temp_warmest_days_substrate_future2C.rds")

Future climate (+4C)

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Substrate/4C/daily_temp_warmest_days_substrate_4C.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

### Remove species that are paedomorphic as they live exclusively in water
pre_data_for_imputation <- readRDS("RData/General_data/pre_data_for_imputation.rds")
pre_data_for_imputation <- dplyr::select(pre_data_for_imputation, tip.label, strategy)
paedomorphic_species <- filter(pre_data_for_imputation, strategy == "Paedomorphic")

species_occurrence <- anti_join(species_occurrence, paedomorphic_species, by = "tip.label")

### Combine datasets
species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Substrate/4C/species_daily_temp_warmest_days_substrate_future4C.rds")

Function to run meta-analytic models

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean or maximum weekly
# temperature

species_meta <- function(species_name, species_data, temp_species) {

    cat("Processing:", species_name, "\n")

    dat <- dplyr::filter(species_data, tip.label == species_name)
    dat2 <- dplyr::filter(temp_species, tip.label == species_name)

    # Fit a meta-analytic model
    fit <- metafor::rma(yi = CTmax, sei = se, mod = ~acclimation_temp, data = dat)

    int_slope <- coef(fit)
    se <- fit$se

    cat("Get model coefficients:\n")
    coefs <- data.frame(tip.label = dat$tip.label, intercept = coef(fit)[1], intercept_se = fit$se[1],
        slope = coef(fit)[2], slope_se = fit$se[2])
    print(head(coefs))

    prediction_mean <- predict(fit, newmods = dat2$mean_weekly_temp)
    prediction_max <- predict(fit, newmods = dat2$max_weekly_temp)

    cat("Generate predictions, mean temp:\n")
    print(head(prediction_mean))
    cat("Generate predictions, max temp:\n")
    print(head(prediction_max))

    daily_CTmax_substrate_mean_acc_current <- dplyr::select((cbind(dat2, cbind(predicted_CTmax = prediction_mean$pred,
        predicted_CTmax_se = prediction_mean$se))), -max_weekly_temp)
    daily_CTmax_substrate_max_acc_current <- dplyr::select((cbind(dat2, cbind(predicted_CTmax = prediction_max$pred,
        predicted_CTmax_se = prediction_max$se))), -mean_weekly_temp)

    return(list(coefs, daily_CTmax_substrate_mean_acc_current, daily_CTmax_substrate_max_acc_current))

}

Current climate

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Substrate/current/species_daily_temp_warmest_days_substrate_current.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

# Find common species between species_data and temp_species. This is needed
# because paedomorphic species were taken out from substrate temperature data
common_species <- intersect(unique(species_data$tip.label), unique(temp_species$tip.label))

# Filter both datasets to include only the matching species
species_data <- species_data %>%
    filter(tip.label %in% common_species)
temp_species <- temp_species %>%
    filter(tip.label %in% common_species)

saveRDS(temp_species, file = "RData/Biophysical_modelling/Substrate/current/species_daily_temp_warmest_days_substrate_current_adj.rds")

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_substrate_current_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_1 <- do.call(rbind, lapply(result_list_1,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_1, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_1st_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_1, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_1st_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_1, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_substrate_current_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_2 <- do.call(rbind, lapply(result_list_2,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_2, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_2nd_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_2, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_2nd_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_2, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_substrate_current_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_3 <- do.call(rbind, lapply(result_list_3,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_3, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_3rd_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_3, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_3rd_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_3, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_substrate_current_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_4 <- do.call(rbind, lapply(result_list_4,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_4, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_4th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_4, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_4th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_4, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_4th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[5]]
result_list_5 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_5 <- c(result_list_5, result_chunk)
}

species_ARR_substrate_current_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_5 <- do.call(rbind, lapply(result_list_5,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_5)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_5, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_5th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_5, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_5th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_5, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_5th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[6]]
result_list_6 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_6 <- c(result_list_6, result_chunk)
}

species_ARR_substrate_current_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_6 <- do.call(rbind, lapply(result_list_6,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_6)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_6, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_6th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_6, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_6th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_6, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_6th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[7]]
result_list_7 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_7 <- c(result_list_7, result_chunk)
}

species_ARR_substrate_current_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_7 <- do.call(rbind, lapply(result_list_7,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_7)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_7, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_7th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_7, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_7th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_7, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_7th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[8]]
result_list_8 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_8 <- c(result_list_8, result_chunk)
}

species_ARR_substrate_current_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_8 <- do.call(rbind, lapply(result_list_8,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_8)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_8, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_8th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_8, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_8th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_8, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_8th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[9]]
result_list_9 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_9 <- c(result_list_9, result_chunk)
}

species_ARR_substrate_current_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_9 <- do.call(rbind, lapply(result_list_9,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_9)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_9, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_9th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_9, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_9th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_9, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_9th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[10]]
result_list_10 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_10 <- c(result_list_10, result_chunk)
}

species_ARR_substrate_current_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_current_10 <- do.call(rbind, lapply(result_list_10,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_current_10 <- do.call(rbind, lapply(result_list_10,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_10)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_current_10, file = "RData/Climate_vulnerability/Substrate/current/temp_files_ARR/species_ARR_substrate_current_10th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current_10, file = "RData/Climate_vulnerability/Substrate/current/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_current_10th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_current_10, file = "RData/Climate_vulnerability/Substrate/current/temp_files_max_acc/daily_CTmax_substrate_max_acc_current_10th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save

species_ARR_substrate_current <- distinct(rbind(species_ARR_substrate_current_1,
    species_ARR_substrate_current_2, species_ARR_substrate_current_3, species_ARR_substrate_current_4,
    species_ARR_substrate_current_5, species_ARR_substrate_current_6, species_ARR_substrate_current_7,
    species_ARR_substrate_current_8, species_ARR_substrate_current_9, species_ARR_substrate_current_10))

daily_CTmax_substrate_mean_acc_current <- rbind(daily_CTmax_substrate_mean_acc_current_1,
    daily_CTmax_substrate_mean_acc_current_2, daily_CTmax_substrate_mean_acc_current_3,
    daily_CTmax_substrate_mean_acc_current_4, daily_CTmax_substrate_mean_acc_current_5,
    daily_CTmax_substrate_mean_acc_current_6, daily_CTmax_substrate_mean_acc_current_7,
    daily_CTmax_substrate_mean_acc_current_8, daily_CTmax_substrate_mean_acc_current_9,
    daily_CTmax_substrate_mean_acc_current_10)

daily_CTmax_substrate_max_acc_current <- rbind(daily_CTmax_substrate_max_acc_current_1,
    daily_CTmax_substrate_max_acc_current_2, daily_CTmax_substrate_max_acc_current_3,
    daily_CTmax_substrate_max_acc_current_4, daily_CTmax_substrate_max_acc_current_5,
    daily_CTmax_substrate_max_acc_current_6, daily_CTmax_substrate_max_acc_current_7,
    daily_CTmax_substrate_max_acc_current_8, daily_CTmax_substrate_max_acc_current_9,
    daily_CTmax_substrate_max_acc_current_10)


saveRDS(species_ARR_substrate_current, file = "RData/Climate_vulnerability/Substrate/current/species_ARR_substrate_current.rds")
saveRDS(daily_CTmax_substrate_mean_acc_current, file = "RData/Climate_vulnerability/Substrate/current/daily_CTmax_substrate_mean_acc_current.rds")
saveRDS(daily_CTmax_substrate_max_acc_current, file = "RData/Climate_vulnerability/Substrate/current/daily_CTmax_substrate_max_acc_current.rds")

Future climate (+2C)

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Substrate/2C/species_daily_temp_warmest_days_substrate_future2C.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

# Find common species between species_data and temp_species. This is needed
# because paedomorphic species were taken out from substrate temperature data
common_species <- intersect(unique(species_data$tip.label), unique(temp_species$tip.label))

# Filter both datasets to include only the matching species
species_data <- species_data %>%
    filter(tip.label %in% common_species)
temp_species <- temp_species %>%
    filter(tip.label %in% common_species)

saveRDS(temp_species, file = "RData/Biophysical_modelling/Substrate/2C/species_daily_temp_warmest_days_substrate_future2C_adj.rds")

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_substrate_future2C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_1 <- do.call(rbind, lapply(result_list_1,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_1 <- do.call(rbind, lapply(result_list_1,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_1, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_1st_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_1, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_1st_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_1, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_substrate_future2C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_2 <- do.call(rbind, lapply(result_list_2,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_2 <- do.call(rbind, lapply(result_list_2,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_2, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_2nd_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_2, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_2nd_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_2, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_substrate_future2C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_3 <- do.call(rbind, lapply(result_list_3,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_3 <- do.call(rbind, lapply(result_list_3,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_3, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_3rd_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_3, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_3rd_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_3, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_substrate_future2C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_4 <- do.call(rbind, lapply(result_list_4,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_4 <- do.call(rbind, lapply(result_list_4,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_4, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_4th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_4, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_4th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_4, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_4th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[5]]
result_list_5 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_5 <- c(result_list_5, result_chunk)
}

species_ARR_substrate_future2C_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_5 <- do.call(rbind, lapply(result_list_5,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_5 <- do.call(rbind, lapply(result_list_5,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_5)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_5, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_5th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_5, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_5th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_5, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_5th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[6]]
result_list_6 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_6 <- c(result_list_6, result_chunk)
}

species_ARR_substrate_future2C_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_6 <- do.call(rbind, lapply(result_list_6,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_6 <- do.call(rbind, lapply(result_list_6,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_6)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_6, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_6th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_6, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_6th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_6, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_6th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[7]]
result_list_7 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_7 <- c(result_list_7, result_chunk)
}

species_ARR_substrate_future2C_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_7 <- do.call(rbind, lapply(result_list_7,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_7 <- do.call(rbind, lapply(result_list_7,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_7)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_7, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_7th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_7, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_7th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_7, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_7th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[8]]
result_list_8 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_8 <- c(result_list_8, result_chunk)
}

species_ARR_substrate_future2C_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_8 <- do.call(rbind, lapply(result_list_8,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_8 <- do.call(rbind, lapply(result_list_8,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_8)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_8, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_8th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_8, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_8th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_8, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_8th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[9]]
result_list_9 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_9 <- c(result_list_9, result_chunk)
}

species_ARR_substrate_future2C_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_9 <- do.call(rbind, lapply(result_list_9,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_9 <- do.call(rbind, lapply(result_list_9,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_9)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_9, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_9th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_9, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_9th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_9, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_9th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[10]]
result_list_10 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_10 <- c(result_list_10, result_chunk)
}

species_ARR_substrate_future2C_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future2C_10 <- do.call(rbind, lapply(result_list_10,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future2C_10 <- do.call(rbind, lapply(result_list_10,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_10)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future2C_10, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_ARR/species_ARR_substrate_future2C_10th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C_10, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future2C_10th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C_10, file = "RData/Climate_vulnerability/Substrate/future2C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future2C_10th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save
species_ARR_substrate_future2C <- distinct(rbind(species_ARR_substrate_future2C_1,
    species_ARR_substrate_future2C_2, species_ARR_substrate_future2C_3, species_ARR_substrate_future2C_4,
    species_ARR_substrate_future2C_5, species_ARR_substrate_future2C_6, species_ARR_substrate_future2C_7,
    species_ARR_substrate_future2C_8, species_ARR_substrate_future2C_9, species_ARR_substrate_future2C_10))

daily_CTmax_substrate_mean_acc_future2C <- rbind(daily_CTmax_substrate_mean_acc_future2C_1,
    daily_CTmax_substrate_mean_acc_future2C_2, daily_CTmax_substrate_mean_acc_future2C_3,
    daily_CTmax_substrate_mean_acc_future2C_4, daily_CTmax_substrate_mean_acc_future2C_5,
    daily_CTmax_substrate_mean_acc_future2C_6, daily_CTmax_substrate_mean_acc_future2C_7,
    daily_CTmax_substrate_mean_acc_future2C_8, daily_CTmax_substrate_mean_acc_future2C_9,
    daily_CTmax_substrate_mean_acc_future2C_10)

daily_CTmax_substrate_max_acc_future2C <- rbind(daily_CTmax_substrate_max_acc_future2C_1,
    daily_CTmax_substrate_max_acc_future2C_2, daily_CTmax_substrate_max_acc_future2C_3,
    daily_CTmax_substrate_max_acc_future2C_4, daily_CTmax_substrate_max_acc_future2C_5,
    daily_CTmax_substrate_max_acc_future2C_6, daily_CTmax_substrate_max_acc_future2C_7,
    daily_CTmax_substrate_max_acc_future2C_8, daily_CTmax_substrate_max_acc_future2C_9,
    daily_CTmax_substrate_max_acc_future2C_10)


saveRDS(species_ARR_substrate_future2C, file = "RData/Climate_vulnerability/Substrate/future2C/species_ARR_substrate_future2C.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future2C, file = "RData/Climate_vulnerability/Substrate/future2C/daily_CTmax_substrate_mean_acc_future2C.rds")
saveRDS(daily_CTmax_substrate_max_acc_future2C, file = "RData/Climate_vulnerability/Substrate/future2C/daily_CTmax_substrate_max_acc_future2C.rds")

Future climate (+4C)

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Substrate/4C/species_daily_temp_warmest_days_substrate_future4C.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

# Find common species between species_data and temp_species. This is needed
# because paedomorphic species were taken out from substrate temperature data
common_species <- intersect(unique(species_data$tip.label), unique(temp_species$tip.label))

# Filter both datasets to include only the matching species
species_data <- species_data %>%
    filter(tip.label %in% common_species)
temp_species <- temp_species %>%
    filter(tip.label %in% common_species)

saveRDS(temp_species, file = "RData/Biophysical_modelling/Substrate/4C/species_daily_temp_warmest_days_substrate_future4C_adj.rds")

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_substrate_future4C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_1 <- do.call(rbind, lapply(result_list_1,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_1 <- do.call(rbind, lapply(result_list_1,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_1, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_1st_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_1, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_1st_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_1, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_substrate_future4C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_2 <- do.call(rbind, lapply(result_list_2,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_2 <- do.call(rbind, lapply(result_list_2,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_2, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_2nd_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_2, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_2nd_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_2, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_substrate_future4C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_3 <- do.call(rbind, lapply(result_list_3,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_3 <- do.call(rbind, lapply(result_list_3,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_3, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_3rd_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_3, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_3rd_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_3, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_substrate_future4C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_4 <- do.call(rbind, lapply(result_list_4,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_4 <- do.call(rbind, lapply(result_list_4,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_4, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_4th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_4, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_4th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_4, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_4th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[5]]
result_list_5 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_5 <- c(result_list_5, result_chunk)
}

species_ARR_substrate_future4C_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_5 <- do.call(rbind, lapply(result_list_5,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_5 <- do.call(rbind, lapply(result_list_5,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_5)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_5, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_5th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_5, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_5th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_5, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_5th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[6]]
result_list_6 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_6 <- c(result_list_6, result_chunk)
}

species_ARR_substrate_future4C_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_6 <- do.call(rbind, lapply(result_list_6,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_6 <- do.call(rbind, lapply(result_list_6,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_6)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_6, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_6th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_6, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_6th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_6, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_6th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[7]]
result_list_7 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_7 <- c(result_list_7, result_chunk)
}

species_ARR_substrate_future4C_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_7 <- do.call(rbind, lapply(result_list_7,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_7 <- do.call(rbind, lapply(result_list_7,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_7)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_7, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_7th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_7, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_7th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_7, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_7th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[8]]
result_list_8 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_8 <- c(result_list_8, result_chunk)
}

species_ARR_substrate_future4C_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_8 <- do.call(rbind, lapply(result_list_8,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_8 <- do.call(rbind, lapply(result_list_8,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_8)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_8, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_8th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_8, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_8th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_8, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_8th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[9]]
result_list_9 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_9 <- c(result_list_9, result_chunk)
}

species_ARR_substrate_future4C_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_9 <- do.call(rbind, lapply(result_list_9,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_9 <- do.call(rbind, lapply(result_list_9,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_9)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_9, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_9th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_9, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_9th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_9, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_9th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[10]]
result_list_10 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_10 <- c(result_list_10, result_chunk)
}

species_ARR_substrate_future4C_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[1]]))
daily_CTmax_substrate_mean_acc_future4C_10 <- do.call(rbind, lapply(result_list_10,
    function(x) x[[2]]))
daily_CTmax_substrate_max_acc_future4C_10 <- do.call(rbind, lapply(result_list_10,
    function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_10)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_substrate_future4C_10, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_ARR/species_ARR_substrate_future4C_10th_chunk.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C_10, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_mean_acc/daily_CTmax_substrate_mean_acc_future4C_10th_chunk.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C_10, file = "RData/Climate_vulnerability/Substrate/future4C/temp_files_max_acc/daily_CTmax_substrate_max_acc_future4C_10th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save

species_ARR_substrate_future4C <- distinct(rbind(species_ARR_substrate_future4C_1,
    species_ARR_substrate_future4C_2, species_ARR_substrate_future4C_3, species_ARR_substrate_future4C_4,
    species_ARR_substrate_future4C_5, species_ARR_substrate_future4C_6, species_ARR_substrate_future4C_7,
    species_ARR_substrate_future4C_8, species_ARR_substrate_future4C_9, species_ARR_substrate_future4C_10))

daily_CTmax_substrate_mean_acc_future4C <- rbind(daily_CTmax_substrate_mean_acc_future4C_1,
    daily_CTmax_substrate_mean_acc_future4C_2, daily_CTmax_substrate_mean_acc_future4C_3,
    daily_CTmax_substrate_mean_acc_future4C_4, daily_CTmax_substrate_mean_acc_future4C_5,
    daily_CTmax_substrate_mean_acc_future4C_6, daily_CTmax_substrate_mean_acc_future4C_7,
    daily_CTmax_substrate_mean_acc_future4C_8, daily_CTmax_substrate_mean_acc_future4C_9,
    daily_CTmax_substrate_mean_acc_future4C_10)

daily_CTmax_substrate_max_acc_future4C <- rbind(daily_CTmax_substrate_max_acc_future4C_1,
    daily_CTmax_substrate_max_acc_future4C_2, daily_CTmax_substrate_max_acc_future4C_3,
    daily_CTmax_substrate_max_acc_future4C_4, daily_CTmax_substrate_max_acc_future4C_5,
    daily_CTmax_substrate_max_acc_future4C_6, daily_CTmax_substrate_max_acc_future4C_7,
    daily_CTmax_substrate_max_acc_future4C_8, daily_CTmax_substrate_max_acc_future4C_9,
    daily_CTmax_substrate_max_acc_future4C_10)


saveRDS(species_ARR_substrate_future4C, file = "RData/Climate_vulnerability/Substrate/future4C/species_ARR_substrate_future4C.rds")
saveRDS(daily_CTmax_substrate_mean_acc_future4C, file = "RData/Climate_vulnerability/Substrate/future4C/daily_CTmax_substrate_mean_acc_future4C.rds")
saveRDS(daily_CTmax_substrate_max_acc_future4C, file = "RData/Climate_vulnerability/Substrate/future4C/daily_CTmax_substrate_max_acc_future4C.rds")

Current climate

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Pond/current/daily_temp_warmest_days_pond.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Pond/current/species_daily_temp_warmest_days_pond_current.rds")

Future climate (+2C)

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Pond/2C/daily_temp_warmest_days_pond_2C.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Pond/2C/species_daily_temp_warmest_days_pond_future2C.rds")

Future climate (+4C)

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Pond/4C/daily_temp_warmest_days_pond_4C.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted.rds")

species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Pond/4C/species_daily_temp_warmest_days_pond_future4C.rds")

Function to run meta-analytic models

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean or maximum weekly
# temperature

species_meta <- function(species_name, species_data, temp_species) {

    cat("Processing:", species_name, "\n")

    dat <- dplyr::filter(species_data, tip.label == species_name)
    dat2 <- dplyr::filter(temp_species, tip.label == species_name)

    # Fit a meta-analytic model
    fit <- metafor::rma(yi = CTmax, sei = se, mod = ~acclimation_temp, data = dat)

    int_slope <- coef(fit)
    se <- fit$se

    cat("Get model coefficients:\n")
    coefs <- data.frame(tip.label = dat$tip.label, intercept = coef(fit)[1], intercept_se = fit$se[1],
        slope = coef(fit)[2], slope_se = fit$se[2])
    print(head(coefs))

    prediction_mean <- predict(fit, newmods = dat2$mean_weekly_temp)
    prediction_max <- predict(fit, newmods = dat2$max_weekly_temp)

    cat("Generate predictions, mean temp:\n")
    print(head(prediction_mean))
    cat("Generate predictions, max temp:\n")
    print(head(prediction_max))

    daily_CTmax_pond_mean_acc_current <- dplyr::select((cbind(dat2, cbind(predicted_CTmax = prediction_mean$pred,
        predicted_CTmax_se = prediction_mean$se))), -max_weekly_temp)
    daily_CTmax_pond_max_acc_current <- dplyr::select((cbind(dat2, cbind(predicted_CTmax = prediction_max$pred,
        predicted_CTmax_se = prediction_max$se))), -mean_weekly_temp)

    return(list(coefs, daily_CTmax_pond_mean_acc_current, daily_CTmax_pond_max_acc_current))

}

Current climate

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Pond/current/species_daily_temp_warmest_days_pond_current.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

saveRDS(temp_species, file = "RData/Biophysical_modelling/Pond/current/species_daily_temp_warmest_days_pond_current_adj.rds")

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_pond_current_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_1, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_1st_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_1, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_1st_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_1, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_pond_current_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_2, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_2nd_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_2, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_2nd_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_2, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_pond_current_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_3, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_3rd_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_3, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_3rd_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_3, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_pond_current_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_4, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_4th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_4, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_4th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_4, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_4th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[5]]
result_list_5 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_5 <- c(result_list_5, result_chunk)
}

species_ARR_pond_current_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_5)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_5, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_5th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_5, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_5th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_5, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_5th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[6]]
result_list_6 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_6 <- c(result_list_6, result_chunk)
}

species_ARR_pond_current_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_6)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_6, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_6th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_6, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_6th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_6, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_6th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[7]]
result_list_7 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_7 <- c(result_list_7, result_chunk)
}

species_ARR_pond_current_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_7)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_7, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_7th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_7, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_7th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_7, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_7th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[8]]
result_list_8 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_8 <- c(result_list_8, result_chunk)
}

species_ARR_pond_current_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_8)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_8, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_8th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_8, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_8th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_8, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_8th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[9]]
result_list_9 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_9 <- c(result_list_9, result_chunk)
}

species_ARR_pond_current_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_9)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_9, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_9th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_9, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_9th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_9, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_9th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[10]]
result_list_10 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_10 <- c(result_list_10, result_chunk)
}

species_ARR_pond_current_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_current_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[2]]))
daily_CTmax_pond_max_acc_current_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_10)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_current_10, file = "RData/Climate_vulnerability/Pond/current/temp_files_ARR/species_ARR_pond_current_10th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_current_10, file = "RData/Climate_vulnerability/Pond/current/temp_files_mean_acc/daily_CTmax_pond_mean_acc_current_10th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_current_10, file = "RData/Climate_vulnerability/Pond/current/temp_files_max_acc/daily_CTmax_pond_max_acc_current_10th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save
species_ARR_pond_current <- distinct(rbind(species_ARR_pond_current_1, species_ARR_pond_current_2,
    species_ARR_pond_current_3, species_ARR_pond_current_4, species_ARR_pond_current_5,
    species_ARR_pond_current_6, species_ARR_pond_current_7, species_ARR_pond_current_8,
    species_ARR_pond_current_9, species_ARR_pond_current_10))

daily_CTmax_pond_mean_acc_current <- rbind(daily_CTmax_pond_mean_acc_current_1, daily_CTmax_pond_mean_acc_current_2,
    daily_CTmax_pond_mean_acc_current_3, daily_CTmax_pond_mean_acc_current_4, daily_CTmax_pond_mean_acc_current_5,
    daily_CTmax_pond_mean_acc_current_6, daily_CTmax_pond_mean_acc_current_7, daily_CTmax_pond_mean_acc_current_8,
    daily_CTmax_pond_mean_acc_current_9, daily_CTmax_pond_mean_acc_current_10)

daily_CTmax_pond_max_acc_current <- rbind(daily_CTmax_pond_max_acc_current_1, daily_CTmax_pond_max_acc_current_2,
    daily_CTmax_pond_max_acc_current_3, daily_CTmax_pond_max_acc_current_4, daily_CTmax_pond_max_acc_current_5,
    daily_CTmax_pond_max_acc_current_6, daily_CTmax_pond_max_acc_current_7, daily_CTmax_pond_max_acc_current_8,
    daily_CTmax_pond_max_acc_current_9, daily_CTmax_pond_max_acc_current_10)


saveRDS(species_ARR_pond_current, file = "RData/Climate_vulnerability/Pond/current/species_ARR_pond_current.rds")
saveRDS(daily_CTmax_pond_mean_acc_current, file = "RData/Climate_vulnerability/Pond/current/daily_CTmax_pond_mean_acc_current.rds")
saveRDS(daily_CTmax_pond_max_acc_current, file = "RData/Climate_vulnerability/Pond/current/daily_CTmax_pond_max_acc_current.rds")

Future climate (+2C)

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Pond/2C/species_daily_temp_warmest_days_pond_future2C.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

saveRDS(temp_species, file = "RData/Biophysical_modelling/Pond/2C/species_daily_temp_warmest_days_pond_future2C_adj.rds")

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_pond_future2C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_1, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_1st_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_1, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_1st_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_1, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_pond_future2C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_2, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_2nd_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_2, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_2nd_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_2, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_pond_future2C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_3, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_3rd_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_3, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_3rd_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_3, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_pond_future2C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_4, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_4th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_4, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_4th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_4, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_4th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[5]]
result_list_5 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_5 <- c(result_list_5, result_chunk)
}

species_ARR_pond_future2C_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_5)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_5, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_5th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_5, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_5th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_5, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_5th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[6]]
result_list_6 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_6 <- c(result_list_6, result_chunk)
}

species_ARR_pond_future2C_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_6)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_6, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_6th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_6, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_6th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_6, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_6th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[7]]
result_list_7 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_7 <- c(result_list_7, result_chunk)
}

species_ARR_pond_future2C_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_7)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_7, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_7th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_7, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_7th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_7, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_7th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[8]]
result_list_8 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_8 <- c(result_list_8, result_chunk)
}

species_ARR_pond_future2C_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_8)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_8, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_8th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_8, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_8th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_8, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_8th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[9]]
result_list_9 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_9 <- c(result_list_9, result_chunk)
}

species_ARR_pond_future2C_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_9)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_9, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_9th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_9, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_9th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_9, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_9th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[10]]
result_list_10 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_10 <- c(result_list_10, result_chunk)
}

species_ARR_pond_future2C_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future2C_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future2C_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_10)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future2C_10, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_ARR/species_ARR_pond_future2C_10th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C_10, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future2C_10th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C_10, file = "RData/Climate_vulnerability/Pond/future2C/temp_files_max_acc/daily_CTmax_pond_max_acc_future2C_10th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save

species_ARR_pond_future2C <- distinct(rbind(species_ARR_pond_future2C_1, species_ARR_pond_future2C_2,
    species_ARR_pond_future2C_3, species_ARR_pond_future2C_4, species_ARR_pond_future2C_5,
    species_ARR_pond_future2C_6, species_ARR_pond_future2C_7, species_ARR_pond_future2C_8,
    species_ARR_pond_future2C_9, species_ARR_pond_future2C_10))

daily_CTmax_pond_mean_acc_future2C <- rbind(daily_CTmax_pond_mean_acc_future2C_1,
    daily_CTmax_pond_mean_acc_future2C_2, daily_CTmax_pond_mean_acc_future2C_3, daily_CTmax_pond_mean_acc_future2C_4,
    daily_CTmax_pond_mean_acc_future2C_5, daily_CTmax_pond_mean_acc_future2C_6, daily_CTmax_pond_mean_acc_future2C_7,
    daily_CTmax_pond_mean_acc_future2C_8, daily_CTmax_pond_mean_acc_future2C_9, daily_CTmax_pond_mean_acc_future2C_10)

daily_CTmax_pond_max_acc_future2C <- rbind(daily_CTmax_pond_max_acc_future2C_1, daily_CTmax_pond_max_acc_future2C_2,
    daily_CTmax_pond_max_acc_future2C_3, daily_CTmax_pond_max_acc_future2C_4, daily_CTmax_pond_max_acc_future2C_5,
    daily_CTmax_pond_max_acc_future2C_6, daily_CTmax_pond_max_acc_future2C_7, daily_CTmax_pond_max_acc_future2C_8,
    daily_CTmax_pond_max_acc_future2C_9, daily_CTmax_pond_max_acc_future2C_10)


saveRDS(species_ARR_pond_future2C, file = "RData/Climate_vulnerability/Pond/future2C/species_ARR_pond_future2C.rds")
saveRDS(daily_CTmax_pond_mean_acc_future2C, file = "RData/Climate_vulnerability/Pond/future2C/daily_CTmax_pond_mean_acc_future2C.rds")
saveRDS(daily_CTmax_pond_max_acc_future2C, file = "RData/Climate_vulnerability/Pond/future2C/daily_CTmax_pond_max_acc_future2C.rds")

Future climate (+4C)

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Pond/4C/species_daily_temp_warmest_days_pond_future4C.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

saveRDS(temp_species, file = "RData/Biophysical_modelling/Pond/4C/species_daily_temp_warmest_days_pond_future4C_adj.rds")

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_pond_future4C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_1, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_1st_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_1, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_1st_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_1, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_pond_future4C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_2, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_2nd_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_2, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_2nd_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_2, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_pond_future4C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_3, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_3rd_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_3, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_3rd_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_3, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_pond_future4C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_4, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_4th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_4, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_4th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_4, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_4th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[5]]
result_list_5 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_5 <- c(result_list_5, result_chunk)
}

species_ARR_pond_future4C_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_5 <- do.call(rbind, lapply(result_list_5, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_5)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_5, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_5th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_5, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_5th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_5, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_5th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[6]]
result_list_6 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_6 <- c(result_list_6, result_chunk)
}

species_ARR_pond_future4C_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_6 <- do.call(rbind, lapply(result_list_6, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_6)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_6, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_6th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_6, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_6th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_6, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_6th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[7]]
result_list_7 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_7 <- c(result_list_7, result_chunk)
}

species_ARR_pond_future4C_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_7 <- do.call(rbind, lapply(result_list_7, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_7)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_7, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_7th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_7, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_7th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_7, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_7th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[8]]
result_list_8 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_8 <- c(result_list_8, result_chunk)
}

species_ARR_pond_future4C_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_8 <- do.call(rbind, lapply(result_list_8, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_8)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_8, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_8th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_8, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_8th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_8, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_8th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[9]]
result_list_9 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_9 <- c(result_list_9, result_chunk)
}

species_ARR_pond_future4C_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_9 <- do.call(rbind, lapply(result_list_9, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_9)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_9, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_9th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_9, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_9th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_9, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_9th_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[10]]
result_list_10 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_10 <- c(result_list_10, result_chunk)
}

species_ARR_pond_future4C_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[1]]))
daily_CTmax_pond_mean_acc_future4C_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[2]]))
daily_CTmax_pond_max_acc_future4C_10 <- do.call(rbind, lapply(result_list_10, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_10)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_pond_future4C_10, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_ARR/species_ARR_pond_future4C_10th_chunk.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C_10, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_mean_acc/daily_CTmax_pond_mean_acc_future4C_10th_chunk.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C_10, file = "RData/Climate_vulnerability/Pond/future4C/temp_files_max_acc/daily_CTmax_pond_max_acc_future4C_10th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save
species_ARR_pond_future4C <- distinct(rbind(species_ARR_pond_future4C_1, species_ARR_pond_future4C_2,
    species_ARR_pond_future4C_3, species_ARR_pond_future4C_4, species_ARR_pond_future4C_5,
    species_ARR_pond_future4C_6, species_ARR_pond_future4C_7, species_ARR_pond_future4C_8,
    species_ARR_pond_future4C_9, species_ARR_pond_future4C_10))

daily_CTmax_pond_mean_acc_future4C <- rbind(daily_CTmax_pond_mean_acc_future4C_1,
    daily_CTmax_pond_mean_acc_future4C_2, daily_CTmax_pond_mean_acc_future4C_3, daily_CTmax_pond_mean_acc_future4C_4,
    daily_CTmax_pond_mean_acc_future4C_5, daily_CTmax_pond_mean_acc_future4C_6, daily_CTmax_pond_mean_acc_future4C_7,
    daily_CTmax_pond_mean_acc_future4C_8, daily_CTmax_pond_mean_acc_future4C_9, daily_CTmax_pond_mean_acc_future4C_10)

daily_CTmax_pond_max_acc_future4C <- rbind(daily_CTmax_pond_max_acc_future4C_1, daily_CTmax_pond_max_acc_future4C_2,
    daily_CTmax_pond_max_acc_future4C_3, daily_CTmax_pond_max_acc_future4C_4, daily_CTmax_pond_max_acc_future4C_5,
    daily_CTmax_pond_max_acc_future4C_6, daily_CTmax_pond_max_acc_future4C_7, daily_CTmax_pond_max_acc_future4C_8,
    daily_CTmax_pond_max_acc_future4C_9, daily_CTmax_pond_max_acc_future4C_10)


saveRDS(species_ARR_pond_future4C, file = "RData/Climate_vulnerability/Pond/future4C/species_ARR_pond_future4C.rds")
saveRDS(daily_CTmax_pond_mean_acc_future4C, file = "RData/Climate_vulnerability/Pond/future4C/daily_CTmax_pond_mean_acc_future4C.rds")
saveRDS(daily_CTmax_pond_max_acc_future4C, file = "RData/Climate_vulnerability/Pond/future4C/daily_CTmax_pond_max_acc_future4C.rds")

Current climate

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Arboreal/current/daily_temp_warmest_days_arboreal.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted_arboreal.rds")

species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Arboreal/current/species_daily_temp_warmest_days_arboreal_current.rds")

Future climate (+2C)

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Arboreal/2C/daily_temp_warmest_days_arboreal_2C.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted_arboreal.rds")

species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Arboreal/2C/species_daily_temp_warmest_days_arboreal_future2C.rds")

Future climate (+4C)

### Daily temperature of the warmest days
daily_temp_warmest_days <- readRDS("RData/Biophysical_modelling/Arboreal/4C/daily_temp_warmest_days_arboreal_4C.rds")

species_occurrence <- readRDS(file = "RData/General_data/species_coordinates_adjusted_arboreal.rds")

species_temp_warmest_days <- merge(daily_temp_warmest_days, species_occurrence, by = c("lon",
    "lat"))

saveRDS(species_temp_warmest_days, file = "RData/Biophysical_modelling/Arboreal/4C/species_daily_temp_warmest_days_arboreal_future4C.rds")

Function to run meta-analytic models

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean or maximum weekly
# temperature

## Create function
species_meta <- function(species_name, species_data, temp_species) {

    cat("Processing:", species_name, "\n")

    dat <- dplyr::filter(species_data, tip.label == species_name)
    dat2 <- dplyr::filter(temp_species, tip.label == species_name)

    # Fit a meta-analytic model
    fit <- metafor::rma(yi = CTmax, sei = se, mod = ~acclimation_temp, data = dat)

    int_slope <- coef(fit)
    se <- fit$se

    cat("Get model coefficients:\n")
    coefs <- data.frame(tip.label = dat$tip.label, intercept = coef(fit)[1], intercept_se = fit$se[1],
        slope = coef(fit)[2], slope_se = fit$se[2])
    print(head(coefs))

    prediction_mean <- predict(fit, newmods = dat2$mean_weekly_temp)
    prediction_max <- predict(fit, newmods = dat2$max_weekly_temp)

    cat("Generate predictions, mean temp:\n")
    print(head(prediction_mean))
    cat("Generate predictions, max temp:\n")
    print(head(prediction_max))

    daily_CTmax_arboreal_mean_acc_current <- dplyr::select((cbind(dat2, cbind(predicted_CTmax = prediction_mean$pred,
        predicted_CTmax_se = prediction_mean$se))), -max_weekly_temp)
    daily_CTmax_arboreal_max_acc_current <- dplyr::select((cbind(dat2, cbind(predicted_CTmax = prediction_max$pred,
        predicted_CTmax_se = prediction_max$se))), -mean_weekly_temp)

    return(list(coefs, daily_CTmax_arboreal_mean_acc_current, daily_CTmax_arboreal_max_acc_current))

}

Current climate

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Arboreal/current/species_daily_temp_warmest_days_arboreal_current.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

saveRDS(temp_species, file = "RData/Biophysical_modelling/Arboreal/current/species_daily_temp_warmest_days_arboreal_current_adj.rds")

species_data <- filter(species_data, tip.label %in% temp_species$tip.label)

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_arboreal_current_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_current_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_current_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_current_1, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_ARR/species_ARR_arboreal_current_1st_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_current_1, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_current_1st_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_current_1, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_max_acc/daily_CTmax_arboreal_max_acc_current_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_arboreal_current_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_current_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_current_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_current_2, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_ARR/species_ARR_arboreal_current_2nd_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_current_2, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_current_2nd_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_current_2, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_max_acc/daily_CTmax_arboreal_max_acc_current_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_arboreal_current_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_current_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_current_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_current_3, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_ARR/species_ARR_arboreal_current_3rd_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_current_3, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_current_3rd_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_current_3, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_max_acc/daily_CTmax_arboreal_max_acc_current_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_arboreal_current_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_current_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_current_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_current_4, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_ARR/species_ARR_arboreal_current_4th_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_current_4, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_current_4th_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_current_4, file = "RData/Climate_vulnerability/Arboreal/current/temp_files_max_acc/daily_CTmax_arboreal_max_acc_current_4th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save
species_ARR_arboreal_current <- distinct(rbind(species_ARR_arboreal_current_1, species_ARR_arboreal_current_2,
    species_ARR_arboreal_current_3, species_ARR_arboreal_current_4))

daily_CTmax_arboreal_mean_acc_current <- rbind(daily_CTmax_arboreal_mean_acc_current_1,
    daily_CTmax_arboreal_mean_acc_current_2, daily_CTmax_arboreal_mean_acc_current_3,
    daily_CTmax_arboreal_mean_acc_current_4)

daily_CTmax_arboreal_max_acc_current <- rbind(daily_CTmax_arboreal_max_acc_current_1,
    daily_CTmax_arboreal_max_acc_current_2, daily_CTmax_arboreal_max_acc_current_3,
    daily_CTmax_arboreal_max_acc_current_4)


saveRDS(species_ARR_arboreal_current, file = "RData/Climate_vulnerability/Arboreal/current/species_ARR_arboreal_current.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_current, file = "RData/Climate_vulnerability/Arboreal/current/daily_CTmax_arboreal_mean_acc_current.rds")
saveRDS(daily_CTmax_arboreal_max_acc_current, file = "RData/Climate_vulnerability/Arboreal/current/daily_CTmax_arboreal_max_acc_current.rds")

Future climate (+2C)

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Arboreal/2C/species_daily_temp_warmest_days_arboreal_future2C.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

saveRDS(temp_species, file = "RData/Biophysical_modelling/Arboreal/2C/species_daily_temp_warmest_days_arboreal_future2C_adj.rds")

species_data <- filter(species_data, tip.label %in% temp_species$tip.label)

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_arboreal_future2C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_future2C_1 <- do.call(rbind, lapply(result_list_1,
    function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_future2C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_future2C_1, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_ARR/species_ARR_arboreal_future2C_1st_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future2C_1, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_future2C_1st_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future2C_1, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_max_acc/daily_CTmax_arboreal_max_acc_future2C_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_arboreal_future2C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_future2C_2 <- do.call(rbind, lapply(result_list_2,
    function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_future2C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_future2C_2, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_ARR/species_ARR_arboreal_future2C_2nd_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future2C_2, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_future2C_2nd_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future2C_2, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_max_acc/daily_CTmax_arboreal_max_acc_future2C_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_arboreal_future2C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_future2C_3 <- do.call(rbind, lapply(result_list_3,
    function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_future2C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_future2C_3, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_ARR/species_ARR_arboreal_future2C_3rd_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future2C_3, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_future2C_3rd_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future2C_3, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_max_acc/daily_CTmax_arboreal_max_acc_future2C_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_arboreal_future2C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_future2C_4 <- do.call(rbind, lapply(result_list_4,
    function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_future2C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_future2C_4, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_ARR/species_ARR_arboreal_future2C_4th_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future2C_4, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_future2C_4th_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future2C_4, file = "RData/Climate_vulnerability/Arboreal/future2C/temp_files_max_acc/daily_CTmax_arboreal_max_acc_future2C_4th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save
species_ARR_arboreal_future2C <- distinct(rbind(species_ARR_arboreal_future2C_1,
    species_ARR_arboreal_future2C_2, species_ARR_arboreal_future2C_3, species_ARR_arboreal_future2C_4))

daily_CTmax_arboreal_mean_acc_future2C <- rbind(daily_CTmax_arboreal_mean_acc_future2C_1,
    daily_CTmax_arboreal_mean_acc_future2C_2, daily_CTmax_arboreal_mean_acc_future2C_3,
    daily_CTmax_arboreal_mean_acc_future2C_4)

daily_CTmax_arboreal_max_acc_future2C <- rbind(daily_CTmax_arboreal_max_acc_future2C_1,
    daily_CTmax_arboreal_max_acc_future2C_2, daily_CTmax_arboreal_max_acc_future2C_3,
    daily_CTmax_arboreal_max_acc_future2C_4)


saveRDS(species_ARR_arboreal_future2C, file = "RData/Climate_vulnerability/Arboreal/future2C/species_ARR_arboreal_future2C.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future2C, file = "RData/Climate_vulnerability/Arboreal/future2C/daily_CTmax_arboreal_mean_acc_future2C.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future2C, file = "RData/Climate_vulnerability/Arboreal/future2C/daily_CTmax_arboreal_max_acc_future2C.rds")

Future climate (+4C)

results_imputation <- readRDS("RData/Imputation/results/imputation_5th_cycle.Rds")

CTmax_data <- dplyr::select(results_imputation, CTmax = filled_mean_UTL5, lowerCI = lower_mean_UTL,
    upperCI = upper_mean_UTL, acclimation_temp, tip.label, imputed)  # Select relevant columns

original_data <- dplyr::filter(CTmax_data, imputed == "no")  # Original experimental data
imputed_data <- dplyr::filter(CTmax_data, imputed == "yes")  # Imputed data

# Calculate standard error of each observation
imputed_data <- imputed_data %>%
    mutate(se = (upperCI - CTmax)/1.96)

# Group data by species
species_data <- imputed_data %>%
    group_by(tip.label)

temp_species <- readRDS("RData/Biophysical_modelling/Arboreal/4C/species_daily_temp_warmest_days_arboreal_future4C.rds")
temp_species$tip.label <- gsub("_", " ", temp_species$tip.label)

temp_species$tip.label[temp_species$tip.label == "Scinax x signatus"] <- "Scinax x-signatus"
temp_species$tip.label[temp_species$tip.label == "Pristimantis w nigrum"] <- "Pristimantis w-nigrum"

saveRDS(temp_species, file = "RData/Biophysical_modelling/Arboreal/4C/species_daily_temp_warmest_days_arboreal_future4C_adj.rds")

species_data <- filter(species_data, tip.label %in% temp_species$tip.label)

# Run meta-analytic models to calculate species-level ARR and intercept; and
# predict the CTmax of each day once acclimated to the mean weekly temperature

temp_species <- temp_species %>%
    dplyr::select(tip.label, lon, lat, YEAR, DOY, max_temp, mean_weekly_temp, max_weekly_temp)

# Create chunks of 3 species at a time
species_list <- unique(species_data$tip.label)
chunk_size <- 3
num_chunks <- ceiling(length(species_list)/chunk_size)

# Split the species list into chunks
chunk_species_list <- split(species_list, cut(1:length(species_list), breaks = num_chunks,
    labels = FALSE))

# Now, create larger chunks of small chunks Running all chunks at once will
# require an enormous amount of RAM, so we proceed with 175 chunks at a time in
# 10 batches.
larger_chunk_size <- 175
num_larger_chunks <- ceiling(num_chunks/larger_chunk_size)

# Split the chunk list into larger chunks
larger_chunk_list <- split(chunk_species_list, cut(1:length(chunk_species_list),
    breaks = num_larger_chunks, labels = FALSE))


# Set up parallel processing
cl <- makeCluster(16)

# Load packages on nodes
clusterEvalQ(cl, {
    library(dplyr)
    library(metafor)
})

# Check processing time
Sys.time()

# Processing for first larger chunk
current_larger_chunk <- larger_chunk_list[[1]]
result_list_1 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_1 <- c(result_list_1, result_chunk)
}

species_ARR_arboreal_future4C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_future4C_1 <- do.call(rbind, lapply(result_list_1,
    function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_future4C_1 <- do.call(rbind, lapply(result_list_1, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_1)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_future4C_1, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_ARR/species_ARR_arboreal_future4C_1st_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future4C_1, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_future4C_1st_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future4C_1, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_max_acc/daily_CTmax_arboreal_max_acc_future4C_1st_chunk.rds")

################################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[2]]
result_list_2 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_2 <- c(result_list_2, result_chunk)
}

species_ARR_arboreal_future4C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_future4C_2 <- do.call(rbind, lapply(result_list_2,
    function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_future4C_2 <- do.call(rbind, lapply(result_list_2, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_2)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_future4C_2, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_ARR/species_ARR_arboreal_future4C_2nd_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future4C_2, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_future4C_2nd_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future4C_2, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_max_acc/daily_CTmax_arboreal_max_acc_future4C_2nd_chunk.rds")

###################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[3]]
result_list_3 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_3 <- c(result_list_3, result_chunk)
}

species_ARR_arboreal_future4C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_future4C_3 <- do.call(rbind, lapply(result_list_3,
    function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_future4C_3 <- do.call(rbind, lapply(result_list_3, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_3)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_future4C_3, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_ARR/species_ARR_arboreal_future4C_3rd_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future4C_3, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_future4C_3rd_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future4C_3, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_max_acc/daily_CTmax_arboreal_max_acc_future4C_3rd_chunk.rds")

######################

Sys.time()

# Processing for second larger chunk
current_larger_chunk <- larger_chunk_list[[4]]
result_list_4 <- list()

# Loop over the small chunks within the current larger chunk
for (i in seq_along(current_larger_chunk)) {
    current_species <- current_larger_chunk[[i]]

    # Filter data for only the species in the current chunk
    chunk_species_data <- dplyr::filter(species_data, tip.label %in% current_species)
    chunk_temp_species <- dplyr::filter(temp_species, tip.label %in% current_species)

    # Export only the filtered data and the current species list to the cluster
    clusterExport(cl, c("chunk_species_data", "chunk_temp_species", "current_species",
        "species_meta"))

    # Call species_meta for each species in the chunk
    result_chunk <- parallel::parLapply(cl, current_species, function(x) species_meta(x,
        chunk_species_data, chunk_temp_species))

    result_list_4 <- c(result_list_4, result_chunk)
}

species_ARR_arboreal_future4C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[1]]))
daily_CTmax_arboreal_mean_acc_future4C_4 <- do.call(rbind, lapply(result_list_4,
    function(x) x[[2]]))
daily_CTmax_arboreal_max_acc_future4C_4 <- do.call(rbind, lapply(result_list_4, function(x) x[[3]]))

rm(chunk_species_data)
rm(chunk_temp_species)
rm(result_chunk)
rm(result_list_4)

Sys.time()

# Save the results for first chunk
saveRDS(species_ARR_arboreal_future4C_4, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_ARR/species_ARR_arboreal_future4C_4th_chunk.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future4C_4, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_mean_acc/daily_CTmax_arboreal_mean_acc_future4C_4th_chunk.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future4C_4, file = "RData/Climate_vulnerability/Arboreal/future4C/temp_files_max_acc/daily_CTmax_arboreal_max_acc_future4C_4th_chunk.rds")

######################

# Stop the cluster
stopCluster(cl)
gc()

# Combine results from all chunks and save
species_ARR_arboreal_future4C <- distinct(rbind(species_ARR_arboreal_future4C_1,
    species_ARR_arboreal_future4C_2, species_ARR_arboreal_future4C_3, species_ARR_arboreal_future4C_4))

daily_CTmax_arboreal_mean_acc_future4C <- rbind(daily_CTmax_arboreal_mean_acc_future4C_1,
    daily_CTmax_arboreal_mean_acc_future4C_2, daily_CTmax_arboreal_mean_acc_future4C_3,
    daily_CTmax_arboreal_mean_acc_future4C_4)

daily_CTmax_arboreal_max_acc_future4C <- rbind(daily_CTmax_arboreal_max_acc_future4C_1,
    daily_CTmax_arboreal_max_acc_future4C_2, daily_CTmax_arboreal_max_acc_future4C_3,
    daily_CTmax_arboreal_max_acc_future4C_4)


saveRDS(species_ARR_arboreal_future4C, file = "RData/Climate_vulnerability/Arboreal/future4C/species_ARR_arboreal_future4C.rds")
saveRDS(daily_CTmax_arboreal_mean_acc_future4C, file = "RData/Climate_vulnerability/Arboreal/future4C/daily_CTmax_arboreal_mean_acc_future4C.rds")
saveRDS(daily_CTmax_arboreal_max_acc_future4C, file = "RData/Climate_vulnerability/Arboreal/future4C/daily_CTmax_arboreal_max_acc_future4C.rds")

Vegetated substrate

# Load data
pop_sub_current <- readRDS("RData/Climate_vulnerability/Substrate/current/population_vulnerability_substrate_mean_acc_current.rds")

kable(head(pop_sub_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
pop_sub_future2C <- readRDS("RData/Climate_vulnerability/Substrate/future2C/population_vulnerability_substrate_mean_acc_future2C.rds")

kable(head(pop_sub_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
pop_sub_future4C <- readRDS("RData/Climate_vulnerability/Substrate/future4C/population_vulnerability_substrate_mean_acc_future4C.rds")

kable(head(pop_sub_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

Pond or wetland

# Load data
pop_pond_current <- readRDS("RData/Climate_vulnerability/Pond/current/population_vulnerability_pond_mean_acc_current.rds")

kable(head(pop_pond_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
pop_pond_future2C <- readRDS("RData/Climate_vulnerability/Pond/future2C/population_vulnerability_pond_mean_acc_future2C.rds")

kable(head(pop_pond_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
pop_pond_future4C <- readRDS("RData/Climate_vulnerability/Pond/future4C/population_vulnerability_pond_mean_acc_future4C.rds")

kable(head(pop_pond_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

Above-ground vegetation

# Load data
pop_arb_current <- readRDS("RData/Climate_vulnerability/Arboreal/current/population_vulnerability_arboreal_mean_acc_current.rds")

kable(head(pop_arb_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
pop_arb_future2C <- readRDS("RData/Climate_vulnerability/Arboreal/future2C/population_vulnerability_arboreal_mean_acc_future2C.rds")

kable(head(pop_arb_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
pop_arb_future4C <- readRDS("RData/Climate_vulnerability/Arboreal/future4C/population_vulnerability_arboreal_mean_acc_future4C.rds")

kable(head(pop_arb_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

Vegetated substrate

# Load data
pop_sub_current <- readRDS("RData/Climate_vulnerability/Substrate/current/population_vulnerability_substrate_mean_acc_current.rds")
pop_sub_future2C <- readRDS("RData/Climate_vulnerability/Substrate/future2C/population_vulnerability_substrate_mean_acc_future2C.rds")
pop_sub_future4C <- readRDS("RData/Climate_vulnerability/Substrate/future4C/population_vulnerability_substrate_mean_acc_future4C.rds")

# Counts for each climatic scenario
n_pop_current <- n_distinct(pop_sub_current[pop_sub_current$overheating_risk > 0,
    ])
n_pop_future2C <- n_distinct(pop_sub_future2C[pop_sub_future2C$overheating_risk >
    0, ])
n_pop_future4C <- n_distinct(pop_sub_future4C[pop_sub_future4C$overheating_risk >
    0, ])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_pop_overheating = c(n_pop_current, n_pop_future2C,
    n_pop_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Pond or wetland

# Load data
pop_pond_current <- readRDS("RData/Climate_vulnerability/Pond/current/population_vulnerability_pond_mean_acc_current.rds")
pop_pond_future2C <- readRDS("RData/Climate_vulnerability/Pond/future2C/population_vulnerability_pond_mean_acc_future2C.rds")
pop_pond_future4C <- readRDS("RData/Climate_vulnerability/Pond/future4C/population_vulnerability_pond_mean_acc_future4C.rds")

# Counts for each climatic scenario
n_pop_current <- n_distinct(pop_pond_current[pop_pond_current$overheating_risk >
    0, ])
n_pop_future2C <- n_distinct(pop_pond_future2C[pop_pond_future2C$overheating_risk >
    0, ])
n_pop_future4C <- n_distinct(pop_pond_future4C[pop_pond_future4C$overheating_risk >
    0, ])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_pop_overheating = c(n_pop_current, n_pop_future2C,
    n_pop_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Above-ground vegetation

# Load data
pop_arb_current <- readRDS("RData/Climate_vulnerability/Arboreal/current/population_vulnerability_arboreal_mean_acc_current.rds")
pop_arb_future2C <- readRDS("RData/Climate_vulnerability/Arboreal/future2C/population_vulnerability_arboreal_mean_acc_future2C.rds")
pop_arb_future4C <- readRDS("RData/Climate_vulnerability/Arboreal/future4C/population_vulnerability_arboreal_mean_acc_future4C.rds")

# Counts for each climatic scenario
n_pop_current <- n_distinct(pop_arb_current[pop_arb_current$overheating_risk > 0,
    ])
n_pop_future2C <- n_distinct(pop_arb_future2C[pop_arb_future2C$overheating_risk >
    0, ])
n_pop_future4C <- n_distinct(pop_arb_future4C[pop_arb_future4C$overheating_risk >
    0, ])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_pop_overheating = c(n_pop_current, n_pop_future2C,
    n_pop_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Arboreal species on substrate conditions

# Filter substrate data to only arboreal species
pop_sub_current_arb_subset <- filter(pop_sub_current, tip.label %in% pop_arb_current$tip.label)
pop_sub_future2C_arb_subset <- filter(pop_sub_future2C, tip.label %in% pop_arb_future2C$tip.label)
pop_sub_future4C_arb_subset <- filter(pop_sub_future4C, tip.label %in% pop_arb_future4C$tip.label)


# Counts for each climatic scenario
n_pop_current <- n_distinct(pop_sub_current_arb_subset[pop_sub_current_arb_subset$overheating_risk >
    0, ])
n_pop_future2C <- n_distinct(pop_sub_future2C_arb_subset[pop_sub_future2C_arb_subset$overheating_risk >
    0, ])
n_pop_future4C <- n_distinct(pop_sub_future4C_arb_subset[pop_sub_future4C_arb_subset$overheating_risk >
    0, ])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_pop_overheating = c(n_pop_current, n_pop_future2C,
    n_pop_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Vegetated substrate

# Counts for each climatic scenario
n_sp_current <- n_distinct(pop_sub_current$tip.label[pop_sub_current$overheating_risk >
    0])
n_sp_future2C <- n_distinct(pop_sub_future2C$tip.label[pop_sub_future2C$overheating_risk >
    0])
n_sp_future4C <- n_distinct(pop_sub_future4C$tip.label[pop_sub_future4C$overheating_risk >
    0])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_sp_overheating = c(n_sp_current, n_sp_future2C,
    n_sp_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Pond or wetland

# Counts for each climatic scenario
n_sp_current <- n_distinct(pop_pond_current$tip.label[pop_pond_current$overheating_risk >
    0])
n_sp_future2C <- n_distinct(pop_pond_future2C$tip.label[pop_pond_future2C$overheating_risk >
    0])
n_sp_future4C <- n_distinct(pop_pond_future4C$tip.label[pop_pond_future4C$overheating_risk >
    0])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_sp_overheating = c(n_sp_current, n_sp_future2C,
    n_sp_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Above-ground vegetation

# Counts for each climatic scenario
n_sp_current <- n_distinct(pop_arb_current$tip.label[pop_arb_current$overheating_risk >
    0])
n_sp_future2C <- n_distinct(pop_arb_future2C$tip.label[pop_arb_future2C$overheating_risk >
    0])
n_sp_future4C <- n_distinct(pop_arb_future4C$tip.label[pop_arb_future4C$overheating_risk >
    0])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_sp_overheating = c(n_sp_current, n_sp_future2C,
    n_sp_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Arboreal species on substrate conditions

# Counts for each climatic scenario
n_sp_current <- n_distinct(pop_sub_current_arb_subset$tip.label[pop_sub_current_arb_subset$overheating_risk >
    0])
n_sp_future2C <- n_distinct(pop_sub_future2C_arb_subset$tip.label[pop_sub_future2C_arb_subset$overheating_risk >
    0])
n_sp_future4C <- n_distinct(pop_sub_future4C_arb_subset$tip.label[pop_sub_future4C_arb_subset$overheating_risk >
    0])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_sp_overheating = c(n_sp_current, n_sp_future2C,
    n_sp_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Vegetated substrate

kable(summary(pop_sub_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

kable(summary(pop_sub_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

kable(summary(pop_sub_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Pond or wetland

kable(summary(pop_pond_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

kable(summary(pop_pond_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

kable(summary(pop_pond_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Above-ground vegetation

kable(summary(pop_arb_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

kable(summary(pop_arb_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

kable(summary(pop_arb_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Vegetated substrate

# Load data
community_sub_current <- readRDS("RData/Climate_vulnerability/Substrate/current/community_vulnerability_substrate_mean_acc_current.rds")

kable(head(community_sub_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
community_sub_future2C <- readRDS("RData/Climate_vulnerability/Substrate/future2C/community_vulnerability_substrate_mean_acc_future2C.rds")

kable(head(community_sub_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
community_sub_future4C <- readRDS("RData/Climate_vulnerability/Substrate/future4C/community_vulnerability_substrate_mean_acc_future4C.rds")

kable(head(community_sub_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

Pond or wetland

# Load data
community_pond_current <- readRDS("RData/Climate_vulnerability/Pond/current/community_vulnerability_pond_mean_acc_current.rds")

kable(head(community_pond_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
community_pond_future2C <- readRDS("RData/Climate_vulnerability/Pond/future2C/community_vulnerability_pond_mean_acc_future2C.rds")

kable(head(community_pond_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
community_pond_future4C <- readRDS("RData/Climate_vulnerability/Pond/future4C/community_vulnerability_pond_mean_acc_future4C.rds")

kable(head(community_pond_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

Above-ground vegetation

# Load data
community_arb_current <- readRDS("RData/Climate_vulnerability/Arboreal/current/community_vulnerability_arboreal_mean_acc_current.rds")

kable(head(community_arb_current), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
community_arb_future2C <- readRDS("RData/Climate_vulnerability/Arboreal/future2C/community_vulnerability_arboreal_mean_acc_future2C.rds")

kable(head(community_arb_future2C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

# Load data
community_arb_future4C <- readRDS("RData/Climate_vulnerability/Arboreal/future4C/community_vulnerability_arboreal_mean_acc_future4C.rds")

kable(head(community_arb_future4C), "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "500px")

Vegetated substrate

# Load data
community_sub_current <- readRDS("RData/Climate_vulnerability/Substrate/current/community_vulnerability_substrate_mean_acc_current.rds")
community_sub_future2C <- readRDS("RData/Climate_vulnerability/Substrate/future2C/community_vulnerability_substrate_mean_acc_future2C.rds")
community_sub_future4C <- readRDS("RData/Climate_vulnerability/Substrate/future4C/community_vulnerability_substrate_mean_acc_future4C.rds")

# Counts for each climatic scenario
n_commu_current <- n_distinct(community_sub_current[community_sub_current$n_species_overheating >
    0, ])
n_commu_future2C <- n_distinct(community_sub_future2C[community_sub_future2C$n_species_overheating >
    0, ])
n_commu_future4C <- n_distinct(community_sub_future4C[community_sub_future4C$n_species_overheating >
    0, ])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_sp_overheating = c(n_commu_current, n_commu_future2C,
    n_commu_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Pond or wetland

# Load data
community_pond_current <- readRDS("RData/Climate_vulnerability/Pond/current/community_vulnerability_pond_mean_acc_current.rds")
community_pond_future2C <- readRDS("RData/Climate_vulnerability/Pond/future2C/community_vulnerability_pond_mean_acc_future2C.rds")
community_pond_future4C <- readRDS("RData/Climate_vulnerability/Pond/future4C/community_vulnerability_pond_mean_acc_future4C.rds")

# Counts for each climatic scenario
n_commu_current <- n_distinct(community_pond_current[community_pond_current$n_species_overheating >
    0, ])
n_commu_future2C <- n_distinct(community_pond_future2C[community_pond_future2C$n_species_overheating >
    0, ])
n_commu_future4C <- n_distinct(community_pond_future4C[community_pond_future4C$n_species_overheating >
    0, ])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_sp_overheating = c(n_commu_current, n_commu_future2C,
    n_commu_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Above-ground vegetation

# Load data
community_arb_current <- readRDS("RData/Climate_vulnerability/Arboreal/current/community_vulnerability_arboreal_mean_acc_current.rds")
community_arb_future2C <- readRDS("RData/Climate_vulnerability/Arboreal/future2C/community_vulnerability_arboreal_mean_acc_future2C.rds")
community_arb_future4C <- readRDS("RData/Climate_vulnerability/Arboreal/future4C/community_vulnerability_arboreal_mean_acc_future4C.rds")

# Counts for each climatic scenario
n_commu_current <- n_distinct(community_arb_current[community_arb_current$n_species_overheating >
    0, ])
n_commu_future2C <- n_distinct(community_arb_future2C[community_arb_future2C$n_species_overheating >
    0, ])
n_commu_future4C <- n_distinct(community_arb_future4C[community_arb_future4C$n_species_overheating >
    0, ])

results_summary <- data.frame(Climate_Scenario = c("Current Climate", "Future Climate (+2C)",
    "Future Climate (+4C)"), Number_sp_overheating = c(n_commu_current, n_commu_future2C,
    n_commu_future4C))

kable(results_summary, "html") %>%
    row_spec(0, background = "white", color = "black", bold = TRUE) %>%
    kable_styling(fixed_thead = T, position = "left", full_width = F) %>%
    scroll_box(width = "100%", height = "250px")

Vegetated substrate

summary(community_sub_current)

##       lon               lat         community_CTmax community_CTmax_se
##  Min.   :-166.50   Min.   :-54.50   Min.   :29.26   Min.   : 0.1213   
##  1st Qu.: -61.50   1st Qu.:  0.50   1st Qu.:34.98   1st Qu.: 0.5730   
##  Median :  30.50   Median : 33.50   Median :36.74   Median : 1.1903   
##  Mean   :  23.33   Mean   : 26.42   Mean   :36.65   Mean   : 1.5986   
##  3rd Qu.: 102.50   3rd Qu.: 53.50   3rd Qu.:38.68   3rd Qu.: 2.0408   
##  Max.   : 178.50   Max.   : 71.50   Max.   :45.43   Max.   :18.0169   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   : 1.106     Min.   : 0.2772       Min.   : 7.326   Min.   : 0.1213  
##  1st Qu.:16.677     1st Qu.: 0.9795       1st Qu.:12.324   1st Qu.: 0.5730  
##  Median :21.426     Median : 1.5833       Median :14.791   Median : 1.1903  
##  Mean   :20.921     Mean   : 1.8187       Mean   :15.191   Mean   : 1.5986  
##  3rd Qu.:26.198     3rd Qu.: 2.4244       3rd Qu.:17.302   3rd Qu.: 2.0408  
##  Max.   :31.130     Max.   :11.4393       Max.   :33.523   Max.   :18.0169  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   :  1.00   Min.   : 0.00000      Min.   :0.000000              
##  1st Qu.:  2.00   1st Qu.: 0.00000      1st Qu.:0.000000              
##  Median :  7.00   Median : 0.00000      Median :0.000000              
##  Mean   : 14.47   Mean   : 0.05933      Mean   :0.002082              
##  3rd Qu.: 19.00   3rd Qu.: 0.00000      3rd Qu.:0.000000              
##  Max.   :158.00   Max.   :18.00000      Max.   :1.000000              
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0.000000                  Min.   :0.000000            
##  1st Qu.:0.000000                  1st Qu.:0.000000            
##  Median :0.000000                  Median :0.000000            
##  Mean   :0.004606                  Mean   :0.005819            
##  3rd Qu.:0.000000                  3rd Qu.:0.000000            
##  Max.   :0.707107                  Max.   :4.000000            
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0.000e+00                     Min.   :0.0000000                       
##  1st Qu.:0.000e+00                     1st Qu.:0.0000000                       
##  Median :0.000e+00                     Median :0.0000000                       
##  Mean   :8.284e-05                     Mean   :0.0005369                       
##  3rd Qu.:0.000e+00                     3rd Qu.:0.0000000                       
##  Max.   :3.846e-02                     Max.   :0.1932390

summary(community_sub_future2C)

##       lon               lat         community_CTmax community_CTmax_se
##  Min.   :-166.50   Min.   :-54.50   Min.   :29.32   Min.   : 0.1167   
##  1st Qu.: -61.50   1st Qu.:  0.50   1st Qu.:35.13   1st Qu.: 0.5223   
##  Median :  30.50   Median : 33.50   Median :36.93   Median : 0.9993   
##  Mean   :  23.33   Mean   : 26.43   Mean   :36.80   Mean   : 1.3283   
##  3rd Qu.: 102.50   3rd Qu.: 53.50   3rd Qu.:38.86   3rd Qu.: 1.7352   
##  Max.   : 178.50   Max.   : 71.50   Max.   :45.35   Max.   :16.8344   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   : 1.601     Min.   : 0.2740       Min.   : 6.862   Min.   : 0.1167  
##  1st Qu.:17.813     1st Qu.: 0.9301       1st Qu.:11.512   1st Qu.: 0.5223  
##  Median :23.010     Median : 1.5320       Median :13.584   Median : 0.9993  
##  Mean   :22.035     Mean   : 1.7857       Mean   :14.298   Mean   : 1.3283  
##  3rd Qu.:27.173     3rd Qu.: 2.3963       3rd Qu.:16.419   3rd Qu.: 1.7352  
##  Max.   :32.315     Max.   :12.5131       Max.   :32.257   Max.   :16.8344  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   :  1.00   Min.   : 0.0000       Min.   :0.000000              
##  1st Qu.:  2.00   1st Qu.: 0.0000       1st Qu.:0.000000              
##  Median :  7.00   Median : 0.0000       Median :0.000000              
##  Mean   : 14.47   Mean   : 0.1011       Mean   :0.003736              
##  3rd Qu.: 19.00   3rd Qu.: 0.0000       3rd Qu.:0.000000              
##  Max.   :158.00   Max.   :20.0000       Max.   :1.000000              
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0.00000                   Min.   :0.00000             
##  1st Qu.:0.00000                   1st Qu.:0.00000             
##  Median :0.00000                   Median :0.00000             
##  Mean   :0.00789                   Mean   :0.01462             
##  3rd Qu.:0.00000                   3rd Qu.:0.00000             
##  Max.   :0.57735                   Max.   :8.00000             
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0.0000000                     Min.   :0.000000                        
##  1st Qu.:0.0000000                     1st Qu.:0.000000                        
##  Median :0.0000000                     Median :0.000000                        
##  Mean   :0.0002319                     Mean   :0.001232                        
##  3rd Qu.:0.0000000                     3rd Qu.:0.000000                        
##  Max.   :0.1666667                     Max.   :0.408248

summary(community_sub_future4C)

##       lon               lat         community_CTmax community_CTmax_se
##  Min.   :-166.50   Min.   :-54.50   Min.   :29.40   Min.   : 0.1191   
##  1st Qu.: -61.50   1st Qu.:  0.50   1st Qu.:35.39   1st Qu.: 0.4885   
##  Median :  30.50   Median : 33.50   Median :37.31   Median : 0.8511   
##  Mean   :  23.33   Mean   : 26.43   Mean   :37.07   Mean   : 1.0712   
##  3rd Qu.: 102.50   3rd Qu.: 53.50   3rd Qu.:39.17   3rd Qu.: 1.4807   
##  Max.   : 178.50   Max.   : 71.50   Max.   :45.32   Max.   :15.3900   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   : 1.434     Min.   : 0.2730       Min.   : 4.053   Min.   : 0.1191  
##  1st Qu.:19.971     1st Qu.: 0.9353       1st Qu.: 9.834   1st Qu.: 0.4885  
##  Median :25.568     Median : 1.5527       Median :11.754   Median : 0.8511  
##  Mean   :24.226     Mean   : 1.8062       Mean   :12.587   Mean   : 1.0712  
##  3rd Qu.:29.080     3rd Qu.: 2.4510       3rd Qu.:14.868   3rd Qu.: 1.4807  
##  Max.   :35.135     Max.   :12.0536       Max.   :35.323   Max.   :15.3900  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   :  1.00   Min.   : 0.0000       Min.   :0.00000               
##  1st Qu.:  2.00   1st Qu.: 0.0000       1st Qu.:0.00000               
##  Median :  7.00   Median : 0.0000       Median :0.00000               
##  Mean   : 14.47   Mean   : 0.3015       Mean   :0.01797               
##  3rd Qu.: 19.00   3rd Qu.: 0.0000       3rd Qu.:0.00000               
##  Max.   :158.00   Max.   :37.0000       Max.   :1.00000               
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0.00000                   Min.   : 0.0000             
##  1st Qu.:0.00000                   1st Qu.: 0.0000             
##  Median :0.00000                   Median : 0.0000             
##  Mean   :0.02985                   Mean   : 0.1033             
##  3rd Qu.:0.00000                   3rd Qu.: 0.0000             
##  Max.   :0.70711                   Max.   :15.0000             
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0.000000                      Min.   :0.0000                          
##  1st Qu.:0.000000                      1st Qu.:0.0000                          
##  Median :0.000000                      Median :0.0000                          
##  Mean   :0.004919                      Mean   :0.0105                          
##  3rd Qu.:0.000000                      3rd Qu.:0.0000                          
##  Max.   :1.000000                      Max.   :0.7071

Pond or wetland

summary(community_pond_current)

##       lon               lat         community_CTmax community_CTmax_se
##  Min.   :-166.50   Min.   :-54.50   Min.   :29.07   Min.   : 0.1182   
##  1st Qu.: -61.50   1st Qu.:  0.50   1st Qu.:35.08   1st Qu.: 0.5134   
##  Median :  30.50   Median : 33.50   Median :36.95   Median : 0.9164   
##  Mean   :  23.32   Mean   : 26.42   Mean   :36.82   Mean   : 1.3063   
##  3rd Qu.: 102.50   3rd Qu.: 53.50   3rd Qu.:38.99   3rd Qu.: 1.7381   
##  Max.   : 178.50   Max.   : 71.50   Max.   :45.27   Max.   :19.1743   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   :-9.592     Min.   :0.1390        Min.   : 8.137   Min.   : 0.1182  
##  1st Qu.:13.874     1st Qu.:0.5659        1st Qu.:13.941   1st Qu.: 0.5134  
##  Median :18.979     Median :1.3682        Median :17.292   Median : 0.9164  
##  Mean   :18.785     Mean   :1.4041        Mean   :17.590   Mean   : 1.3063  
##  3rd Qu.:24.943     3rd Qu.:2.0225        3rd Qu.:20.157   3rd Qu.: 1.7381  
##  Max.   :30.137     Max.   :5.8776        Max.   :43.526   Max.   :19.1743  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   :  1.00   Min.   :0             Min.   :0                     
##  1st Qu.:  2.00   1st Qu.:0             1st Qu.:0                     
##  Median :  7.00   Median :0             Median :0                     
##  Mean   : 14.53   Mean   :0             Mean   :0                     
##  3rd Qu.: 19.00   3rd Qu.:0             3rd Qu.:0                     
##  Max.   :158.00   Max.   :0             Max.   :0                     
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0                         Min.   :0                   
##  1st Qu.:0                         1st Qu.:0                   
##  Median :0                         Median :0                   
##  Mean   :0                         Mean   :0                   
##  3rd Qu.:0                         3rd Qu.:0                   
##  Max.   :0                         Max.   :0                   
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0                             Min.   :0                               
##  1st Qu.:0                             1st Qu.:0                               
##  Median :0                             Median :0                               
##  Mean   :0                             Mean   :0                               
##  3rd Qu.:0                             3rd Qu.:0                               
##  Max.   :0                             Max.   :0

summary(community_pond_future2C)

##       lon               lat         community_CTmax community_CTmax_se
##  Min.   :-166.50   Min.   :-54.50   Min.   :29.22   Min.   : 0.1155   
##  1st Qu.: -61.50   1st Qu.:  0.50   1st Qu.:35.28   1st Qu.: 0.4899   
##  Median :  30.50   Median : 33.50   Median :37.18   Median : 0.8535   
##  Mean   :  23.32   Mean   : 26.43   Mean   :37.02   Mean   : 1.1815   
##  3rd Qu.: 102.50   3rd Qu.: 53.50   3rd Qu.:39.21   3rd Qu.: 1.5879   
##  Max.   : 178.50   Max.   : 71.50   Max.   :45.56   Max.   :17.9086   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   :-8.232     Min.   :0.1393        Min.   : 7.405   Min.   : 0.1155  
##  1st Qu.:15.219     1st Qu.:0.5907        1st Qu.:13.088   1st Qu.: 0.4899  
##  Median :20.217     Median :1.3659        Median :16.328   Median : 0.8535  
##  Mean   :20.098     Mean   :1.4214        Mean   :16.624   Mean   : 1.1815  
##  3rd Qu.:26.223     3rd Qu.:2.0425        3rd Qu.:19.167   3rd Qu.: 1.5879  
##  Max.   :31.782     Max.   :6.0906        Max.   :42.484   Max.   :17.9086  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   :  1.00   Min.   :0             Min.   :0                     
##  1st Qu.:  2.00   1st Qu.:0             1st Qu.:0                     
##  Median :  7.00   Median :0             Median :0                     
##  Mean   : 14.53   Mean   :0             Mean   :0                     
##  3rd Qu.: 19.00   3rd Qu.:0             3rd Qu.:0                     
##  Max.   :158.00   Max.   :0             Max.   :0                     
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0                         Min.   :0                   
##  1st Qu.:0                         1st Qu.:0                   
##  Median :0                         Median :0                   
##  Mean   :0                         Mean   :0                   
##  3rd Qu.:0                         3rd Qu.:0                   
##  Max.   :0                         Max.   :0                   
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0                             Min.   :0                               
##  1st Qu.:0                             1st Qu.:0                               
##  Median :0                             Median :0                               
##  Mean   :0                             Mean   :0                               
##  3rd Qu.:0                             3rd Qu.:0                               
##  Max.   :0                             Max.   :0

summary(community_pond_future4C)

##       lon               lat         community_CTmax community_CTmax_se
##  Min.   :-166.50   Min.   :-54.50   Min.   :29.36   Min.   : 0.1214   
##  1st Qu.: -61.50   1st Qu.:  0.50   1st Qu.:35.61   1st Qu.: 0.5146   
##  Median :  30.50   Median : 33.50   Median :37.56   Median : 0.9767   
##  Mean   :  23.32   Mean   : 26.43   Mean   :37.32   Mean   : 1.2968   
##  3rd Qu.: 102.50   3rd Qu.: 53.50   3rd Qu.:39.45   3rd Qu.: 1.6013   
##  Max.   : 178.50   Max.   : 71.50   Max.   :46.05   Max.   :16.0988   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   :-5.07      Min.   :0.1369        Min.   : 4.432   Min.   : 0.1214  
##  1st Qu.:17.48      1st Qu.:0.6343        1st Qu.:11.620   1st Qu.: 0.5146  
##  Median :22.34      Median :1.3655        Median :14.912   Median : 0.9767  
##  Mean   :22.21      Mean   :1.4339        Mean   :15.091   Mean   : 1.2968  
##  3rd Qu.:28.09      3rd Qu.:2.0254        3rd Qu.:17.706   3rd Qu.: 1.6013  
##  Max.   :34.55      Max.   :6.6509        Max.   :39.749   Max.   :16.0988  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   :  1.00   Min.   :0.000000      Min.   :0.0000000             
##  1st Qu.:  2.00   1st Qu.:0.000000      1st Qu.:0.0000000             
##  Median :  7.00   Median :0.000000      Median :0.0000000             
##  Mean   : 14.53   Mean   :0.003974      Mean   :0.0002084             
##  3rd Qu.: 19.00   3rd Qu.:0.000000      3rd Qu.:0.0000000             
##  Max.   :158.00   Max.   :2.000000      Max.   :0.2857143             
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0.0000000                 Min.   :0.0000000           
##  1st Qu.:0.0000000                 1st Qu.:0.0000000           
##  Median :0.0000000                 Median :0.0000000           
##  Mean   :0.0007117                 Mean   :0.0008516           
##  3rd Qu.:0.0000000                 3rd Qu.:0.0000000           
##  Max.   :0.4879500                 Max.   :2.0000000           
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0.000e+00                     Min.   :0.0000000                       
##  1st Qu.:0.000e+00                     1st Qu.:0.0000000                       
##  Median :0.000e+00                     Median :0.0000000                       
##  Mean   :7.511e-05                     Mean   :0.0002021                       
##  3rd Qu.:0.000e+00                     3rd Qu.:0.0000000                       
##  Max.   :2.857e-01                     Max.   :0.4879500

Above-ground vegetation

summary(community_arb_current)

##       lon               lat          community_CTmax community_CTmax_se
##  Min.   :-158.50   Min.   :-51.500   Min.   :31.27   Min.   : 0.2136   
##  1st Qu.: -61.50   1st Qu.:-12.500   1st Qu.:37.94   1st Qu.: 0.8569   
##  Median :  17.50   Median :  4.500   Median :39.05   Median : 1.6694   
##  Mean   :  16.65   Mean   :  7.019   Mean   :38.76   Mean   : 2.2242   
##  3rd Qu.:  99.50   3rd Qu.: 27.500   3rd Qu.:39.59   3rd Qu.: 3.1685   
##  Max.   : 177.50   Max.   : 57.500   Max.   :45.59   Max.   :19.2463   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   : 2.168     Min.   :0.2319        Min.   : 7.765   Min.   : 0.2136  
##  1st Qu.:22.172     1st Qu.:0.6832        1st Qu.:12.074   1st Qu.: 0.8569  
##  Median :25.430     Median :0.9272        Median :13.608   Median : 1.6694  
##  Mean   :24.242     Mean   :1.1104        Mean   :14.252   Mean   : 2.2242  
##  3rd Qu.:27.046     3rd Qu.:1.3950        3rd Qu.:16.044   3rd Qu.: 3.1685  
##  Max.   :29.827     Max.   :9.2086        Max.   :33.467   Max.   :19.2463  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   : 1.000   Min.   :0.00000       Min.   :0.0000000             
##  1st Qu.: 1.000   1st Qu.:0.00000       1st Qu.:0.0000000             
##  Median : 4.000   Median :0.00000       Median :0.0000000             
##  Mean   : 8.499   Mean   :0.02298       Mean   :0.0005957             
##  3rd Qu.:10.000   3rd Qu.:0.00000       3rd Qu.:0.0000000             
##  Max.   :88.000   Max.   :6.00000       Max.   :0.2000000             
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0.000000                  Min.   :0.000000            
##  1st Qu.:0.000000                  1st Qu.:0.000000            
##  Median :0.000000                  Median :0.000000            
##  Mean   :0.002402                  Mean   :0.001058            
##  3rd Qu.:0.000000                  3rd Qu.:0.000000            
##  Max.   :0.447214                  Max.   :1.000000            
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0.000e+00                     Min.   :0.0000000                       
##  1st Qu.:0.000e+00                     1st Qu.:0.0000000                       
##  Median :0.000e+00                     Median :0.0000000                       
##  Mean   :2.006e-05                     Mean   :0.0001456                       
##  3rd Qu.:0.000e+00                     3rd Qu.:0.0000000                       
##  Max.   :2.174e-02                     Max.   :0.1474420

summary(community_arb_future2C)

##       lon               lat          community_CTmax community_CTmax_se
##  Min.   :-158.50   Min.   :-51.500   Min.   :31.35   Min.   : 0.2143   
##  1st Qu.: -61.50   1st Qu.:-12.500   1st Qu.:38.04   1st Qu.: 0.7129   
##  Median :  17.50   Median :  4.500   Median :39.16   Median : 1.3155   
##  Mean   :  16.65   Mean   :  7.019   Mean   :38.87   Mean   : 1.8070   
##  3rd Qu.:  99.50   3rd Qu.: 27.500   3rd Qu.:39.69   3rd Qu.: 2.5081   
##  Max.   : 177.50   Max.   : 57.500   Max.   :45.50   Max.   :17.2673   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   : 1.844     Min.   :0.2266        Min.   : 7.474   Min.   : 0.2143  
##  1st Qu.:23.443     1st Qu.:0.6620        1st Qu.:11.415   1st Qu.: 0.7129  
##  Median :26.366     Median :0.8841        Median :12.797   Median : 1.3155  
##  Mean   :25.224     Mean   :1.0645        Mean   :13.424   Mean   : 1.8070  
##  3rd Qu.:27.752     3rd Qu.:1.3196        3rd Qu.:14.990   3rd Qu.: 2.5081  
##  Max.   :30.435     Max.   :9.7651        Max.   :33.790   Max.   :17.2673  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   : 1.000   Min.   :0.00000       Min.   :0.000000              
##  1st Qu.: 1.000   1st Qu.:0.00000       1st Qu.:0.000000              
##  Median : 4.000   Median :0.00000       Median :0.000000              
##  Mean   : 8.499   Mean   :0.04279       Mean   :0.001336              
##  3rd Qu.:10.000   3rd Qu.:0.00000       3rd Qu.:0.000000              
##  Max.   :88.000   Max.   :8.00000       Max.   :0.500000              
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0.000000                  Min.   :0.000000            
##  1st Qu.:0.000000                  1st Qu.:0.000000            
##  Median :0.000000                  Median :0.000000            
##  Mean   :0.004311                  Mean   :0.003175            
##  3rd Qu.:0.000000                  3rd Qu.:0.000000            
##  Max.   :0.707107                  Max.   :2.000000            
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0.000e+00                     Min.   :0.0000000                       
##  1st Qu.:0.000e+00                     1st Qu.:0.0000000                       
##  Median :0.000e+00                     Median :0.0000000                       
##  Mean   :6.163e-05                     Mean   :0.0004048                       
##  3rd Qu.:0.000e+00                     3rd Qu.:0.0000000                       
##  Max.   :3.846e-02                     Max.   :0.1941839

summary(community_arb_future4C)

##       lon               lat          community_CTmax community_CTmax_se
##  Min.   :-158.50   Min.   :-51.500   Min.   :31.51   Min.   : 0.2132   
##  1st Qu.: -61.50   1st Qu.:-12.500   1st Qu.:38.24   1st Qu.: 0.6157   
##  Median :  17.50   Median :  4.500   Median :39.39   Median : 1.0321   
##  Mean   :  16.65   Mean   :  7.019   Mean   :39.07   Mean   : 1.3027   
##  3rd Qu.:  99.50   3rd Qu.: 27.500   3rd Qu.:39.91   3rd Qu.: 1.6991   
##  Max.   : 177.50   Max.   : 57.500   Max.   :45.66   Max.   :15.2617   
##  community_max_temp community_max_temp_se community_TSM    community_TSM_se 
##  Min.   : 2.172     Min.   : 0.2195       Min.   : 6.080   Min.   : 0.2132  
##  1st Qu.:25.844     1st Qu.: 0.6673       1st Qu.: 9.968   1st Qu.: 0.6157  
##  Median :28.143     Median : 0.9061       Median :11.171   Median : 1.0321  
##  Mean   :27.133     Mean   : 1.0827       Mean   :11.819   Mean   : 1.3027  
##  3rd Qu.:29.381     3rd Qu.: 1.3465       3rd Qu.:13.104   3rd Qu.: 1.6991  
##  Max.   :33.787     Max.   :11.7245       Max.   :34.630   Max.   :15.2617  
##    n_species      n_species_overheating proportion_species_overheating
##  Min.   : 1.000   Min.   : 0.0000       Min.   :0.000000              
##  1st Qu.: 1.000   1st Qu.: 0.0000       1st Qu.:0.000000              
##  Median : 4.000   Median : 0.0000       Median :0.000000              
##  Mean   : 8.499   Mean   : 0.1131       Mean   :0.003957              
##  3rd Qu.:10.000   3rd Qu.: 0.0000       3rd Qu.:0.000000              
##  Max.   :88.000   Max.   :11.0000       Max.   :1.000000              
##  proportion_species_overheating_se n_species_overheating_strict
##  Min.   :0.00000                   Min.   :0.00000             
##  1st Qu.:0.00000                   1st Qu.:0.00000             
##  Median :0.00000                   Median :0.00000             
##  Mean   :0.01137                   Mean   :0.03961             
##  3rd Qu.:0.00000                   3rd Qu.:0.00000             
##  Max.   :0.70711                   Max.   :7.00000             
##  proportion_species_overheating_strict proportion_species_overheating_se_strict
##  Min.   :0.0000000                     Min.   :0.000000                        
##  1st Qu.:0.0000000                     1st Qu.:0.000000                        
##  Median :0.0000000                     Median :0.000000                        
##  Mean   :0.0008389                     Mean   :0.003495                        
##  3rd Qu.:0.0000000                     3rd Qu.:0.000000                        
##  Max.   :0.1206897                     Max.   :0.328611