1364 lines
42 KiB
R
1364 lines
42 KiB
R
# ============================================================================
|
|
# Fotofallen-Poweranalyse fuer Reh-, Rot- und Gamswild
|
|
# ----------------------------------------------------------------------------
|
|
# Ziel:
|
|
# Ermitteln, mit welcher Anzahl und raeumlichen Verteilung von Kameras eine
|
|
# zeitliche Abnahme der Nutzung einer Fokusflaeche gegenueber einem Buffer
|
|
# verlaesslich erkannt werden kann.
|
|
#
|
|
# Methodische Idee (nach Calenge et al. 2026, Appendix S1):
|
|
# 1) Bewegungen einzelner Tiere mit raeumlicher Bindung an Streifgebiete
|
|
# und Attraktionspunkte simulieren.
|
|
# 2) Kameras mit entfernungsabhaengiger Detektion simulieren.
|
|
# 3) wiederholte Stichproben-Designs vergleichen.
|
|
# 4) Power fuer eine Zeit x Zone-Interaktion bestimmen.
|
|
#
|
|
# WICHTIG:
|
|
# - Die voreingestellten Artparameter sind plausible STARTWERTE, keine
|
|
# belastbaren lokalen Schaetzungen. Bitte mit GPS-/Literaturdaten kalibrieren.
|
|
# - "Dichte" ist bei nicht individuell erkennbaren Tieren nur unter weiteren
|
|
# Annahmen schaetzbar. Das Skript berichtet daher primaer relative
|
|
# Detektionsrate (RAI) und optional eine REM-artige Dichtekennzahl.
|
|
# ============================================================================
|
|
|
|
# ---- 0. Pakete --------------------------------------------------------------
|
|
required <- c("sf", "data.table", "ggplot2", "MASS", "future", "future.apply")
|
|
missing <- required[!vapply(required, requireNamespace, logical(1), quietly = TRUE)]
|
|
if (length(missing) > 0) {
|
|
stop("Bitte zuerst installieren: install.packages(c(",
|
|
paste(sprintf('"%s"', missing), collapse = ", "), "))")
|
|
}
|
|
|
|
library(sf)
|
|
library(data.table)
|
|
library(ggplot2)
|
|
library(MASS)
|
|
library(future)
|
|
library(future.apply)
|
|
|
|
# Optional fuer robuste Negativ-Binomial-Modelle:
|
|
has_glmmTMB <- requireNamespace("glmmTMB", quietly = TRUE)
|
|
|
|
set.seed(20260730)
|
|
|
|
# ---- 1. Globale Einstellungen ----------------------------------------------
|
|
# CFG <- list(
|
|
# crs = 32632, # Beispiel: UTM 32N; an Projektgebiet anpassen
|
|
# years = 1:5,
|
|
# survey_days = 30,
|
|
# fixes_per_day = 48, # 30-min Schritte; fuer feinere Detektion erhoehen
|
|
# n_replicates = 200, # fuer finale Analyse eher 500-1000
|
|
# alpha = 0.05,
|
|
# target_power = 0.80,
|
|
# # Kameradesign: "random" = vorgegebene Anzahl zufaelliger Standorte;
|
|
# # "grid" = zufaellig verschobenes/gedrehtes Raster.
|
|
# camera_design_mode = "grid",
|
|
# camera_numbers = c(12, 20, 30, 40, 60),
|
|
# allocations_focus = c(0.35, 0.50, 0.65, 0.80),
|
|
# min_camera_spacing_m = 300,
|
|
# # Bei Grid-Design bestimmt der Rasterabstand direkt die Kamerazahl.
|
|
# # Mehrere Werte koennen in der Poweranalyse verglichen werden.
|
|
# grid_spacings_m = c(300, 400, 500, 700),
|
|
# grid_random_rotation = TRUE,
|
|
# grid_clip_to = "outer", # "outer", "focus" oder "buffer"
|
|
#
|
|
# focus_radius_m = 1000,
|
|
# buffer_width_m = 1500,
|
|
# landscape_margin_m = 1800,
|
|
# detection_radius_m = 20,
|
|
# p_detect_5m = 0.95,
|
|
# p_detect_18m = 0.05,
|
|
# independence_minutes = 30,
|
|
# # relative Aenderung der Nutzung der Fokusflaeche von Jahr 1 bis Jahr 5:
|
|
# focus_use_multiplier_end = 0.60,
|
|
# # Gesamtpopulation konstant (=0) oder jaehrliche proportionale Aenderung:
|
|
# annual_population_change = 0.00,
|
|
# # gleiche Kamerastandorte ueber die Jahre erhoehen Vergleichbarkeit:
|
|
# permanent_cameras = TRUE
|
|
# )
|
|
#
|
|
# # ---- 2. Artprofile ----------------------------------------------------------
|
|
# # home_range_ha beeinflusst die Streuung um das Streifgebietszentrum.
|
|
# # step_scale_m beeinflusst kurzfristige Bewegung; attraction_strength die
|
|
# # Rueckkehr zu Attraktionspunkten. Gamswild kann zusaetzlich durch ein
|
|
# # Habitat-/Topographie-Raster gewichtet werden (siehe habitat_weight_function).
|
|
# SPECIES <- list(
|
|
# Rehwild = list(
|
|
# n_animals = 20,
|
|
# home_range_ha = 70,
|
|
# step_scale_m = 38,
|
|
# n_attraction_points = 7,
|
|
# attraction_strength = 0.10,
|
|
# resting_probability = 0.22,
|
|
# speed_km_day = 3.5,
|
|
# group_size_mean = 1.3
|
|
# ),
|
|
# Rotwild = list(
|
|
# n_animals = 40,
|
|
# home_range_ha = 300,
|
|
# step_scale_m = 105,
|
|
# n_attraction_points = 10,
|
|
# attraction_strength = 0.055,
|
|
# resting_probability = 0.16,
|
|
# speed_km_day = 7.0,
|
|
# group_size_mean = 3.5
|
|
# ),
|
|
# Gamswild = list(
|
|
# n_animals = 50,
|
|
# home_range_ha = 150,
|
|
# step_scale_m = 70,
|
|
# n_attraction_points = 8,
|
|
# attraction_strength = 0.075,
|
|
# resting_probability = 0.18,
|
|
# speed_km_day = 5.0,
|
|
# group_size_mean = 4.2
|
|
# )
|
|
# )
|
|
|
|
# ---- 3. Untersuchungsraum: Fokusflaeche, Buffer, Landschaft ----------------
|
|
make_study_area <- function(cfg = CFG) {
|
|
center <- st_sfc(st_point(c(0, 0)), crs = cfg$crs)
|
|
focus <- st_buffer(center, cfg$focus_radius_m)
|
|
outer <- st_buffer(focus, cfg$buffer_width_m)
|
|
buffer <- st_difference(outer, focus)
|
|
landscape <- st_buffer(outer, cfg$landscape_margin_m)
|
|
|
|
zones <- st_sf(
|
|
zone = c("Fokus", "Buffer"),
|
|
geometry = st_sfc(st_geometry(focus)[[1]], st_geometry(buffer)[[1]]),
|
|
crs = cfg$crs
|
|
)
|
|
list(center = center, focus = focus, buffer = buffer,
|
|
outer = outer, landscape = landscape, zones = zones)
|
|
}
|
|
|
|
#AREA <- make_study_area()
|
|
|
|
# ---- 4. Hilfsfunktionen -----------------------------------------------------
|
|
random_points_min_distance <- function(polygon, n, min_dist, max_tries = 5000) {
|
|
if (n == 0) return(st_sf(geometry = st_sfc(crs = st_crs(polygon))))
|
|
accepted <- NULL
|
|
tries <- 0
|
|
while ((is.null(accepted) || nrow(accepted) < n) && tries < max_tries) {
|
|
tries <- tries + 1
|
|
cand <- st_sample(polygon, size = max(5, n), type = "random")
|
|
if (length(cand) == 0) next
|
|
cand_sf <- st_sf(geometry = cand)
|
|
for (i in seq_len(nrow(cand_sf))) {
|
|
p <- cand_sf[i, ]
|
|
if (is.null(accepted)) {
|
|
accepted <- p
|
|
} else {
|
|
d <- as.numeric(st_distance(p, accepted))
|
|
if (all(d >= min_dist)) accepted <- rbind(accepted, p)
|
|
}
|
|
if (nrow(accepted) >= n) break
|
|
}
|
|
}
|
|
if (is.null(accepted) || nrow(accepted) < n) {
|
|
stop("Kamerazahl/Minimalabstand fuer die Flaeche nicht realisierbar. ",
|
|
"Minimalabstand reduzieren oder Flaeche vergroessern.")
|
|
}
|
|
accepted[seq_len(n), ]
|
|
}
|
|
|
|
# Regelmaessiges Raster mit zufaelligem Versatz und optional zufaelliger Drehung.
|
|
# Der Abstand grid_spacing_m bestimmt die Zahl der Kameras; n_cameras und
|
|
# prop_focus werden im Grid-Modus nicht zur Standortwahl verwendet.
|
|
make_randomized_grid <- function(area = AREA, grid_spacing_m, cfg = CFG) {
|
|
stopifnot(is.numeric(grid_spacing_m), length(grid_spacing_m) == 1,
|
|
is.finite(grid_spacing_m), grid_spacing_m > 0)
|
|
|
|
target <- switch(cfg$grid_clip_to,
|
|
outer = area$outer,
|
|
focus = area$focus,
|
|
buffer = area$buffer,
|
|
stop("cfg$grid_clip_to muss 'outer', 'focus' oder 'buffer' sein."))
|
|
|
|
bb <- st_bbox(target)
|
|
# Grosszuegige Ausgangsausdehnung, damit nach Drehung die Zielflaeche abgedeckt ist.
|
|
cx <- mean(c(bb["xmin"], bb["xmax"]))
|
|
cy <- mean(c(bb["ymin"], bb["ymax"]))
|
|
diagonal <- sqrt((bb["xmax"] - bb["xmin"])^2 +
|
|
(bb["ymax"] - bb["ymin"])^2)
|
|
|
|
# Zufaelliger Rasterursprung innerhalb einer Rasterzelle.
|
|
off_x <- runif(1, 0, grid_spacing_m)
|
|
off_y <- runif(1, 0, grid_spacing_m)
|
|
lim <- as.numeric(diagonal / 2 + 2 * grid_spacing_m)
|
|
xs <- seq(cx - lim + off_x, cx + lim, by = grid_spacing_m)
|
|
ys <- seq(cy - lim + off_y, cy + lim, by = grid_spacing_m)
|
|
xy <- as.matrix(expand.grid(x = xs, y = ys))
|
|
|
|
angle <- if (isTRUE(cfg$grid_random_rotation)) runif(1, 0, pi / 2) else 0
|
|
if (angle != 0) {
|
|
centered <- sweep(xy, 2, c(cx, cy), "-")
|
|
rot <- matrix(c(cos(angle), -sin(angle),
|
|
sin(angle), cos(angle)), nrow = 2, byrow = TRUE)
|
|
xy <- centered %*% t(rot)
|
|
xy <- sweep(xy, 2, c(cx, cy), "+")
|
|
}
|
|
|
|
pts <- st_as_sf(data.frame(x = xy[,1], y = xy[,2]),
|
|
coords = c("x", "y"), crs = cfg$crs)
|
|
pts <- pts[lengths(st_within(pts, target)) > 0, , drop = FALSE]
|
|
if (nrow(pts) == 0) stop("Das Raster erzeugt keine Kamerastandorte in der Zielflaeche.")
|
|
|
|
pts$zone <- ifelse(lengths(st_within(pts, area$focus)) > 0,
|
|
"Fokus", "Buffer")
|
|
pts$grid_spacing_m <- grid_spacing_m
|
|
pts$grid_angle_deg <- angle * 180 / pi
|
|
pts$grid_offset_x_m <- off_x
|
|
pts$grid_offset_y_m <- off_y
|
|
pts
|
|
}
|
|
|
|
make_camera_design <- function(n_cameras = NULL, prop_focus = NULL, area = AREA,
|
|
cfg = CFG, grid_spacing_m = NULL) {
|
|
if (identical(cfg$camera_design_mode, "grid")) {
|
|
if (is.null(grid_spacing_m)) {
|
|
if (length(cfg$grid_spacings_m) != 1)
|
|
stop("Im Einzelaufruf grid_spacing_m angeben oder nur einen Wert in cfg$grid_spacings_m setzen.")
|
|
grid_spacing_m <- cfg$grid_spacings_m
|
|
}
|
|
cams <- make_randomized_grid(area, grid_spacing_m, cfg)
|
|
} else if (identical(cfg$camera_design_mode, "random")) {
|
|
if (is.null(n_cameras) || is.null(prop_focus))
|
|
stop("Im Random-Modus muessen n_cameras und prop_focus angegeben werden.")
|
|
n_focus <- round(n_cameras * prop_focus)
|
|
n_buffer <- n_cameras - n_focus
|
|
cf <- random_points_min_distance(area$focus, n_focus, cfg$min_camera_spacing_m)
|
|
cb <- random_points_min_distance(area$buffer, n_buffer, cfg$min_camera_spacing_m)
|
|
cf$zone <- "Fokus"; cb$zone <- "Buffer"
|
|
cams <- rbind(cf, cb)
|
|
cams$grid_spacing_m <- NA_real_
|
|
cams$grid_angle_deg <- NA_real_
|
|
cams$grid_offset_x_m <- NA_real_
|
|
cams$grid_offset_y_m <- NA_real_
|
|
} else {
|
|
stop("cfg$camera_design_mode muss 'random' oder 'grid' sein.")
|
|
}
|
|
|
|
cams$camera_id <- sprintf("K%03d", seq_len(nrow(cams)))
|
|
cams[, c("camera_id", "zone", "grid_spacing_m", "grid_angle_deg",
|
|
"grid_offset_x_m", "grid_offset_y_m", "geometry")]
|
|
}
|
|
|
|
home_range_sd <- function(home_range_ha) {
|
|
# Kreisflaeche A = pi*r^2; ca. 95%-Radius ~ 2.45*SD bei isotroper Normalverteilung
|
|
radius <- sqrt(home_range_ha * 10000 / pi)
|
|
radius / 2.45
|
|
}
|
|
|
|
focus_multiplier_by_year <- function(year, cfg = CFG) {
|
|
# geometrische Interpolation; Jahr 1 = 1, letztes Jahr = Endmultiplikator
|
|
n <- length(cfg$years)
|
|
cfg$focus_use_multiplier_end ^ ((year - min(cfg$years)) / max(1, n - 1))
|
|
}
|
|
|
|
population_multiplier_by_year <- function(year, cfg = CFG) {
|
|
(1 + cfg$annual_population_change) ^ (year - min(cfg$years))
|
|
}
|
|
|
|
# Gamswild-Anpassung: hier koennen Hangneigung, Hoehe, Exposition, Felsanteil etc.
|
|
# aus Rasterdaten eingebaut werden. Ohne externe Raster wird ein synthetischer
|
|
# alpiner Gradientenfaktor verwendet. Rueckgabewert muss zwischen 0 und 1 liegen.
|
|
habitat_weight_function <- function(x, y, species) {
|
|
if (species != "Gamswild") return(rep(1, length(x)))
|
|
ridge <- exp(-((y - 0.35 * x - 500)^2) / (2 * 850^2))
|
|
rugged <- 0.55 + 0.45 * (sin(x / 230) * cos(y / 270) + 1) / 2
|
|
pmin(1, pmax(0.05, ridge * rugged))
|
|
}
|
|
|
|
sample_centers <- function(n, species, year, area = AREA, cfg = CFG) {
|
|
# Ablehnungssampling: Nutzung der Fokusflaeche kann im Zeitverlauf sinken.
|
|
pts <- vector("list", n)
|
|
focus_mult <- focus_multiplier_by_year(year, cfg)
|
|
i <- 1; tries <- 0
|
|
while (i <= n && tries < 100000) {
|
|
tries <- tries + 1
|
|
cand <- st_sample(area$outer, 1)
|
|
xy <- st_coordinates(cand)
|
|
inside_focus <- lengths(st_intersects(cand, area$focus)) > 0
|
|
w_zone <- ifelse(inside_focus, focus_mult, 1)
|
|
w_hab <- habitat_weight_function(xy[,1], xy[,2], species)
|
|
if (runif(1) < w_zone * w_hab) {
|
|
pts[[i]] <- cand[[1]]
|
|
i <- i + 1
|
|
}
|
|
}
|
|
if (i <= n) stop("Zu wenige Streifgebietszentren akzeptiert.")
|
|
st_sf(animal_id = sprintf("A%04d", seq_len(n)),
|
|
geometry = st_sfc(pts, crs = cfg$crs))
|
|
}
|
|
|
|
simulate_tracks <- function(species, year, pars, area = AREA, cfg = CFG) {
|
|
n <- max(1, round(pars$n_animals * population_multiplier_by_year(year, cfg)))
|
|
centers <- sample_centers(n, species, year, area, cfg)
|
|
center_xy <- st_coordinates(centers)
|
|
hr_sd <- home_range_sd(pars$home_range_ha)
|
|
n_steps <- cfg$survey_days * cfg$fixes_per_day
|
|
dt_hours <- 24 / cfg$fixes_per_day
|
|
|
|
out <- vector("list", n)
|
|
for (a in seq_len(n)) {
|
|
# Attraktionspunkte innerhalb des Streifgebietes
|
|
att <- cbind(
|
|
rnorm(pars$n_attraction_points, center_xy[a,1], hr_sd),
|
|
rnorm(pars$n_attraction_points, center_xy[a,2], hr_sd)
|
|
)
|
|
pos <- matrix(NA_real_, n_steps, 2)
|
|
pos[1, ] <- center_xy[a, ]
|
|
target <- sample.int(nrow(att), 1)
|
|
active <- rep(TRUE, n_steps)
|
|
|
|
for (t in 2:n_steps) {
|
|
if (runif(1) < 0.025) target <- sample.int(nrow(att), 1)
|
|
active[t] <- runif(1) > pars$resting_probability
|
|
if (!active[t]) {
|
|
pos[t, ] <- pos[t-1, ]
|
|
} else {
|
|
pull_att <- pars$attraction_strength * (att[target, ] - pos[t-1, ])
|
|
pull_ctr <- 0.012 * (center_xy[a, ] - pos[t-1, ])
|
|
eps <- rnorm(2, 0, pars$step_scale_m)
|
|
proposed <- pos[t-1, ] + pull_att + pull_ctr + eps
|
|
|
|
# Bei Gamswild: ungeeignete Punkte werden haeufig verworfen.
|
|
hw <- habitat_weight_function(proposed[1], proposed[2], species)
|
|
if (runif(1) > hw) proposed <- pos[t-1, ] + 0.35 * eps + pull_ctr
|
|
pos[t, ] <- proposed
|
|
}
|
|
}
|
|
|
|
out[[a]] <- data.table(
|
|
species = species, year = year,
|
|
animal_id = centers$animal_id[a],
|
|
step = seq_len(n_steps),
|
|
time_hours = (seq_len(n_steps) - 1) * dt_hours,
|
|
x = pos[,1], y = pos[,2], active = active
|
|
)
|
|
}
|
|
rbindlist(out)
|
|
}
|
|
|
|
# Kalibrierung der Distanz-Detektionsfunktion analog zum Tutorial:
|
|
detection_coefficients <- function(p1, d1, p2, d2) {
|
|
beta_d <- (log(-log(1-p1)) - log(-log(1-p2))) / (d1-d2)
|
|
beta_0 <- log(-log(1-p2)) - beta_d*d2
|
|
c(beta0 = beta_0, beta_d = beta_d)
|
|
}
|
|
|
|
# simulate_detections <- function(tracks, cameras, cfg = CFG) {
|
|
# cam_xy <- st_coordinates(cameras)
|
|
# beta <- detection_coefficients(cfg$p_detect_5m, 5,
|
|
# cfg$p_detect_18m, 18)
|
|
# tr <- copy(tracks)
|
|
# # Pro Kamerapunkt nur Positionen innerhalb des Maximalradius pruefen.
|
|
# detections <- vector("list", nrow(cameras))
|
|
# for (k in seq_len(nrow(cameras))) {
|
|
# dx <- tr$x - cam_xy[k,1]
|
|
# dy <- tr$y - cam_xy[k,2]
|
|
# d <- sqrt(dx^2 + dy^2)
|
|
# idx <- which(d <= cfg$detection_radius_m & tr$active)
|
|
# if (length(idx) == 0) next
|
|
# hazard <- exp(beta["beta0"] + beta["beta_d"] * d[idx])
|
|
# p <- 1 - exp(-hazard)
|
|
# hit <- runif(length(idx)) < p
|
|
# idx <- idx[hit]
|
|
# if (length(idx) == 0) next
|
|
# detections[[k]] <- tr[idx, .(
|
|
# species, year, animal_id, step, time_hours
|
|
# )][, `:=`(
|
|
# camera_id = cameras$camera_id[k],
|
|
# zone = cameras$zone[k]
|
|
# )]
|
|
# }
|
|
# det <- rbindlist(detections, fill = TRUE)
|
|
# if (nrow(det) == 0) return(det)
|
|
#
|
|
# # Unabhaengige Ereignisse je Tier x Kamera mit Mindestabstand
|
|
# gap_steps <- max(1, ceiling(cfg$independence_minutes / 60 * cfg$fixes_per_day / 24))
|
|
# setorder(det, camera_id, animal_id, step)
|
|
# det[, new_event := is.na(shift(step)) | (step - shift(step) > gap_steps),
|
|
# by = .(camera_id, animal_id, year)]
|
|
# det <- det[new_event == TRUE]
|
|
#
|
|
# det[, new_event := NULL]
|
|
#
|
|
# }
|
|
|
|
simulate_detections <- function(tracks, cameras, cfg = CFG, verbose = TRUE) {
|
|
|
|
stopifnot(
|
|
all(c("x", "y", "active", "species", "year",
|
|
"animal_id", "step", "time_hours") %in% names(tracks)),
|
|
inherits(cameras, "sf"),
|
|
nrow(cameras) > 0
|
|
)
|
|
|
|
cam_xy <- sf::st_coordinates(cameras)
|
|
|
|
beta <- detection_coefficients(
|
|
p1 = cfg$p_detect_5m,
|
|
d1 = 5,
|
|
p2 = cfg$p_detect_18m,
|
|
d2 = 18
|
|
)
|
|
|
|
tr <- data.table::as.data.table(data.table::copy(tracks))
|
|
|
|
# Immer einen definierten Datentyp zurückgeben
|
|
empty_result <- data.table::data.table(
|
|
species = character(),
|
|
year = integer(),
|
|
animal_id = character(),
|
|
step = integer(),
|
|
time_hours = numeric(),
|
|
camera_id = character(),
|
|
zone = character(),
|
|
distance_m = numeric(),
|
|
p_detect = numeric()
|
|
)
|
|
|
|
if (nrow(tr) == 0) {
|
|
if (verbose) message("Keine Bewegungspositionen vorhanden.")
|
|
return(empty_result)
|
|
}
|
|
|
|
detections <- vector("list", nrow(cameras))
|
|
|
|
n_positions_in_radius <- 0L
|
|
n_stochastic_hits <- 0L
|
|
|
|
for (k in seq_len(nrow(cameras))) {
|
|
|
|
dx <- tr$x - cam_xy[k, 1]
|
|
dy <- tr$y - cam_xy[k, 2]
|
|
distance_m <- sqrt(dx^2 + dy^2)
|
|
|
|
# isTRUE funktioniert hier nicht, da active ein Vektor ist
|
|
active_idx <- !is.na(tr$active) & tr$active == TRUE
|
|
|
|
idx <- which(
|
|
distance_m <= cfg$detection_radius_m &
|
|
active_idx
|
|
)
|
|
|
|
if (length(idx) == 0L) {
|
|
next
|
|
}
|
|
|
|
n_positions_in_radius <- n_positions_in_radius + length(idx)
|
|
|
|
hazard <- exp(
|
|
beta["beta0"] +
|
|
beta["beta_d"] * distance_m[idx]
|
|
)
|
|
|
|
p_detect <- 1 - exp(-hazard)
|
|
p_detect <- pmin(pmax(p_detect, 0), 1)
|
|
|
|
detected <- stats::runif(length(idx)) < p_detect
|
|
|
|
idx_detected <- idx[detected]
|
|
|
|
if (length(idx_detected) == 0L) {
|
|
next
|
|
}
|
|
|
|
n_stochastic_hits <- n_stochastic_hits + length(idx_detected)
|
|
|
|
detections[[k]] <- tr[idx_detected, .(
|
|
species,
|
|
year,
|
|
animal_id,
|
|
step,
|
|
time_hours,
|
|
distance_m = distance_m[idx_detected],
|
|
p_detect = p_detect[detected]
|
|
)][, `:=`(
|
|
camera_id = as.character(cameras$camera_id[k]),
|
|
zone = as.character(cameras$zone[k])
|
|
)]
|
|
}
|
|
|
|
detections <- Filter(Negate(is.null), detections)
|
|
|
|
if (length(detections) == 0L) {
|
|
if (verbose) {
|
|
message(
|
|
"Keine Detektionen erzeugt. ",
|
|
"Aktive Positionen im Detektionsradius: ",
|
|
n_positions_in_radius,
|
|
"; stochastische Treffer: 0."
|
|
)
|
|
}
|
|
|
|
return(empty_result)
|
|
}
|
|
|
|
det <- data.table::rbindlist(
|
|
detections,
|
|
use.names = TRUE,
|
|
fill = TRUE
|
|
)
|
|
|
|
# Zeitabstand der simulierten Positionen in Minuten
|
|
fix_interval_minutes <- 24 * 60 / cfg$fixes_per_day
|
|
|
|
gap_steps <- max(
|
|
1L,
|
|
ceiling(
|
|
cfg$independence_minutes /
|
|
fix_interval_minutes
|
|
)
|
|
)
|
|
|
|
data.table::setorder(
|
|
det,
|
|
camera_id,
|
|
animal_id,
|
|
year,
|
|
step
|
|
)
|
|
|
|
det[, previous_step := data.table::shift(step),
|
|
by = .(camera_id, animal_id, year)]
|
|
|
|
det[, new_event :=
|
|
is.na(previous_step) |
|
|
step - previous_step > gap_steps]
|
|
|
|
det <- det[new_event == TRUE]
|
|
|
|
det[, c("previous_step", "new_event") := NULL]
|
|
|
|
if (verbose) {
|
|
message(
|
|
"Detektionssimulation abgeschlossen: ",
|
|
n_positions_in_radius,
|
|
" aktive Positionen im Radius, ",
|
|
n_stochastic_hits,
|
|
" einzelne Treffer und ",
|
|
nrow(det),
|
|
" unabhängige Ereignisse."
|
|
)
|
|
}
|
|
|
|
det[]
|
|
}
|
|
|
|
# summarise_camera_counts <- function(det, cameras, year, species, cfg = CFG) {
|
|
# base <- data.table(
|
|
# camera_id = cameras$camera_id,
|
|
# zone = cameras$zone,
|
|
# year = year,
|
|
# species = species,
|
|
# effort_days = cfg$survey_days
|
|
# )
|
|
# if (nrow(det) == 0) {
|
|
# base[, events := 0L]
|
|
# } else {
|
|
# cnt <- det[, .(events = .N), by = .(camera_id, zone, year, species)]
|
|
# base <- merge(base, cnt, by = c("camera_id", "zone", "year", "species"),
|
|
# all.x = TRUE)
|
|
# base[is.na(events), events := 0L]
|
|
# }
|
|
# base[, RAI_100_days := 100 * events / effort_days]
|
|
# base
|
|
# }
|
|
|
|
summarise_camera_counts <- function(
|
|
det,
|
|
cameras,
|
|
year,
|
|
species,
|
|
cfg = CFG,
|
|
verbose = TRUE
|
|
) {
|
|
|
|
# Eingaben prüfen
|
|
if (!inherits(cameras, "sf")) {
|
|
stop("'cameras' muss ein sf-Objekt sein.")
|
|
}
|
|
|
|
if (nrow(cameras) == 0L) {
|
|
stop("'cameras' enthält keine Kamerastandorte.")
|
|
}
|
|
|
|
required_camera_columns <- c("camera_id", "zone")
|
|
missing_camera_columns <- setdiff(
|
|
required_camera_columns,
|
|
names(cameras)
|
|
)
|
|
|
|
if (length(missing_camera_columns) > 0L) {
|
|
stop(
|
|
"In 'cameras' fehlen folgende Spalten: ",
|
|
paste(missing_camera_columns, collapse = ", ")
|
|
)
|
|
}
|
|
|
|
# Geometrie entfernen und Datentypen vereinheitlichen
|
|
camera_data <- data.table::as.data.table(
|
|
sf::st_drop_geometry(cameras)
|
|
)
|
|
|
|
base <- camera_data[, .(
|
|
camera_id = as.character(camera_id),
|
|
zone = as.character(zone)
|
|
)]
|
|
|
|
# Doppelte Kamera-IDs verhindern
|
|
if (anyDuplicated(base$camera_id)) {
|
|
stop("Die Spalte 'camera_id' enthält doppelte Werte.")
|
|
}
|
|
|
|
base[, `:=`(
|
|
year = as.integer(year),
|
|
species = as.character(species),
|
|
effort_days = as.numeric(cfg$survey_days),
|
|
events = 0L
|
|
)]
|
|
|
|
# NULL oder vollständig leere Detektionstabelle behandeln
|
|
if (!is.null(det) && NROW(det) > 0L) {
|
|
|
|
det_dt <- data.table::as.data.table(
|
|
data.table::copy(det)
|
|
)
|
|
|
|
required_detection_columns <- c(
|
|
"camera_id",
|
|
"zone",
|
|
"year",
|
|
"species"
|
|
)
|
|
|
|
missing_detection_columns <- setdiff(
|
|
required_detection_columns,
|
|
names(det_dt)
|
|
)
|
|
|
|
if (length(missing_detection_columns) > 0L) {
|
|
stop(
|
|
"In 'det' fehlen folgende Spalten: ",
|
|
paste(missing_detection_columns, collapse = ", ")
|
|
)
|
|
}
|
|
|
|
# Einheitliche Datentypen sind wichtig für den Join
|
|
det_dt[, `:=`(
|
|
camera_id = as.character(camera_id),
|
|
zone = as.character(zone),
|
|
year = as.integer(year),
|
|
species = as.character(species)
|
|
)]
|
|
|
|
counts <- det_dt[
|
|
,
|
|
.(events = .N),
|
|
by = .(camera_id, zone, year, species)
|
|
]
|
|
|
|
# Update-Join: vorhandene Nullen werden durch Ereigniszahlen ersetzt
|
|
base[
|
|
counts,
|
|
on = .(camera_id, zone, year, species),
|
|
events := i.events
|
|
]
|
|
}
|
|
|
|
base[, RAI_100_days := data.table::fifelse(
|
|
effort_days > 0,
|
|
100 * events / effort_days,
|
|
NA_real_
|
|
)]
|
|
|
|
data.table::setorder(base, zone, camera_id)
|
|
|
|
if (verbose) {
|
|
message(
|
|
"Zusammenfassung erstellt: ",
|
|
nrow(base), " Kameras, ",
|
|
sum(base$events), " Ereignisse, Jahr ",
|
|
year, ", Art ", species, "."
|
|
)
|
|
}
|
|
|
|
return(base[])
|
|
}
|
|
|
|
# ---- 5. Statistischer Test: nimmt Fokus relativ zum Buffer ab? --------------
|
|
fit_change_test <- function(camera_counts) {
|
|
dat <- copy(camera_counts)
|
|
dat[, year_c := year - min(year)]
|
|
dat[, zone := factor(zone, levels = c("Buffer", "Fokus"))]
|
|
|
|
# Zielparameter: year_c:zoneFokus < 0
|
|
if (has_glmmTMB) {
|
|
fit <- try(glmmTMB::glmmTMB(
|
|
events ~ year_c * zone + offset(log(effort_days)) + (1 | camera_id),
|
|
family = glmmTMB::nbinom2(), data = dat
|
|
), silent = TRUE)
|
|
if (!inherits(fit, "try-error")) {
|
|
sm <- summary(fit)$coefficients$cond
|
|
term <- "year_c:zoneFokus"
|
|
if (term %in% rownames(sm)) {
|
|
est <- sm[term, "Estimate"]
|
|
p_two <- sm[term, "Pr(>|z|)"]
|
|
p_one <- if (est < 0) p_two / 2 else 1 - p_two / 2
|
|
return(list(estimate = est, p_one_sided = p_one,
|
|
detected = is.finite(p_one) && p_one < CFG$alpha && est < 0,
|
|
method = "NB-GLMM"))
|
|
}
|
|
}
|
|
}
|
|
|
|
# Robuster Fallback: NB-GLM mit Kamera als fixer Effekt
|
|
fit <- try(MASS::glm.nb(
|
|
events ~ year_c * zone + factor(camera_id) + offset(log(effort_days)),
|
|
data = dat
|
|
), silent = TRUE)
|
|
if (inherits(fit, "try-error")) {
|
|
return(list(estimate = NA_real_, p_one_sided = NA_real_,
|
|
detected = FALSE, method = "failed"))
|
|
}
|
|
sm <- coef(summary(fit)); term <- "year_c:zoneFokus"
|
|
if (!term %in% rownames(sm)) {
|
|
return(list(estimate = NA_real_, p_one_sided = NA_real_,
|
|
detected = FALSE, method = "term missing"))
|
|
}
|
|
est <- sm[term, "Estimate"]
|
|
p_two <- sm[term, "Pr(>|z|)"]
|
|
p_one <- if (est < 0) p_two / 2 else 1 - p_two / 2
|
|
list(estimate = est, p_one_sided = p_one,
|
|
detected = is.finite(p_one) && p_one < CFG$alpha && est < 0,
|
|
method = "NB-GLM")
|
|
}
|
|
|
|
# Einfache REM-artige Kennzahl; nur als Sensitivitaetsanalyse verwenden.
|
|
# D proportional zu Ereignisrate / (Geschwindigkeit * Detektionsbreite).
|
|
rem_density_index <- function(camera_counts, species_pars, cfg = CFG) {
|
|
effective_width_km <- 2 * cfg$detection_radius_m / 1000
|
|
camera_counts[, density_index :=
|
|
(events / effort_days) /
|
|
pmax(1e-9, species_pars$speed_km_day * effective_width_km)]
|
|
camera_counts
|
|
}
|
|
|
|
# `%||%` <- function(x, y) {
|
|
# if (!is.null(x)) x else y
|
|
# }
|
|
|
|
|
|
`%||%` <- function(x, y) {
|
|
if (is.null(x) || length(x) == 0L) y else x
|
|
}
|
|
# ---- 6. Eine Simulationswiederholung ---------------------------------------
|
|
run_one_replicate <- function(species, pars, n_cameras = NA_integer_,
|
|
prop_focus = NA_real_, grid_spacing_m = NA_real_,
|
|
replicate_id, cfg = CFG) {
|
|
make_cams <- function() make_camera_design(
|
|
n_cameras = n_cameras, prop_focus = prop_focus, area = AREA, cfg = cfg,
|
|
grid_spacing_m = if (is.finite(grid_spacing_m)) grid_spacing_m else NULL
|
|
)
|
|
cams_fixed <- if (cfg$permanent_cameras) make_cams() else NULL
|
|
|
|
yearly <- vector("list", length(cfg$years))
|
|
for (j in seq_along(cfg$years)) {
|
|
yr <- cfg$years[j]
|
|
cams <- if (cfg$permanent_cameras) cams_fixed else make_cams()
|
|
tracks <- simulate_tracks(species, yr, pars, AREA, cfg)
|
|
det <- simulate_detections(tracks, cams, cfg)
|
|
yearly[[j]] <- summarise_camera_counts(det, cams, yr, species, cfg)
|
|
}
|
|
counts <- rbindlist(yearly)
|
|
counts <- rem_density_index(counts, pars, cfg)
|
|
tst <- fit_change_test(counts)
|
|
|
|
data.table(
|
|
species = species,
|
|
replicate = replicate_id,
|
|
n_cameras = nrow(cams_fixed %||% cams),
|
|
prop_focus = mean((cams_fixed %||% cams)$zone == "Fokus"),
|
|
grid_spacing_m = if (identical(cfg$camera_design_mode, "grid")) grid_spacing_m else NA_real_,
|
|
estimate_interaction = tst$estimate,
|
|
p_one_sided = tst$p_one_sided,
|
|
detected_decline = tst$detected,
|
|
method = tst$method,
|
|
mean_events = mean(counts$events),
|
|
zero_fraction = mean(counts$events == 0)
|
|
)
|
|
}
|
|
|
|
# ---- 7. Vollstaendige Poweranalyse -----------------------------------------
|
|
run_power_analysis <- function(species_names = names(SPECIES), cfg = CFG) {
|
|
if (identical(cfg$camera_design_mode, "grid")) {
|
|
design <- CJ(
|
|
species = species_names,
|
|
grid_spacing_m = cfg$grid_spacings_m,
|
|
replicate = seq_len(cfg$n_replicates),
|
|
unique = TRUE
|
|
)
|
|
design[, `:=`(n_cameras = NA_integer_, prop_focus = NA_real_)]
|
|
} else {
|
|
design <- CJ(
|
|
species = species_names,
|
|
n_cameras = cfg$camera_numbers,
|
|
prop_focus = cfg$allocations_focus,
|
|
replicate = seq_len(cfg$n_replicates),
|
|
unique = TRUE
|
|
)
|
|
design[, grid_spacing_m := NA_real_]
|
|
}
|
|
results <- vector("list", nrow(design))
|
|
|
|
for (i in seq_len(nrow(design))) {
|
|
d <- design[i]
|
|
if (identical(cfg$camera_design_mode, "grid")) {
|
|
message(sprintf("%d/%d: %s, Grid %.0f m, Rep %d",
|
|
i, nrow(design), d$species, d$grid_spacing_m, d$replicate))
|
|
} else {
|
|
message(sprintf("%d/%d: %s, %d Kameras, %.0f%% Fokus, Rep %d",
|
|
i, nrow(design), d$species, d$n_cameras,
|
|
100*d$prop_focus, d$replicate))
|
|
}
|
|
results[[i]] <- tryCatch(
|
|
run_one_replicate(d$species, SPECIES[[d$species]],
|
|
n_cameras = d$n_cameras, prop_focus = d$prop_focus,
|
|
grid_spacing_m = d$grid_spacing_m,
|
|
replicate_id = d$replicate, cfg = cfg),
|
|
error = function(e) data.table(
|
|
species=d$species, replicate=d$replicate,
|
|
n_cameras=d$n_cameras, prop_focus=d$prop_focus,
|
|
grid_spacing_m=d$grid_spacing_m,
|
|
estimate_interaction=NA_real_, p_one_sided=NA_real_,
|
|
detected_decline=FALSE, method=paste("ERROR:", e$message),
|
|
mean_events=NA_real_, zero_fraction=NA_real_
|
|
)
|
|
)
|
|
}
|
|
raw <- rbindlist(results, fill = TRUE)
|
|
if (identical(cfg$camera_design_mode, "grid")) {
|
|
summary <- raw[, .(
|
|
power = mean(detected_decline, na.rm = TRUE),
|
|
valid_runs = sum(is.finite(p_one_sided)),
|
|
mean_effect = mean(estimate_interaction, na.rm = TRUE),
|
|
n_cameras = mean(n_cameras, na.rm = TRUE),
|
|
n_cameras_min = min(n_cameras, na.rm = TRUE),
|
|
n_cameras_max = max(n_cameras, na.rm = TRUE),
|
|
prop_focus = mean(prop_focus, na.rm = TRUE),
|
|
median_events_per_camera_year = median(mean_events, na.rm = TRUE),
|
|
mean_zero_fraction = mean(zero_fraction, na.rm = TRUE)
|
|
), by = .(species, grid_spacing_m)]
|
|
} else {
|
|
summary <- raw[, .(
|
|
power = mean(detected_decline, na.rm = TRUE),
|
|
valid_runs = sum(is.finite(p_one_sided)),
|
|
mean_effect = mean(estimate_interaction, na.rm = TRUE),
|
|
median_events_per_camera_year = median(mean_events, na.rm = TRUE),
|
|
mean_zero_fraction = mean(zero_fraction, na.rm = TRUE)
|
|
), by = .(species, n_cameras, prop_focus)]
|
|
summary[, grid_spacing_m := NA_real_]
|
|
}
|
|
summary[, reaches_target := power >= cfg$target_power]
|
|
list(raw = raw, summary = summary)
|
|
}
|
|
|
|
|
|
# Run Power Analysis in Parallel ------------------------------------------
|
|
|
|
run_power_analysis_parallel <- function(
|
|
species_names = names(SPECIES),
|
|
cfg = CFG,
|
|
species_profiles = SPECIES,
|
|
n_cores = max(1, parallel::detectCores() - 1),
|
|
seed = 777
|
|
) {
|
|
|
|
requireNamespace("future", quietly = TRUE)
|
|
requireNamespace("future.apply", quietly = TRUE)
|
|
requireNamespace("data.table", quietly = TRUE)
|
|
|
|
future::plan(
|
|
future::multisession,
|
|
workers = n_cores
|
|
)
|
|
|
|
on.exit(
|
|
future::plan(future::sequential),
|
|
add = TRUE
|
|
)
|
|
|
|
# ------------------------------------------------------------
|
|
# Szenarien definieren
|
|
# ------------------------------------------------------------
|
|
|
|
if (cfg$camera_design_mode == "grid") {
|
|
|
|
scenarios <- expand.grid(
|
|
species = species_names,
|
|
grid_spacing_m = cfg$grid_spacings_m,
|
|
stringsAsFactors = FALSE
|
|
)
|
|
|
|
} else {
|
|
|
|
scenarios <- expand.grid(
|
|
species = species_names,
|
|
n_cameras = cfg$camera_numbers,
|
|
prop_focus = cfg$allocations_focus,
|
|
stringsAsFactors = FALSE
|
|
)
|
|
}
|
|
|
|
all_results <- vector(
|
|
"list",
|
|
nrow(scenarios)
|
|
)
|
|
|
|
# ------------------------------------------------------------
|
|
# Szenarien
|
|
# ------------------------------------------------------------
|
|
|
|
for (s in seq_len(nrow(scenarios))) {
|
|
|
|
species <- scenarios$species[s]
|
|
|
|
if (cfg$camera_design_mode == "grid") {
|
|
|
|
grid_spacing_m <- scenarios$grid_spacing_m[s]
|
|
|
|
message(
|
|
"Szenario ",
|
|
s, "/", nrow(scenarios),
|
|
": ",
|
|
species,
|
|
" | Grid ",
|
|
grid_spacing_m,
|
|
" m"
|
|
)
|
|
|
|
} else {
|
|
|
|
n_cameras <- scenarios$n_cameras[s]
|
|
prop_focus <- scenarios$prop_focus[s]
|
|
|
|
message(
|
|
"Szenario ",
|
|
s, "/", nrow(scenarios),
|
|
": ",
|
|
species,
|
|
" | ",
|
|
n_cameras,
|
|
" Kameras | Fokusanteil ",
|
|
prop_focus
|
|
)
|
|
}
|
|
|
|
# ----------------------------------------------------------
|
|
# Replikate parallel ausführen
|
|
# ----------------------------------------------------------
|
|
|
|
reps <- future.apply::future_lapply(
|
|
|
|
seq_len(cfg$n_replicates),
|
|
|
|
function(rep_id) {
|
|
|
|
tryCatch({
|
|
|
|
if (cfg$camera_design_mode == "grid") {
|
|
|
|
res <- run_one_replicate(
|
|
species = species,
|
|
pars = species_profiles[[species]],
|
|
grid_spacing_m = grid_spacing_m,
|
|
replicate_id = rep_id,
|
|
cfg = cfg
|
|
)
|
|
|
|
} else {
|
|
|
|
res <- run_one_replicate(
|
|
species = species,
|
|
pars = species_profiles[[species]],
|
|
n_cameras = n_cameras,
|
|
allocation_focus = prop_focus,
|
|
replicate_id = rep_id,
|
|
cfg = cfg
|
|
)
|
|
}
|
|
|
|
res <- data.table::as.data.table(res)
|
|
|
|
# Erfolgreicher Lauf
|
|
res[, `:=`(
|
|
error = FALSE,
|
|
error_message = NA_character_
|
|
)]
|
|
|
|
res
|
|
|
|
}, error = function(e) {
|
|
|
|
# Fehlgeschlagener Lauf erhält exakt dieselbe Struktur
|
|
data.table::data.table(
|
|
|
|
species = species,
|
|
|
|
replicate = rep_id,
|
|
|
|
n_cameras =
|
|
if (cfg$camera_design_mode == "random")
|
|
as.numeric(n_cameras)
|
|
else
|
|
NA_real_,
|
|
|
|
prop_focus =
|
|
if (cfg$camera_design_mode == "random")
|
|
as.numeric(prop_focus)
|
|
else
|
|
NA_real_,
|
|
|
|
grid_spacing_m =
|
|
if (cfg$camera_design_mode == "grid")
|
|
as.numeric(grid_spacing_m)
|
|
else
|
|
NA_real_,
|
|
|
|
estimate_interaction = NA_real_,
|
|
|
|
p_one_sided = NA_real_,
|
|
|
|
detected_decline = NA,
|
|
|
|
method = NA_character_,
|
|
|
|
mean_events = NA_real_,
|
|
|
|
zero_fraction = NA_real_,
|
|
|
|
error = TRUE,
|
|
|
|
error_message = conditionMessage(e)
|
|
)
|
|
})
|
|
|
|
},
|
|
|
|
future.seed = seed + s
|
|
)
|
|
|
|
all_results[[s]] <- data.table::rbindlist(
|
|
reps,
|
|
use.names = TRUE,
|
|
fill = TRUE
|
|
)
|
|
}
|
|
|
|
# ------------------------------------------------------------
|
|
# Alle Ergebnisse zusammenführen
|
|
# ------------------------------------------------------------
|
|
|
|
raw <- data.table::rbindlist(
|
|
all_results,
|
|
use.names = TRUE,
|
|
fill = TRUE
|
|
)
|
|
|
|
# Sicherheitsnetz
|
|
if (!"error" %in% names(raw)) {
|
|
raw[, error := FALSE]
|
|
}
|
|
|
|
if (!"error_message" %in% names(raw)) {
|
|
raw[, error_message := NA_character_]
|
|
}
|
|
|
|
# ------------------------------------------------------------
|
|
# POWER-ZUSAMMENFASSUNG
|
|
# ------------------------------------------------------------
|
|
|
|
if (cfg$camera_design_mode == "grid") {
|
|
|
|
summary <- raw[
|
|
,
|
|
.(
|
|
n_requested = .N,
|
|
|
|
n_valid = sum(
|
|
!error &
|
|
!is.na(detected_decline)
|
|
),
|
|
|
|
n_errors = sum(error),
|
|
|
|
error_rate = mean(error),
|
|
|
|
power = {
|
|
z <- detected_decline[
|
|
!error &
|
|
!is.na(detected_decline)
|
|
]
|
|
|
|
if (!length(z)) {
|
|
NA_real_
|
|
} else {
|
|
mean(z)
|
|
}
|
|
},
|
|
|
|
mean_n_cameras = {
|
|
z <- n_cameras[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
min_n_cameras = {
|
|
z <- n_cameras[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
min(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
max_n_cameras = {
|
|
z <- n_cameras[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
max(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
mean_prop_focus = {
|
|
z <- prop_focus[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
mean_interaction = {
|
|
z <- estimate_interaction[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
mean_p_one_sided = {
|
|
z <- p_one_sided[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
mean_events = {
|
|
z <- mean_events[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
mean_zero_fraction = {
|
|
z <- zero_fraction[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
}
|
|
),
|
|
|
|
by = .(
|
|
species,
|
|
grid_spacing_m
|
|
)
|
|
]
|
|
|
|
} else {
|
|
|
|
summary <- raw[
|
|
,
|
|
.(
|
|
n_requested = .N,
|
|
|
|
n_valid = sum(
|
|
!error &
|
|
!is.na(detected_decline)
|
|
),
|
|
|
|
n_errors = sum(error),
|
|
|
|
error_rate = mean(error),
|
|
|
|
power = {
|
|
z <- detected_decline[
|
|
!error &
|
|
!is.na(detected_decline)
|
|
]
|
|
|
|
if (!length(z)) NA_real_ else mean(z)
|
|
},
|
|
|
|
mean_interaction = {
|
|
z <- estimate_interaction[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
mean_events = {
|
|
z <- mean_events[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
},
|
|
|
|
mean_zero_fraction = {
|
|
z <- zero_fraction[!error]
|
|
|
|
if (!length(z) || all(is.na(z))) {
|
|
NA_real_
|
|
} else {
|
|
mean(z, na.rm = TRUE)
|
|
}
|
|
}
|
|
),
|
|
|
|
by = .(
|
|
species,
|
|
n_cameras,
|
|
prop_focus
|
|
)
|
|
]
|
|
}
|
|
|
|
# ------------------------------------------------------------
|
|
# Fehlertabelle
|
|
# ------------------------------------------------------------
|
|
|
|
errors <- raw[
|
|
error == TRUE,
|
|
.(
|
|
N = .N
|
|
),
|
|
by = .(
|
|
species,
|
|
grid_spacing_m,
|
|
error_message
|
|
)
|
|
][order(-N)]
|
|
|
|
# ------------------------------------------------------------
|
|
# Rückgabe
|
|
# ------------------------------------------------------------
|
|
|
|
list(
|
|
raw = raw,
|
|
summary = summary,
|
|
errors = errors
|
|
)
|
|
}
|
|
|
|
|
|
# ---- 8. Beispiel / Hauptlauf -----------------------------------------------
|
|
# Zuerst einen kleinen Testlauf starten. Danach n_replicates in CFG erhoehen.
|
|
RUN_FULL_ANALYSIS <- FALSE
|
|
|
|
if (RUN_FULL_ANALYSIS) {
|
|
ans <- run_power_analysis()
|
|
fwrite(ans$raw, "power_raw.csv")
|
|
fwrite(ans$summary, "power_summary.csv")
|
|
|
|
# Auch im Grid-Modus wird gegen die tatsaechlich resultierende Kamerazahl geplottet.
|
|
p <- ggplot(ans$summary,
|
|
aes(x = n_cameras, y = power,
|
|
group = if (identical(CFG$camera_design_mode, "grid"))
|
|
factor(grid_spacing_m) else factor(prop_focus),
|
|
linetype = if (identical(CFG$camera_design_mode, "grid"))
|
|
factor(grid_spacing_m) else factor(prop_focus))) +
|
|
geom_line() + geom_point() +
|
|
geom_hline(yintercept = CFG$target_power, linetype = 2) +
|
|
facet_wrap(~ species) +
|
|
scale_y_continuous(limits = c(0,1)) +
|
|
labs(x = "Gesamtzahl Kameras", y = "Power",
|
|
linetype = if (identical(CFG$camera_design_mode, "grid"))
|
|
"Grid-Abstand (m)" else "Anteil Fokus",
|
|
title = "Power zur Erkennung einer Abnahme der Fokusflaechennutzung") +
|
|
theme_bw()
|
|
ggsave("power_sampling_design.png", p, width = 10, height = 6, dpi = 300)
|
|
|
|
# Kleinstes Design je Art mit Ziel-Power:
|
|
recommendation <- ans$summary[reaches_target == TRUE][
|
|
order(n_cameras, -power), .SD[1], by = species]
|
|
print(recommendation)
|
|
}
|
|
|
|
# ---- 9. Schneller Funktionscheck -------------------------------------------
|
|
# Dieser Block ist absichtlich klein und kann direkt ausgefuehrt werden.
|
|
RUN_SMOKE_TEST <- FALSE
|
|
if (RUN_SMOKE_TEST) {
|
|
cfg_test <- CFG
|
|
cfg_test$years <- 1:3
|
|
cfg_test$survey_days <- 5
|
|
cfg_test$fixes_per_day <- 24
|
|
cfg_test$n_replicates <- 2
|
|
cfg_test$camera_design_mode <- "grid"
|
|
cfg_test$grid_spacings_m <- 700
|
|
|
|
smoke <- run_one_replicate(
|
|
species = "Rehwild", pars = SPECIES$Rehwild,
|
|
grid_spacing_m = 700, replicate_id = 1, cfg = cfg_test
|
|
)
|
|
print(smoke)
|
|
}
|
|
|
|
# ---- 10. Empfohlene Kalibrierung mit realen Daten --------------------------
|
|
# A) Streifgebietsgroessen:
|
|
# SPECIES[[Art]]$home_range_ha aus GPS-Daten (z.B. AKDE/MCP) setzen.
|
|
# B) Bewegung:
|
|
# step_scale_m und resting_probability anhand Schrittlaengen/Aktivitaet.
|
|
# C) Gamswild:
|
|
# habitat_weight_function durch Vorhersagen eines RSF/SSF-Modells mit
|
|
# Hoehe, Hangneigung, Exposition, Fels/Wald und Schneelage ersetzen.
|
|
# D) Kameras:
|
|
# camera_design_mode = "grid" und grid_spacings_m anpassen; jeder Lauf
|
|
# verwendet einen zufaelligen Rasterversatz und optional eine Drehung.
|
|
# Fuer feste reale Standorte vorhandene/erlaubte Punkte als sf einlesen.
|
|
# E) Effektszenarien:
|
|
# focus_use_multiplier_end = 0.9, 0.8, 0.7, ... fuer minimale erkennbare
|
|
# Abnahme testen; annual_population_change separat variieren.
|
|
# F) Interpretation:
|
|
# Eine sinkende Detektionsrate kann durch geringere Dichte, geringere
|
|
# Nutzung, veraenderte Aktivitaet oder Detektierbarkeit entstehen. Das
|
|
# Fokus-vs-Buffer-BACI-aehnliche Design hilft, trennt diese Prozesse aber
|
|
# nicht ohne Zusatzdaten vollstaendig.
|