Files
ffdaten_simulation_R/fotofallen_power_simulation_schalenwild_rai.R
2026-08-18 22:48:25 +00:00

508 lines
12 KiB
R

library(data.table)
library(future)
library(future.apply)
simulate_rai_designs <- function(
run_id,
CFG,
SPECIES,
AREA,
year = 1,
species_names = c("Rehwild", "Rotwild", "Gamswild"),
save_each_design = TRUE,
output_dir = "rai_results",
parallel = FALSE,
n_cores = max(1, parallel::detectCores() - 1),
seed = 777
) {
dir.create(
output_dir,
showWarnings = FALSE,
recursive = TRUE
)
# ------------------------------------------------------------
# 1. Tracks nur einmal pro Art simulieren
# ------------------------------------------------------------
message("Simuliere Tracks ...")
tracks <- lapply(
species_names,
function(sp) {
simulate_tracks(
species = sp,
year = year,
pars = SPECIES[[sp]],
area = AREA,
cfg = CFG
)
}
)
names(tracks) <- species_names
# ------------------------------------------------------------
# 2. Alle Sampling-Designs als Tabelle erzeugen
# ------------------------------------------------------------
grid_designs <- data.table(
sampling = "grid",
grid_spacing = CFG$grid_spacings_m,
n_cameras_requested = NA_integer_,
prop_focus_requested = NA_real_
)
random_designs <- CJ(
n_cameras_requested = CFG$camera_numbers,
prop_focus_requested = CFG$allocations_focus
)
random_designs[, `:=`(
sampling = "random",
grid_spacing = NA_real_
)]
designs <- rbindlist(
list(
grid_designs,
random_designs
),
use.names = TRUE,
fill = TRUE
)
designs[, design_id := .I]
message(
"Anzahl Sampling-Designs: ",
nrow(designs)
)
# ------------------------------------------------------------
# 3. Funktion für EIN Sampling-Design
# ------------------------------------------------------------
simulate_one_design <- function(i) {
design <- designs[i]
set.seed(seed + run_id * 100000 + design$design_id)
# ----------------------------------------------------------
# Dateiname schon vorab definieren
# ----------------------------------------------------------
filename <- if (design$sampling == "grid") {
sprintf(
"run_%04d_grid_%04dm.csv",
run_id,
round(design$grid_spacing)
)
} else {
sprintf(
"run_%04d_random_%03dcams_focus_%03d.csv",
run_id,
round(design$n_cameras_requested),
round(100 * design$prop_focus_requested)
)
}
# ----------------------------------------------------------
# Gesamtes Design absichern
# ----------------------------------------------------------
result <- tryCatch({
# --------------------------------------------------------
# Kameradesign erzeugen
# --------------------------------------------------------
if (design$sampling == "grid") {
cfg_design <- CFG
cfg_design$camera_design_mode <- "grid"
cfg_design$grid_random_rotation <- TRUE
cameras <- make_camera_design(
area = AREA,
cfg = cfg_design,
grid_spacing_m = design$grid_spacing
)
} else {
cfg_design <- CFG
cfg_design$camera_design_mode <- "random"
cameras <- make_camera_design(
n_cameras = design$n_cameras_requested,
area = AREA,
cfg = cfg_design,
prop_focus = design$prop_focus_requested
)
}
# --------------------------------------------------------
# Zusätzliche Plausibilitätschecks
# --------------------------------------------------------
if (is.null(cameras) || nrow(cameras) == 0) {
stop("Es konnten keine Kamerastandorte erzeugt werden.")
}
if (!"zone" %in% names(cameras)) {
stop("Das Kameradesign enthält keine Spalte 'zone'.")
}
# --------------------------------------------------------
# Alle Arten
# --------------------------------------------------------
species_results <- lapply(
species_names,
function(sp) {
tryCatch({
det <- simulate_detections(
tracks = tracks[[sp]],
cameras = cameras,
cfg = cfg_design,
verbose = FALSE
)
out <- summarise_camera_counts(
det = det,
cameras = cameras,
year = year,
species = sp,
cfg = cfg_design,
verbose = FALSE
)
out[, `:=`(
run = run_id,
sampling = design$sampling,
grid_spacing =
if (design$sampling == "grid")
design$grid_spacing
else
NA_real_,
cameras = nrow(cameras),
n_cameras_requested =
design$n_cameras_requested,
prop_focus_requested =
design$prop_focus_requested,
prop_focus_realised =
mean(cameras$zone == "Fokus"),
design_id = design$design_id,
simulation_ok = TRUE,
error_stage = NA_character_,
error_message = NA_character_
)]
out
}, error = function(e) {
# Fehler nur für eine Art:
data.table::data.table(
run = run_id,
year = year,
species = sp,
sampling = design$sampling,
grid_spacing =
if (design$sampling == "grid")
design$grid_spacing
else
NA_real_,
cameras = nrow(cameras),
n_cameras_requested =
design$n_cameras_requested,
prop_focus_requested =
design$prop_focus_requested,
prop_focus_realised =
mean(cameras$zone == "Fokus"),
design_id = design$design_id,
simulation_ok = FALSE,
error_stage = "species_simulation",
error_message = conditionMessage(e),
camera_id = NA_character_,
zone = NA_character_,
effort_days = NA_real_,
events = NA_integer_,
RAI_100_days = NA_real_
)
})
}
)
data.table::rbindlist(
species_results,
use.names = TRUE,
fill = TRUE
)
}, error = function(e) {
# --------------------------------------------------------
# Fehler beim gesamten Sampling-Design
# z.B. Mindestabstand nicht realisierbar
# --------------------------------------------------------
data.table::data.table(
run = run_id,
year = year,
species = species_names,
sampling = design$sampling,
grid_spacing =
if (design$sampling == "grid")
design$grid_spacing
else
NA_real_,
cameras = NA_integer_,
n_cameras_requested =
design$n_cameras_requested,
prop_focus_requested =
design$prop_focus_requested,
prop_focus_realised = NA_real_,
design_id = design$design_id,
simulation_ok = FALSE,
error_stage = "camera_design",
error_message = conditionMessage(e),
camera_id = NA_character_,
zone = NA_character_,
effort_days = NA_real_,
events = NA_integer_,
RAI_100_days = NA_real_
)
})
# ----------------------------------------------------------
# Zwischenstand IMMER speichern
# auch wenn das Design fehlgeschlagen ist
# ----------------------------------------------------------
if (save_each_design) {
data.table::fwrite(
result,
file.path(output_dir, filename)
)
}
# Konsolenmeldung
if (all(result$simulation_ok %in% FALSE)) {
message(
"Design ", design$design_id,
" fehlgeschlagen: ",
unique(result$error_message)[1]
)
} else {
message(
"Design ", design$design_id,
" erfolgreich abgeschlossen."
)
}
return(result)
}
# ------------------------------------------------------------
# 4. Designs sequenziell oder parallel
# ------------------------------------------------------------
if (parallel) {
future::plan(
future::multisession,
workers = n_cores
)
on.exit(
future::plan(future::sequential),
add = TRUE
)
message(
"Parallelisierung mit ",
n_cores,
" Workern."
)
results <- future.apply::future_lapply(
seq_len(nrow(designs)),
simulate_one_design,
future.seed = TRUE
)
} else {
results <- lapply(
seq_len(nrow(designs)),
function(i) {
message(
"Design ",
i,
"/",
nrow(designs)
)
simulate_one_design(i)
}
)
}
# ------------------------------------------------------------
# 5. Alles zusammenführen
# ------------------------------------------------------------
all_results <- rbindlist(
results,
use.names = TRUE,
fill = TRUE
)
# ------------------------------------------------------------
# 6. Gesamten Run speichern
# ------------------------------------------------------------
run_file <- file.path(
output_dir,
sprintf(
"run_%04d_all_designs.csv",
run_id
)
)
fwrite(
all_results,
run_file
)
# ------------------------------------------------------------
# 7. RAI-Zusammenfassung
# ------------------------------------------------------------
rai_summary <- all_results[
simulation_ok == TRUE,
.(
mean_RAI = mean(RAI_100_days, na.rm = TRUE),
sd_RAI = sd(RAI_100_days, na.rm = TRUE),
median_RAI = median(RAI_100_days, na.rm = TRUE),
n_cameras = uniqueN(camera_id),
n_zero_cameras = sum(events == 0, na.rm = TRUE),
prop_zero_cameras = mean(
events == 0,
na.rm = TRUE
),
total_events = sum(
events,
na.rm = TRUE
)
),
by = .(
run,
species,
sampling,
grid_spacing,
n_cameras_requested,
prop_focus_requested,
prop_focus_realised,
cameras
)
]
fwrite(
rai_summary,
file.path(
output_dir,
sprintf(
"run_%04d_RAI_summary.csv",
run_id
)
)
)
error_summary <- all_results[
simulation_ok == FALSE,
.(
n_errors = .N
),
by = .(
run,
sampling,
grid_spacing,
n_cameras_requested,
prop_focus_requested,
error_stage,
error_message
)
]
fwrite(
error_summary,
file.path(
output_dir,
sprintf(
"run_%04d_errors.csv",
run_id
)
)
)
return(
list(
camera_level = all_results,
rai_summary = rai_summary,
designs = designs
)
)
}