Upload 24 files

code/00_verify_bundle.R

@@ -0,0 +1,18 @@
+#!/usr/bin/env Rscript
+
+file_arg <- grep("^--file=", commandArgs(FALSE), value = TRUE)
+script_path <- sub("^--file=", "", file_arg[[1]])
+source(file.path(dirname(normalizePath(script_path, mustWork = FALSE)), "common.R"))
+
+root <- set_replication_root()
+verify_hash <- !parse_env_flag("IMAGEDECONFOUND_SKIP_HASH", default = FALSE)
+summary <- verify_bundle(verify_hash = verify_hash)
+
+cat("\nBundle summary\n")
+cat("Root: ", summary$root, "\n", sep = "")
+cat("Processed result files: ", summary$results_processed_n, "\n", sep = "")
+cat("Manuscript figure assets: ", summary$manuscript_fig_n, "\n", sep = "")
+cat("Per-run CSV directories:\n")
+for (name in names(summary$per_run_csv_counts)) {
+  cat("  - ", name, ": ", summary$per_run_csv_counts[[name]], "\n", sep = "")
+}

code/01_rebuild_paper_outputs.R

@@ -0,0 +1,13 @@
+#!/usr/bin/env Rscript
+
+file_arg <- grep("^--file=", commandArgs(FALSE), value = TRUE)
+script_path <- sub("^--file=", "", file_arg[[1]])
+source(file.path(dirname(normalizePath(script_path, mustWork = FALSE)), "common.R"))
+
+root <- set_replication_root()
+message("Rebuilding consolidated outputs, figures, and tables from bundled replication assets.")
+
+sys.source(file.path(root, "code", "04_consolidate_results.R"), envir = new.env(parent = globalenv()))
+sys.source(file.path(root, "code", "05_build_figures_tables.R"), envir = new.env(parent = globalenv()))
+
+message("Rebuild complete.")

code/02_run_main_ate_optional.R

@@ -0,0 +1,48 @@
+#!/usr/bin/env Rscript
+
+file_arg <- grep("^--file=", commandArgs(FALSE), value = TRUE)
+script_path <- sub("^--file=", "", file_arg[[1]])
+source(file.path(dirname(normalizePath(script_path, mustWork = FALSE)), "common.R"))
+
+root <- set_replication_root()
+args <- commandArgs(trailingOnly = TRUE)
+if (length(args) == 0) {
+  stop("Pass one or more outer-sequence row indices. Example: Rscript code/02_run_main_ate_optional.R 1")
+}
+
+resave_tfrecords <- parse_env_flag("IMAGEDECONFOUND_RESAVE_TFRECORDS", default = FALSE)
+tfrecord_home <- resolve_external_path("IMAGEDECONFOUND_TFRECORD_HOME", "external_artifacts/tfrecords")
+image_root <- resolve_external_path("IMAGEDECONFOUND_IMAGE_ROOT", "external_artifacts/images/dhs_tifs_5k_3yr")
+
+ensure_dir(tfrecord_home)
+
+if (!resave_tfrecords) {
+  tfrecord_n <- length(list.files(tfrecord_home, pattern = "\\.tfrecord$", full.names = TRUE))
+  if (tfrecord_n == 0) {
+    stop(
+      "No TFRecord files were found in ", tfrecord_home, ". ",
+      "Either place the required TFRecords there or rerun with IMAGEDECONFOUND_RESAVE_TFRECORDS=true ",
+      "after downloading the excluded image files locally."
+    )
+  }
+} else if (!dir.exists(image_root)) {
+  stop(
+    "IMAGEDECONFOUND_RESAVE_TFRECORDS=true but the image directory does not exist: ",
+    image_root
+  )
+}
+
+run_replication_script(
+  "code/lib/call_CI_Conf_5k_3yr.R",
+  overrides = list(
+    SAVE_RESULTS_FOLDER_OVERRIDE = "per_run_csv/Epoch5EarlyStopNewTreatDefLabelS_Run2",
+    X_APPROACH_OPTIONS_OVERRIDE = c(
+      "noX", "onlyX", "onlyFE", "onlyXandFE",
+      "withX", "withFE", "withXandFE"
+    ),
+    REQUIRE_EXPLICIT_OUTER_SEQ = TRUE,
+    TFRECORD_HOME_OVERRIDE = tfrecord_home,
+    IMAGE_ROOT_OVERRIDE = image_root,
+    RESAVE_TFRECORDS_OVERRIDE = resave_tfrecords
+  )
+)

code/03_run_within_unit_robustness.R

@@ -0,0 +1,18 @@
+#!/usr/bin/env Rscript
+
+file_arg <- grep("^--file=", commandArgs(FALSE), value = TRUE)
+script_path <- sub("^--file=", "", file_arg[[1]])
+source(file.path(dirname(normalizePath(script_path, mustWork = FALSE)), "common.R"))
+
+set_replication_root()
+message("Running bundled within-unit robustness analyses (unit FE and DiD).")
+
+run_replication_script(
+  "code/lib/call_CI_Conf_5k_3yr.R",
+  overrides = list(
+    SAVE_RESULTS_FOLDER_OVERRIDE = "per_run_csv/Epoch5EarlyStopNewTreatDefLabelS_Run2",
+    X_APPROACH_OPTIONS_OVERRIDE = c("unitFE", "did"),
+    REQUIRE_EXPLICIT_OUTER_SEQ = FALSE,
+    RESAVE_TFRECORDS_OVERRIDE = FALSE
+  )
+)

code/04_consolidate_results.R

@@ -0,0 +1,58 @@
+#!/usr/bin/env Rscript
+
+file_arg <- grep("^--file=", commandArgs(FALSE), value = TRUE)
+script_path <- sub("^--file=", "", file_arg[[1]])
+source(file.path(dirname(normalizePath(script_path, mustWork = FALSE)), "common.R"))
+
+root <- set_replication_root()
+results_root_relative <- "./results/per_run_csv/Epoch5EarlyStopNewTreatDefLabelS_Run2"
+results_root <- file.path(root, "results", "per_run_csv", "Epoch5EarlyStopNewTreatDefLabelS_Run2")
+
+ensure_dir(file.path(results_root, "results_processed"))
+
+message("Consolidating main image-confounding outputs.")
+run_replication_script(
+  "code/lib/consolidate_CI_output_across_runs.R",
+  overrides = list(
+    CONSOLIDATE_RESULTS_DIR_OVERRIDE = results_root_relative
+  )
+)
+
+message("Consolidating unit fixed-effects robustness outputs.")
+run_replication_script(
+  "code/lib/consolidate_CI_output_across_did.R",
+  overrides = list(
+    WITHIN_UNIT_RESULTS_DIR_OVERRIDE = file.path(results_root_relative, "vt_3yr_unitFE"),
+    WITHIN_UNIT_OUTPUT_OVERRIDE = file.path(
+      results_root_relative,
+      "results_processed",
+      "wb_vs_ch_sector_scatter_WithinUnitVar.pdf"
+    ),
+    WITHIN_UNIT_CAPTION_OVERRIDE = "Estimation method: Unit fixed effects."
+  )
+)
+
+message("Consolidating difference-in-differences robustness outputs.")
+run_replication_script(
+  "code/lib/consolidate_CI_output_across_did.R",
+  overrides = list(
+    WITHIN_UNIT_RESULTS_DIR_OVERRIDE = file.path(results_root_relative, "vt_3yr_did"),
+    WITHIN_UNIT_OUTPUT_OVERRIDE = file.path(
+      results_root_relative,
+      "results_processed",
+      "wb_vs_ch_sector_scatter_DiD.pdf"
+    ),
+    WITHIN_UNIT_CAPTION_OVERRIDE = "Estimation method: Difference-in-differences."
+  )
+)
+
+sync_results_processed()
+sync_table_assets()
+
+unit_fe_plot <- file.path(root, "results", "processed", "wb_vs_ch_sector_scatter_WithinUnitVar.pdf")
+unit_fe_alias <- file.path(root, "results", "processed", "wb_vs_ch_sector_scatter_WithinUnitFE.pdf")
+if (file.exists(unit_fe_plot)) {
+  file.copy(unit_fe_plot, unit_fe_alias, overwrite = TRUE)
+}
+
+message("Consolidated outputs are available in results/processed.")

code/05_build_figures_tables.R

@@ -0,0 +1,19 @@
+#!/usr/bin/env Rscript
+
+file_arg <- grep("^--file=", commandArgs(FALSE), value = TRUE)
+script_path <- sub("^--file=", "", file_arg[[1]])
+source(file.path(dirname(normalizePath(script_path, mustWork = FALSE)), "common.R"))
+
+root <- set_replication_root()
+ensure_dir(file.path(root, "figures"))
+ensure_dir(file.path(root, "tables"))
+
+message("Rebuilding descriptive figures.")
+run_replication_script("code/lib/chart_projects.R")
+run_replication_script("code/lib/chart_dhs_projs.R")
+
+message("Rebuilding descriptive tables.")
+run_replication_script("code/lib/prep_desc_stats.R")
+sync_table_assets()
+
+message("Figures are available in figures/ and tables are available in tables/.")

code/06_list_run_grid.R

@@ -0,0 +1,41 @@
+#!/usr/bin/env Rscript
+
+file_arg <- grep("^--file=", commandArgs(FALSE), value = TRUE)
+script_path <- sub("^--file=", "", file_arg[[1]])
+source(file.path(dirname(normalizePath(script_path, mustWork = FALSE)), "common.R"))
+
+set_replication_root()
+
+args <- commandArgs(trailingOnly = TRUE)
+grid_name <- if (length(args) > 0) args[[1]] else "main"
+
+fund_sect_params <- c(
+  "ch_430", "ch_520", "ch_700", "ch_140", "ch_230", "ch_220",
+  "ch_310", "ch_160", "wb_330", "wb_410", "ch_110", "ch_210",
+  "wb_240", "wb_220", "ch_150", "ch_120", "wb_320", "wb_230",
+  "wb_110", "wb_120", "wb_310", "wb_160", "wb_140", "wb_210", "wb_150"
+)
+
+if (identical(grid_name, "within_unit")) {
+  x_approach_options <- c("unitFE", "did")
+} else if (identical(grid_name, "main")) {
+  x_approach_options <- c(
+    "noX", "onlyX", "onlyFE", "onlyXandFE",
+    "withX", "withFE", "withXandFE"
+  )
+} else {
+  stop("Unknown grid name: ", grid_name, ". Use 'main' or 'within_unit'.")
+}
+
+combos <- expand.grid(
+  X_approach = x_approach_options,
+  vision_backbone = "vt",
+  fund_sect_param = fund_sect_params,
+  RUN_MODE = c("MAIN", "ROBUST_NO_NTL", "ROBUST_BUFFER", "ROBUST_STRICT"),
+  stringsAsFactors = FALSE
+)
+combos <- combos[order(grepl("only", combos$X_approach), decreasing = TRUE), ]
+combos$row_id <- seq_len(nrow(combos))
+combos <- combos[, c("row_id", "X_approach", "vision_backbone", "fund_sect_param", "RUN_MODE")]
+
+write.table(combos, row.names = FALSE, sep = ",", quote = FALSE)

code/common.R

@@ -0,0 +1,317 @@
+parse_env_flag <- function(name, default = FALSE) {
+  value <- Sys.getenv(name, unset = if (default) "true" else "false")
+  tolower(trimws(value)) %in% c("1", "true", "yes", "y")
+}
+
+find_replication_root <- function() {
+  file_arg <- grep("^--file=", commandArgs(FALSE), value = TRUE)
+  script_dir <- character()
+  if (length(file_arg) > 0) {
+    script_path <- sub("^--file=", "", file_arg[[1]])
+    script_dir <- dirname(normalizePath(script_path, mustWork = FALSE))
+  }
+
+  candidates <- unique(Filter(
+    nzchar,
+    c(
+      Sys.getenv("IMAGEDECONFOUND_REPLICATION_ROOT", unset = ""),
+      getwd(),
+      dirname(getwd()),
+      dirname(dirname(getwd())),
+      script_dir,
+      dirname(script_dir)
+    )
+  ))
+
+  for (candidate in candidates) {
+    candidate <- normalizePath(candidate, winslash = "/", mustWork = FALSE)
+    if (!dir.exists(candidate)) {
+      next
+    }
+    if (file.exists(file.path(candidate, "code", "lib", "call_CI_Conf_5k_3yr.R")) &&
+        dir.exists(file.path(candidate, "data", "interim")) &&
+        dir.exists(file.path(candidate, "results"))) {
+      return(candidate)
+    }
+  }
+
+  stop("Could not locate the replication root. Set IMAGEDECONFOUND_REPLICATION_ROOT explicitly.")
+}
+
+set_replication_root <- function(root = NULL, quiet = FALSE) {
+  root <- normalizePath(root %||% find_replication_root(), winslash = "/", mustWork = FALSE)
+  options(replication.root = root)
+  setwd(root)
+  if (!quiet) {
+    message("Replication root: ", root)
+  }
+  invisible(root)
+}
+
+`%||%` <- function(lhs, rhs) {
+  if (is.null(lhs) || length(lhs) == 0) {
+    return(rhs)
+  }
+  lhs
+}
+
+bundle_results_root <- function(root = getOption("replication.root")) {
+  file.path(root, "results", "per_run_csv", "Epoch5EarlyStopNewTreatDefLabelS_Run2")
+}
+
+bundle_results_processed_dir <- function(root = getOption("replication.root")) {
+  file.path(bundle_results_root(root), "results_processed")
+}
+
+bundle_public_results_dir <- function(root = getOption("replication.root")) {
+  file.path(root, "results", "processed")
+}
+
+bundle_tables_dir <- function(root = getOption("replication.root")) {
+  file.path(root, "tables")
+}
+
+ensure_dir <- function(path) {
+  dir.create(path, recursive = TRUE, showWarnings = FALSE)
+  invisible(path)
+}
+
+resolve_external_path <- function(envvar, default_relative) {
+  root <- getOption("replication.root", default = find_replication_root())
+  env_value <- Sys.getenv(envvar, unset = "")
+  if (nzchar(env_value)) {
+    return(normalizePath(env_value, winslash = "/", mustWork = FALSE))
+  }
+  normalizePath(file.path(root, default_relative), winslash = "/", mustWork = FALSE)
+}
+
+run_replication_script <- function(script_relative, overrides = list()) {
+  root <- set_replication_root(quiet = TRUE)
+  script_path <- file.path(root, script_relative)
+  if (!file.exists(script_path)) {
+    stop("Missing script: ", script_path)
+  }
+
+  keep_names <- unique(c(
+    names(overrides),
+    get0("KeepObjectsAcrossAnalysisStrings", ifnotfound = character(), inherits = TRUE)
+  ))
+
+  env <- new.env(parent = globalenv())
+  if (length(overrides) > 0) {
+    list2env(overrides, envir = env)
+  }
+  env$KeepObjectsAcrossAnalysisStrings <- keep_names
+
+  sys.source(script_path, envir = env)
+  invisible(env)
+}
+
+copy_named_files <- function(files, destination_dir, overwrite = TRUE) {
+  ensure_dir(destination_dir)
+  if (length(files) == 0) {
+    return(invisible(character()))
+  }
+
+  ok <- file.copy(files, destination_dir, overwrite = overwrite)
+  if (any(!ok)) {
+    failed <- basename(files[!ok])
+    warning("Some files failed to copy: ", paste(failed, collapse = ", "))
+  }
+  invisible(files[ok])
+}
+
+sync_results_processed <- function(overwrite = TRUE) {
+  source_dir <- bundle_results_processed_dir()
+  destination_dir <- bundle_public_results_dir()
+
+  if (!dir.exists(source_dir)) {
+    warning("No nested results_processed directory found at ", source_dir)
+    return(invisible(character()))
+  }
+
+  files <- list.files(source_dir, full.names = TRUE)
+  copied <- copy_named_files(files, destination_dir, overwrite = overwrite)
+  message("Synced ", length(copied), " processed result files into results/processed.")
+  invisible(copied)
+}
+
+sync_table_assets <- function(overwrite = TRUE) {
+  results_dir <- bundle_public_results_dir()
+  tables_dir <- bundle_tables_dir()
+  tex_files <- list.files(results_dir, pattern = "\\.tex$", full.names = TRUE)
+  copied <- copy_named_files(tex_files, tables_dir, overwrite = overwrite)
+  if (length(copied) > 0) {
+    message("Synced ", length(copied), " LaTeX table/macro files into tables/.")
+  }
+  invisible(copied)
+}
+
+compute_sha256 <- function(path) {
+  sha256sum_bin <- Sys.which("sha256sum")
+  shasum_bin <- Sys.which("shasum")
+
+  if (nzchar(sha256sum_bin)) {
+    output <- system2(sha256sum_bin, shQuote(path), stdout = TRUE, stderr = TRUE)
+    return(strsplit(output[[1]], "\\s+")[[1]][[1]])
+  }
+  if (nzchar(shasum_bin)) {
+    output <- system2(shasum_bin, c("-a", "256", shQuote(path)), stdout = TRUE, stderr = TRUE)
+    return(strsplit(output[[1]], "\\s+")[[1]][[1]])
+  }
+  NA_character_
+}
+
+verify_manifest_file <- function(manifest_path, verify_hash = TRUE) {
+  if (!file.exists(manifest_path)) {
+    message("Manifest not found at ", manifest_path, ". Skipping checksum verification.")
+    return(invisible(NULL))
+  }
+
+  manifest <- read.csv(manifest_path, stringsAsFactors = FALSE)
+  required_columns <- c("path", "size_bytes", "sha256", "role")
+  missing_columns <- setdiff(required_columns, names(manifest))
+  if (length(missing_columns) > 0) {
+    stop("Manifest is missing columns: ", paste(missing_columns, collapse = ", "))
+  }
+
+  root <- getOption("replication.root", default = find_replication_root())
+  resolved_paths <- file.path(root, manifest$path)
+  exists_flag <- file.exists(resolved_paths)
+  if (!all(exists_flag)) {
+    stop(
+      "Manifest references missing files: ",
+      paste(manifest$path[!exists_flag], collapse = ", ")
+    )
+  }
+
+  actual_sizes <- file.info(resolved_paths)$size
+  if (!all(actual_sizes == manifest$size_bytes)) {
+    bad_rows <- which(actual_sizes != manifest$size_bytes)
+    stop(
+      "Manifest size mismatch for: ",
+      paste(manifest$path[bad_rows], collapse = ", ")
+    )
+  }
+
+  if (verify_hash) {
+    sample_hash <- compute_sha256(resolved_paths[[1]])
+    if (is.na(sample_hash)) {
+      message("No SHA-256 utility found. Skipping checksum verification.")
+      return(invisible(manifest))
+    }
+
+    actual_hashes <- vapply(resolved_paths, compute_sha256, character(1))
+    if (!all(actual_hashes == manifest$sha256)) {
+      bad_rows <- which(actual_hashes != manifest$sha256)
+      stop(
+        "Manifest checksum mismatch for: ",
+        paste(manifest$path[bad_rows], collapse = ", ")
+      )
+    }
+  }
+
+  message("Manifest verification passed for ", nrow(manifest), " files.")
+  invisible(manifest)
+}
+
+verify_bundle <- function(verify_hash = TRUE) {
+  root <- set_replication_root(quiet = TRUE)
+
+  required_dirs <- c(
+    "code/lib",
+    "data/interim",
+    "data/country_regions",
+    "results/per_run_csv/Epoch5EarlyStopNewTreatDefLabelS_Run2",
+    "results/processed",
+    "figures/manuscript",
+    "tables",
+    "env",
+    "manifests"
+  )
+  required_files <- c(
+    "README.md",
+    "code/common.R",
+    "code/00_verify_bundle.R",
+    "code/01_rebuild_paper_outputs.R",
+    "code/02_run_main_ate_optional.R",
+    "code/03_run_within_unit_robustness.R",
+    "code/04_consolidate_results.R",
+    "code/05_build_figures_tables.R",
+    "data/interim/dhs_5k_confounders.csv",
+    "data/interim/dhs_treated_sector_3yr.csv",
+    "data/interim/africa_oda_sector_group.csv",
+    "results/processed/ICA_xruns_all_vt_emb_3yr_2013.csv",
+    "results/processed/wb_vs_ch_sector_scatter_WithinUnitVar.pdf",
+    "env/R_packages.txt",
+    "env/requirements-image-download.txt",
+    "manifests/external_requirements.md"
+  )
+
+  missing_dirs <- required_dirs[!dir.exists(file.path(root, required_dirs))]
+  missing_files <- required_files[!file.exists(file.path(root, required_files))]
+  if (length(missing_dirs) > 0 || length(missing_files) > 0) {
+    problems <- c(
+      if (length(missing_dirs) > 0) paste("Missing directories:", paste(missing_dirs, collapse = ", ")),
+      if (length(missing_files) > 0) paste("Missing files:", paste(missing_files, collapse = ", "))
+    )
+    stop(paste(problems, collapse = " | "))
+  }
+
+  expected_run_counts <- c(
+    vt_3yr_noX = 99L,
+    vt_3yr_onlyFE = 100L,
+    vt_3yr_onlyX = 100L,
+    vt_3yr_onlyXandFE = 100L,
+    vt_3yr_withFE = 100L,
+    vt_3yr_withX = 400L,
+    vt_3yr_withXandFE = 100L,
+    vt_3yr_unitFE = 100L,
+    vt_3yr_did = 49L
+  )
+
+  run_root <- bundle_results_root(root)
+  actual_run_counts <- vapply(
+    names(expected_run_counts),
+    function(name) {
+      length(list.files(file.path(run_root, name), pattern = "\\.csv$", full.names = TRUE))
+    },
+    integer(1)
+  )
+
+  if (any(actual_run_counts < expected_run_counts)) {
+    bad <- names(actual_run_counts)[actual_run_counts < expected_run_counts]
+    stop(
+      "Incomplete per-run CSV directories: ",
+      paste(
+        sprintf("%s (%s < %s)", bad, actual_run_counts[bad], expected_run_counts[bad]),
+        collapse = ", "
+      )
+    )
+  }
+
+  results_processed_n <- length(list.files(bundle_public_results_dir(root), full.names = TRUE))
+  if (results_processed_n < 100L) {
+    stop("results/processed looks incomplete: found only ", results_processed_n, " files.")
+  }
+
+  manuscript_fig_n <- length(list.files(file.path(root, "figures", "manuscript"), full.names = TRUE))
+  if (manuscript_fig_n < 100L) {
+    stop("figures/manuscript looks incomplete: found only ", manuscript_fig_n, " files.")
+  }
+
+  verify_manifest_file(
+    file.path(root, "manifests", "file_manifest.csv"),
+    verify_hash = verify_hash
+  )
+
+  summary <- list(
+    root = root,
+    per_run_csv_counts = actual_run_counts,
+    results_processed_n = results_processed_n,
+    manuscript_fig_n = manuscript_fig_n
+  )
+
+  message("Bundle verification passed.")
+  invisible(summary)
+}

code/lib/AidDeconfound_Branch.R

@@ -0,0 +1,40 @@
+# Script: AidDeconfound_Branch.R 
+{
+  if(!"RUN_MODE" %in% ls()){
+    RUN_MODE <- "MAIN"            # : Standard analysis (Original submission settings) - uses main tfrecords + same confounder files (BOTH WRITTEN)
+    #RUN_MODE <- "ROBUST_NO_NTL"   # : Excludes pre-treatment Nighttime Lights (Bias) - uses main tfrecords + same confounder files (BOTH WRITTEN)
+    #RUN_MODE <- "ROBUST_BUFFER"   # : Increases buffer to 10km (Displacement) - requires own tfrecords + diff confounder files (BOTH WRITTEN)
+    #RUN_MODE <- "ROBUST_STRICT"   # : Excludes ADM2/Precision 3 projects (Unit of Analysis) - requires own tfrecords + diff confounder files
+  }
+  
+  # --- AUTO-CONFIGURATION BASED ON MODE ---
+  robust_params <- list()
+  if (RUN_MODE == "MAIN") {
+    robust_params$exclude_NTL      <- FALSE # Done
+    robust_params$strict_precision <- FALSE
+    robust_params$large_buffer     <- FALSE # partial -> reconsider 
+    robust_params$suffix           <- "" # No suffix for main file
+    robust_params$RUN_MODE     <- "MAIN"
+  } else if (RUN_MODE == "ROBUST_NO_NTL") {
+    robust_params$exclude_NTL      <- TRUE
+    robust_params$strict_precision <- FALSE
+    robust_params$large_buffer     <- FALSE
+    robust_params$suffix           <- "_NoNTL"
+    robust_params$RUN_MODE     <- "ROBUST_NO_NTL"
+  } else if (RUN_MODE == "ROBUST_STRICT") {
+    robust_params$exclude_NTL      <- FALSE
+    robust_params$strict_precision <- TRUE
+    robust_params$large_buffer     <- FALSE
+    robust_params$suffix           <- "_StrictPrec"
+    robust_params$RUN_MODE     <- "ROBUST_STRICT"
+  } else if (RUN_MODE == "ROBUST_BUFFER") {
+    robust_params$exclude_NTL      <- FALSE
+    robust_params$strict_precision <- FALSE
+    robust_params$large_buffer     <- TRUE # Activates 10km buffer
+    robust_params$suffix           <- "_LargeBuff"
+    robust_params$RUN_MODE     <- "ROBUST_BUFFER"
+  }
+  print(paste0(">>> STARTING RUN MODE: ", RUN_MODE))
+  print(paste0(">>> FILE SUFFIX: ", robust_params$suffix))
+  
+}

code/lib/call_CI_Conf_5k_3yr.R

@@ -0,0 +1,1575 @@
+{
+# Script: call_CI_Conf_5k_3yr.R
+# install.packages("~/Documents/causalimages-software/causalimages",repos = NULL, type = "source",force = F)
+# devtools::install_github(repo = "cjerzak/causalimages-software/causalimages") 
+# causalimages::BuildBackend()
+# conda activate jax_gpu 
+# uv pip install --upgrade tensorflow optax torch transformers pillow tf-keras equinox jmp 
+# uv pip install jax==0.5.0  
+#  
+# call_CI_Conf_5k_3yr.R
+# Desc:  Calls Causal Image Confounding over DHS points.
+#        Uses three-year composite images, three-year averages of
+#        confounders. Caller specifies computer vision backbone parameter.
+library(causalimages); options(error = NULL)
+library(dplyr)
+
+replication_root <- getOption("replication.root", default = getwd())
+setwd(replication_root)
+
+# key branch parameters
+SaveResultsFolder <- get0("SAVE_RESULTS_FOLDER_OVERRIDE",
+                          ifnotfound = "per_run_csv/Epoch5EarlyStopNewTreatDefLabelS_Run2")
+ReSaveTFRecords <- get0(
+  "RESAVE_TFRECORDS_OVERRIDE",
+  ifnotfound = tolower(Sys.getenv("IMAGEDECONFOUND_RESAVE_TFRECORDS",
+                                  unset = "false")) %in% c("1", "true", "yes")
+)
+JustCheckNaiveATEs <- FALSE
+plotResults <- TRUE
+ForceRerunResults <- TRUE
+
+#conda_env <- sample( c("CausalImagesEnv" ,"jax_gpu"),prob=c(0.75,0.25),size=1)
+conda_env <- get0("CONDA_ENV_OVERRIDE",
+                  ifnotfound = Sys.getenv("IMAGEDECONFOUND_CONDA_ENV",
+                                          unset = "CausalImagesEnv")) # (uses CPU)
+#conda_env <- "jax_gpu" # 0.5s
+#conda_env <- "jax_cpu" #  0.9s
+  
+# Define memory to allocate 
+work_root <- Sys.getenv("WORK", unset = "")
+if(nzchar(work_root) &&
+   !dir.exists(file.path(work_root, "ImageDeconfoundAid")) &&
+   conda_env=="jax_gpu"){
+  Sys.setenv( 
+              XLA_PYTHON_CLIENT_PREALLOCATE = "true" ,
+              XLA_PYTHON_CLIENT_MEM_FRACTION = as.character(0.90 / 5),
+              XLA_PYTHON_CLIENT_ALLOCATOR = "platform" # Helps on Metal to reduce fragmentation
+              )
+}
+#rm(list=ls()[!ls() %in% (Keeps <- c("t0","KeepObjectsAcrossAnalysisStrings","conda_env", "PrepData","RunAnalysis","AnalyzeResults"))] )
+source("./code/lib/call_CI_Conf_5k_3yr_Helpers.R")
+
+# Create all parameter combinations based on bash script
+default_x_approach_options <- c("noX", "onlyX", "onlyFE", "onlyXandFE",
+                                "withX", "withFE", "withXandFE")
+X_approach_options <- get0("X_APPROACH_OPTIONS_OVERRIDE",
+                           ifnotfound = default_x_approach_options)
+if(ReSaveTFRecords){ X_approach_options <- c("noX") }
+
+tfrecord_home <- normalizePath(
+  get0("TFRECORD_HOME_OVERRIDE",
+       ifnotfound = Sys.getenv("IMAGEDECONFOUND_TFRECORD_HOME",
+                               unset = "./external_artifacts/tfrecords")),
+  winslash = "/",
+  mustWork = FALSE
+)
+dir.create(tfrecord_home, recursive = TRUE, showWarnings = FALSE)
+
+# key modeling parameters 
+earlyStopThreshold <- TRUE
+kFolds = 2L
+nSGD <- "dynamic"; MAX_CLASS_EPOCHS <- 5L
+#nSGD <- 100L
+batchSize <- 32L
+if(abs(get_total_ram_gb() - 32)<2){ batchSize <- 24L }
+if(abs(get_total_ram_gb() - 16)<2){ batchSize <- 12L }
+learningRateMax = 5*10^(-3)*batchSize/512
+nDepth_ImageRep = 8L
+nWidth_ImageRep = 256L
+dropoutRate = 0.1
+droppathRate = 0.1
+useTrainingPertubations <- FALSE
+nonLinearScaler = NULL
+
+args <- commandArgs(trailingOnly = TRUE)
+{
+  fund_sect_params <- c("ch_430", "ch_520", "ch_700", "ch_140", "ch_230", "ch_220", 
+                        "ch_310", "ch_160", "wb_330", "wb_410", "ch_110", "ch_210",
+                        "wb_240", "wb_220", "ch_150", "ch_120", "wb_320", "wb_230",
+                        "wb_110", "wb_120", "wb_310", "wb_160", "wb_140", "wb_210", "wb_150")
+  
+  # Create combinations for both R1 and R2
+  COMBS_MAT <- {expand.grid(
+    X_approach = X_approach_options,
+    vision_backbone = "vt",
+    
+    fund_sect_param = fund_sect_params,
+    #fund_sect_param = "wb_160", # test case 
+    
+    RUN_MODE = c("MAIN","ROBUST_NO_NTL","ROBUST_BUFFER","ROBUST_STRICT"), # ALL
+    #RUN_MODE = c("MAIN","ROBUST_BUFFER","ROBUST_STRICT"), # just new tfrecords 
+    #RUN_MODE = "MAIN", # just run specific analysis
+    
+    stringsAsFactors = FALSE
+  )}
+  head(COMBS_MAT)
+  print(dim(COMBS_MAT))
+  
+  # order dataset 
+  #COMBS_MAT <- COMBS_MAT[order(apply(COMBS_MAT, 1, function(x){ rlang::hash(paste(x, collapse = "_")) })),]
+  COMBS_MAT <- COMBS_MAT[order( grepl(COMBS_MAT$X_approach, pattern="only"),decreasing=T ),]
+  which( grepl(COMBS_MAT$X_approach,pattern="only")) # 1:75
+
+  # Extract the specific combination
+  COMBS_MAT$ReSaveTFRecords <- ReSaveTFRecords
+  if(length(args) == 0 && isTRUE(get0("REQUIRE_EXPLICIT_OUTER_SEQ", ifnotfound = FALSE))){
+    stop("No outer-sequence argument supplied. Pass one or more COMBS_MAT row indices to run this script.")
+  }
+  if(length(args) == 0){
+    #OUTER_SEQ <- 1
+    OUTER_SEQ <- 1:nrow(COMBS_MAT)
+    #OUTER_SEQ <- which(COMBS_MAT$X_approach=="onlyXandFE")[1]
+  }
+  if(length(args) != 0){
+    pdf(file = NULL);options(device = NULL)  # All subsequent base plots go to null device
+    OUTER_SEQ <- as.integer(args[1])
+  }
+  
+  for(OUTER_ in OUTER_SEQ){
+  selected_combo <- COMBS_MAT[OUTER_, ]
+  
+  # source the analysis robustnests branch - depends on COMBS_MAT
+  RUN_MODE <- as.character(selected_combo["RUN_MODE"])
+  source("./code/lib/AidDeconfound_Branch.R")
+  data_suffix_model_input <- robust_params$suffix
+  if( robust_params$RUN_MODE %in% c("MAIN","ROBUST_NO_NTL") ){ 
+    data_suffix_model_input <- ""   
+  }
+
+  # Set the variables as expected by the rest of the script
+  fund_sect_param <- selected_combo$fund_sect_param
+  time_approach <- "3yr" # Fixed as per script defaults
+  vision_backbone <- selected_combo$vision_backbone
+  X_approach <- selected_combo$X_approach
+  ReSaveTFRecords <- selected_combo$ReSaveTFRecords  # Fixed as per script defaults
+  run <- paste0(vision_backbone, "_", time_approach, "_", X_approach)
+  
+  # set seed 
+  set.seed(as.numeric(as.character(unlist(lapply(strsplit(fund_sect_param,split="_"),function(l_){l_[2]})))),
+           kind="Wichmann-Hill");
+
+saveName <- paste(fund_sect_param,
+                  time_approach,
+                  vision_backbone,
+                  X_approach, sep = "_")
+
+XForceModal <- FALSE; if(X_approach %in% c("onlyX","onlyFE","onlyXandFE")){
+  XForceModal <- TRUE; nDepth_ImageRep <- 1L 
+}
+
+################################################################################
+# Initial setup, parameter processing, reading input files 
+################################################################################
+results_dir <- paste0("./results/",SaveResultsFolder, "/", run,"/")
+dir.create(paste0("./results/",SaveResultsFolder), recursive = TRUE, showWarnings = FALSE)
+#create the results directory for this run if it doesn't exist already
+if (!dir.exists(results_dir)) { dir.create(results_dir) }
+sector_param <- sub(".*_(\\d+).*", "\\1", fund_sect_param)
+funder_param <- sub("(wb|ch).*", "\\1", fund_sect_param)
+other_funder <- ifelse(funder_param=="wb","ch","wb")
+
+##### read confounder and treatment data from files
+dhs_confounders_df <- read.csv(sprintf("./data/interim/dhs_5k_confounders%s.csv",data_suffix_model_input)) %>% 
+  select(-year)  %>% #remove survey year column that could be confused with oda year
+  mutate(across(starts_with("log_ch_loan_proj_n"),as.numeric)) #ensure numeric not integer
+
+#get list of all dhs_id's and their iso3 for use below
+dhs_iso3_df <- dhs_confounders_df %>% 
+  distinct(dhs_id,iso3)
+
+#get treated by this funder
+# sort(table(paste0(dhs_t_df$funder,"_",dhs_t_df$sector)))
+dhs_t_df <- read.csv(sprintf("./data/interim/dhs_treated_sector_3yr%s.csv",data_suffix_model_input)) %>% 
+  filter(sector==sector_param & funder==funder_param & year_group!="2014:2016") %>% 
+  #exclude DHS points where confounder data not available 
+  inner_join(dhs_confounders_df %>% 
+               select(dhs_id, ID_adm2), by = join_by(dhs_id)) 
+
+#get logged count of projects in other sectors for each dhs point and year group
+dhs_other_sect_n_df <- read.csv(sprintf("./data/interim/dhs_treated_sector_3yr%s.csv",data_suffix_model_input)) %>% 
+  filter(sector!=sector_param & funder==funder_param &
+           #exclude DHS points where confounder data not available 
+           dhs_id %in% dhs_confounders_df$dhs_id & year_group!="2014:2016") %>% 
+  group_by(dhs_id, year_group) %>% 
+  summarize(other_sect_n=sum(proj_count),.groups="drop") %>% 
+  mutate(log_other_sect_n=log(other_sect_n + 1)) %>% 
+  ungroup() %>% 
+  select(-other_sect_n)
+
+#get logged count of the other funder's simultaneous projects
+dhs_treated_other_funder_n_df <- read.csv(sprintf("./data/interim/dhs_treated_sector_3yr%s.csv",data_suffix_model_input)) %>% 
+  filter(funder==other_funder &
+         #exclude DHS points where confounder data not available 
+         dhs_id %in% dhs_confounders_df$dhs_id & year_group!="2014:2016") %>% 
+  group_by(dhs_id, year_group) %>% 
+  summarize(treated_other_funder_n=sum(proj_count),.groups="drop") %>% 
+  mutate(log_treated_other_funder_n=log(treated_other_funder_n + 1)) %>% 
+  ungroup() %>% 
+  select(-treated_other_funder_n)
+
+#identify countries where funder is operating in this sector
+funder_sector_iso3 <- dhs_confounders_df %>% 
+  filter(dhs_id %in% (dhs_t_df %>%  pull(dhs_id))) %>% 
+  distinct(iso3) %>% pull(iso3)
+
+#identify all dhs_points in countries where funder is operating in this sector
+dhs_in_operating_countries <- dhs_iso3_df %>% 
+  filter(iso3 %in% funder_sector_iso3) %>% 
+  pull(dhs_id)
+
+#construct 3yr controls, limiting to countries where funder operated in sector
+year_group_v <- c('2002:2004', '2005:2007', '2008:2010', '2011:2013') #, '2014:2016')
+
+#generate dataframe of all dhs points for all year groups in operating countries 
+all_t_c_df <- data.frame(expand.grid(year_group = year_group_v,
+                        dhs_id = dhs_in_operating_countries)) 
+
+#construct controls 
+dhs_c_df <- all_t_c_df %>% 
+  #exclude dhs_points treated in each year_group
+  anti_join(dhs_t_df,by=c("dhs_id","year_group")) %>% 
+  #exclude DHS points where confounder data not available, get ID_adm2 
+  inner_join(dhs_confounders_df %>% 
+             select(dhs_id, ID_adm2), by = join_by(dhs_id)) 
+
+#get neighbor project counts for spillover effects
+adm2_adjacent_3yr_treat_count_df <- read.csv(sprintf("./data/interim/adm2_adjacent_3yr_treat_count%s.csv",data_suffix_model_input)) %>% 
+  filter(year_group!="2014:2016")
+
+#define variable order and names for boxplots and dropped cols variables
+var_order_all <- c("iwi_est_post_oda","log_pc_nl_pre_oda","log_avg_pop_dens",
+               "log_avg_min_to_city",
+               "log_dist_km_to_gold","log_dist_km_to_gems",        
+               "log_dist_km_to_dia","log_dist_km_to_petro", 
+               "leader_birthplace","log_ch_loan_proj_n",
+               "log_3yr_pre_conflict_deaths","log_disasters",
+               "election_year","unsc_aligned_us","unsc_non_aligned_us",
+               "country_gini",
+               "corruption_control", "gov_effectiveness", "political_stability",
+               "reg_quality", "rule_of_law","voice_accountability", 																				
+               "landsat578","log_treated_other_funder_n","log_other_sect_n",
+               "log_total_neighbor_projs")
+var_labels_all <- c("Wealth","Nightlights per cap", "Pop Density",
+                    "Minutes to City", "Dist to Gold",
+                    "Dist to Gems", "Dist to Diam",
+                    "Dist to Oil", "Leader birthplace", "China Loan Projs",
+                    "Conflict deaths", "Natural Disasters", "Election year",  
+                    "UNSC US Aligned","UNSC Non-US Align", "Country gini", 
+                    "Cntry Cntrl Corruption", "Cntry Gov Effective",
+                    "Cntry Political Stability","Cntry Reg Quality",
+                    "Cntry Rule of Law","Cntry Voice/Account",
+                    "Landsat 5,7,& 8","Other Funder Treat n","Other Sector Proj n",
+                    "Adj ADM2 Proj n")
+
+################################################################################
+# Function called by AnalyzeImageConfounding to read images 
+################################################################################
+if(FALSE){ # sanity check 
+    setwd(getOption("replication.root", default = getwd())); options(error = NULL)
+    dhs_confounders_df <- read.csv(sprintf("./data/interim/dhs_5k_confounders%s.csv",data_suffix_model_input))
+    analyzeThis_ <- "angola_2006/00000.tif"
+    i_<-grep(dhs_confounders_df$image_file_5k_3yr,pattern=analyzeThis_)
+    c(dhs_confounders_df$lat[i_],dhs_confounders_df$lon[i_])
+    im <- terra::rast(file.path(
+      get0("IMAGE_ROOT_OVERRIDE",
+           ifnotfound = Sys.getenv("IMAGEDECONFOUND_IMAGE_ROOT",
+                                   unset = "./external_artifacts/images/dhs_tifs_5k_3yr")),
+      analyzeThis_
+    ))
+    band_ <- sample(20,1)
+    plot(unlist(lapply(im,function(l_) {sd(matrix(l_))})))
+    which(unlist(lapply(im,function(l_) {sd(matrix(l_))}))==0)
+    causalimages::image2(matrix(im[[band_]],nrow =175,ncol=174,byrow=T))
+}
+      
+acquireImageRepFromDisk_orig <- function(keys, training = FALSE) {
+  #imageWidth <- imageHeight <- 167L
+  imageWidth <- imageHeight <- 164L
+  NBANDS      <- 5L 
+  nkeys       <- length(keys)
+  
+  # Pre‐allocate: [n_images × H × W × bands]
+  imgs_array <- array(0, dim = c(nkeys, imageHeight, imageWidth, NBANDS))
+  
+  for (idx in seq_along(keys)) {
+    key_ <- keys[idx]
+    
+    # extract the "2002:2004"‐style suffix and the .tif path
+    oda_year_group <- sub(".*\\.tif(.*)", "\\1", key_)
+    image_file     <- sub("(.*\\.tif).*", "\\1", key_)
+    
+    # choose which layers to pull
+    nIncrement <- 5
+    bands_to_select <- case_when(
+      oda_year_group == '2002:2004' ~ seq(1,                     nIncrement),
+      oda_year_group == '2005:2007' ~ seq(nIncrement   + 1, 2 * nIncrement),
+      oda_year_group == '2008:2010' ~ seq(2 * nIncrement + 1, 3 * nIncrement),
+      oda_year_group == '2011:2013' ~ seq(3 * nIncrement + 1, 4 * nIncrement),
+      oda_year_group == '2014:2016' ~ seq(4 * nIncrement + 1, 5 * nIncrement)
+    )
+    
+    for (b in seq_len(NBANDS)) {
+      # print(c(key_,b))
+      band_num  <- bands_to_select[b]
+      layer_name <- paste0(gsub(".*/(\\d{5})\\.tif$", "\\1", image_file),"_", band_num)
+      ras   <- terra::rast( 
+                           gsub(image_file,pattern = "_c1_",replace="_"),
+                           lyrs = band_num)
+      TifDims <- dim(ras)[1:2]
+      vals  <- c(terra::values(ras)) / 0.0001    # apply scale factor
+      # reshape into H×W matrix (row‐major)
+      img_mat <- matrix(vals, nrow = TifDims[1], ncol = TifDims[2], byrow = TRUE)
+      #img_mat <- img_mat[1:imageWidth,1:imageHeight]
+      # causalimages::image2(img_mat)# sanity check 
+      imgs_array[idx, 
+                 1:min(c(imageWidth,TifDims[1])),
+                 1:min(c(imageWidth,TifDims[2])), 
+                 b] <- img_mat[1:min(c(imageWidth,TifDims[1])),
+                               1:min(c(imageWidth,TifDims[2]))]
+    }
+  }
+  
+  return( imgs_array ) 
+}
+acquireImageRepFromDisk <- function(keys, image_size = 164L, NBANDS = 5L, scale_by = 0.0001) {
+  imageWidth <- imageHeight <- as.integer(image_size)
+  nkeys      <- length(keys)
+  imgs_array <- array(0, dim = c(nkeys, imageHeight, imageWidth, NBANDS))
+  image_root <- normalizePath(
+    get0("IMAGE_ROOT_OVERRIDE",
+         ifnotfound = Sys.getenv("IMAGEDECONFOUND_IMAGE_ROOT",
+                                 unset = "./external_artifacts/images/dhs_tifs_5k_3yr")),
+    winslash = "/",
+    mustWork = FALSE
+  )
+  
+  year_groups <- c("2002:2004","2005:2007","2008:2010","2011:2013","2014:2016")
+  nIncrement  <- 5L
+  
+  for (idx in seq_len(nkeys)) {
+    key_ <- keys[[idx]]
+    oda_year_group <- sub(".*\\.tif(.*)", "\\1", key_)
+    image_file     <- sub("(.*\\.tif).*", "\\1", key_)
+    src_file       <- file.path(image_root,
+                                gsub(pattern = "_c1_", replacement = "_", x = image_file))
+    
+    grp_idx <- match(oda_year_group, year_groups)
+    bands_all <- seq.int((grp_idx - 1L) * nIncrement + 1L, grp_idx * nIncrement)
+    bands_to_select <- bands_all[seq_len(NBANDS)]
+    
+    ras  <- terra::rast(src_file, lyrs = bands_to_select)      # read all bands at once
+    dims <- dim(ras)  # rows, cols, nlyr
+    tif_h <- dims[1]; tif_w <- dims[2]
+    H <- min(imageHeight, tif_h); W <- min(imageWidth, tif_w)
+    
+    # values() returns an ncell × NBANDS matrix when nlyr > 1
+    V <- as.matrix(terra::values(ras)) / scale_by
+    for (b in seq_len(NBANDS)) {
+      mat <- matrix(V[, b], nrow = tif_h, ncol = tif_w, byrow = TRUE)
+      imgs_array[idx, seq_len(H), seq_len(W), b] <- mat[seq_len(H), seq_len(W)]
+    }
+  }
+  
+  imgs_array
+}
+
+################################################################################
+# Set tabular confounding variables based on start year
+################################################################################
+treat_count <- nrow(dhs_t_df) 
+control_count <- nrow(dhs_c_df)
+
+if(!file.exists(paste0(results_dir,
+                       "ICA_", 
+                       fund_sect_param, "_", 
+                       run,
+                       "_iFINAL",
+                       robust_params$suffix,
+                       ".csv")) | ForceRerunResults){
+if (treat_count < 80) {
+  print(treat_count)
+  print(paste0("[",format(Sys.time(), "%Y-%m-%d %H:%M:%S"),"]",
+               " Skipping ",fund_sect_param," because fewer than threshold treated (",
+               treat_count,")"))
+  next 
+} else if (control_count == 0) {
+  print(paste0("[",format(Sys.time(), "%Y-%m-%d %H:%M:%S"),"]",
+               " Skipping ",fund_sect_param," because no controls"))
+  next 
+} else {
+  print(paste0("[",format(Sys.time(), "%Y-%m-%d %H:%M:%S"),"]",
+               " Processing ",fund_sect_param,
+               ", treat n:",treat_count,
+               ", control n: ",control_count,
+               ", run: ",run,
+               ", nSGD: ",nSGD,
+               ", backbone: ",vision_backbone
+  ))
+  
+  ##############################################################################
+  # combine treated & controls into same dataframe, join with confounders,
+  # and adjust to be appropriate for start year  
+  ##############################################################################
+  obs_year_group_df <- rbind(
+    dhs_t_df %>% 
+       mutate(treated=1) %>% 
+       select(dhs_id,year_group,treated),
+    dhs_c_df %>% 
+       mutate(treated=0) %>% 
+       select(dhs_id,year_group,treated)
+    ) %>% 
+    left_join(dhs_confounders_df,by="dhs_id") %>% 
+    #get count of projects in neighboring adm2s for the period
+    left_join(adm2_adjacent_3yr_treat_count_df,by=join_by("ID_adm2","year_group"),
+              multiple="all") %>% 
+    #replace NAs with 0s for dhs points without neighboring projects
+    mutate(log_total_neighbor_projs=if_else(is.na(log_total_neighbor_projs),
+                                                    0,log_total_neighbor_projs)) %>% 
+    #get logged count of funder's projs in other sectors for both treated and controls
+    left_join(dhs_other_sect_n_df,by=c("dhs_id","year_group")) %>%
+    #replace NAs with 0s for dhs points untreated in other sectors
+    mutate(log_other_sect_n=if_else(is.na(log_other_sect_n),0,log_other_sect_n)) %>% 
+    #get logged count of other funder's projs for both treated and controls
+    left_join(dhs_treated_other_funder_n_df,by=c("dhs_id","year_group")) %>% 
+    #replace NAs with 0s for dhs points untreated by the other funder
+    mutate(log_treated_other_funder_n = if_else(is.na(log_treated_other_funder_n),
+                                                  0,log_treated_other_funder_n)) %>% 
+    mutate(
+      iwi_est_post_oda = case_when(
+        year_group == '2002:2004' ~ iwi_2005_2007_est,
+        year_group == '2005:2007' ~ iwi_2008_2010_est,
+        year_group == '2008:2010' ~ iwi_2011_2013_est,
+        year_group == '2011:2013' ~ iwi_2014_2016_est,
+        year_group == '2014:2016' ~ iwi_2017_2019_est),
+      log_dist_km_to_gold = log_dist_km_to_gold_2001,
+      log_dist_km_to_petro = case_when(
+        year_group == '2002:2004' ~ log_dist_km_to_petro_1999_2001,
+        year_group == '2005:2007' ~ log_dist_km_to_petro_2002_2004,
+        year_group == '2008:2010' ~ log_dist_km_to_petro_2005_2007,
+        year_group == '2011:2013' ~ log_dist_km_to_petro_2008_2010,
+        year_group == '2014:2016' ~ log_dist_km_to_petro_2011_2013),        
+      log_pc_nl_pre_oda = case_when(
+        year_group == '2002:2004' ~ log_pc_nl_2000_2001,
+        year_group == '2005:2007' ~ log_pc_nl_2002_2004,
+        year_group == '2008:2010' ~ log_pc_nl_2005_2007,
+        year_group == '2011:2013' ~ log_pc_nl_2008_2010,
+        year_group == '2014:2016' ~ log_pc_nl_2011_2013),
+      log_avg_pop_dens = case_when(
+        year_group == '2002:2004' ~ log_avg_pop_dens_2000_2001,
+        year_group == '2005:2007' ~ log_avg_pop_dens_2002_2004,
+        year_group == '2008:2010' ~ log_avg_pop_dens_2005_2007,
+        year_group == '2011:2013' ~ log_avg_pop_dens_2008_2010,
+        year_group == '2014:2016' ~ log_avg_pop_dens_2011_2013),  
+      leader_birthplace = case_when(
+        year_group == '2002:2004' ~ leader_1999_2001,
+        year_group == '2005:2007' ~ leader_2002_2004,
+        year_group == '2008:2010' ~ leader_2005_2007,
+        year_group == '2011:2013' ~ leader_2008_2010,
+        year_group == '2014:2016' ~ leader_2011_2013), 
+      log_3yr_pre_conflict_deaths = case_when(
+        year_group == '2002:2004' ~ log_deaths1999_2001,
+        year_group == '2005:2007' ~ log_deaths2002_2004,
+        year_group == '2008:2010' ~ log_deaths2005_2007,
+        year_group == '2011:2013' ~ log_deaths2008_2010,
+        year_group == '2014:2016' ~ log_deaths2011_2013), 
+      log_disasters = case_when(
+        year_group == '2002:2004' ~ log_disasters1999_2001,
+        year_group == '2005:2007' ~ log_disasters2002_2004,
+        year_group == '2008:2010' ~ log_disasters2005_2007,
+        year_group == '2011:2013' ~ log_disasters2008_2010,
+        year_group == '2014:2016' ~ log_disasters2011_2013),        
+      log_ch_loan_proj_n = as.numeric(case_when(
+        year_group == '2002:2004' ~ log_ch_loan_proj_n_2002_2004,
+        year_group == '2005:2007' ~ log_ch_loan_proj_n_2005_2007,
+        year_group == '2008:2010' ~ log_ch_loan_proj_n_2008_2010,
+        year_group == '2011:2013' ~ log_ch_loan_proj_n_2011_2013,
+        year_group == '2014:2016' ~ log_ch_loan_proj_n_2014_2016)),
+      #set indicator variables for the combination of satellite images in pre-project images
+      #Landsat 5 only in images from 1990:1998, excluded here because of missing data
+      #Landsat 5&7 in images from    1999:2010  - won't include this column to avoid collinearity
+      #Landsat 5,7, & 8 in images from 2011:2013
+      landsat578 = if_else(year_group %in% c('2011:2013','2014:2016'),1,0)
+      #Landsat 7&8 in images from 2014:2019 - we aren't using any of these
+      ) 
+
+  #join to country-level parameters, which are year specific, and construct year group data
+  country_confounders_df <- read.csv(sprintf("./data/interim/country_confounders%s.csv",data_suffix_model_input))  %>% 
+    #exclude countries where we don't have dhs points
+    filter(iso3 %in% dhs_iso3_df$iso3) %>% 
+    select(-country) %>%
+    #set year group to pre-treatment 3-year span for join below
+    mutate(year_group = case_when(
+             year %in% 1999:2001 ~ '2002:2004',
+             year %in% 2002:2004 ~ '2005:2007',
+             year %in% 2005:2007 ~ '2008:2010',
+             year %in% 2008:2010 ~ '2011:2013',
+             year %in% 2011:2013 ~ '2014:2016')) %>%
+    group_by(iso3,year_group)  %>% 
+    #calculate the max for binary variables (three-year group 1 if any year was 1)
+    summarize(across(c("election_year","unsc_aligned_us","unsc_non_aligned_us"), 
+                     ~max(., na.rm = TRUE)),
+              #calculate a mean for each year group for each continuous variable
+              across(c("country_gini","polity2","log_gdp_per_cap_USD2015","corruption_control",
+                       "gov_effectiveness","political_stability","reg_quality",
+                       "rule_of_law","voice_accountability"), 
+                     ~mean(., na.rm = TRUE))) %>%
+    ungroup() 
+
+  run_df <- obs_year_group_df %>% 
+    left_join(country_confounders_df,
+              by=c("iso3", "year_group"))
+
+  #create input_df and write to file
+  pre_shuffle_df <- run_df %>% 
+    select(dhs_id, country, iso3, ID_adm2, lat, lon, treated, log_treated_other_funder_n,
+           log_other_sect_n, year_group, image_file_5k_3yr, iwi_est_post_oda,
+           log_pc_nl_pre_oda, log_avg_min_to_city, log_avg_pop_dens,
+           log_3yr_pre_conflict_deaths, log_disasters, log_ch_loan_proj_n, 
+           leader_birthplace, log_dist_km_to_gold, log_dist_km_to_gems, 
+           log_dist_km_to_dia, log_dist_km_to_petro, election_year, 
+           unsc_aligned_us, unsc_non_aligned_us,country_gini, 
+           corruption_control,gov_effectiveness, political_stability, 
+           reg_quality, rule_of_law, voice_accountability, landsat578,
+           log_total_neighbor_projs) %>% 
+    rename(adm2 = ID_adm2) %>%
+    #extract first year of group to use in function
+    mutate(first_year_group = as.integer(sub("^(\\d{4}).*", "\\1",year_group)))
+  
+  #shuffle data to reorder it before use; set.seed call makes it reproducible
+  set.seed(sector_param,kind="Wichmann-Hill");
+  input_df <- pre_shuffle_df[sample(x=1:nrow(pre_shuffle_df),size=nrow(pre_shuffle_df),replace=FALSE),]
+  
+  if ( robust_params$large_buffer ) {
+    # --- ROBUSTNESS: coarsen outcome to ~13.4km grid when large_buffer is on ---
+    message(">>> ROBUSTNESS CHECK: Aggregating IWI_est_post_oda to ~13.4km outcome grid")
+    
+    # Always keep the original 5km outcome around, so we never re-aggregate a
+    # previously aggregated value if this script is re-run.
+    if (!"iwi_est_post_oda_5k" %in% names(input_df)) {
+      input_df$iwi_est_post_oda_5k <- input_df$iwi_est_post_oda
+    }
+    base_iwi <- input_df$iwi_est_post_oda_5k
+    
+    # Build sf object in a metric CRS for distance-based neighbors
+    dhs_sf <- sf::st_as_sf(input_df,
+                           coords = c("lon", "lat"),
+                           crs = 4326)
+    # Any metric CRS is fine; 3857 keeps it simple
+    dhs_sf <- sf::st_transform(dhs_sf, 3857)
+    
+    # Neighbors within ~6.7km (to approximate a 2x2 grid of 6.7km pixels ≈ 13.4km)
+    nb_list <- sf::st_is_within_distance(dhs_sf, dhs_sf, dist = 6700)
+    # nb_list <- nngeo::st_nn(dhs_sf, dhs_sf, k = 5, returnDist = FALSE, progress = FALSE) # alt option based on nearest neighors 
+    
+    # Average IWI across each neighborhood (including self)
+    iwi_coarse <- vapply(
+      nb_list,
+      FUN.VALUE = numeric(1),
+      FUN = function(idx) mean(base_iwi[idx], na.rm = TRUE)
+    )
+    
+    # Overwrite the outcome used downstream; everything else (conf_matrix, plots, etc.)
+    # now sees the coarser 13.4km outcome.
+    input_df$iwi_est_post_oda <- iwi_coarse
+  }
+   
+  write.csv(input_df, paste0("./data/interim/input_",
+                             run,"_",fund_sect_param,
+                             robust_params$suffix,
+                             ".csv"),row.names = FALSE)
+  
+  if (nrow(input_df[!complete.cases(input_df),]) > 0) {
+    print(paste0("Stopping because incomplete cases.  See ./data/interim/input_",
+                 run,"_",fund_sect_param,robust_params$suffix,".csv"))
+  } else {
+    conf_matrix <- data.frame(
+        "first_year_group"           =input_df$first_year_group - 2001,
+        
+        #"landsat578"                 =input_df$landsat578,                  #pre-treat image
+        "log_total_neighbor_projs"   =input_df$log_total_neighbor_projs,     #neighbor ADM2s
+        
+        "log_pc_nl_pre_oda"          =input_df$log_pc_nl_pre_oda,           #scene level
+        "log_avg_min_to_city"        =input_df$log_avg_min_to_city,         #scene level
+        "log_avg_pop_dens"           =input_df$log_avg_pop_dens,            #scene level
+        "log_dist_km_to_gold"        =input_df$log_dist_km_to_gold,         #scene level
+        "log_dist_km_to_gems"        =input_df$log_dist_km_to_gems,         #scene level
+        "log_dist_km_to_dia"         =input_df$log_dist_km_to_dia,          #scene level
+        "log_dist_km_to_petro"       =input_df$log_dist_km_to_petro,        #scene level
+        
+        "log_treated_other_funder_n" =input_df$log_treated_other_funder_n,  #inherited from ADM2
+        "log_ch_loan_proj_n"         =input_df$log_ch_loan_proj_n,          #inherited from ADM1, ADM2
+        "log_other_sect_n"           =input_df$log_other_sect_n,            #inherited from ADM2
+        "log_3yr_pre_conflict_deaths"=input_df$log_3yr_pre_conflict_deaths, #inherited from ADM1
+        "log_disasters"              =input_df$log_disasters,               #inherited from ADM1,2,or3
+        "leader_birthplace"          =input_df$leader_birthplace,           #inherited from ADM1
+        
+        "election_year"              =input_df$election_year,               #country level
+        "unsc_aligned_us"            =input_df$unsc_aligned_us,             #country level
+        "unsc_non_aligned_us"        =input_df$unsc_non_aligned_us,         #country level
+        "country_gini"               =input_df$country_gini,                #country level
+        "corruption_control"         =input_df$corruption_control,          #country level
+        "gov_effectiveness"          =input_df$gov_effectiveness,           #country level
+        "political_stability"        =input_df$political_stability,         #country level
+        "reg_quality"                =input_df$reg_quality,                 #country level
+        "rule_of_law"                =input_df$rule_of_law,                 #country level
+        "voice_accountability"       =input_df$voice_accountability         #country level
+    )
+    # summary(lm(input_df$treated~as.matrix(conf_matrix)))
+    # add multiple columns for adm2 fixed effects variables
+    # conf_matrix <- cbind(as.matrix(conf_matrix, model.matrix(~ adm2 - 1, input_df))) 
+    # all(row.names(conf_matrix) == row.names(input_df))
+    
+    # conf_matrix <- 
+    #   as.matrix(data.frame(
+    #     "first_year_group"           =input_df$first_year_group - 2001,
+    #     #"first_year_group_squared"   =(input_df$first_year_group - 2001)^2,
+    #     "log_pc_nl_pre_oda"          =input_df$log_pc_nl_pre_oda,           #scene level
+    #     "log_avg_min_to_city"        =input_df$log_avg_min_to_city,         #scene level
+    #     "log_avg_pop_dens"           =input_df$log_avg_pop_dens,            #scene level
+    #     "log_dist_km_to_gold"        =input_df$log_dist_km_to_gold,         #scene level
+    #     "log_dist_km_to_gems"        =input_df$log_dist_km_to_gems,         #scene level
+    #     "log_dist_km_to_dia"         =input_df$log_dist_km_to_dia,          #scene level
+    #     "log_dist_km_to_petro"       =input_df$log_dist_km_to_petro,        #scene level
+    #     "log_treated_other_funder_n" =input_df$log_treated_other_funder_n,  #inherited from ADM2
+    #     "log_ch_loan_proj_n"         =input_df$log_ch_loan_proj_n,          #inherited from ADM1, ADM2
+    #     "log_other_sect_n"           =input_df$log_other_sect_n,            #inherited from ADM2
+    #     "log_3yr_pre_conflict_deaths"=input_df$log_3yr_pre_conflict_deaths, #inherited from ADM1
+    #     "log_disasters"              =input_df$log_disasters,               #inherited from ADM1,2,or3			 
+    #     "leader_birthplace"          =input_df$leader_birthplace,           #inherited from ADM1
+    #     "election_year"              =input_df$election_year,               #country level
+    #     "unsc_aligned_us"            =input_df$unsc_aligned_us,             #country level
+    #     "unsc_non_aligned_us"        =input_df$unsc_non_aligned_us,         #country level
+    #     "country_gini"               =input_df$country_gini,                #country level
+    #     "corruption_control"         =input_df$corruption_control,          #country level
+    #     "gov_effectiveness"          =input_df$gov_effectiveness,           #country level 
+    #     "political_stability"        =input_df$political_stability,         #country level
+    #     "reg_quality"                =input_df$reg_quality,                 #country level
+    #     "rule_of_law"                =input_df$rule_of_law,                 #country level           
+    #     "voice_accountability"       =input_df$voice_accountability,        #country level 
+    #     "landsat578"                 =input_df$landsat578,                  #pre-treat image 
+    #     "log_total_neighbor_projs"   =input_df$log_total_neighbor_projs     #neighbor ADM2s
+    #   ))
+    
+    #remove any columns that have insufficient cross-treatment variability before passing to function
+    before_cols <-  colnames(conf_matrix)
+    conf_matrix <- scale(conf_matrix)
+    SD_THRES <- 0.25
+    conf_matrix <- conf_matrix[,which((apply(conf_matrix[input_df$treated==0,],2,sd) > SD_THRES &
+                                    apply(conf_matrix[input_df$treated==1,],2,sd) > SD_THRES & 
+                                      apply(conf_matrix,2,sd) > SD_THRES))]
+    if( mean(is.na(conf_matrix)) > 0){stop("Some NAs in conf_matrix")}
+    if( ncol(conf_matrix) < 1){stop("Some no columns left in conf_matrix")}
+    # apply(conf_matrix,2,sd)
+    #conf_matrix <- conf_matrix[,which(apply(conf_matrix,2,sd)>0)] 
+    dropped_cols <- setdiff(before_cols, colnames(conf_matrix))
+    dropped_labels <- paste(na.omit(var_labels_all[match(setdiff(before_cols,
+                                                         colnames(conf_matrix)),
+                                                 var_order_all)]),collapse="; ")
+    # note: some ADM2 fixed effects dropped also 
+    if (dropped_labels != "") {
+      print(paste("Dropped for 0 SD: ", dropped_labels))
+    }
+
+    #remove no-variation columns from the variables that control later figures
+    var_order <- setdiff(var_order_all,dropped_cols)
+    var_labels <- setdiff(var_labels_all,
+                          var_labels_all[match(setdiff(before_cols, 
+                                                       colnames(conf_matrix)),var_order_all)])
+    
+    #cleanup unneeded objects in memory before calling function
+    rm(country_confounders_df, dhs_c_df,dhs_confounders_df,
+       dhs_iso3_df,dhs_t_df,funder_sector_iso3,obs_year_group_df,
+       run_df, pre_shuffle_df)
+    
+    ################################################################################
+    # Generate tf_records file for this sector/funder/time_approach if not present 
+    ################################################################################
+    # if (vision_backbone=="emb") {
+    #   tf_rec_filename <- paste0("./data/interim/tfrecords/",fund_sect_param,"_",
+    #                             time_approach,"_5k_emb.tfrecord")
+    #   
+    #   if (!file.exists(tf_rec_filename)) {
+    #     print(paste0("[",format(Sys.time(), "%Y-%m-%d %H:%M:%S"),"]",
+    #                  " Start creating tfrecord file: ",tf_rec_filename))
+    #     
+    #     causalimages::WriteTfRecord(file = tf_rec_filename,
+    #                                 uniqueImageKeys = paste0(input_df$image_file_5k_3yr,
+    #                                                          input_df$year_group),
+    #                                 acquireImageFxn = acquireImageRepFromDisk,
+    #                                 conda_env = NULL,
+    #                                 conda_env_required = T
+    #     )
+    #     print(paste0("[",format(Sys.time(), "%Y-%m-%d %H:%M:%S"),"]",
+    #                  " Finished creating tfrecord file: ",tf_rec_filename))
+    #   }
+    # } else {
+      # setup for balanced sampling 
+      if (fund_sect_param %in% c("wb_220","ch_520")) {
+        testFrac <- 20/length(input_df$iwi_est_post_oda) #ctj edit 
+        #testFrac <- 0.1 
+      }
+      if( !(fund_sect_param %in% c("wb_220","ch_520"))) {
+        testFrac <- .01 # special cases  
+      }
+    
+      # define train test splits (avoid overlap in ADM2)
+      {
+        # Get unique ADM2 regions with their treatment/control counts
+        adm2_summary <- input_df %>%
+          group_by(adm2) %>%
+          summarise(
+            n_treated = sum(treated == 1),
+            n_control = sum(treated == 0),
+            n_total = n(),
+            has_both = (n_treated > 0) & (n_control > 0),
+            .groups = 'drop'
+          )
+        
+        # Separate ADM2s that have both treatment and control from those that don't
+        adm2_with_both <- adm2_summary %>% 
+          filter(has_both) %>% 
+          pull(adm2)
+        
+        adm2_only_treated <- adm2_summary %>% 
+          filter(n_treated > 0 & n_control == 0) %>% 
+          pull(adm2)
+        
+        adm2_only_control <- adm2_summary %>% 
+          filter(n_treated == 0 & n_control > 0) %>% 
+          pull(adm2)
+  
+        # Calculate target test set size
+        n_test_adm2 <- max(2, ceiling(length(unique(input_df$adm2)) * testFrac))
+        
+        # Sample ADM2s for test set, ensuring representation of both treatment types
+        test_adm2s <- c()
+        
+        # First, add some ADM2s that have both treatment and control
+        if(length(adm2_with_both) > 0) {
+          n_both_for_test <- min(ceiling(n_test_adm2 * 0.5), length(adm2_with_both))
+          test_adm2s <- c(test_adm2s, sample(adm2_with_both, n_both_for_test))
+        }
+        
+        # Then add some treatment-only and control-only ADM2s if available
+        remaining_slots <- n_test_adm2 - length(test_adm2s)
+        if(remaining_slots > 0) {
+          # Add some treatment-only ADM2s
+          if(length(adm2_only_treated) > 0) {
+            n_treated_for_test <- min(ceiling(remaining_slots * 0.5), length(adm2_only_treated))
+            test_adm2s <- c(test_adm2s, sample(adm2_only_treated, n_treated_for_test))
+          }
+          
+          # Add some control-only ADM2s
+          remaining_slots <- n_test_adm2 - length(test_adm2s)
+          if(length(adm2_only_control) > 0 && remaining_slots > 0) {
+            n_control_for_test <- min(remaining_slots, length(adm2_only_control))
+            test_adm2s <- c(test_adm2s, sample(adm2_only_control, n_control_for_test))
+          }
+        }
+        
+        # Define indices based on ADM2 membership
+        TestIndices <- which(input_df$adm2 %in% test_adm2s)
+        TrainIndices <- which(!(input_df$adm2 %in% test_adm2s))
+        
+        # Separate control and treatment indices for the TFRecordControl
+        TestControlIndices <- which(input_df$adm2 %in% test_adm2s & input_df$treated == 0)
+        TrainControlIndices <- which(!(input_df$adm2 %in% test_adm2s) & input_df$treated == 0)
+        TestTreatmentIndices <- which(input_df$adm2 %in% test_adm2s & input_df$treated == 1)
+        TrainTreatmentIndices <- which(!(input_df$adm2 %in% test_adm2s) & input_df$treated == 1)
+        
+        # Update TFRecordControl
+        TFRecordControl = list(
+          "nTest" = length(TestIndices),
+          "nControlTrain" = length(TrainControlIndices),
+          "nTreatmentTrain" = length(TrainTreatmentIndices)
+        )
+        
+        # Verify no ADM2 overlap
+        train_adm2s <- unique( input_df$adm2[TrainIndices] )
+        test_adm2s_verify <- unique( input_df$adm2[TestIndices] )
+        if(length(intersect(train_adm2s, test_adm2s_verify)) > 0) {
+          stop("ERROR: ADM2 overlap detected between train and test sets!")
+        }
+        
+        # Print summary statistics
+        cat("\n=== ADM2-based Train/Test Split Summary ===\n")
+        cat(sprintf("Total ADM2 regions: %d\n", length(unique(input_df$adm2))))
+        cat(sprintf("Test ADM2 regions: %d\n", length(test_adm2s)))
+        cat(sprintf("Train ADM2 regions: %d\n", length(train_adm2s)))
+        cat(sprintf("\nTest set: %d observations (%d treated, %d control)\n", 
+                    length(TestIndices), length(TestTreatmentIndices), length(TestControlIndices)))
+        cat(sprintf("Train set: %d observations (%d treated, %d control)\n", 
+                    length(TrainIndices), length(TrainTreatmentIndices), length(TrainControlIndices)))
+        cat(sprintf("Test fraction: %.2f%%\n", 100 * length(TestIndices) / nrow(input_df)))
+        if( sum(input_df$treated[TrainControlIndices]) > 0){ stop("Some treatment indices in TrainControlIndices")}
+        if( mean(input_df$treated[TrainTreatmentIndices]) < 1){ stop("Some control indices in TrainTreatmentIndices")}
+        
+        # Update the data scrambling to respect the new indices
+        set.seed(9939L, kind="Wichmann-Hill"); 
+        SCRAMBLED_ORDER <- c(sample(TestIndices), 
+                             sample(TrainControlIndices), 
+                             sample(TrainTreatmentIndices))
+        set.seed(sector_param, kind="Wichmann-Hill")
+        input_df <- input_df[SCRAMBLED_ORDER,] # FE is later based on this 
+        conf_matrix <- conf_matrix[SCRAMBLED_ORDER,] # this denotes "X" 
+        plot(input_df$treated[1:length(TestIndices)])
+        plot(input_df$treated[-c(1:(length(TestIndices)+length(TrainControlIndices) ))])
+      }
+      
+      # old definition of TFRecordControl 
+      #{
+      #n_test_size <-  as.integer(round(testFrac * length(unique(paste0(input_df$image_file_5k_3yr,
+      #                                                                 input_df$year_group))) ))
+      #TestIndices <- c(which(input_df$treated== 0)[TestC <- 1:ceiling(n_test_size/2)], 
+      #                 which(input_df$treated== 1)[TestT <- 1:ceiling(n_test_size/2)])
+      #ControlIndices <- which(input_df$treated== 0)[-TestC]
+      #TreatmentIndices <- which(input_df$treated== 1)[-TestT] 
+      
+      #TFRecordControl = list("nTest" = length(TestIndices),
+      #                       "nControl" = length(ControlIndices),
+      #                       "nTreatment" = length(TreatmentIndices))
+      
+      # scramble all the indices now WITHIN type and select data according to indices 
+      #if(!all(row.names(conf_matrix) == row.names(input_df))){ stop("Misalignment between conf_matrix and input_df...") }
+      # set.seed(999L,kind="Wichmann-Hill"); input_df <- input_df[SCRAMBLED_ORDER <- 
+      #                                       c(sample(TestIndices),
+      #                                        sample(ControlIndices), 
+      #                                        sample(TreatmentIndices)),]; set.seed(sector_param,kind="Wichmann-Hill");
+      #conf_matrix <- conf_matrix[SCRAMBLED_ORDER,]
+      #}
+
+      tf_rec_filename <- file.path(
+        tfrecord_home,
+        paste0(fund_sect_param, "_", time_approach, "_5k_bal",
+               data_suffix_model_input, ".tfrecord")
+      )
+    
+      #if ( !file.exists(tf_rec_filename) | ReSaveTFRecords ) {
+      if (  ReSaveTFRecords ) {
+        print(sprintf("Creating file: %s", tf_rec_filename))
+        print(paste0("[",format(Sys.time(), "%Y-%m-%d %H:%M:%S"),"]",
+                     " Start creating tfrecord file: ",tf_rec_filename))
+        
+        print(sprintf("DHS head: %s", paste(head(input_df$dhs_id),collapse=", ")))
+        causalimages::WriteTfRecord(file = tf_rec_filename,
+                                    uniqueImageKeys = unique(paste0(input_df$image_file_5k_3yr,
+                                                                    input_df$year_group)),
+                                    acquireImageFxn = acquireImageRepFromDisk,
+                                    conda_env = conda_env, 
+                                    conda_env_required = TRUE)
+        print(paste0("[",format(Sys.time(), "%Y-%m-%d %H:%M:%S"),"]",
+                     " Finished creating tfrecord file: ",tf_rec_filename))
+      }
+#    }
+      
+    # Define the fixed effects matrix
+    {
+      fe_matrix <- scale( model.matrix(~ adm2 - 1, input_df) ) 
+        
+      # Remove columns with insufficient variability 
+      before_cols <- colnames(fe_matrix)
+      fe_matrix <- fe_matrix[,!(apply(fe_matrix[input_df$treated==0,],2,sd) < SD_THRES |
+                                    apply(fe_matrix[input_df$treated==1,],2,sd) < SD_THRES)]
+      dropped_fe_cols <- setdiff(before_cols, colnames(fe_matrix))
+      if (length(dropped_fe_cols) > 0) {
+          print(paste("Dropped FE columns for 0 SD:", paste(dropped_fe_cols, collapse = "; ")))
+      }
+    }
+      
+    if(any( row.names(input_df) != row.names(conf_matrix) )){stop("Misalignment between input_df and conf_matrix ")}
+    if(any( row.names(fe_matrix) != row.names(conf_matrix) )){stop("Misalignment between fe_matrix and conf_matrix")}
+    ###############################
+    # call AnalyzeImageConfounding
+    ###############################
+    # write.csv(file = "~/Downloads/input_df.csv", input_df); write.csv(file = "~/Downloads/conf_matrix.csv", conf_matrix)
+    # conf_matrix <- read.csv(file = "~/Downloads/conf_matrix.csv"); input_df <-  read.csv(file = "~/Downloads/input_df.csv")
+    if(!ReSaveTFRecords){ 
+    if(nSGD =="dynamic"){
+      # epochs = batchSize * nSGD / datasize
+      # nSGD = epochs * datasize / batchSize
+      nSGD <- as.integer(round(max(100,
+                                   min((MAX_CLASS_EPOCHS*table(input_df$treated)) / (batchSize/2)) ) ))
+      print(sprintf("Selected nSGD: %.3i", nSGD))
+    }
+    
+    if(X_approach %in% c("noX","did","unitFE")){ X_USE <- NULL } 
+    if(X_approach %in% c("withX","onlyX")){ X_USE <- conf_matrix } 
+    if(X_approach %in% c("withFE","onlyFE")){ X_USE <- fe_matrix } 
+    if(X_approach %in% c("withXandFE","onlyXandFE")){ X_USE <- cbind(conf_matrix, fe_matrix) }
+    
+    if( X_approach == "did"){    
+      source("./code/lib/call_CI_Conf_5k_3yr_DiD.R")  
+    }
+    if( X_approach == "unitFE"){    
+      source("./code/lib/call_CI_Conf_5k_3yr_unitFE.R")  
+    }
+    if( !X_approach %in% c("did","unitFE")){   
+      
+    # sanity check for treatment status arrangement 
+    {
+      # table(input_df$treated)
+      checkADM2_bal <- do.call(
+        plyr::rbind.fill,
+        tapply(
+          input_df$treated,
+          paste0(input_df$adm2, "_", input_df$year_group),
+          function(x) {
+            # drop NAs in treated
+            x <- x[!is.na(x)]
+            # ensure both 0 and 1 are present as levels
+            tab <- table(factor(x, levels = c(0, 1)))
+            # proportions; if group is empty, return zeros
+            prop <- if (sum(tab) > 0) as.numeric(tab) / sum(tab) else c(0, 0)
+            data.frame(X0 = prop[1], X1 = prop[2], stringsAsFactors = FALSE)
+          }
+        )
+      )
+      # proportions - are they all 0 or 1?
+      (table(checkADM2_bal[,2]))
+      prop.table(table(checkADM2_bal[,2]))
+      # plot(checkADM2_bal[,1], checkADM2_bal[,2])
+      # table(table(apply(round(conf_matrix,3L),1,function(x){paste(x,collapse="_")})))
+      # summary( lm(input_df$treated~conf_matrix) ) 
+    }
+    
+    if( robust_params$exclude_NTL ){ # drop nightlights in robustness test 
+        nCol_predrop <- ncol(X_USE)
+        X_USE <- X_USE[,!colnames(X_USE) %in% "log_pc_nl_pre_oda"]
+        if(ncol(X_USE) == nCol_predrop){ warning("Dropping nightlights failed! Nighltight already dropped") }
+        if(ncol(X_USE) != nCol_predrop){ warning("Nightlights success! Nighltight dropped in robustness") }
+    }  
+      
+    if(JustCheckNaiveATEs){
+        # Compute Meta Parameters and Naive Statistics
+        n_treat   <- sum(input_df$treated == 1)
+        n_control <- sum(input_df$treated == 0)
+        
+        # Calculate means safely (handle potential 0 counts gracefully)
+        mean_treat   <- if(n_treat > 0) mean(input_df$iwi_est_post_oda[input_df$treated == 1],na.rm=T) else NA
+        mean_control <- if(n_control > 0) mean(input_df$iwi_est_post_oda[input_df$treated == 0],na.rm=T) else NA
+        diff_means   <- mean_treat - mean_control
+        
+        # Create Data Frame of Results
+        naive_results_df <- data.frame(
+          fund_sect_param = fund_sect_param,
+          funder          = funder_param,
+          sector          = sector_param,
+          vision_backbone = vision_backbone,
+          X_approach      = X_approach,
+          n_treated       = n_treat,
+          n_control       = n_control,
+          n_total         = n_treat + n_control,
+          mean_treated    = mean_treat,
+          mean_control    = mean_control,
+          naive_ate       = diff_means,
+          save_name       = saveName,
+          robust_suffix   = robust_params$suffix,
+          timestamp       = as.character(Sys.time())
+        )
+        
+        # Output Results
+        output_file_naive <- file.path("./results", SaveResultsFolder, 
+                                       paste0("NaiveATEAnalysis_", saveName, 
+                                              robust_params$suffix, ".csv"))
+        
+        # Ensure the directory exists
+        write.csv(naive_results_df, output_file_naive, row.names = FALSE)
+        print(paste0("Naive ATE computed: ", round(diff_means, 5), ". Saved to: ", output_file_naive))
+    }  
+    if(!JustCheckNaiveATEs){ 
+    if(vision_backbone=="vt") {
+      print(dim(input_df)); print(TFRecordControl)
+      ImageConfoundingAnalysis <- causalimages::AnalyzeImageConfounding(
+        obsW = input_df$treated,
+        obsY = input_df$iwi_est_post_oda,  
+        file = tf_rec_filename,
+        X = X_USE,
+        XCrossModal = TRUE, 
+        XForceModal = XForceModal, 
+        #concatenate the image file location and oda year group into a single keys parameter
+        imageKeysOfUnits = paste0(input_df$image_file_5k_3yr,input_df$year_group), 
+        nBoot = 1000L,
+        lat = input_df$lat,
+        long = input_df$lon,
+        conda_env = conda_env,
+        conda_env_required = TRUE,
+        figuresTag = paste0(fund_sect_param,"_",run,"_i","FINAL", robust_params$suffix),
+        figuresPath = results_dir, # figures saved here
+        plotBands=c(3,2,1),  #red, green, blue
+        kFolds = kFolds,
+        learningRateMax = learningRateMax,
+        nDepth_ImageRep = nDepth_ImageRep,
+        nWidth_ImageRep = nWidth_ImageRep,    
+        batchSize = batchSize,
+        dropoutRate = dropoutRate,
+        droppathRate = droppathRate, 
+        nonLinearScaler = nonLinearScaler,
+        earlyStopThreshold = earlyStopThreshold,
+        plotResults = plotResults,
+        nDepth_Dense = 1L, 
+        imageModelClass = "VisionTransformer", 
+        optimizeImageRep = TRUE,
+        nSGD = nSGD,
+        testFrac = testFrac, 
+        TFRecordControl = TFRecordControl,
+        atError = 'stop'
+      )  
+    }
+    if(vision_backbone=="emb") {
+      ImageConfoundingAnalysis <- causalimages::AnalyzeImageConfounding(
+        obsW = input_df$treated,
+        obsY = input_df$iwi_est_post_oda,  
+        X = X_USE, 
+        file = tf_rec_filename,
+        #concatenate the image file location and oda year group into a single keys parameter
+        imageKeysOfUnits = paste0(input_df$image_file_5k_3yr,input_df$year_group), 
+        nBoot = 10L,  #costly operation; do few
+        lat = input_df$lat,
+        long = input_df$lon,
+        conda_env = conda_env, # not using conda env
+        conda_env_required = TRUE,
+        plotResults = FALSE,
+        kFolds = 1L, 
+        figuresTag = paste0(fund_sect_param,"_",run,"_i","FINAL",robust_params$suffix),
+        figuresPath = results_dir, # figures saved here
+        plotBands=c(3,2,1),  #red, green, blue
+        learningRateMax = learningRateMax,
+        nDepth_ImageRep = nDepth_ImageRep,
+        nWidth_ImageRep = nWidth_ImageRep,    
+        batchSize = as.integer(4L*batchSize),
+        dropoutRate = dropoutRate,
+        droppathRate = droppathRate, 
+        nonLinearScaler = nonLinearScaler,
+        earlyStopThreshold = earlyStopThreshold,
+        nDepth_Dense = 1L, 
+        imageModelClass = "VisionTransformer",
+        optimizeImageRep = FALSE,
+        nSGD = nSGD,
+        atError = 'debug'
+      )
+    } 
+    
+    # sanity checks 
+    {
+        plot(ImageConfoundingAnalysis$prW_est[ImageConfoundingAnalysis$testIndices],
+             input_df$treated[ImageConfoundingAnalysis$testIndices], 
+             cex = 0.15)
+        pROC::auc(pROC::roc(
+                            response = input_df$treated[ImageConfoundingAnalysis$testIndices],
+                            predictor = ImageConfoundingAnalysis$prW_est[ImageConfoundingAnalysis$testIndices], 
+                            levels = c(0, 1), direction = "<"))
+        tapply(ImageConfoundingAnalysis$prW_est[ImageConfoundingAnalysis$testIndices],
+               input_df$treated[ImageConfoundingAnalysis$testIndices], summary)
+        FBeta_max <- max(as.numeric(as.character((sapply(seq(0.1,0.9,by=0.1),function(thres_){ 
+          try(yardstick::f_meas_vec(
+                    as.factor(input_df$treated[ImageConfoundingAnalysis$testIndices]),
+                    as.factor(1*(ImageConfoundingAnalysis$prW_est[ImageConfoundingAnalysis$testIndices]>thres_)), 
+                    beta = 2) ,T)
+        })))),na.rm=T)
+
+        # Note, for indices, see:
+        # ImageConfoundingAnalysis$ModelEvaluationMetrics$AUC_out
+        # ImageConfoundingAnalysis$ModelEvaluationMetrics$AUPRC_out
+        # ImageConfoundingAnalysis$ModelEvaluationMetrics$FBeta_OUT
+        # ImageConfoundingAnalysis$testIndices
+        # table(input_df$treated[ImageConfoundingAnalysis$testIndices])
+        # ImageConfoundingAnalysis$trainIndices 
+    }
+  
+    ica_df <- data.frame(t(unlist(ImageConfoundingAnalysis))) %>% 
+      select(-starts_with("prW_est"),-starts_with("SalienceX.adm2"),
+             -starts_with("SalienceX_se.adm2"),-starts_with("SGD_loss_vec"),
+             -starts_with("tauHat_propensityHajek_vec"),-starts_with("trainIndices"),
+             -starts_with("testIndices"))
+    output_df <- cbind(data.frame(run,fund_sect_param,treat_count,control_count,
+                                  dropped_labels,
+                                  ica_df))
+    print(paste0("[",format(Sys.time(), "%Y-%m-%d %H:%M:%S"),"]",
+                 " Writing to ",results_dir,"ICA_",fund_sect_param,"_",run,"_i",
+                 "FINAL",
+                 robust_params$suffix, 
+                 ".csv"))
+    write.csv(output_df,paste0(results_dir,"ICA_",fund_sect_param,"_",run,"_i",
+                               "FINAL",
+                               robust_params$suffix,
+                               ".csv"),row.names = FALSE)
+
+    ############################################################################
+    # generate plots for this run
+    ############################################################################
+    library(tidyr)  
+    library(ggplot2)
+     
+    #plot the distribution of other sector project counts
+    log_other_sect_projs <- input_df %>% 
+      mutate(year_color=as.factor(year_group)) %>% 
+      ggplot(aes(log_other_sect_n, color=year_color)) +
+      geom_density() +
+      labs(x = paste0(toupper(funder_param)," project count (log + 1) in sectors other than ",sector_param), 
+           y = "Density across DHS points",
+           title=paste0(toupper(funder_param),
+                        " project count (log + 1) by year group in sectors other than ",
+                        sector_param),
+           color="Year Group")  +
+      theme_bw()
+
+    ggsave(paste0(results_dir,fund_sect_param,"_15other_sect_projs_",run,robust_params$suffix,".pdf"),
+           log_other_sect_projs,
+           width=6, height = 6, dpi=300,
+           bg="white", units="in")
+     
+    long_funder <- case_when(
+      startsWith(fund_sect_param, "ch") ~ "China",
+      startsWith(fund_sect_param, "wb") ~ "World Bank",
+      startsWith(fund_sect_param, "both") ~ "Both China & World Bank"
+    )
+
+    sector_names_df <- read.csv(sprintf("./data/interim/sector_group_names%s.csv",robust_params$suffix)) %>% 
+      mutate(sec_pre_name = paste0(ad_sector_names," (",ad_sector_codes,")"))
+
+    sector_name <- sector_names_df %>%
+      filter(ad_sector_codes==sector_param) %>%
+      pull(sec_pre_name)
+
+    # Convert to long format for boxplots
+    long_input_df <- input_df %>%
+      select(treated,all_of(var_order)) %>%
+      tidyr::pivot_longer(c(-treated),names_to="variable_name", values_to="value")
+  
+    sub_l1 <- paste("Funder:",long_funder,"     Sector:", sector_name)
+    sub_l2 <- ifelse(nzchar(dropped_labels),
+                     paste0("Dropped due to no variation: ", dropped_labels),
+                     "")
+    
+    combined_boxplot <- ggplot(long_input_df, aes(x = factor(treated), y = value)) +
+      geom_boxplot() +
+      labs(title = "Distribution of Wealth Outcome and Confounders for Treated and Control Neighborhoods",
+           subtitle = paste(sub_l1,sub_l2,sep="\n"),
+           x = paste0("Treatment/Control: 0:control (n ",control_count,"), 1:treated (n ",treat_count,")"),
+           y = "Value",
+           color = "Highest Pr(T=1)",
+           fill = "Lowest Pr(T=1)") +
+      facet_wrap(~ variable_name, scales = "free") +
+      facet_wrap(~ factor(variable_name, levels = var_order, labels = var_labels), scales = "free") +
+      theme_bw()  +
+      theme(panel.grid = element_blank()) 
+
+    ggsave(paste0(results_dir,fund_sect_param,"_20boxplots_",run,robust_params$suffix, ".pdf"),
+           combined_boxplot,
+           width=10, height = 8, dpi=300,
+           bg="white", units="in")
+    
+    #############################################################################
+    ##### create a scatterplot comparing confounders to outcome variable
+    #############################################################################
+    # Set the treated color based on funder
+    treat_color <- case_when(
+      startsWith(fund_sect_param, "ch") ~ "indianred1",
+      startsWith(fund_sect_param, "wb") ~ "mediumblue"
+    )
+
+    #Convert to longer format for density plots, leaving outcome as separate column
+    hybrid_input_df <- input_df %>%
+      select(treated,all_of(var_order)) %>% 
+      tidyr::pivot_longer(c(-treated,-iwi_est_post_oda),names_to="variable_name", values_to="value")  
+
+    outcome_confounders_plot <- ggplot(hybrid_input_df, aes(x = iwi_est_post_oda, y=value, color = factor(treated))) +
+      geom_point(alpha = 0.3) +
+      facet_wrap(~ variable_name, scales = "free_y", ncol = 3) +
+      facet_wrap(~ factor(variable_name, levels = var_order, labels = var_labels), scales = "free") +
+      labs(title = "Confounders vs. Estimated wealth for Treated and Control Neighborhoods",
+           subtitle = paste(sub_l1,sub_l2,sep="\n"),
+           x = "Estimated Wealth Index one 3-year lag after project commitment period",
+           y = "Value",
+           color="") +
+      scale_color_manual(values = c("gray60", treat_color),
+                         labels = c("Control", "Treated")) +
+      theme_bw()  +
+      theme(panel.grid = element_blank(),
+            legend.position = "top",
+            legend.justification = c("right","top"),
+            legend.margin=margin(0,0,0,0),
+            legend.direction="horizontal")
+    
+    ggsave(paste0(results_dir,fund_sect_param,"_30conf_iwi_",run, robust_params$suffix, ".png"),
+           outcome_confounders_plot,
+           width=10, height = 8, dpi=300,
+           bg="white", units="in")
+
+    ##########################################################################
+    ##### generate treatment/control map
+    ##########################################################################
+    library(tmap)
+    #tmap_options(check.and.fix = TRUE)
+    tmap::tm_check_fix()
+    projection <- "ESRI:102023"
+    
+    #convert DHS points df to sf object
+    input_sf <- sf::st_as_sf(input_df, coords=c("lon","lat"),crs="EPSG:4326")  %>%
+      sf::st_transform(crs=sf::st_crs(projection))
+    ###############################################################
+    #### Load administrative borders and ISO list excluding islands
+    ###############################################################
+    africa_map_isos_df <- read.csv("./data/interim/africa_map_isos.csv")
+    
+    country_borders <-  sf::read_sf("./data/country_regions/gadm28_adm0.shp") %>%
+      filter(ISO %in% africa_map_isos_df$iso3)
+    sf::st_crs(country_borders) = "EPSG:4326"
+    country_borders <- sf::st_transform(country_borders,crs=sf::st_crs(projection))
+    country_borders <- sf::st_make_valid(country_borders)
+    
+    ########################
+    #### Generate map
+    ########################
+    treat_control_map <- tm_shape(country_borders) +
+      tm_borders(lwd=2) +
+      tm_shape(input_sf[input_sf$treated == 0, ]) +  
+      tm_dots(size=.3, col="gray80", alpha=.3) +
+      tm_shape(input_sf[input_sf$treated == 1, ]) +  
+      tm_dots(size=.5, col=treat_color, alpha=.3) +
+      tm_add_legend(type = "fill"
+                    , col = c(treat_color,"gray80")
+                    , labels = c(paste0("Treated (n ",treat_count,")"),
+                                 paste0("Control (n ",control_count,")")))  +
+      tm_layout(main.title.size=1,
+                main.title = paste0(long_funder,": ",sector_name,"\nTreatment and Control Locations (2002-2013)"),
+                main.title.position=c("center","top"),
+                legend.position = c("left", "bottom"),
+                legend.text.size = 1,
+                legend.width=-1,
+                frame = T ,
+                legend.outside = F, 
+                outer.margins = c(0, 0, 0, 0), 
+                legend.outside.size = .25
+      )
+    tmap_save(treat_control_map,paste0(results_dir,fund_sect_param,"_10map_",run,robust_params$suffix, ".png"))
+  
+    library(glmnet); library(scales)
+    #####################################################################
+    #function to estimate ATE and standard error with ridge regression
+    #####################################################################
+    est_ate_with_se_ridge <- function(X, obsW, obsY, nBoot = 100, trainIndices, testIndices) {
+      ate_vec <- c();
+      pb <- txtProgressBar(min = 0, max = nBoot, style = 3) # Initialize progress bar
+      for (i in 1L:(nBoot + 1L)) {
+        if(i %%10 ==0){print(sprintf("Boot %s of %s",i,nBoot))}
+        setTxtProgressBar(pb, i)
+        if(i != (nBoot + 1L)){ boot_indices <- sample(1:length(obsY), length(obsY), replace = TRUE) }
+        if(i == (nBoot + 1L)){ boot_indices <- 1:length(obsY) }
+        ridge_model <- glmnet::cv.glmnet(
+          x = as.matrix(X[boot_indices,]),
+          y = as.matrix(obsW[boot_indices]),
+          nfolds = 5,
+          alpha = 0, # alpha = 0 is the ridge penalty
+          type.measure = "auc",
+          family = "binomial")
+        obs_treated <- obsW[boot_indices]
+        obs_outcome <- obsY[boot_indices]
+        est_pr_treated <- predict(ridge_model, s = "lambda.min",
+                                  newx = as.matrix(X[boot_indices,]), type = "response")
+        # Trim propensity scores to avoid division by zero in IPW
+        est_pr_treated <- pmax(0.01, pmin(0.99, est_pr_treated))
+        ate_vec[i] <- sum(obs_outcome*prop.table(obs_treated/c(est_pr_treated))) -
+          sum(obs_outcome*prop.table((1-obs_treated)/c(1-est_pr_treated) ))
+        if(i == (nBoot + 1L)) {
+          # Create a data frame with predicted probabilities, and actual treatment status
+          ridge_result_df <- data.frame(predicted_probs = est_pr_treated,
+                                        treated = obs_treated)
+          # Plot it in thesis style
+          ridge_conf_density <- ggplot(ridge_result_df, aes(x = lambda.min, fill = factor(treated))) +
+            geom_density(alpha = 0.5) +
+            labs(title = "Ridge regression: Density Plot for\nEstimated Pr(T=1 | Tabular Covariates)",
+                 subtitle = paste(sub_l1,sub_l2,sep="\n"),
+                 x = "Predicted Treatment Propensity",
+                 y = "Density",
+                 fill="Status") +
+            scale_fill_manual(values = c("gray80", treat_color),
+                              labels = c("Control", "Treated")) +
+            scale_x_continuous(labels=label_number_auto(),limits=c(0,1)) +
+            theme_bw() +
+            theme(panel.grid = element_blank())
+          #save
+          ggsave(paste0(results_dir,fund_sect_param,"_50ridge_prop_",run,robust_params$suffix,".pdf"),
+                 ridge_conf_density,
+                 width=6, height = 4, dpi=300,
+                 bg="white", units="in")
+          # Plot it in AnalyzeImageConfounding style
+          try({
+            print("Plotting ridge tabular only propensity histogram...")
+            pdf(sprintf("%s%s_55ridge_prop_%s%s.pdf",results_dir,fund_sect_param,run,robust_params$suffix))
+            {
+              par(mfrow=c(1,1))
+              d0 <- density(est_pr_treated[obsW==0])
+              d1 <- density(est_pr_treated[obsW==1])
+              plot(d1,lwd=2,xlim = c(-0.1,1.1),ylim =c(0,max(c(d1$y,d0$y),na.rm=T)*1.2),
+                   cex.axis = 1.2,ylab = "",xaxt = "n",
+                   xlab = paste0(fund_sect_param,"_",run,"_i","FINAL"),
+                   main = "Density Plots for \n Estimated Pr(T=1 | Tabular Covariates)",cex.main = 2)
+              axis(1, at = seq(0,1,by = 0.25))
+              points(d0,lwd=2,type = "l",col="gray",lty=2)
+              text(d0$x[which.max(d0$y)[1]],
+                   max(d0$y,na.rm=T)*1.1,label = "T = 0",col="gray",cex=2)
+              text(d1$x[which.max(d1$y)[1]],
+                   max(d1$y,na.rm=T)*1.1,label = "T = 1",col="black",cex=2)
+            }
+            dev.off()
+          }, T)
+          # run again for coefficients / use cross-validation to choose lambda
+          cv_model_ridge <- cv.glmnet(x=as.matrix(X[boot_indices,]),
+                                      y=as.matrix(obsW[boot_indices]),
+                                      nfolds=5,
+                                      family = "binomial",
+                                      alpha = 0)
+          best_lambda_ridge <- cv_model_ridge$lambda.min
+          # Fit model with best lambda
+          ridge_model_best <- glmnet(x=as.matrix(X[boot_indices,]),
+                                     y=as.matrix(obsW[boot_indices]),
+                                     family = "binomial", alpha = 0,
+                                     lambda = best_lambda_ridge)
+          ridge_coeffs_df <- broom::tidy(ridge_model_best)
+        } #end of last iteration check
+      } #end of for loop
+      close(pb) # Close the progress bar after the loop
+      # Compute model evaluation metrics using provided train/test indices
+      ridge_model_metrics <- glmnet::cv.glmnet(
+        x = as.matrix(X[trainIndices,]),
+        y = as.matrix(obsW[trainIndices]),
+        nfolds = 5,
+        alpha = 0,
+        type.measure = "auc",
+        family = "binomial"
+      )
+      est_pr_treated_metrics <- predict(ridge_model_metrics, s = "lambda.min",
+                                        newx = as.matrix(X), type = "response")
+      baseline_pr <- mean(obsW[trainIndices])
+      pr_baseline <- rep(baseline_pr, length(obsW))
+      binaryCrossLoss <- function(W, prW) { -mean(W * log(prW) + (1 - W) * log(1 - prW)) }
+      classError <- function(W, prW) { mean((prW > 0.5 & W == 0) | (prW <= 0.5 & W == 1)) }
+      in_sample <- trainIndices
+      out_sample <- testIndices
+      lossCE_IN <- binaryCrossLoss(obsW[in_sample], est_pr_treated_metrics[in_sample])
+      lossCE_OUT <- binaryCrossLoss(obsW[out_sample], est_pr_treated_metrics[out_sample])
+      lossCE_IN_baseline <- binaryCrossLoss(obsW[in_sample], pr_baseline[in_sample])
+      lossCE_OUT_baseline <- binaryCrossLoss(obsW[out_sample], pr_baseline[out_sample])
+      ClassError_IN <- classError(obsW[in_sample], est_pr_treated_metrics[in_sample])
+      ClassError_OUT <- classError(obsW[out_sample], est_pr_treated_metrics[out_sample])
+      ClassError_IN_baseline <- classError(obsW[in_sample], pr_baseline[in_sample])
+      ClassError_OUT_baseline <- classError(obsW[out_sample], pr_baseline[out_sample])
+      AUC_IN <- pROC::auc(pROC::roc(obsW[in_sample], est_pr_treated_metrics[in_sample], levels = c(0, 1), direction = "<"))
+      AUC_OUT <- pROC::auc(pROC::roc(obsW[out_sample], est_pr_treated_metrics[out_sample], levels = c(0, 1), direction = "<"))
+      AUPRC_IN <- PRROC::pr.curve(scores.class0 = est_pr_treated_metrics[in_sample][obsW[in_sample] == 1],
+                                  scores.class1 = est_pr_treated_metrics[in_sample][obsW[in_sample] == 0],
+                                  curve = FALSE)$auc.integral
+      AUPRC_OUT <- PRROC::pr.curve(scores.class0 = est_pr_treated_metrics[out_sample][obsW[out_sample] == 1],
+                                   scores.class1 = est_pr_treated_metrics[out_sample][obsW[out_sample] == 0],
+                                   curve = FALSE)$auc.integral
+      ModelEvaluationMetrics <- list(
+        AUC_out = AUC_OUT,
+        AUC_in = AUC_IN,
+        AUPRC_out = AUPRC_OUT,
+        AUPRC_in = AUPRC_IN,
+        CELoss_out = lossCE_OUT,
+        CELoss_out_baseline = lossCE_OUT_baseline,
+        CELoss_in = lossCE_IN,
+        CELoss_in_baseline = lossCE_IN_baseline,
+        ClassError_out = ClassError_OUT,
+        ClassError_out_baseline = ClassError_OUT_baseline,
+        ClassError_in = ClassError_IN,
+        ClassError_in_baseline = ClassError_IN_baseline
+      )
+      return(list(
+        "ate" = ate_vec[length(ate_vec)],
+        "ate_se" = sd(ate_vec[-length(ate_vec)]),
+        "coeffs_df" = ridge_coeffs_df,
+        "ModelEvaluationMetrics" = ModelEvaluationMetrics))
+    } #end of est_ate_with_se_ridge
+    
+    ############################################################################
+    ##### ridge regression for treatment probabilities with tabular covs only
+    ############################################################################
+    if(X_approach == "withX"){ 
+    nBoot <- 100 # tabular nBoot 
+    # do bootstrap with tabular only results 
+    {
+    output <- est_ate_with_se_ridge(X=conf_matrix,
+                                    obsW=input_df$treated,
+                                    obsY=input_df$iwi_est_post_oda,
+                                    nBoot=nBoot,
+                                    trainIndices = ImageConfoundingAnalysis$trainIndices,
+                                    testIndices = ImageConfoundingAnalysis$testIndices)
+    treat_prob_log_r_df <- output$coeffs_df %>%
+      rename(ridge_est=estimate)
+    output_df <- data.frame("fund_sect_param"=fund_sect_param,
+                            "ate_ridge"=output$ate,
+                            "ate_se_ridge"=output$ate_se,
+                            t(unlist(output$ModelEvaluationMetrics)))
+    write.csv(output_df,
+              paste0(results_dir,fund_sect_param,sprintf("_ridge_tab_only%s.csv",robust_params$suffix)), 
+              row.names=FALSE) 
+    }
+    
+    # do bootstrap with fixed effects only results 
+    {
+      # Run bootstrap with fixed effects only
+      output_fe <- est_ate_with_se_ridge(X = fe_matrix,
+                                         obsW = input_df$treated,
+                                         obsY = input_df$iwi_est_post_oda,
+                                         nBoot = nBoot,
+                                         trainIndices = ImageConfoundingAnalysis$trainIndices,
+                                         testIndices = ImageConfoundingAnalysis$testIndices)
+      treat_prob_log_r_fe_df <- output_fe$coeffs_df %>%
+        rename(ridge_est = estimate)
+      
+      output_fe_df <- data.frame("fund_sect_param" = fund_sect_param,
+                                 "ate_ridge_fe" = output_fe$ate,
+                                 "ate_se_ridge_fe" = output_fe$ate_se,
+                                 t(unlist(output_fe$ModelEvaluationMetrics)))
+      
+      write.csv(output_fe_df,
+                paste0(results_dir, fund_sect_param, sprintf("_ridge_fe_only%s.csv",robust_params$suffix)),
+                row.names = FALSE)
+    }
+    }
+
+    ############################################################################
+    ##### add SalienceX & .se to df, save, and plot ridge and SalienceX values
+    ############################################################################    
+    #extract tabular confounder salience values from image confounding output
+    if(X_approach == "withX"){
+    if (vision_backbone %in% c("vt")) {
+        #doesn't have se for Salience scores
+        tab_conf_salience_df <- ica_df %>%
+          select(starts_with("SalienceX."))  %>%
+          rename_with(~sub("^SalienceX\\.", "", .), starts_with("SalienceX.")) %>%
+          pivot_longer(cols=everything())
+        
+        #join to dataframe with ridge output
+        tab_conf_compare_df <-  treat_prob_log_r_df %>% 
+          right_join(tab_conf_salience_df, join_by("term"=="name")) %>% 
+          rename(Salience_AIC = value)
+      }
+    if( vision_backbone %in% "emb") {
+        tab_conf_salience_df <- ica_df %>%
+          select(starts_with("SalienceX"))  %>%
+          pivot_longer(cols=everything()) %>% 
+          tidyr::separate_wider_delim(name,delim=".",names=c("measure","term")) %>% 
+          pivot_wider(names_from = measure, values_from=value) %>% 
+          mutate(SalienceX_tscore = abs(SalienceX/SalienceX_se),
+                 SalienceX_sig = ifelse(SalienceX_tscore >= 1.96, "*",""))
+        
+        #join to dataframe with ridge output
+        tab_conf_compare_df <-  treat_prob_log_r_df %>% 
+          right_join(tab_conf_salience_df, by="term") %>% 
+          rename(Salience_AIC = SalienceX) 
+      }
+      
+    #write to file
+    write.csv(tab_conf_compare_df,
+              paste0(results_dir,fund_sect_param,"_tab_conf_compare_", run, robust_params$suffix, ".csv"),
+              row.names = FALSE)
+
+    #plot these
+    #before doing so, remove ADM2 variables
+    tab_conf_compare_df <- tab_conf_compare_df %>% 
+      filter(!grepl("adm2",term))
+    #determine the limits of the plot
+    max_abs_value_x <- max(abs(tab_conf_compare_df$ridge_est),na.rm=T)
+    max_abs_value_y <- max(abs(tab_conf_compare_df$Salience_AIC),na.rm=T)
+    
+    tab_est_images <- tab_conf_compare_df %>% 
+      mutate(term=case_match(term,
+                             "log_pc_nl_pre_oda" ~ "percap_nightlights",
+                             "log_avg_min_to_city" ~ "min_to_city",
+                             "log_avg_pop_dens" ~ "pop_dens",
+                             "log_3yr_pre_conflict_deaths" ~ "conflict_deaths",
+                             "log_disasters" ~ "natural_disasters",
+                             "log_ch_loan_proj_n" ~ "ch_loan_projs",
+                             "log_dist_km_to_gold" ~ "dist_to_gold",
+                             "log_dist_km_to_gems" ~ "dist_to_gems",
+                             "log_dist_km_to_dia" ~ "dist_to_dia",
+                             "log_dist_km_to_petro" ~ "dist_to_petro",
+                             "log_total_neighbor_projs" ~ "neighbor_oda",
+                             "log_other_sect_n" ~ "other_sector_oda",
+                             "log_treated_other_funder_n" ~ "other_funder_oda",
+                             .default=term)) %>% 
+      ggplot(aes(x = ridge_est, y = Salience_AIC, label = term)) +
+      geom_point(color=treat_color) +
+      ggrepel::geom_text_repel(box.padding = 1,max.overlaps=Inf,color=treat_color,
+                               segment.color="gray80") + 
+      geom_vline(xintercept=0,color="gray80") +
+      geom_hline(yintercept=0, color="gray80") +
+      geom_abline(intercept=0, slope=1, linetype="dashed",color="gray80") +
+      labs(title = "Tabular confounder estimates with and without images",
+           subtitle = paste(sub_l1,sub_l2,sep="\n"),
+           x = "Tabular covariates only: Ridge estimate",
+           y = "Salience with Image Confounding") +   
+      coord_cartesian(xlim=c(-1*max_abs_value_x,max_abs_value_x),
+                  ylim=c(-1*max_abs_value_y,max_abs_value_y)) +
+      theme_bw()  +
+      theme(panel.grid = element_blank())
+    
+    #save
+    ggsave(paste0(results_dir,fund_sect_param,"_90xy_tab_conf_images_",run,robust_params$suffix,".pdf"),
+           tab_est_images,
+           width=6, height = 6, dpi=300,
+           bg="white", units="in")
+  }
+    
+    ############################################################################
+    #print these messages again to be at the end of the logfile
+    ############################################################################
+    if (dropped_labels != "") {
+      print(paste("Done! Dropped for 0 SD: ", dropped_labels))
+    }
+    print("Done with call_CI_Conf_5k_3yr.R iteration!")
+    }
+    }
+   }
+  }
+}
+}
+}
+}
+}
+
+if(FALSE){# Check JAX
+  reticulate::use_condaenv("jax_gpu",required=TRUE)
+  jax <- reticulate::import("jax")
+  jax$numpy$array(4.)
+}
+if(FALSE){ # Check naive ATEs
+  # 1. Identify the directory and list all Naive ATE files
+  target_path <- file.path("./results", SaveResultsFolder)
+  all_naive_df <- do.call(rbind, lapply(list.files(target_path, 
+                            pattern = "NaiveATEAnalysis_.*\\.csv$", 
+                            full.names = TRUE), read.csv))
+  plot(all_naive_df$naive_ate,col=(all_naive_df$funder=="ch")+1)
+  
+  # --- Heterogeneity by Funder ---
+  cat("\n[Analysis 1] Mean Naive ATE (Wealth Index) by Funder:\n")
+  funder_stats <- all_naive_df %>%
+    group_by(funder) %>%
+    summarize(
+      Mean_Naive_ATE = mean(naive_ate, na.rm = TRUE),
+      Median_Naive_ATE = median(naive_ate, na.rm = TRUE),
+      SD_Naive_ATE = sd(naive_ate, na.rm = TRUE),
+      N_Sectors = n()
+    )
+  print(funder_stats)
+  
+  # --- Sector-Level Outliers ---
+  cat("\n[Analysis 2] Top 3 Most Positive and Negative Sector Associations:\n")
+  top_bottom_sectors <- all_naive_df %>%
+    arrange(desc(naive_ate)) %>%
+    select(funder, sector, n_treated, n_control, naive_ate) %>%
+    slice(c(1:3, (n()-2):n()))
+  print(top_bottom_sectors)
+  
+  # Save the aggregated file for easy inspection later
+  write.csv(all_naive_df, 
+            file.path(target_path, "Aggregated_Naive_ATE_Results.csv"), 
+            row.names = FALSE)
+  print(paste0("Aggregated results saved to: ", file.path(target_path, "Aggregated_Naive_ATE_Results.csv")))
+}
+

code/lib/call_CI_Conf_5k_3yr_DiD.R

@@ -0,0 +1,43 @@
+# Script: call_CI_Conf_5k_3k_DiD.R
+# de Chaisemartin & D’Haultfœuille (2020/2022)
+  {
+        # Assume full data is in 'input_df' (tibble/data.frame with columns: dhs_id, year_group, treated, iwi_est_post_oda)
+        # Map year_group (chr) to numeric time (midpoint of bins for ordering)
+        library(tidyr)
+        input_df <- input_df %>%
+          mutate(time = case_when(
+            year_group == "2002:2004" ~ 2003,
+            year_group == "2005:2007" ~ 2006,
+            year_group == "2008:2010" ~ 2009,
+            year_group == "2011:2013" ~ 2012,
+            TRUE ~ NA_real_  # Extend as needed for more bins
+          )) %>% drop_na(time)  # Drop invalid year_groups if any
+        
+        if(FALSE){ 
+        write.csv(input_df,
+                  file = sprintf("./%s/InputData_%s_DiD.csv",results_dir, fund_sect_param))
+        }
+        
+        did_dyn <- DIDmultiplegt::did_multiplegt(
+          mode      = "dyn",
+          input_df,                             # data
+          outcome   = "iwi_est_post_oda",       # outcome variable
+          group     = "dhs_id",                 # group (unit) id  
+          time      = "time",                   # time variable (numeric)
+          treatment = "treated",                # treatment (0/1)
+          cluster   = "dhs_id",                 # cluster for SEs
+          ci_level  = 95,                       # confidence level
+          graph_off = FALSE                     # show event-study graph (FALSE to show, TRUE to hide)
+        )
+        
+        # write to disk 
+        write.csv(file = sprintf("./%s/%s_unitFE.csv",results_dir, fund_sect_param),
+                  cbind("fund_sect_param"=fund_sect_param,
+                        "time_approach"=time_approach,
+                        "vision_backbone"=vision_backbone,
+                        "X_approach"=X_approach,
+                        "run"=run,
+                        unlist(did_dyn$results$ATE)))
+        print("Done with DiD estimation!")
+}
+

code/lib/call_CI_Conf_5k_3yr_Helpers.R

@@ -0,0 +1,21 @@
+{
+  get_total_ram_gb <- function() {
+    os <- Sys.info()["sysname"]
+    if (os == "Linux") {
+      meminfo <- readLines("/proc/meminfo")
+      total_line <- grep("MemTotal:", meminfo)
+      total_kb <- as.numeric(gsub("[^0-9]", "", meminfo[total_line]))
+      return(total_kb / 1024^2)
+    } else if (os == "Darwin") {
+      total_bytes <- as.numeric(system("sysctl -n hw.memsize", intern = TRUE))
+      return(total_bytes / 1024^3)
+    } else if (os == "Windows") {
+      mem_lines <- system("wmic MemoryChip get Capacity", intern = TRUE)
+      capacities <- as.numeric(mem_lines[grepl("^[0-9]+$", trimws(mem_lines))])
+      total_bytes <- sum(capacities)
+      return(total_bytes / 1024^3)
+    } else {
+      stop("Unsupported OS")
+    }
+  }
+}

code/lib/call_CI_Conf_5k_3yr_unitFE.R

@@ -0,0 +1,32 @@
+# Unit FE analysis
+{
+  {
+    input_df$IWI <- input_df$iwi_est_post_oda
+    input_df[input_df$dhs_id==sample(input_df$dhs_id,1),c(
+      "dhs_id","year_group","treated","IWI")]
+    
+    input_noNAs <- na.omit(input_df[, c("dhs_id", "first_year_group", "iwi_est_post_oda", "treated", "adm2")])
+    library(plm);library(clubSandwich);library(sandwich);library(lmtest)
+    pdata <- pdata.frame(input_noNAs, index = c("dhs_id","first_year_group"))
+    demeaned_est <- plm(iwi_est_post_oda ~ treated,
+                        effect = "twoways",
+                        data = pdata, model = "within")
+    summary(demeaned_est) # treated  0.63017    0.10251  6.1476 8.058e-10 ***
+    
+    # For the main model
+    vcov_main <- vcovCR(demeaned_est, cluster = pdata$adm2, type = "CR1")  # CR1 is a common finite-sample correction; alternatives: CR0, CR2, CR3
+    coeftest_main <- coeftest(demeaned_est, vcov = vcov_main)
+    
+    # write to disk 
+    write.csv(file = sprintf("./%s/%s_unitFE%s.csv",results_dir, fund_sect_param, robust_params$suffix),
+              cbind("fund_sect_param"=fund_sect_param,
+                    "time_approach"=time_approach,
+                    "vision_backbone"=vision_backbone,
+                    "X_approach"=X_approach,
+                    "run"=run,
+                    "Estimate" = coeftest_main[1], 
+                    "SE" = coeftest_main[2]
+                    ))
+    print("Done with unit FE estimation!")
+  }
+}

code/lib/chart_dhs_projs.R

@@ -0,0 +1,173 @@
+################################################################################
+# chart_dhs.R:  charts and descriptive stats on dhs points and their intersection
+# with projects by sector 
+################################################################################
+setwd(getOption("replication.root", default = getwd())); options(error = NULL)
+library(dplyr)
+library(tidyr)
+library(ggplot2)
+
+KeepObjectsAcrossAnalysisStrings <- get0("KeepObjectsAcrossAnalysisStrings", ifnotfound = character())
+try(rm(list=ls()[!ls() %in% (Keeps <- c("t0",KeepObjectsAcrossAnalysisStrings))] ),T)
+
+#get dhs treatment/control counts for actual (not estimated) DHS points
+treat_control_actual_dhs_df <- read.csv("./data/interim/dhs_treat_control_3yr_actual_counts.csv") 
+
+###########################################################
+#calc dhs treatment/control counts for estimated DHS points
+###########################################################
+##### read confounder and treatment data from files
+dhs_confounders_df <- read.csv("./data/interim/dhs_5k_confounders.csv") %>% 
+  dplyr::select(-year)  #remove survey year column that could be confused with oda year
+
+#get list of all dhs_id's and their iso3 for use below from confounder set
+#since those without confounder data are not usable
+dhs_iso3_df <- dhs_confounders_df %>% 
+  distinct(dhs_id,iso3) 
+
+#get treated for all funders and sectors
+dhs_t_df <- read.csv("./data/interim/dhs_treated_sector_3yr.csv") %>% 
+  #exclude DHS points where confounder data not available 
+  inner_join(dhs_confounders_df %>% 
+               dplyr::select(dhs_id, ID_adm2), by = join_by(dhs_id)) %>% 
+  filter(year_group!="2014:2016")
+
+##### calculate control points #############################
+#identify countries where each funder is operating in each sector
+funder_sector_iso3 <- dhs_t_df %>% 
+  #join to dhs_confounders to get iso3 and limit to dhs points with confounder data
+  inner_join(dhs_confounders_df, by="dhs_id") %>%  
+  distinct(funder,sector,iso3)
+  
+#create a record for each year_group for panel data
+year_group_v <- c('2002:2004', '2005:2007', '2008:2010', '2011:2013')
+
+#generate dataframe of all dhs points for all year groups in operating countries 
+all_t_c_df <- funder_sector_iso3 %>%
+  #create a row for each year group
+  crossing(year_group = year_group_v) %>% 
+  #create a row for each dhs_id
+  left_join(dhs_iso3_df,by="iso3",
+            multiple = "all")
+
+#remove treated funder/sector/dhs/year_group observations to construct controls 
+dhs_c_df <- all_t_c_df %>% 
+  #exclude dhs_points treated in each year_group
+  anti_join(dhs_t_df,by=c("sector","funder","dhs_id","year_group"))
+
+treat_dhs_count_df  <- dhs_t_df %>%   
+  group_by(funder,sector) %>%
+  summarize(treat_n = n()) %>% 
+  ungroup()
+
+control_dhs_count_df  <- dhs_c_df %>%   
+  group_by(funder,sector) %>%
+  summarize(control_n = n()) %>% 
+  ungroup()
+
+#join control and treated into a single dataframe
+treat_control_est_dhs_df <- treat_dhs_count_df %>% 
+  left_join(control_dhs_count_df, by=c("funder","sector")) %>% 
+  rename(est_iwi_treat_n = treat_n,
+         est_iwi_control_n = control_n)
+
+#join with t/c counts from actual IWI DHS locations rather than estimates
+t_c_est_act_df <- treat_control_est_dhs_df %>% 
+  left_join(treat_control_actual_dhs_df, by=c("funder","sector")) %>% 
+  rename(act_iwi_treat_n = treat_n,
+         act_iwi_control_n = control_n) %>% 
+  mutate(act_iwi_treat_n = ifelse(is.na(act_iwi_treat_n),0,act_iwi_treat_n),
+         act_iwi_control_n = ifelse(is.na(act_iwi_control_n),0,act_iwi_control_n))
+
+write.csv(t_c_est_act_df,"./tables/dhs_treat_control_est_act_compare.csv",row.names=FALSE)
+
+#adjust for display
+sector_names_df <- read.csv("./data/interim/sector_group_names.csv") %>% 
+  mutate(sec_pre_name = paste0(ad_sector_names," (",ad_sector_codes,")")) %>% 
+  dplyr::select(ad_sector_codes, sec_pre_name)
+
+t_c_est_act_display_df <- t_c_est_act_df %>% 
+  left_join(sector_names_df,join_by(sector==ad_sector_codes)) %>% 
+  pivot_longer(
+    cols = c(est_iwi_treat_n, est_iwi_control_n, act_iwi_treat_n, act_iwi_control_n),
+    names_to = "count_name",
+    values_to = "count_obs"
+  ) %>%
+  unite("funder_count_name", funder, count_name, sep = "_") %>%
+  pivot_wider(
+    names_from = funder_count_name,
+    values_from = count_obs
+  ) %>% 
+  dplyr::select(-sector)
+  
+#write display version
+write.csv(t_c_est_act_display_df,"./tables/dhs_treat_control_est_act_display.csv",row.names=FALSE)
+
+#################################################################################
+#xy plots to compare treated and control n for actual and estimated wealth 
+#################################################################################
+
+#determine the limits of the plot
+max_abs_value <- max(abs(t_c_est_act_df$est_iwi_treat_n),
+                     abs(t_c_est_act_df$act_iwi_treat_n),
+                     na.rm=T)
+
+treated_est_act <- t_c_est_act_df %>% 
+  ggplot(aes(x = act_iwi_treat_n, y = est_iwi_treat_n, color=funder, 
+             label=sector)) +
+  geom_point() +
+  ggrepel::geom_text_repel(box.padding = .1,max.overlaps=Inf,show.legend=FALSE) +
+  scale_color_manual(name = "Funder",
+                     values = c("ch"="indianred1","wb"="mediumblue"),
+                     labels = c("China","World Bank")) +
+  geom_abline(intercept=0, slope=1, linetype="dashed",color="gray80") +
+  labs(title = "Treated Observations: Actual DHS Versus Estimated Wealth Outcomes\nBy Funder and Sector Number",
+       x = "Actual DHS Wealth Data Treated Number (Cross-Sectional Data)",
+       y = "Estimated Wealth Data Treated Number (Panel Data)",
+       legend = "Funder") +   
+  coord_cartesian(xlim=c(0,max_abs_value),
+                  ylim=c(0,max_abs_value)) +
+  theme_bw()  +
+  theme(panel.grid = element_blank())
+
+#save
+ggsave("./figures/xy_treated_n_est_act.pdf",
+       treated_est_act,
+       width=8, height = 6, dpi=300,
+       bg="white", units="in")
+
+
+#determine the limits of the plot
+max_abs_value_tc <- max(abs(t_c_est_act_df$est_iwi_treat_n),
+                     abs(t_c_est_act_df$act_iwi_treat_n),
+                     abs(t_c_est_act_df$est_iwi_control_n),
+                     abs(t_c_est_act_df$act_iwi_control_n),
+                     na.rm=T)
+
+t_c_est_act_fig <- t_c_est_act_df %>% 
+  pivot_longer(cols=starts_with("est"),names_to="var_est",values_to="estimated_n") %>% 
+  mutate(var=ifelse(grepl("_iwi_treat_n",var_est),"Treated","Control")) %>% 
+  dplyr::select(-var_est) %>% 
+  mutate(actual_n=ifelse(var=="Treated",act_iwi_treat_n,act_iwi_control_n)) %>% 
+  dplyr::select(-act_iwi_treat_n,-act_iwi_control_n ) %>% 
+  ggplot(aes(x = actual_n, y = estimated_n, color=funder, 
+             label=sector)) +
+  facet_wrap(var ~ funder,scales="free",
+             labeller=labeller(funder=c("ch"="China","wb"="World Bank"))) + 
+  geom_point(show.legend=FALSE) +
+  ggrepel::geom_text_repel(box.padding = .1,max.overlaps=Inf,show.legend=FALSE) +
+  scale_color_manual(values = c("ch"="indianred1","wb"="mediumblue"),
+                     labels = c("China","World Bank")) +
+  geom_abline(intercept=0, slope=1, linetype="dashed",color="gray80") +
+  labs(title = "Observation Number With Actual DHS Versus Estimated Wealth Outcomes\nBy Funder and Sector Number",
+       x = "Actual DHS Wealth Data Observations (Cross-Sectional Data)",
+       y = "Estimated Wealth Data Observations (Panel Data)",
+       legend = "Funder") +   
+  theme_bw()  +
+  theme(panel.grid = element_blank())
+
+#save
+ggsave("./figures/xy_cntrl_treated_n_est_act.pdf",
+       t_c_est_act_fig,
+       width=8, height = 8, dpi=300,
+       bg="white", units="in")

code/lib/chart_projects.R

@@ -0,0 +1,201 @@
+################################################################################
+# chart_projects.R:  charts and descriptive stats on projects
+################################################################################
+library(dplyr)
+library(ggplot2)
+
+KeepObjectsAcrossAnalysisStrings <- get0("KeepObjectsAcrossAnalysisStrings", ifnotfound = character())
+rm(list=ls()[!ls() %in% (Keeps <- c("t0",KeepObjectsAcrossAnalysisStrings))] )
+setwd(getOption("replication.root", default = getwd()))
+
+#read consolidated project list
+oda_df <- read.csv("./data/interim/africa_oda_sector_group.csv") %>% 
+  filter(transactions_start_year >= 2002 &
+         transactions_start_year <= 2013  )
+
+### Project counts by year and funder
+proj_year_count <- oda_df %>% 
+  group_by(funder, transactions_start_year) %>% 
+  count() %>% 
+ggplot(aes(x = transactions_start_year, y = n, fill = funder)) +
+  geom_bar(stat = "identity", position = "dodge") +
+  labs(title = "African aid by start year and funder",
+       x = "Transaction Start Year", y = "Project Count") +
+  theme_bw() + 
+  theme(panel.grid = element_blank()) +
+  scale_x_continuous(breaks = unique(oda_df$transactions_start_year), 
+                     labels = unique(oda_df$transactions_start_year)) + 
+  guides(fill = guide_legend(title = "Funder")) + 
+  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
+  scale_fill_manual(values = c("CH" = "indianred1", "WB" = "mediumblue"),
+                    labels = c("China","World Bank")) 
+
+ggsave("./figures/proj_year_counts.png",proj_year_count, width=6, height = 4, dpi=300,
+       bg="white", units="in")
+
+
+# proj_year_prec_count <- oda_df %>% 
+#   group_by(funder, transactions_start_year, precision_code) %>% 
+#   count() %>% 
+#   ggplot(aes(x = transactions_start_year, y = n, fill = funder, alpha=precision_code/4)) +
+#   geom_bar(stat = "identity", position = "dodge",color = "black", width = 0.7) +
+#   labs(title = "Count of African aid projects by start year",
+#        x = "Transaction Start Year", y = "Count") +
+#   theme_minimal() + 
+#   scale_x_continuous(breaks = unique(oda_df$transactions_start_year), 
+#                      labels = unique(oda_df$transactions_start_year)) + 
+#   guides(fill = guide_legend(title = "Funder"),
+#          alpha = guide_legend(title= "Precision Code")) + 
+#   scale_alpha_continuous(breaks=c(.25,.5,.75,1),labels = c("1 Exact", "2 Near", "3 ADM2", "4 ADM1")) +
+#   theme(axis.text.x = element_text(angle = 45, hjust = 1))
+
+### Project counts by year, funder, and precision
+proj_year_prec_count <- oda_df %>% 
+  group_by(funder, transactions_start_year, precision_code) %>% 
+  count() %>% 
+  ggplot(aes(x = transactions_start_year, y = n, fill = funder, alpha = factor(precision_code/4))) +
+  geom_bar(stat = "identity", position = position_dodge(width = .9), width = 0.7) +
+  labs(title = "African aid project location counts by start year and precision",
+       x = "Transaction Start Year", y = "Count") +
+  theme_bw() + 
+  theme(panel.grid = element_blank()) +
+  scale_x_continuous(breaks = unique(oda_df$transactions_start_year), 
+                     labels = unique(oda_df$transactions_start_year)) + 
+  guides(fill = guide_legend(title = "Funder"),
+         alpha = guide_legend(title = "Precision Code")) + 
+  scale_alpha_manual(values = c(1, 0.75, 0.5, 0.25),
+                     labels = c("1 Exact", "2 Near", "3 ADM2", "4 ADM1")) +
+  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
+  scale_fill_manual(values = c("CH" = "indianred1", "WB" = "mediumblue"),
+                    labels = c("China","World Bank")) 
+
+
+ggsave("./figures/proj_year_prec_counts.png",proj_year_prec_count, width=6, height = 4, dpi=300,
+       bg="white", units="in")
+
+### Project Precision Counts
+proj_prec_count <- oda_df %>% 
+  group_by(funder, precision_code) %>% 
+  count() %>% 
+  ggplot(aes(x = factor(precision_code), y = n, fill = funder)) +
+  geom_bar(stat = "identity", position = "dodge") +
+  labs(title = "African aid project location counts by precision and funder",
+       x = "Precision Code", y = "Project location count") +
+  theme_bw() + 
+  theme(panel.grid = element_blank()) +
+  guides(fill = guide_legend(title = "Funder"),
+         alpha = guide_legend(title = "Precision Code")) + 
+  scale_x_discrete(labels = c("1 Exact", "2 Near", "3 ADM2", "4 ADM1")) +
+  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
+  scale_fill_manual(values = c("CH" = "indianred1", "WB" = "mediumblue"),
+                    labels = c("China","World Bank")) 
+
+ggsave("./figures/proj_prec_counts.png", proj_prec_count, width = 6, height = 4, dpi = 300,
+       bg = "white", units = "in")
+
+
+oda_df %>% 
+  filter(precision_code %in% c(1,3)) %>% 
+  group_by(funder, location_type_name, location_type_code, geographic_exactness) %>% 
+  count() %>% 
+  filter(geographic_exactness==2)
+#The only records with "approximate" are Chinese ADM2, 3, or 4 projects.
+# funder location_type_name                   location_type_code geographic_exactness     n
+# <chr>  <chr>                                <chr>                             <int> <int>
+# 1 CH     fourth-order administrative division ADM4                                  2     2
+# 2 CH     second-order administrative division ADM2                                  2    45
+# 3 CH     third-order administrative division  ADM3                                  2     4
+
+
+### Location Type Codes
+#plot top location type codes
+loc_type_plot <- oda_df %>% 
+  filter(precision_code %in% c(1,3)) %>% 
+  group_by(funder, location_type_name, location_type_code, geographic_exactness) %>% 
+  count() %>% 
+  filter(n > 10) %>% 
+  mutate(geographic_exactness = factor(geographic_exactness / 2)) %>% 
+ggplot(aes(y = reorder(location_type_name,n), x = n, fill = funder, alpha=geographic_exactness)) +
+  #geom_bar(stat = "identity", position = "dodge") +
+  geom_bar(stat = "identity", position = position_dodge(width = .9), width = 0.7) +
+  labs(title = "Most Frequent Location Types (n>10)",
+       subtitle = "Aid Project Precision 1 or 3",
+       y = "Location Type", x = "Count") +
+  theme_bw() + 
+  theme(panel.grid = element_blank()) +
+  guides(fill = guide_legend(title = "Funder"),
+         alpha = guide_legend(title = "Geographic Exactness")) + 
+  scale_alpha_manual(values = c(.5, 1),
+                     labels = c("1 Exact", "2 Approximate")) +
+  scale_fill_manual(values = c("CH" = "indianred1", "WB" = "mediumblue"),
+                    labels = c("China", "World Bank")) 
+
+ggsave("./figures/top_loc_types.png",loc_type_plot, width=6, height = 4, dpi=300,
+       bg="white", units="in")
+
+### Count by Country 
+country_plot <- oda_df %>% 
+  filter(precision_code %in% c(1,2,3)) %>% 
+  group_by(funder, recipients) %>% 
+  count() %>% 
+  ggplot(aes(y = recipients, x = n, fill = funder)) +
+  geom_bar(stat = "identity", position = "dodge") +
+  labs(title = "Aid projects by recipients and funder",
+       subtitle = "Aid Project Precision 1, 2, and 3",
+       y = "Recipient(s)", x = "Count") +
+  theme_bw() + 
+  theme(panel.grid = element_blank()) + 
+  guides(fill = guide_legend(title = "Funder")) +
+  scale_fill_manual(values = c("CH" = "indianred1", "WB" = "mediumblue"),
+                    labels = c("China", "World Bank")) 
+
+ggsave("./figures/country_counts.png",country_plot, width=6, height = 8, dpi=300,
+       bg="white", units="in")
+
+### Count by Sector 
+sector_plot <- oda_df %>% 
+  filter(precision_code %in% c(1,2,3)) %>% 
+  group_by(funder, ad_sector_names) %>% 
+  mutate(ad_sector_names = paste0(substr(ad_sector_names, 1, 30),
+                                 " (",ad_sector_codes,")")) %>%
+  count() %>% 
+  ggplot(aes(y = ad_sector_names, x = n, fill = funder)) +
+  geom_bar(stat = "identity", position = "dodge") +
+  labs(title = "African Aid projects 2002-2013 by sector and funder",
+       subtitle = "Aid Project Precisions: Exact, Near, and ADM2",
+       y = "Sector", x = "Count") +
+  theme_bw() + 
+  theme(panel.grid = element_blank()) +
+  guides(fill = guide_legend(title = "Funder")) +
+  scale_fill_manual(values = c("CH" = "indianred1", "WB" = "mediumblue"),
+                    labels = c("China", "World Bank")) 
+
+ggsave("./figures/sector_counts.png",sector_plot, width=8, height = 8, dpi=300,
+       bg="white", units="in")
+
+
+### Project length by sector
+sector_length_plot <- oda_df %>% 
+  filter(precision_code %in% c(1,2,3)) %>%
+  mutate(start_year=as.integer(sub("^(\\d{4})-.*","\\1",start_actual_isodate)),
+         end_year=as.integer(sub("^(\\d{4})-.*","\\1",end_actual_isodate)),
+         proj_length = ifelse(is.na(end_year) | is.na(start_year),-1,
+                              end_year - start_year)) %>% 
+  mutate(ad_sector_names = paste0(substr(ad_sector_names, 1, 30),
+                                  " (",ad_sector_codes,")"))  %>% 
+  group_by(funder, ad_sector_names, proj_length) %>%
+  ggplot(aes(y = ad_sector_names, x = proj_length, color = funder)) +
+  geom_boxplot(outlier.color=NULL) +
+  geom_vline(xintercept=0,color="gray80") +
+  labs(title = "African aid project length (years) by Sector and Funder (2002-2013)",
+       subtitle = "Includes only projects of precisions: Exact, Near, and ADM2",
+       y = "Sector", x = "Project Length (Years, -1 = Unknown end date)") +
+  theme_bw() + 
+  theme(panel.grid = element_blank()) +
+  guides(color = guide_legend(title = "Funder")) +
+  scale_color_manual(values = c("CH" = "indianred1", "WB" = "mediumblue"),
+                    labels = c("China", "World Bank")) +
+  scale_x_continuous(n.breaks=14)
+
+ggsave("./figures/sector_proj_length.png",sector_length_plot, width=10, height = 8, dpi=300,
+       bg="white", units="in")

code/lib/consolidate_CI_output_across_did.R

@@ -0,0 +1,139 @@
+{
+  #consolidate_CI_output_across_runs.R
+  # install.packages("~/Documents/causalimages-software/causalimages",repos = NULL, type = "source",force = F)
+  # install.packages("~/Documents/helpeRs-software/helpeRs",repos = NULL, type = "source",force = F)
+  # consolidate .csv files produced by AnalyzeCausalImages runs (after 9/9)
+  #   into a single csv
+  # v4 makes graphs for Latitude Analysis and ModelEvaluationMetrics
+  # parameter:  run version ("v9","v10",etc)
+  KeepObjectsAcrossAnalysisStrings <- get0("KeepObjectsAcrossAnalysisStrings", ifnotfound = character())
+  try(rm(list=ls()[!ls() %in% (Keeps <- c("t0",KeepObjectsAcrossAnalysisStrings))] ),T)
+  
+  # set wd and load packages
+  setwd(getOption("replication.root", default = getwd())); options(error = NULL)
+  
+  # load packages
+  library(dplyr);library(data.table);library(ggplot2);library(ggtext);library(tidyr)
+  
+  results_dir <- get0(
+    "WITHIN_UNIT_RESULTS_DIR_OVERRIDE",
+    ifnotfound = "./results/per_run_csv/Epoch5EarlyStopNewTreatDefLabelS_Run2/vt_3yr_unitFE/"
+  )
+  output_file <- get0(
+    "WITHIN_UNIT_OUTPUT_OVERRIDE",
+    ifnotfound = file.path(dirname(results_dir), "results_processed",
+                           "wb_vs_ch_sector_scatter_WithinUnitVar.pdf")
+  )
+  plot_caption <- get0("WITHIN_UNIT_CAPTION_OVERRIDE",
+                       ifnotfound = "Estimation method: Unit FE.")
+  csvs <- list.files(results_dir)
+  csvs <- csvs[grepl(csvs,pattern="\\.csv")]
+  csvs <- csvs[!grepl("^InputData_", csvs)]
+  csvs <- csvs[grepl("unitFE.*\\.csv$", csvs)]
+  my_df <- c(); for(csv in csvs){
+    #my_df <- rbind(my_df, read.csv(sprintf("./results/did/%s",csv)))
+    my_df <- rbind(my_df, read.csv(sprintf("%s/%s",results_dir, csv)))
+  }
+  
+  # ---- Packages ----
+  # If needed: install.packages(c("dplyr","tidyr","ggplot2","ggrepel"))
+  library(dplyr)
+  library(tidyr)
+  library(ggplot2)
+  library(ggrepel)
+
+  # ---- Prep: normalize the fund-sector column name ----
+  df <- my_df
+  if ("fund_sect_param" %in% names(df)) {
+    df$fund_sect_str <- df$fund_sect_param
+  } else if ("fund_sect" %in% names(df)) {
+    df$fund_sect_str <- df$fund_sect
+  } else {
+    stop("Expected a 'fund_sect_param' or 'fund_sect' column with values like 'ch_110'/'wb_110'.")
+  }
+  
+  # If CI bounds aren't present, derive 95% CI from SE
+  if (!("LB.CI" %in% names(df)) && ("SE" %in% names(df))) {
+    df$LB.CI <- df$Estimate - 1.96 * df$SE
+  }
+  if (!("UB.CI" %in% names(df)) && ("SE" %in% names(df))) {
+    df$UB.CI <- df$Estimate + 1.96 * df$SE
+  }
+  
+  # df[df$fund_sect_param %in% c("wb_150","wb_310"),]
+  
+  # ---- Extract prefix (ch/wb) and sector code ----
+  df2 <- df %>%
+    mutate(prefix = sub("_.*$", "", fund_sect_str),
+           sector_code = as.integer(sub("^.*_", "", fund_sect_str))) %>%
+    filter(prefix %in% c("ch", "wb"))
+  
+  # ---- Resolve duplicates per (prefix, sector_code) if any ----
+  # Keep the row with the largest N for stability; adjust if you prefer another rule.
+  df2_unique <- df2 %>%
+    #arrange(desc(N)) %>%
+    arrange(desc(SE)) %>%
+    group_by(prefix, sector_code) %>%
+    slice(1) %>%
+    ungroup()
+  
+  # ---- Pivot wide: one row per sector with CH & WB side-by-side ----
+  wide <- df2_unique %>%
+    dplyr::select(prefix, sector_code, Estimate, LB.CI, UB.CI) %>%
+    tidyr::pivot_wider(
+      names_from = prefix,
+      values_from = c(Estimate, LB.CI, UB.CI),
+      names_sep = "."
+    ) %>%
+    dplyr::rename(
+      ch_est = Estimate.ch, ch_lb = LB.CI.ch, ch_ub = UB.CI.ch,
+      wb_est = Estimate.wb, wb_lb = LB.CI.wb, wb_ub = UB.CI.wb
+    ) %>%
+    dplyr::filter(!is.na(ch_est), !is.na(wb_est)) %>%
+    dplyr::arrange(sector_code)
+  
+  if(FALSE){ wide <- df2_unique %>%
+    select(prefix, sector_code, Estimate, LB.CI, UB.CI) %>%
+    pivot_wider(
+      names_from = prefix,
+      values_from = c(Estimate, LB.CI, UB.CI),
+      names_sep = "."
+    ) %>%
+    rename(
+      ch_est = Estimate.ch, ch_lb = LB.CI.ch, ch_ub = UB.CI.ch,
+      wb_est = Estimate.wb, wb_lb = LB.CI.wb, wb_ub = UB.CI.wb
+    ) %>%
+    filter(!is.na(ch_est), !is.na(wb_est)) %>%
+    arrange(sector_code)
+}
+  
+  # ---- Plot: Y = China vs X = World Bank; 95% CI crosshairs ----
+  p <- ggplot(wide, aes(x = wb_est, y = ch_est, label = sector_code)) +
+    # horizontal CI for WB (x)
+    geom_errorbarh(aes(xmin = wb_lb, xmax = wb_ub),
+                   height = 0, alpha = 0.25, linewidth = 0.6) +
+    # vertical CI for CH (y)
+    geom_errorbar(aes(ymin = ch_lb, ymax = ch_ub),
+                  width = 0, alpha = 0.25, linewidth = 0.6) +
+    geom_point(size = 2) +
+    geom_abline(slope = 1, intercept = 0, linetype = "dashed", linewidth = 0.4, alpha = 0.7) +
+    ggrepel::geom_text_repel(size = 3, max.overlaps = 50) +
+    coord_equal() +
+    labs(
+      title = "Sector ATT estimates: China vs. World Bank",
+      subtitle = "Each point is a sector code; crosshairs show 95% CIs",
+      x = "World Bank estimate (95% CI)",
+      y = "China estimate (95% CI)",
+      caption = plot_caption
+    ) +
+    geom_hline(yintercept = 0, linetype = "dashed", color = "gray60", linewidth = 0.3) +
+    geom_vline(xintercept = 0, linetype = "dashed", color = "gray60", linewidth = 0.3) +
+    theme_minimal(base_size = 18) +
+    theme(panel.grid = element_blank()) # Removes background gridding
+  
+  print(p)
+  
+  # ---- Optional: save to file ----
+  ggsave(output_file, 
+         p, width = 8, height = 8, dpi = 300)
+}

code/lib/optional/get_images/GetImageRun_3y.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Script: GetImageRun_3y.py
+Orchestrates Google Earth Engine exports for DHS cluster points.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import os
+from pathlib import Path
+import pandas as pd
+import ee
+
+# Local package
+from satellite_sampling_5k_3y_ctj import export_images
+
+# --------------------------------------------------------------------------- #
+# Configuration                                                               #
+# --------------------------------------------------------------------------- #
+ROOT_DIR          = os.environ.get(
+    'IMAGEDECONFOUND_REPLICATION_ROOT',
+    str(Path(__file__).resolve().parents[3])
+)
+INTERIM_DATA_DIR  = os.path.join(ROOT_DIR, 'data', 'interim')
+DATA_DIR          = os.environ.get(
+    'IMAGEDECONFOUND_IMAGE_DOWNLOAD_ROOT',
+    os.path.join(ROOT_DIR, 'external_artifacts', 'images')
+)
+DHS_FILE          = os.path.join(INTERIM_DATA_DIR, 'dhs_est_iwi.csv')
+
+SPAN_LENGTH_YRS   = 3          # each frame is a 3‑year composite
+NUM_WORKERS       = 8         # concurrent EE tasks to launch
+
+# --------------------------------------------------------------------------- #
+# Helper                                                                      #
+# --------------------------------------------------------------------------- #
+
+def _already_downloaded(row: pd.Series, folder: str, min_bytes: int = 2_600_000) -> bool:
+    """True iff the expected .tif exists and is larger than the safety margin."""
+    tif = os.path.join(folder, f"{row['dhs_id']}.tif")
+    return os.path.isfile(tif) and os.stat(tif).st_size > min_bytes
+
+# --------------------------------------------------------------------------- #
+# Main                                                                         #
+# --------------------------------------------------------------------------- #
+
+def main() -> None:
+    os.chdir(ROOT_DIR)                                # keep relative paths tidy
+
+    # ---- GEE session ------------------------------------------------------- #
+    ee.Authenticate()                                 # cached after first run
+    ee.Initialize(opt_url='https://earthengine-highvolume.googleapis.com')
+
+    # ---- Load DHS clusters -------------------------------------------------- #
+    df             = pd.read_csv(DHS_FILE)
+    grouped        = df.groupby(['country', 'year'])
+
+    for (country, year), survey_df in grouped:
+        ts   = dt.datetime.now().strftime('%d.%b %Y %H:%M:%S')
+        print(f'Downloading images for {country}-{year} … {ts}')
+
+        out_dir = os.path.join(DATA_DIR,
+                               f'dhs_tifs_5k_3yr/{country}_{year}')
+        os.makedirs(out_dir, exist_ok=True)
+
+        mask   = ~survey_df.apply(_already_downloaded, axis=1, folder=out_dir)
+        to_do  = survey_df[mask]
+
+        if to_do.empty:
+            print(f'  ✓ all {len(survey_df)} tiles already present')
+            continue
+
+        export_images(to_do, out_dir,
+                      span_length=SPAN_LENGTH_YRS,
+                      num_workers=NUM_WORKERS)
+
+
+if __name__ == '__main__':          # ***** CRUCIAL for multiprocessing *****
+    main()

code/lib/optional/get_images/GetImageRun_annual.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Script: GetImageRun_annual.py
+Orchestrates Google Earth Engine exports for DHS cluster points.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import os
+from pathlib import Path
+import pandas as pd
+import ee
+
+# Local package
+from satellite_sampling_5k_annual_ctj import export_images
+
+# --------------------------------------------------------------------------- #
+# Configuration                                                               #
+# --------------------------------------------------------------------------- #
+ROOT_DIR          = os.environ.get(
+    'IMAGEDECONFOUND_REPLICATION_ROOT',
+    str(Path(__file__).resolve().parents[3])
+)
+INTERIM_DATA_DIR  = os.path.join(ROOT_DIR, 'data', 'interim')
+DATA_DIR          = os.environ.get(
+    'IMAGEDECONFOUND_IMAGE_DOWNLOAD_ROOT',
+    os.path.join(ROOT_DIR, 'external_artifacts', 'images')
+)
+DHS_FILE          = os.path.join(INTERIM_DATA_DIR, 'dhs_est_iwi.csv')
+
+SPAN_LENGTH_YRS   = 1          # each frame is a X‑year composite
+NUM_WORKERS       = 9         # concurrent EE tasks to launch
+
+# --------------------------------------------------------------------------- #
+# Helper                                                                      #
+# --------------------------------------------------------------------------- #
+
+def _already_downloaded(row: pd.Series, folder: str, min_bytes: int = 2_600_000) -> bool:
+    """True iff the expected .tif exists and is larger than the safety margin."""
+    tif = os.path.join(folder, f"{row['dhs_id']}.tif")
+    return os.path.isfile(tif) and os.stat(tif).st_size > min_bytes
+
+# --------------------------------------------------------------------------- #
+# Main                                                                         #
+# --------------------------------------------------------------------------- #
+
+def main() -> None:
+    os.chdir(ROOT_DIR)                                # keep relative paths tidy
+
+    # ---- GEE session ------------------------------------------------------- #
+    ee.Authenticate()                                 # cached after first run
+    ee.Initialize(opt_url='https://earthengine-highvolume.googleapis.com')
+
+    # ---- Load DHS clusters -------------------------------------------------- #
+    df             = pd.read_csv(DHS_FILE)
+    grouped        = df.groupby(['country', 'year'])
+
+    for (country, year), survey_df in grouped:
+        ts   = dt.datetime.now().strftime('%d.%b %Y %H:%M:%S')
+        print(f'Downloading images for {country}-{year} … {ts}')
+
+        out_dir = os.path.join(DATA_DIR,
+                               f'dhs_tifs_annual/{country}_{year}')
+        os.makedirs(out_dir, exist_ok=True)
+
+        mask   = ~survey_df.apply(_already_downloaded, axis=1, folder=out_dir)
+        to_do  = survey_df[mask]
+
+        if to_do.empty:
+            print(f'  ✓ all {len(survey_df)} tiles already present')
+            continue
+
+        export_images(to_do, out_dir,
+                      span_length=SPAN_LENGTH_YRS,
+                      num_workers=NUM_WORKERS)
+
+
+if __name__ == '__main__':          # ***** CRUCIAL for multiprocessing *****
+    main()

code/lib/optional/get_images/gee_exporter_collection2.py

@@ -0,0 +1,209 @@
+# Script: gee_exporter_collection2.py
+
+import ee
+
+class GeeExporter:
+
+    NULL_TOKEN = 0
+
+    def __init__(self, filterpoly: ee.Geometry, start_year: int,
+                 end_year: int, ms_bands: list,
+                 include_nl: bool = False) -> None:
+        """
+        Class for handling Landsat data in GEE
+        :param filterpoly: ee.Geometry
+        :param start_date: str, string representation of start date
+        :param end_date:  str, string representation of end date
+        :param ms_bands: list of multispectral bands to keep from the collections
+        """
+        self.filterpoly = filterpoly
+        self.start_year = start_year
+        self.end_year = end_year
+        self.start_date = f'{start_year}-01-01'
+        self.end_date = f'{end_year}-12-31'
+        self.include_nl = include_nl
+
+        self.l8 = self.init_coll('LANDSAT/LC08/C02/T1_L2', self.start_date, self.end_date)
+        self.l7 = self.init_coll('LANDSAT/LE07/C02/T1_L2', self.start_date, self.end_date)
+        self.l5 = self.init_coll('LANDSAT/LT05/C02/T1_L2', self.start_date, self.end_date)
+
+        self.merged = self.l5.merge(self.l7).merge(self.l8).sort('system:time_start')
+        self.merged = self.merged.map(self.mask_qaclear).select(ms_bands)
+
+        # Adds background to use for missing Landsat images
+        background = ee.Image([self.NULL_TOKEN] * len(ms_bands)).rename(ms_bands)
+        self.background = background.cast(dict(zip(ms_bands, ['float'] * len(ms_bands))))
+
+    def init_coll(self, name: str, start_date: str, end_date: str) -> ee.ImageCollection:
+        """
+        Creates a standardised ee.ImageCollection containing images of desired points
+        between the desired start and end dates.
+        :param name: str, name of collection
+        :param start_date: str, string representation of start date
+        :param end_date: str, string representation of end date
+        :return: ee.ImageCollection
+        """
+        img_col = ee.ImageCollection(name).filterBounds(self.filterpoly).filterDate(start_date, end_date)
+
+        is_landsat_8 = name.startswith('LANDSAT/LC08')
+        if is_landsat_8:
+            return img_col.map(self.rename_l8).map(self.rescale)
+        else:
+            return img_col.map(self.rename_l57).map(self.rescale)
+
+    @staticmethod
+    def mask_qaclear(img: ee.Image) -> ee.Image:
+        """
+        Masks out unusable pixels
+        :param img: ee.Image, Landsat 5/7/8 image containing 'QA_PIXEL' band
+        :return: ee.Image, input image with cloud-shadow, snow, cloud, and unclear
+            pixels masked out
+            
+        Bitmask for QA_PIXEL
+        Bit 0: Fill
+        Bit 1: Dilated Cloud
+        Bit 2: Unused (L5/7) or Cirrus (L8)
+        Bit 3: Cloud
+        Bit 4: Cloud Shadow
+        Bit 5: Snow
+        Bit 6: Clear
+            0: Cloud or Dilated Cloud bits are set
+            1: Cloud and Dilated Cloud bits are not set
+        Bit 7: Water           
+        Also has confidence bits, which I am not using here
+        """        
+        # Get the QA_PIXEL band
+        qa = img.select('QA_PIXEL')
+
+        # Create masks for clouds, cloud shadows, and snow
+        cloud_mask = qa.bitwiseAnd(1 << 3).Or(qa.bitwiseAnd(1 << 1))
+        cloud_shadow_mask = qa.bitwiseAnd(1 << 4)
+        snow_mask = qa.bitwiseAnd(1 << 5)
+
+        # Combine masks
+        mask = cloud_mask.Or(cloud_shadow_mask).Or(snow_mask)
+
+        # Return the image with masked pixels
+        return img.updateMask(mask.Not())            
+
+    @staticmethod
+    def rename_l8(img: ee.Image) -> ee.Image:
+        """
+        Renames bands for a Landsat 8 image
+        :param img: ee.Image, Landsat 8 image
+        :return: ee.Image, with bands renamed
+        See: https://developers.google.com/earth-engine/datasets/catalog/LANDSAT_LC08_C02_T1_L2
+        Name       Scale Factor Description
+        SR_B1            2.75e-05     Band 1 (ultra blue, coastal aerosol) surface reflectance
+        SR_B2            2.75e-05     Band 2 (blue) surface reflectance
+        SR_B3            2.75e-05     Band 3 (green) surface reflectance 
+        SR_B4            2.75e-05     Band 4 (red) surface reflectance 
+        SR_B5            2.75e-05     Band 5 (near infrared) surface reflectance  
+        SR_B6            2.75e-05     Band 6 (shortwave infrared 1) surface reflectance  
+        SR_B7            2.75e-05     Band 7 (shortwave infrared 2) surface reflectance   
+        several more here - included in newnames as their standard values         
+        """
+        newnames = ['SR_B1', 'BLUE', 'GREEN', 'RED', 'NIR', 'SWIR1', 'SWIR2',
+                    'SR_QA_AEROSOL', 'ST_B10', 'ST_ATRAN', 'ST_CDIST', 'ST_DRAD', 'ST_EMIS', 
+                    'ST_EMSD', 'ST_QA', 'ST_TRAD', 'ST_URAD', 'QA_PIXEL', 'QA_RADSAT']
+        return img.rename(newnames)
+
+    @staticmethod
+    def rename_l57(img: ee.Image) -> ee.Image:
+        """
+        Renames bands for a Landsat 5/7 image
+        :param img: ee.Image, Landsat 5/7 image
+        :return: ee.Image, with bands renamed
+        See: https://developers.google.com/earth-engine/datasets/catalog/LANDSAT_LT05_C02_T1_SR
+             https://developers.google.com/earth-engine/datasets/catalog/LANDSAT_LE07_C02_T1_L2
+        Name            Scale Factor Description
+        SR_B1            2.75e-05     Band 1 (blue) surface reflectance
+        SR_B2            2.75e-05     Band 2 (green) surface reflectance
+        SR_B3            2.75e-05     Band 3 (red) surface reflectance
+        SR_B4            2.75e-05     Band 4 (near infrared) surface reflectance
+        SR_B5            2.75e-05     Band 5 (shortwave infrared 1) surface reflectance                                                                                     
+        SR_B7            2.75e-05     Band 7 (shortwave infrared 2) surface reflectance
+        several more here - included in newnames as their standard values 
+        """
+        newnames = ['BLUE', 'GREEN', 'RED', 'NIR', 'SWIR1', 'SWIR2',
+                    'SR_ATMOS_OPACITY', 'SR_CLOUD_QA', 'ST_B6', 'ST_ATRAN', 'ST_CDIST', 
+                    'ST_DRAD', 'ST_EMIS', 'ST_EMSD', 'ST_QA', 'ST_TRAD', 'ST_URAD', 
+                    'QA_PIXEL', 'QA_RADSAT']
+        return img.rename(newnames)
+
+    @staticmethod
+    def rescale(img: ee.Image) -> ee.Image:
+        """
+        Rescales Landsat 5, 7, or 8 image to common scale
+        :param img: ee.Image, Landsat 5/7/8 image, with bands already renamed
+            by rename_l57() or rename_l8()
+        :return: ee.Image, optical and qa bands only, with bands rescaled
+        """
+        opt = img.select(['BLUE', 'GREEN', 'RED', 'NIR', 'SWIR1', 'SWIR2'])
+        masks = img.select(['QA_PIXEL'])
+
+        opt = opt.multiply(0.0000275)
+
+        scaled = ee.Image.cat([opt, masks]).copyProperties(img)
+        # system properties are not copied
+        scaled = scaled.set('system:time_start', img.get('system:time_start'))
+        return scaled
+
+    def get_timeseries_image(self, span_length):
+        """
+        Produce a sequential collection where each image represents a non-overlapping time period.
+        The time series starts at 'start_year', ends at 'end_year' and each image is a composite of
+        'span_length' number of years.
+        :param start_year: int, earliest year to include in the time series
+        :param end_year: int, last possible year to include in the time series.
+            Can be left out depending on the 'span_length'.
+        :param span_length: int, number of years for each
+        :return: ee.ImageCollection, collection with a time series of images
+        """
+
+        # Create list of tuples containing start and end year for each timespan
+        start_years = ee.List.sequence(self.start_year, self.end_year, 
+                                       span_length)
+        end_years = ee.List.sequence(self.start_year + span_length - 1, 
+                                     self.end_year, span_length)
+        spans = start_years.zip(end_years)
+
+        # Define inner function
+        def get_span_image(span: ee.List) -> ee.Image:
+            """
+            Get image with median band values between two dates. Created as an 
+            inner function of 'get_images' since the GEE API doesn't allow maped 
+            functions to access client side variables. This is a functional work-
+            around.
+            :param span: ee.List, tuple containing two integer values representing
+            the start and end year of the timespan.
+            :return: ee.Image, image representation for the given time period
+            """
+            
+            # Excplicilty cast mapped value as list. Extract start and end date
+            span = ee.List(span)
+            start_date = ee.Date.fromYMD(span.get(0), 1, 1)
+            end_date = ee.Date.fromYMD(span.get(1), 12, 31)
+            
+            # Get time span median values for multispectral bands
+            #img = self.merged.filterDate(start_date, end_date).median() # ctj edit
+            img = self.merged.filterDate(start_date, end_date).median().toFloat() # ctj edit
+
+            # Add background values for pixel locations without any images
+            img = ee.ImageCollection([self.background, img]).mosaic() # orig code
+            #img = ee.ImageCollection([img, self.background]).mosaic() # ctj edit
+
+            # Clip image to remove unnecessary regions
+            img = img.clip(self.filterpoly)
+
+            return img.set('system:time_start', start_date.millis())
+
+        # Create one image per time span
+        span_images = ee.ImageCollection.fromImages(spans.map(get_span_image))
+
+        # Converts collection of span_images to a single multi-band image 
+        # containing all of the bands of every span_image in the collection
+        out_image = span_images.toBands()
+
+        return out_image
+

code/lib/optional/get_images/satellite_sampling_5k_3y_ctj.py

@@ -0,0 +1,245 @@
+"""
+Script: satellite_sampling_5k_3y_v3_cj.py
+Launches parallel Earth-Engine Image → Drive export tasks,
+but first waits for free slots in the EE queue to keep under the 3000-task limit.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor
+from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type
+from functools import partial
+import pandas as pd
+import shutil
+import ee
+import requests
+import zipfile
+import random
+import time
+import rasterio
+import errno
+
+from gee_exporter_collection2 import GeeExporter
+
+# --------------------------------------------------------------------------- #
+# Configuration                                                               
+# --------------------------------------------------------------------------- #
+_SCALE         = 30
+#_CRS           = 'EPSG:4326'
+_CRS           = 'EPSG:3857' 
+_NUM_WORKERS   = 10    # tune to your bandwidth/CPU
+#_MAX_QUEUE_TASKS = 3000       # EE’s hard limit
+_MAX_QUEUE_TASKS = 200       # EE’s hard limit
+_POLL_INTERVAL   = 30         # seconds between checks
+_MS_BANDS        = ['BLUE', 'GREEN', 'RED', 'NIR', 'SWIR1']
+
+
+def _wait_for_queue_space(slots_needed: int) -> None:
+    """Block until at least slots_needed queue slots free up."""
+    while True:
+        all_tasks = ee.batch.Task.list()
+        active   = sum(1 for t in all_tasks
+                       if t.status().get('state') in ('READY','RUNNING'))
+        available = _MAX_QUEUE_TASKS - active
+
+        if available >= slots_needed:
+            return
+
+        print(f"[EE Queue full] {active} tasks in queue (limit {_MAX_QUEUE_TASKS}). "
+              f"Need {slots_needed}. Waiting {_POLL_INTERVAL}s…")
+        time.sleep(_POLL_INTERVAL) 
+
+
+@retry(
+    wait=wait_exponential(multiplier=1, min=10, max=60),
+    stop=stop_after_attempt(10),
+    retry=retry_if_exception_type((OSError, requests.exceptions.RequestException))
+)
+def write_with_retry(path: str, url: str, chunk_size: int = 1024*1024):
+    """
+    Download from `url` and safely write to `path` on flaky filesystems.
+    Retries on network and local I/O errors (including ESTALE/Timeout).
+    """
+    # 1) Make sure the containing dir exists
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    tmp_path = path + ".tmp"
+    try:
+        # 2) Stream‐download
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(tmp_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size):
+                    f.write(chunk)
+
+        # 3) Atomic rename into place
+        os.replace(tmp_path, path)
+
+    except OSError as e:
+        # Clean up partial tmp file
+        try:
+            os.remove(tmp_path)
+        except Exception:
+            pass
+
+        # Only retry on transient mount errors
+        if e.errno in (errno.ESTALE, errno.ETIMEDOUT, errno.EIO):
+            raise
+        # Otherwise re-raise without retry
+        raise
+
+
+@retry(
+    wait=wait_exponential(multiplier=1, min=4, max=60),  # Wait 4s to 10s between retries
+    stop=stop_after_attempt(10),                          # Retry up to 5 times
+    retry=retry_if_exception_type(requests.exceptions.RequestException)
+)
+def _download_one(row: pd.Series, dst_folder: str, span_len: int) -> int:
+    import rasterio
+
+    time.sleep(random.uniform(1, 5))
+    geom = ee.Geometry.Point([row['lon'], row['lat']]).buffer(2_500)
+
+    # Define the 3-year spans you want, in order:
+    spans = [
+        (1999, 2001),
+        (2002, 2004),
+        (2005, 2007),
+        (2008, 2010),
+        (2011, 2013),
+        (2014, 2016),
+    ]
+
+    extracted = {}
+    zip_paths = []
+
+    # Loop over each span, download its ZIP and extract the 5 MS bands
+    _wait_for_queue_space(1)
+    for span_i, (start_year, end_year) in enumerate(spans):
+        
+        # note: cloud handling, etc. is performed in GeeExporter()
+        exporter = GeeExporter(
+            filterpoly=geom,
+            start_year=start_year,
+            end_year=end_year,
+            ms_bands=_MS_BANDS
+        )
+        img = exporter.get_timeseries_image(span_len)
+
+        try:
+            bands = img.bandNames().getInfo()
+        except Exception as e:
+            print(f"  ⚠️  Span {start_year}-{end_year}: failed to fetch band names, skipping. ({e})")
+            continue
+        if not bands:
+            print(f"  • Span {start_year}-{end_year}: no data, skipping.")
+            continue
+
+        url = img.getDownloadURL({
+            'scale': _SCALE,
+            'crs': _CRS,
+            'region': geom
+        })
+        print(f"[DEBUG] Download URL for span {start_year}-{end_year}: {url!r}")
+
+        zip_path = os.path.join(dst_folder, f"{row['dhs_id']}_{start_year}_{end_year}.zip")
+        zip_paths.append(zip_path)
+
+        # safe write 
+        write_with_retry(zip_path, url)
+
+        # unsafe write 
+        #with requests.get(url, stream=True) as r:
+        #    r.raise_for_status()
+        #    with open(zip_path, 'wb') as f:
+        #        for chunk in r.iter_content(1024*1024):
+        #            f.write(chunk)
+
+        # Unzip and save each band as its own TIFF
+        with zipfile.ZipFile(zip_path, 'r') as z:
+            for member in z.namelist():
+                if not member.lower().endswith('.tif'):
+                    continue
+                band_name = os.path.splitext(os.path.basename(member))[0].split('_')[-1].upper()
+                if band_name not in _MS_BANDS:
+                    continue
+                dst_tif = os.path.join(
+                    dst_folder,
+                    f"{row['dhs_id']}_{start_year}_{end_year}_{band_name}.tif"
+                )
+                with z.open(member) as src, open(dst_tif, 'wb') as out:
+                    shutil.copyfileobj(src, out)
+                extracted[(span_i, band_name)] = dst_tif
+                
+    if not extracted:
+        return None
+
+    # Build the final multi-band TIFF
+    first_key = next(iter(extracted))
+    with rasterio.open(extracted[first_key]) as src0:
+        meta = src0.meta.copy()
+
+    num_spans = len(spans)
+    ms_count = len(_MS_BANDS)
+
+    # total bands = spans × ms_bands
+    meta.update(count = num_spans * ms_count)
+
+    out_tif = os.path.join(dst_folder, os.path.basename(row['image_file_5k_3yr']))
+    with rasterio.open(out_tif, 'w', **meta) as dst:
+        for span_i in range(num_spans):
+            for idx, band_name in enumerate(_MS_BANDS, start=1):
+                key = (span_i, band_name)
+                if key not in extracted:
+                    continue
+                # and write into contiguous slots
+                dest_band = span_i * ms_count + idx
+                with rasterio.open(extracted[key]) as src:
+                    dst.write(src.read(1), dest_band)
+                    
+    # — quick QC: did we really get the band‐count we asked for?
+    with rasterio.open(out_tif) as chk:
+        expected = num_spans * ms_count
+        if chk.count != expected:
+            raise RuntimeError(f"QC failed: expected {expected} bands, got {chk.count}")
+
+    # Clean up all intermediate files
+    for path in extracted.values():
+        os.remove(path)
+    for zp in zip_paths:
+        os.remove(zp)
+
+    return row.name
+
+
+def export_images(df: pd.DataFrame,
+                  save_dir: str,
+                  span_length: int = 3,
+                  num_workers: int = _NUM_WORKERS) -> None:
+    """
+    For each row in df (must have 'lat','lon','year'), builds a
+    span_length-year composite and downloads it locally.
+
+    Parameters
+    ----------
+    df           : pandas.DataFrame with columns 'lat', 'lon', 'year'
+    save_dir     : directory to write the unzipped TIFF(s)
+    span_length  : number of years per composite (e.g. 3)
+    num_workers  : number of parallel download threads
+    """
+    os.makedirs(save_dir, exist_ok=True)
+
+    rows = [row for _, row in df.iterrows()]
+
+    with ThreadPoolExecutor(max_workers=num_workers) as executor:
+        for idx in executor.map(
+            lambda r: _download_one(r, save_dir, span_length),
+            rows
+        ):
+            # Only print if the download succeeded (idx is not None)
+            if idx is not None:
+                print(f'  • Finished download for row {idx:05d}')
+
+    print(f'Downloaded all {len(rows)} composites into:\n  {save_dir}')

code/lib/optional/get_images/satellite_sampling_5k_annual_ctj.py

@@ -0,0 +1,253 @@
+"""
+Script: satellite_sampling_5k_annual.py
+Launches parallel Earth-Engine Image → Drive export tasks,
+but first waits for free slots in the EE queue to keep under the 3000-task limit.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor
+from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type
+from functools import partial
+import pandas as pd
+import shutil
+import ee
+import requests
+import zipfile
+import random
+import time
+import rasterio
+import errno
+
+from gee_exporter_collection2 import GeeExporter
+
+# --------------------------------------------------------------------------- #
+# Configuration                                                               
+# --------------------------------------------------------------------------- #
+_SCALE         = 30
+#_CRS           = 'EPSG:4326'
+_CRS           = 'EPSG:3857' 
+_NUM_WORKERS   = 10    # tune to your bandwidth/CPU
+#_MAX_QUEUE_TASKS = 3000       # EE’s hard limit
+_MAX_QUEUE_TASKS = 200       # EE’s hard limit
+_POLL_INTERVAL   = 30         # seconds between checks
+_MS_BANDS        = ['BLUE', 'GREEN', 'RED', 'NIR', 'SWIR1']
+
+
+def _wait_for_queue_space(slots_needed: int) -> None:
+    """Block until at least slots_needed queue slots free up."""
+    while True:
+        all_tasks = ee.batch.Task.list()
+        active   = sum(1 for t in all_tasks
+                       if t.status().get('state') in ('READY','RUNNING'))
+        available = _MAX_QUEUE_TASKS - active
+
+        if available >= slots_needed:
+            return
+
+        print(f"[EE Queue full] {active} tasks in queue (limit {_MAX_QUEUE_TASKS}). "
+              f"Need {slots_needed}. Waiting {_POLL_INTERVAL}s…")
+        time.sleep(_POLL_INTERVAL) 
+
+
+@retry(
+    wait=wait_exponential(multiplier=1, min=10, max=60),
+    stop=stop_after_attempt(10),
+    retry=retry_if_exception_type((OSError, requests.exceptions.RequestException))
+)
+def write_with_retry(path: str, url: str, chunk_size: int = 1024*1024):
+    """
+    Download from `url` and safely write to `path` on flaky filesystems.
+    Retries on network and local I/O errors (including ESTALE/Timeout).
+    """
+    # 1) Make sure the containing dir exists
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    tmp_path = path + ".tmp"
+    try:
+        # 2) Stream‐download
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(tmp_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size):
+                    f.write(chunk)
+
+        # 3) Atomic rename into place
+        os.replace(tmp_path, path)
+
+    except OSError as e:
+        # Clean up partial tmp file
+        try:
+            os.remove(tmp_path)
+        except Exception:
+            pass
+
+        # Only retry on transient mount errors
+        if e.errno in (errno.ESTALE, errno.ETIMEDOUT, errno.EIO):
+            raise
+        # Otherwise re-raise without retry
+        raise
+
+
+@retry(
+    wait=wait_exponential(multiplier=1, min=4, max=60),  # Wait 4s to 10s between retries
+    stop=stop_after_attempt(10),                          # Retry up to 5 times
+    retry=retry_if_exception_type(requests.exceptions.RequestException)
+)
+def _download_one(row: pd.Series, dst_folder: str, span_len: int) -> int:
+    import rasterio
+
+    time.sleep(random.uniform(1, 5))
+    geom = ee.Geometry.Point([row['lon'], row['lat']]).buffer(2_500)
+
+    # Define the spans you want, in order:
+    spans = [
+        (2001, 2001),
+        (2002, 2002),
+        (2003, 2003),
+        (2004, 2004),
+        (2005, 2005),
+        (2006, 2006),
+        (2007, 2007),
+        (2008, 2008),
+        (2009, 2009),
+        (2010, 2010),
+        (2011, 2011),
+        (2012, 2012),
+        (2013, 2013),
+        (2014, 2014),
+    ]
+
+    extracted = {}
+    zip_paths = []
+
+    # Loop over each span, download its ZIP and extract the 5 MS bands
+    _wait_for_queue_space(1)
+    for span_i, (start_year, end_year) in enumerate(spans):
+        
+        # note: cloud handling, etc. is performed in GeeExporter()
+        exporter = GeeExporter(
+            filterpoly=geom,
+            start_year=start_year,
+            end_year=end_year,
+            ms_bands=_MS_BANDS
+        )
+        img = exporter.get_timeseries_image(span_len)
+
+        try:
+            bands = img.bandNames().getInfo()
+        except Exception as e:
+            print(f"  ⚠️  Span {start_year}-{end_year}: failed to fetch band names, skipping. ({e})")
+            continue
+        if not bands:
+            print(f"  • Span {start_year}-{end_year}: no data, skipping.")
+            continue
+
+        url = img.getDownloadURL({
+            'scale': _SCALE,
+            'crs': _CRS,
+            'region': geom
+        })
+        print(f"[DEBUG] Download URL for span {start_year}-{end_year}: {url!r}")
+
+        zip_path = os.path.join(dst_folder, f"{row['dhs_id']}_{start_year}_{end_year}.zip")
+        zip_paths.append(zip_path)
+
+        # safe write 
+        write_with_retry(zip_path, url)
+
+        # unsafe write 
+        #with requests.get(url, stream=True) as r:
+        #    r.raise_for_status()
+        #    with open(zip_path, 'wb') as f:
+        #        for chunk in r.iter_content(1024*1024):
+        #            f.write(chunk)
+
+        # Unzip and save each band as its own TIFF
+        with zipfile.ZipFile(zip_path, 'r') as z:
+            for member in z.namelist():
+                if not member.lower().endswith('.tif'):
+                    continue
+                band_name = os.path.splitext(os.path.basename(member))[0].split('_')[-1].upper()
+                if band_name not in _MS_BANDS:
+                    continue
+                dst_tif = os.path.join(
+                    dst_folder,
+                    f"{row['dhs_id']}_{start_year}_{end_year}_{band_name}.tif"
+                )
+                with z.open(member) as src, open(dst_tif, 'wb') as out:
+                    shutil.copyfileobj(src, out)
+                extracted[(span_i, band_name)] = dst_tif
+                
+    if not extracted:
+        return None
+
+    # Build the final multi-band TIFF
+    first_key = next(iter(extracted))
+    with rasterio.open(extracted[first_key]) as src0:
+        meta = src0.meta.copy()
+
+    num_spans = len(spans)
+    ms_count = len(_MS_BANDS)
+
+    # total bands = spans × ms_bands
+    meta.update(count = num_spans * ms_count)
+
+    out_tif = os.path.join(dst_folder, os.path.basename(row['image_file_annual']))
+    with rasterio.open(out_tif, 'w', **meta) as dst:
+        for span_i in range(num_spans):
+            for idx, band_name in enumerate(_MS_BANDS, start=1):
+                key = (span_i, band_name)
+                if key not in extracted:
+                    continue
+                # and write into contiguous slots
+                dest_band = span_i * ms_count + idx
+                with rasterio.open(extracted[key]) as src:
+                    dst.write(src.read(1), dest_band)
+                    
+    # — quick QC: did we really get the band‐count we asked for?
+    with rasterio.open(out_tif) as chk:
+        expected = num_spans * ms_count
+        if chk.count != expected:
+            raise RuntimeError(f"QC failed: expected {expected} bands, got {chk.count}")
+
+    # Clean up all intermediate files
+    for path in extracted.values():
+        os.remove(path)
+    for zp in zip_paths:
+        os.remove(zp)
+
+    return row.name
+
+
+def export_images(df: pd.DataFrame,
+                  save_dir: str,
+                  span_length: int = 1,
+                  num_workers: int = _NUM_WORKERS) -> None:
+    """
+    For each row in df (must have 'lat','lon','year'), builds a
+    span_length-year composite and downloads it locally.
+
+    Parameters
+    ----------
+    df           : pandas.DataFrame with columns 'lat', 'lon', 'year'
+    save_dir     : directory to write the unzipped TIFF(s)
+    span_length  : number of years per composite (e.g. 3)
+    num_workers  : number of parallel download threads
+    """
+    os.makedirs(save_dir, exist_ok=True)
+
+    rows = [row for _, row in df.iterrows()]
+
+    with ThreadPoolExecutor(max_workers=num_workers) as executor:
+        for idx in executor.map(
+            lambda r: _download_one(r, save_dir, span_length),
+            rows
+        ):
+            # Only print if the download succeeded (idx is not None)
+            if idx is not None:
+                print(f'  • Finished download for row {idx:05d}')
+
+    print(f'Downloaded all {len(rows)} composites into:\n  {save_dir}')

code/lib/optional/runP_GrabData_EE.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash 
+set -ex
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+cd "${ROOT_DIR}"
+mkdir -p ./logs
+
+# make sure your Python scripts are executable
+chmod u+r+x ./code/lib/optional/get_images/GetImageRun_3y.py ./code/lib/optional/get_images/GetImageRun_annual.py
+
+# show your resources
+ulimit -a
+parallel --number-of-cpus
+parallel --number-of-cores
+parallel --number-of-threads
+parallel --number-of-sockets
+
+# decide how many parallel jobs to run
+export nParallelJobs=1
+
+# —————————————————————————————————————————
+# 1) run 3-year image export
+#    script: Analysis/GetImages/GetImageRun_3y.py
+# —————————————————————————————————————————
+if false; then
+nohup parallel --jobs ${nParallelJobs} \
+         --joblog ./logs/GetImageRun_3y_log.log \
+         'python3 ./code/lib/optional/get_images/GetImageRun_3y.py {}' ::: 1 \
+	 > ./logs/GetImagesRun_3y_out.out \
+	 2> ./logs/GetImagesRun_3y_err.err &
+fi
+
+# —————————————————————————————————————————
+# 2) run annual image export
+#    script: Analysis/GetImages/GetImageRun_annual.py
+# —————————————————————————————————————————
+if true; then
+nohup parallel --jobs ${nParallelJobs} \
+         --joblog ./logs/GetImageRun_annual_log.log \
+         'python3 ./code/lib/optional/get_images/GetImageRun_annual.py {}' ::: 1 \
+	 > ./logs/GetImagesRun_annual_out.out \
+	 2> ./logs/GetImagesRun_annual_err.err &
+fi

code/lib/prep_desc_stats.R

@@ -0,0 +1,218 @@
+#prep_desc_stats.R
+library(dplyr)
+library(tidyr)
+
+KeepObjectsAcrossAnalysisStrings <- get0("KeepObjectsAcrossAnalysisStrings", ifnotfound = character())
+rm(list=ls()[!ls() %in% (Keeps <- c("t0",KeepObjectsAcrossAnalysisStrings))] )
+setwd(getOption("replication.root", default = getwd()))
+
+#############################################################
+#### Projects by funder
+#############################################################
+oda_sect_group_df <- read.csv("./data/interim/africa_oda_sector_group.csv") %>% 
+  filter(transactions_start_year >= 2002 &
+           transactions_start_year <= 2013)
+
+donor_precision_count <- oda_sect_group_df %>%
+  group_by(funder, precision_code) %>% 
+  summarize(n = n_distinct(project_location_id)) %>%
+  pivot_wider(names_from = funder, values_from = n, values_fill = 0) %>% 
+  mutate(precision_code = paste("project_precision",precision_code)) %>% 
+  rename(description = precision_code)
+
+donor_vars_df <- oda_sect_group_df %>%
+  dplyr::select(funder, project_id, project_location_id, site_iso3, ad_sector_codes) %>%
+  group_by(funder) %>%
+  summarize(across(everything(), ~n_distinct(.))) %>%
+  pivot_longer(cols = -funder, names_to = "description", values_to = "distinct_count") %>%
+  pivot_wider(names_from = funder, values_from = distinct_count, values_fill = 0)
+
+# donor_regional_unspecified_df <- oda_sect_group_df %>%
+#   select(funder, project_location_id, recipients_iso3) %>%
+#   group_by(funder) %>%
+#   filter(grepl("regional|Unspecified",recipients_iso3)) %>% 
+#   summarize(regional_count= n_distinct(project_location_id)) %>%
+#   pivot_longer(cols = -funder, names_to = "description", values_to = "distinct_count") %>%
+#   pivot_wider(names_from = funder, values_from = distinct_count, values_fill = 0)
+#   
+# donor_recipient_site_mismatch_df <- oda_sect_group_df %>%
+#   select(funder, project_location_id, recipients_iso3, site_iso3) %>%
+#   group_by(funder) %>%
+#   filter(!grepl("regional|Unspecified",recipients_iso3) &
+#          recipients_iso3 != site_iso3) %>% 
+#   summarize(mismatch_count= n_distinct(project_location_id)) %>%
+#   pivot_longer(cols = -funder, names_to = "description", values_to = "distinct_count") %>%
+#   pivot_wider(names_from = funder, values_from = distinct_count, values_fill = 0)
+
+no_end_date_df <- oda_sect_group_df %>%
+  dplyr::select(funder,end_actual_isodate) %>%
+  group_by(funder) %>% 
+  summarize(portion_no_end_date = mean(end_actual_isodate=="")) %>% 
+  mutate(portion_no_end_date = round(portion_no_end_date,2)) %>% 
+  pivot_longer(cols = -funder, names_to = "description", values_to = "distinct_count") %>%
+  pivot_wider(names_from = funder, values_from = distinct_count, values_fill = 0)
+
+no_funding_df <- oda_sect_group_df %>%
+  dplyr::select(funder,total_disbursements) %>%
+  group_by(funder) %>% 
+  summarize(portion_no_funding = mean(is.na(total_disbursements))) %>% 
+  mutate(portion_no_funding = round(portion_no_funding,2)) %>% 
+  pivot_longer(cols = -funder, names_to = "description", values_to = "distinct_count") %>%
+  pivot_wider(names_from = funder, values_from = distinct_count, values_fill = 0)
+
+multisector_df <- oda_sect_group_df %>%
+  dplyr::select(funder, geoname_id, transactions_start_year, ad_sector_codes) %>%
+  group_by(funder, geoname_id, transactions_start_year, ad_sector_codes) %>% 
+  count() %>% 
+  group_by(funder) %>% 
+  summarize(portion_multisector = mean(n > 1)) %>% 
+  mutate(portion_multisector = round(portion_multisector,2)) %>% 
+  pivot_longer(cols = -funder, names_to = "description", values_to = "distinct_count") %>%
+  pivot_wider(names_from = funder, values_from = distinct_count, values_fill = 0)
+
+desired_order <- c(3, 4, 1, 2, 5, 6, 7, 8, 9, 10)
+donor_comparison_df <- rbind(donor_vars_df,donor_precision_count, no_end_date_df, 
+                             no_funding_df, multisector_df) %>%
+  slice(match(desired_order, row_number())) %>% 
+  mutate(description = case_match(description,
+                                "site_iso3" ~ "Countries hosting projects count",
+                                "ad_sector_codes" ~ "Sectors funded",
+                                "project_id" ~ "Aid project count",
+                                "project_location_id" ~ "Aid project location count",
+                                "project_precision 1" ~ "Exact locations available (precision 1)", 
+                                "project_precision 2" ~ "Near (<25km) locations available (precision 2)", 
+                                "project_precision 3" ~ "ADM2 locations available (precision 3)", 
+                                "portion_no_end_date" ~ "Portion lacking end date",
+                                "portion_no_funding" ~ "Portion lacking funding information",
+                                "portion_multisector" ~ "Portion with concurrent, co-located, multi-sector projects",
+                                .default = description))
+
+# Table 1:  Funder Comparison: China and World Bank
+# 1 Countries hosting projects count                             50      44   
+# 2 Sectors funded                                               22      13   
+# 3 Aid project count                                           722     513   
+# 4 Aid project location count                                 1373    7115   
+# 5 Exact locations available (precision 1)                     987    4149   
+# 6 Near (<25km) locations available (precision 2)              169     258   
+# 7 ADM2 locations available (precision 3)                      217    2708   
+# 8 Portion lacking end date                                      0.68    0.15
+# 9 Portion lacking funding information                           1       0.28
+# 10 Portion with concurrent, co-located, multi-sector projects    0.03    0.02
+
+#higher than Gehring et al, because they exclude countries with less than 1 million people
+
+write.csv(donor_comparison_df,"./tables/funder_comparison.csv",row.names = FALSE)
+
+#to do: make a sector level table similar to this, but divided by funders
+#consider limiting to sectors actually included in analysis?
+oda_sect_group_df %>% 
+  filter(precision_code < 4) %>% 
+  group_by(funder, ad_sector_codes, ad_sector_names) %>% 
+  count()
+
+
+#############################################################
+#### DHS Units of Analysis 
+#############################################################
+#read file with all DHS points for one survey round per country
+dhs_est_iwi_df <- read.csv("./data/interim/dhs_est_iwi.csv")
+
+#read file that contains confounder data (lower n due to missing confounders)
+dhs_confounders_df <- read.csv("./data/interim/dhs_5k_confounders.csv")
+
+#identify locations excluded due to missing confounders, group by country
+excluded_dhs_df <- anti_join(dhs_est_iwi_df,dhs_confounders_df,by="dhs_id") %>% 
+  group_by(iso3) %>% count() %>% ungroup() %>% 
+  rename(n_excluded=n)
+
+#get formatted country names
+africa_isos_df <- read.csv("./data/interim/africa_isos.csv")
+
+#get treated information
+dhs_t_df <- read.csv("./data/interim/dhs_treated_sector_3yr.csv") %>% 
+  filter(year_group!="2014:2016") %>% 
+  #exclude DHS points where confounder data not available 
+  inner_join(dhs_confounders_df %>% 
+               dplyr::select(dhs_id, ID_adm2), by = join_by(dhs_id)) 
+
+#identify locations that were never treated, group by country
+dhs_never_treated_df <- anti_join(dhs_confounders_df,dhs_t_df,by="dhs_id") %>% 
+  group_by(iso3) %>% count() %>% rename(n_never_treated=n) %>% ungroup()
+
+#create display version of neighborhood descriptive stats
+neighborhoods_df <- dhs_confounders_df %>% 
+  dplyr::select(iso3,survey_start_year,households,rural.x,dhs_id) %>% 
+  group_by(iso3,survey_start_year) %>% 
+  summarize(n_cluster_locations=n_distinct(dhs_id),
+            n_households=sum(households),
+            portion_rural=round(mean(rural.x),2)) %>% 
+  ungroup() %>% 
+  #join to get locations that were never treated
+  left_join(dhs_never_treated_df, by="iso3") %>% 
+  mutate(n_never_treated=ifelse(is.na(n_never_treated),0,n_never_treated)) %>%   
+  mutate(portion_never_treated=round(n_never_treated/n_cluster_locations,2)) %>% 
+  #join to get excluded count
+  left_join(excluded_dhs_df,by="iso3") %>% 
+  mutate(n_excluded=ifelse(is.na(n_excluded),0,n_excluded)) %>%  
+  #join to get country names
+  left_join(africa_isos_df %>% dplyr::select(-iso2), by="iso3") %>% 
+    rename(country=name) %>% 
+    dplyr::select(country,survey_start_year,n_cluster_locations,n_households,
+                  portion_rural,portion_never_treated,n_excluded) %>% 
+  arrange(country)
+
+# country                           survey_start_year n_cluster_l…¹ n_hou…² porti…³ porti…⁴ n_exc…⁵
+# <chr>                                         <int>         <int>   <int>   <dbl>   <dbl>   <dbl>
+#   1 Angola                                         2006            62    1377    0.35    0.4        0
+# 2 Benin                                          1996           190    3152    0.53    0.03       0
+# 3 Burkina Faso                                   1998            81     754    0.62    0.25       0
+# 4 Burundi                                        2010           307    7032    0.88    0.49       0
+# 5 Cameroon                                       2004           464    9254    0.48    0.22       0
+# 6 Central African Republic                       1994            66    1142    0.65    0.86       0
+# 7 Chad                                           2014           235    6499    0.59    0.26       0
+# 8 Comoros                                        2012           242    4286    0.56    0          0
+# 9 Congo, Democratic Republic of the              2007           286    7947    0.57    0          5
+# 10 Côte d'Ivoire                                  1998            63     833    0.49    0.1        0
+# 11 Egypt                                          1995             7     111    0.14    1          0
+# 12 Eswatini                                       2006           210    3689    0.64    0.52       0
+# 13 Ethiopia                                       2000           506    8623    0.73    0          0
+# 14 Gabon                                          2012           332   11151    0.45    0.46       0
+# 15 Ghana                                          1998           144    1373    0.65    0          0
+# 16 Guinea                                         1999           290    3567    0.6     0.06       0
+# 17 Kenya                                          2003           389    7640    0.67    0.45       0
+# 18 Lesotho                                        2004           344    5350    0.72    0.1        0
+# 19 Liberia                                        2009            30     855    0.1     0          0
+# 20 Madagascar                                     1997           260    5610    0.59    0.02       0
+# 21 Malawi                                         2000           554   14057    0.8     0.6        1
+# 22 Mali                                           1995           167    2238    0.57    0.01       0
+# 23 Morocco                                        2003           343    7530    0.42    0.95       1
+# 24 Mozambique                                     2011           609   13303    0.58    0.12       0
+# 25 Namibia                                        2000           258    6236    0.6     0.88       2
+# 26 Niger                                          1998           184    2189    0.51    0.12       0
+# 27 Nigeria                                        2003           356    5599    0.54    0.42       0
+# 28 Rwanda                                         2005           447    8504    0.76    0          0
+# 29 Senegal                                        1997           270    2518    0.63    0.04       0
+# 30 Sierra Leone                                   2008           349    7138    0.59    0          0
+# 31 South Africa                                   2016           745   11035    0.38    0.85       1
+# 32 Tanzania, United Republic of                   1999           171    2831    0.66    0.05       0
+# 33 Togo                                           1998           271    5332    0.52    0.03       0
+# 34 Uganda                                         2000           137    2192    0.55    0.19       0
+# 35 Zambia                                         2007           318    7552    0.64    0.08       1
+# 36 Zimbabwe                                       1999           212    3469    0.64    0.5        0
+
+write.csv(neighborhoods_df,"./tables/neighborhoods.csv",row.names = FALSE)
+
+#get total counts for use in Pipeline Figure
+total_dhs_n_df <- dhs_confounders_df %>% 
+  dplyr::select(iso3,survey_start_year,households,dhs_id) %>% 
+  summarize(n_cluster_locations=n_distinct(dhs_id),
+            n_households=sum(households),
+            n_countries=n_distinct(iso3),
+            n_start_year=n_distinct(survey_start_year)
+  ) 
+write.csv(total_dhs_n_df,"./tables/total_dhs_n.csv",row.names = FALSE)
+
+
+
+
+