diff --git a/.gitignore b/.gitignore
index e68cace..c93216e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,3 +35,12 @@ __pycache__/
 
 .vscode/
 .aider*
+
+#.Renviron
+.Renviron
+
+RSV_files/
+*.parquet
+*.pth
+*.npy
+mlflow.db
\ No newline at end of file
diff --git a/RSV.qmd b/RSV.qmd
new file mode 100644
index 0000000..0a1f177
--- /dev/null
+++ b/RSV.qmd
@@ -0,0 +1,766 @@
+---
+title: "RSV"
+format: pdf
+---
+
+# Training Data Format
+
+| Field | Description | Default or source |
+|----------------|--------------------------|------------------------------|
+| `location_code` | Location identifier | `influpaint/influpaint_locations.csv` |
+| `value` | Observed/modelled values | All rates or all counts, scaled consistently |
+| `fluseason_week` | Week index within season | `season_week()` 1 to 53 |
+| `fluseason` | Season start year | `season_year()` |
+| `datasetH1` | High level dataset identifier | e.g. RSV scenario modelling hub |
+| `datasetH2` | Specific dataset or scenario identifier | e.g. 2023-11-12-NIH-RSV_Phenomenological |
+| `sample` | Sample identifier | e.g. 1.1, 1.2 |
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  warning = FALSE,
+  message = FALSE,
+  fig.width = 10,
+  fig.height = 7,
+  dpi = 300
+)
+```
+
+# Helpers
+
+```{r, helpers}
+library(tidyverse)
+library(arrow)
+
+location_codes <- read_csv("influpaint/influpaint_locations.csv")
+
+#' Get the season year for a given date
+#' @param date A Date object
+#' @param start_month Integer. Month defining season start. Default is June.
+#' @return Integer. The season year.
+#' @details
+#' The start of the season is defined by `start_month` (default is June).
+#' If the date is on or after `start_month`, the season year is the current year.
+#' Else, it is the previous year.
+season_year <- function(date, start_month = 6) {
+  year <- as.integer(format(date, "%Y"))
+  month <- as.integer(format(date, "%m"))
+  ifelse(month >= start_month, year, year - 1)
+}
+#' Get the week index within the season for a given date
+#' @param date A Date object
+#' @param start_month Integer. Month defining season start. Default is June.
+#' @return Integer. Week index within the season (1 to 53)
+#' @details
+#' The start of the season is defined by `start_month` (default is June).
+#' The week index is calculated as the number of weeks since the season start date.
+season_week <- function(date, start_month = 6) {
+  sy <- season_year(date, start_month)
+  season_start <- as.Date(paste(sy, start_month, 1, sep = "-"))
+  as.integer(floor(as.numeric(date - season_start) / 7) + 1)
+}
+```
+
+# Gather RSV Data
+
+## NSSP
+
+National Syndromic Surveillance Program Emergency Department Visits [source](https://cmu-delphi.github.io/delphi-epidata/api/covidcast-signals/nssp.html)
+
+**`pct_ed_visits_rsv` : Percent of ED visits that had a discharge diagnosis code of rsv**
+
+*Earliest date available: 2022-10-01*
+
+```{r, nssp}
+library(epidatr)
+nssp <- pub_covidcast(
+  source = "nssp",
+  signals = "pct_ed_visits_rsv",
+  geo_type = "state",
+  time_type = "week"
+) |>
+  mutate(geo_value = str_to_upper(geo_value)) |>
+  left_join(
+    location_codes |>
+      select(abbreviation, location_code),
+    by = c("geo_value" = "abbreviation")
+  ) |>
+  transmute(
+    location_code,
+    fluseason = season_year(as.Date(time_value)),
+    fluseason_week = season_week(as.Date(time_value)),
+    value,
+    datasetH1 = "NSSP",
+    datasetH2 = "NSSP",
+    sample = "1"
+  )
+
+nssp |>
+  ggplot(aes(x = fluseason_week, y = location_code)) +
+  facet_wrap(~fluseason) +
+  geom_tile(aes(fill = value)) +
+  scale_fill_viridis_c() +
+  scale_x_continuous(breaks = seq(1, 53, by = 4)) +
+  theme_classic()
+
+nssp |>
+  skimr::skim() |>
+  as_tibble() |>
+  select(skim_variable, complete_rate)
+write_parquet(nssp, "RSV_files/NSSP.parquet")
+```
+
+## RSV-Net
+
+Weekly Rates of Laboratory-Confirmed RSV Hospitalizations from the RSV-NET Surveillance System [source:](https://data.cdc.gov/Public-Health-Surveillance/Weekly-Rates-of-Laboratory-Confirmed-RSV-Hospitali/29hc-w46k/about_data)
+
+RSV scenario modeling hub [time-series.csv](https://github.com/midas-network/rsv-scenario-modeling-hub/tree/main/target-data) converts to **weekly number of hospitalizations in each given state**
+
+```{r, rsvnet}
+rsvnet <- read_csv(
+  "https://raw.githubusercontent.com/midas-network/rsv-scenario-modeling-hub/main/target-data/time-series.csv"
+) |>
+  filter(
+    age_group == "0-130",
+    location != "US"
+  ) |>
+  transmute(
+    location_code = location,
+    fluseason = season_year(date),
+    fluseason_week = season_week(date),
+    value = observation,
+    datasetH1 = "RSV-Net",
+    datasetH2 = "RSV-Net",
+    sample = "1"
+  ) |>
+  filter(fluseason >= 2018)
+
+rsvnet |>
+  ggplot(aes(x = fluseason_week, y = location_code)) +
+  facet_wrap(~fluseason) +
+  geom_tile(aes(fill = value)) +
+  scale_fill_viridis_c() +
+  scale_x_continuous(breaks = seq(1, 53, by = 4)) +
+
+  theme_classic()
+
+rsvnet |>
+  skimr::skim() |>
+  as_tibble() |>
+  select(skim_variable, complete_rate)
+write_parquet(rsvnet, "RSV_files/RSV_NET.parquet")
+```
+
+Missing values & exlcude 2020?
+
+## NHSN
+National Healthcare Safety Network (NHSN) [source](https://data.cdc.gov/Public-Health-Surveillance/Weekly-Hospital-Respiratory-Data-HRD-Metrics-by-Ju/ua7e-t2fy/about_data)
+
+**`totalconfrsvnewadm`: Total number of new hospital admissions of patients with confirmed RSV captured during the reporting week (Sunday - Saturday)**
+
+```{r, nhsn}
+library(RSocrata)
+
+nhsn <- read.socrata("https://data.cdc.gov/resource/ua7e-t2fy.json") |>
+  select(
+    weekendingdate,
+    jurisdiction,
+    totalconfrsvnewadm
+  ) |>
+  transmute(
+    fluseason = season_year(as.Date(weekendingdate)),
+    fluseason_week = season_week(as.Date(weekendingdate)),
+    abbreviation = jurisdiction,
+    value = as.numeric(totalconfrsvnewadm),
+    datasetH1 = "NHSN",
+    datasetH2 = "NHSN",
+    sample = "1"
+  ) |>
+  filter(abbreviation != "USA") |>
+  left_join(
+    location_codes |> select(abbreviation, location_code),
+    by = "abbreviation"
+  ) |>
+  drop_na(location_code) |>
+  filter(fluseason >= 2023)
+
+nhsn |>
+  ggplot(aes(x = fluseason_week, y = location_code)) +
+  facet_wrap(~fluseason) +
+  geom_tile(aes(fill = value)) +
+  scale_fill_viridis_c() +
+  scale_x_continuous(breaks = seq(1, 53, by = 4)) +
+  theme_classic()
+
+
+nhsn |>
+  skimr::skim() |>
+  as_tibble() |>
+  select(skim_variable, complete_rate)
+
+write_parquet(nhsn, "RSV_files/NHSN.parquet")
+```
+
+## Modelling Hub
+
+Sample output: Each trajectory must have a unique identifier combining `run_grouping` and `stochastic_run`. Quantile and CDF outputs: There is no stochastic variation. The sample column can also be set to `NA` or to a consistent identifier that reflects the quantile or epiweek?
+
+```{r, rsv_smh}
+library(httr2)
+library(purrr)
+
+gh_ls <- function(url) {
+  request(url) |> req_perform() |> resp_body_json()
+}
+
+base <- "https://api.github.com/repos/midas-network/rsv-scenario-modeling-hub/contents/model-output"
+
+parquet_files <-
+  gh_ls(base) |>
+  keep(~ .x$type == "dir") |>
+  map(~ gh_ls(.x$url)) |>
+  flatten() |>
+  keep(~ grepl("\\.parquet$", .x$name))
+
+data <- parquet_files |>
+  set_names(map_chr(
+    parquet_files,
+    ~ sub(".*/(.*)\\.gz\\.parquet$", "\\1", .x$path)
+  )) |>
+  map(~ read_parquet(.x$download_url))
+
+library(tidytable)
+rsv_smh <- data |>
+  imap(
+    ~ .x |>
+      as_tidytable() |>
+      filter(
+        target == "inc hosp",
+        age_group == "0-130"
+      ) |>
+      mutate(
+        forecast_date = as.Date(origin_date) + weeks(horizon - 1),
+        run_grouping = if ("run_grouping" %in% names(.)) {
+          run_grouping
+        } else {
+          NA_character_
+        },
+        stochastic_run = if ("stochastic_run" %in% names(.)) {
+          stochastic_run
+        } else {
+          NA_character_
+        },
+      ) |>
+      transmute(
+        location_code = location,
+        fluseason = season_year(forecast_date),
+        fluseason_week = season_week(forecast_date),
+        value,
+        datasetH1 = "RSV_SMH",
+        datasetH2 = paste(.y, scenario_id, sep = "_"),
+        sample = case_when(
+          output_type == "sample" ~ paste0(run_grouping, "_", stochastic_run),
+          output_type == "quantile" ~ paste0("q", output_type_id),
+          output_type == "cdf" ~ paste0("p", output_type_id)
+        )
+      )
+  ) |>
+  bind_rows() |>
+  filter(location_code != "US")
+
+# --------- Sanity ---------
+# Keep only fluseasons matching the first season per datasetH2
+rsv_smh <- rsv_smh |>
+  group_by(datasetH2) |>
+  filter(fluseason == min(fluseason)) |>
+  ungroup()
+
+# Aggregated plot
+plot_data <- rsv_smh |>
+  summarise(
+    value = mean(value, na.rm = TRUE),
+    .by = c(fluseason, datasetH2, location_code, fluseason_week)
+  )
+plot_data |>
+  filter(fluseason == "2024") |>
+  ggplot(aes(x = fluseason_week, y = location_code)) +
+  facet_wrap(~datasetH2) +
+  geom_tile(aes(fill = value)) +
+  scale_fill_viridis_c() +
+  scale_x_continuous(breaks = seq(1, 53, by = 4)) +
+  theme_classic()
+
+write_parquet(rsv_smh, "RSV_files/RSV_SMH.parquet")
+```
+
+
+## Converting NSSP to Counts
+We converted NSSP data, which records the percentage of emergency department visits due to RSV, into estimated admission counts. Using weeks and locations with NHSN data (which records the counts), we learned a location-specific scaling factor linking the reported percentage to actual counts. The scaling was done using a Poisson generalized linear mixed-effects model (GLMM) with a random intercept for each location. The predicted counts are the observed percentage scaled by the learned location-specific factor.
+
+```{r, nssp_counts}
+library(lme4)
+
+# Predict counts and merge
+nssp <- read_parquet("RSV_files/NSSP.parquet")
+nhsn <- read_parquet("RSV_files/NHSN.parquet")
+
+
+fit_glmm <- inner_join(
+  nssp |>
+    select(location_code, fluseason, fluseason_week, value),
+  nhsn |>
+    select(location_code, fluseason, fluseason_week, value),
+  by = c("location_code", "fluseason", "fluseason_week")
+) |>
+  filter(value.y >= 0, value.x > 0) |>
+  mutate(log_value = log(value.x)) |>
+  (\(x) {
+    glmer(
+      value.y ~ (1 | location_code) + offset(log_value),
+      data = x,
+      family = poisson(link = "log")
+    )
+  })()
+
+nssp_counts <- nssp |>
+  filter(value > 0) |>
+  mutate(
+    log_value = log(value),
+    value = predict(fit_glmm, newdata = cur_data(), type = "response")
+  ) |>
+  select(location_code, fluseason, fluseason_week, value) |>
+  right_join(
+    nssp |> select(-value),
+    by = c("location_code", "fluseason", "fluseason_week")
+  )
+
+write_parquet(nssp_counts, "RSV_files/NSSP_COUNTS.parquet")
+
+#NHSN vs NSSP Plot
+bind_rows(
+  nssp_counts |> mutate(source = "NSSP (Estimated)"),
+  nhsn |> mutate(source = "NHSN (Actual)")
+) |>
+  ggplot(aes(
+    x = fluseason_week,
+    y = value,
+    colour = location_code,
+    linetype = source
+  )) +
+  facet_wrap(~ fluseason + source) +
+  geom_line(alpha = 0.8) +
+  theme_classic() +
+  theme(legend.position = "none") +
+  scale_x_continuous(breaks = seq(1, 53, by = 7))
+
+```
+
+# Summary
+
+Surveillance data includes:
+- NSSP: Estimated ED visits due to RSV (converted to counts) -> `{r} nrow(nssp_counts)` rows.\
+- RSV-Net: Laboratory-confirmed RSV hospitalizations -> `{r} nrow(rsvnet)` rows.\
+- NHSN: Hospital admissions of patients with confirmed RSV -> `{r} nrow(nhsn)` rows.\
+
+Modeling data includes:
+- RSV Scenario Modeling Hub: Projected hospitalizations under various scenarios -> `{r} nrow(rsv_smh)` rows.\ 
+However we will only take 20 samples per model and scenario for training.
+
+- 2025 is dropped.
+
+```{r, all_data}
+set.seed(123)
+rsv_smh20 <- read_parquet("RSV_files/RSV_SMH.parquet") |>
+  group_by(datasetH2) |>
+  filter(sample %in% sample(unique(sample), min(length(unique(sample)), 20))) |>
+  ungroup()
+
+
+rsv_all <- bind_rows(
+  read_parquet("RSV_files/NSSP_COUNTS.parquet"),
+  read_parquet("RSV_files/RSV_NET.parquet"),
+  read_parquet("RSV_files/NHSN.parquet"),
+  rsv_smh20
+) |>
+  #drop 2025
+  filter(fluseason < 2025)
+
+write_parquet(rsv_all, "RSV_files/RSV_ALL.parquet")
+```
+
+
+# Filling Missing RSV_SMH Values
+This code fills missing values in the RSV_SMH dataset, which may occur because SMH started modelling late in the season. For each location and week, it first uses the NHSN value from the same season if available. If not, it randomly samples from NHSN values for that location and week across all seasons (the latter may be unreasonable)...
+
+```{r}
+set.seed(1)
+
+nhsn_pool <- rsv_all |>
+  filter(datasetH1 == "NHSN", !is.na(value)) |>
+  group_by(location_code, fluseason_week) |>
+  summarise(
+    value_pool = list(value),
+    .groups = "drop"
+  )
+
+nhsn_same_year <- rsv_all |>
+  filter(datasetH1 == "NHSN") |>
+  select(
+    location_code,
+    fluseason_week,
+    fluseason,
+    nhsn_year_value = value
+  )
+
+
+safe_sample <- function(x) {
+  if (is.null(x) || length(x) == 0 || all(is.na(x))) {
+    NA_real_
+  } else {
+    sample(x, 1)
+  }
+}
+
+rsv_filled <- rsv_all |>
+  left_join(
+    nhsn_same_year,
+    by = c("location_code", "fluseason_week", "fluseason")
+  ) |>
+  left_join(
+    nhsn_pool,
+    by = c("location_code", "fluseason_week")
+  ) |>
+  mutate(
+    nhsn_draw = vapply(value_pool, safe_sample, numeric(1)),
+    value = case_when(
+      datasetH1 != "RSV_SMH" ~ value,
+      !is.na(value) ~ value,
+      !is.na(nhsn_year_value) ~ nhsn_year_value,
+      TRUE ~ nhsn_draw
+    )
+  ) |>
+  select(-nhsn_year_value, -value_pool, -nhsn_draw)
+
+
+write_parquet(rsv_filled, "RSV_files/RSV_FILLED.parquet")
+```
+
+
+# Sanity Checks
+1- Check that RSV SMH datasetH2 has unique fluseasons
+```{r, sanity}
+set.seed(123)
+rsv_smh <- read_parquet("RSV_files/RSV_SMH.parquet")
+# check that there is a unique fluseason per datasetH2
+rsv_smh |>
+  group_by(datasetH2) |>
+  summarise(n_fluseason = n_distinct(fluseason)) |>
+  filter(n_fluseason > 1)
+```
+
+
+# Build RSV Training Data
+```{python}
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from pathlib import Path
+import xarray as xr
+import datetime
+# InfluPaint modular imports
+from influpaint.utils import SeasonAxis
+from influpaint.utils import plotting as idplots
+from influpaint.utils import converters
+from influpaint.datasets import mixer as dataset_mixer
+# Setup
+season_setup = SeasonAxis.for_flusight(remove_us=True, remove_territories=True)
+today = datetime.datetime.now().strftime("%Y-%m-%d")
+Path("training_datasets").mkdir(parents=True, exist_ok=True)
+```
+
+
+# Helpers
+`build_dataset_from_framelist` function to convert list of dataframes to xarray DataArray
+```{python}
+def build_dataset_from_framelist(frame_list):
+    main_origins = []
+    for i, frame in enumerate(frame_list):
+        df = frame_list[i]
+        df["fluseason"] = i
+        frame_list[i] = df
+        assert df.season_week.max() == 53 and df.season_week.min() == 1
+        
+        main_origins.append(df["origin"].mode()[0] if not df["origin"].mode().empty else None)
+        
+    all_frames_df = pd.concat(frame_list).reset_index(drop=True)
+    array_list = converters.dataframe_to_arraylist(df=all_frames_df, season_setup=season_setup)
+    array = np.array(array_list)
+    flu_payload_array = xr.DataArray(array, 
+                    coords={'sample': np.arange(array.shape[0]),
+                        'feature': np.arange(array.shape[1]),
+                        'season_week': np.arange(1, array.shape[2]+1),
+                        'place': season_setup.locations + [""]*(array.shape[3] - len(season_setup.locations))}, 
+                    dims=["sample", "feature", "season_week", "place"])
+    return flu_payload_array, main_origins
+```
+
+## Load RSV data
+In the below, we compute the scaling distribution from RSV_SMH dataset to be used for scaling the training data. This means that all datasets will be scaled so that their peak values match the distribution of peak values from the RSV_SMH dataset.
+For example, if the peak value for a season in the RSV_SMH dataset is 1000, and the peak value for the same season in the NSSP dataset is 100, then the NSSP dataset will be scaled by a factor of 10 to match the RSV_SMH peak.
+
+```{python}
+all_datasets_df = pd.read_parquet("RSV_files/RSV_FILLED.parquet")
+all_datasets_df = all_datasets_df.rename(columns={'fluseason_week': 'season_week'})
+all_datasets_df["week_enddate"] = pd.NaT
+
+season_identifiers = ['datasetH1', 'datasetH2', 'fluseason', 'sample']
+time_identifier = 'season_week'
+
+#This sums values across locations for each dataset and week.
+location_sums = all_datasets_df.groupby(season_identifiers + [time_identifier])['value'].sum().reset_index()
+
+#This extracts the peak weekly value per season.
+season_peaks = location_sums.groupby(season_identifiers)['value'].max().reset_index()
+scaling_distribution = season_peaks[season_peaks['datasetH1'] == 'RSV_SMH'].value if 'RSV_SMH' in season_peaks['datasetH1'].unique() else season_peaks.value
+```
+
+## RSV configuration
+
+```{r}
+n_frames <- arrow::read_parquet("RSV_files/RSV_FILLED.parquet") |>
+  group_by(fluseason, datasetH1, sample) |>
+  count() |>
+  group_by(datasetH1) |>
+  summarise(
+    n_frames = n(),
+    .groups = "drop"
+  ) |>
+  mutate(
+    proportions = c(0.1, 0.1, 0.1, 0.7),
+    n_trains = ceiling(n_frames / proportions),
+    check = if_else(
+      n_trains > n_frames,
+      TRUE,
+      FALSE
+    )
+  )
+n_frames |> pull(n_trains) |> max()
+
+```
+
+
+```{python}
+# need to build 512 frames per dataset for training
+RSV_CONFIG = {
+    "100S": {
+        "NSSP": {"multiplier": 20},
+        "RSV-Net": {"multiplier": 20},
+        "NHSN": {"multiplier": 20},
+    },
+    "30S70M": {
+        "NSSP": {"proportion": 0.10, "total": 2229},
+        "RSV-Net": {"proportion": 0.10, "total": 2229},
+        "NHSN": {"proportion": 0.10, "total": 2229},
+        "RSV_SMH": {"proportion": 0.70, "total": 2229},
+    },
+    "100M": {
+        "RSV_SMH": {"multiplier": 1}
+    },
+}
+
+```
+
+
+## Build datasets
+```{python}
+for ds_name, mix_cfg in RSV_CONFIG.items():
+    print(f"Building dataset: {ds_name}")
+    
+    # Build frames using the mixer
+    frame_list = dataset_mixer.build_frames(
+        all_datasets_df, 
+        mix_cfg, 
+        season_axis=season_setup, 
+        fill_missing_locations="random",
+        scaling_distribution=scaling_distribution
+    )
+    
+    # Convert to Xarray
+    flu_payload_array, main_origins = build_dataset_from_framelist(frame_list)
+    
+    # Add metadata
+    flu_payload_array = flu_payload_array.assign_attrs(
+                main_origins=list(main_origins),
+                mix_cfg=mix_cfg.__str__()
+    )
+    
+    # Save to NetCDF
+    filename = f"training_datasets/RSV_{ds_name}_{today}.nc"
+    flu_payload_array.to_netcdf(filename)
+    print(f"Saved {filename}")
+
+```
+
+
+## Inspect array
+```{python}
+arr = xr.open_dataarray("training_datasets/RSV_100S_2026-01-16.nc")
+
+all_origin = arr.attrs.get("main_origins", None)
+prefixes = [entry.split('/')[0] for entry in all_origin]
+segments = []
+start = 0
+current_prefix = prefixes[0]
+for i in range(1, len(prefixes)):
+    if prefixes[i] != current_prefix:
+        segments.append((start, i - 1, current_prefix))
+        start = i
+        current_prefix = prefixes[i]
+# Add the last segment
+segments.append((start, len(prefixes) - 1, current_prefix))
+# Output: list of (start_idx, end_idx, prefix)
+for seg in segments:
+    print(f"{seg[2]}: from index {seg[0]} to {seg[1]} (n={seg[1] - seg[0] + 1})")
+```
+
+## Visualize arr
+```{python}
+
+# mat = arr.sel(sample=0, feature=0)
+# mat.plot()
+idx_tp = 0
+for i in list(np.arange(idx_tp, idx_tp+5*20, step = 17)):
+  print(all_origin[i])
+
+fig, ax = idplots.plot_us_grid(
+    data=arr,
+    season_axis=season_setup,
+    sample_idx=list(np.arange(idx_tp, idx_tp+5*17, step = 17)),
+    multi_line=True,
+    sharey=False,
+)
+
+arr.attrs
+
+```
+
+
+# TRAINING
+The RSV training datasets have been built and saved in the `training_datasets` folder. Each dataset corresponds to a different mixing configuration as specified in the `RSV_CONFIG` dictionary. 
+
+```{python}
+import matplotlib.pyplot as plt
+import seaborn as sns
+from tqdm.auto import tqdm
+import torch
+from torch import nn
+import numpy as np
+import pandas as pd
+import datetime
+import sys
+from pathlib import Path
+from torch.utils.data import DataLoader
+from torch.optim import Adam
+
+# InfluPaint modular imports
+from influpaint.utils import SeasonAxis, plotting as idplots
+from influpaint.batch.scenarios import get_training_scenario, create_scenario_objects
+from influpaint.batch.config import copaint_config_library, create_folders, get_git_revision_short_hash
+from influpaint.utils import ground_truth
+from influpaint.datasets import loaders as training_datasets
+from influpaint.batch.config import transform_library
+# CoPaint imports
+sys.path.append('CoPaint4influpaint')
+from guided_diffusion import O_DDIMSampler
+
+# Configure plotting
+sns.set_style("whitegrid")
+%matplotlib inline
+
+season_setup = SeasonAxis.for_flusight(remove_us=True, remove_territories=True)
+image_size = 64
+channels = 1
+batch_size=512
+epochs=3000
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device: {device}")
+
+if device == "cuda":
+    from influpaint.utils.helpers import cuda_mem_info
+    print(cuda_mem_info())
+    torch.cuda.empty_cache()
+    print(cuda_mem_info())
+
+```
+
+
+```{python}
+
+scn_id = 868  # Choose your training scenario
+experiment_name = "demo_jan2026"  # MLflow experiment name
+scenario_spec = get_training_scenario(scn_id)
+ddpm, dataset, transform, enrich, scaling_per_channel, data_mean, data_sd = create_scenario_objects(
+            scenario_spec, season_setup, image_size, channels, batch_size, epochs, device)
+
+```
+
+
+```{python}
+dataset = training_datasets.FluDataset.from_xarray("training_datasets/RSV_30S70M_2026-01-16.nc",channels=channels,)
+scaling_per_channel = np.array(dataset.max_per_feature) # one number per channel 
+
+transforms_spec, transform_enrich = transform_library(
+    scaling_per_channel,
+    data_mean=dataset.flu_dyn.mean(),
+    data_std=dataset.flu_dyn.std(),
+)
+transform = transforms_spec[scenario_spec.transform_name]
+enrich = transform_enrich[scenario_spec.enrich_name]
+dataset.add_transform(
+    transform=transform["reg"],
+    transform_inv=transform["inv"],
+    transform_enrich=enrich,
+    bypass_test=False,
+)
+
+all_samples = np.array([sample.numpy() for sample in dataset]) #dataset is an iterable that yields tensors tranformed
+plt.hist(all_samples.flatten());
+
+```
+
+
+```{python}
+dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True)
+losses = ddpm.train(dataloader, mlflow_logging=True)
+```
+
+
+
+```{python}
+checkpoint_path = f"rsv.pth"
+ddpm.write_train_checkpoint(save_path=checkpoint_path)
+ddpm.load_model_checkpoint(checkpoint_path)
+
+ddpm.model.eval()
+ddpm.model.to(device)
+
+ft_samples = ddpm.sample() # list of size n_diff_step.
+ft_samples[0].shape
+np.save(f"rsvgen.npy", dataset.apply_transform_inv(ft_samples[-1]))
+ft_samples = np.load("rsvgen.npy")
+n_show = min(batch_size, 10)
+
+fig, axes = plt.subplots(2, 2, figsize=(2.8 * n_show, 7.5), dpi=100)
+for k, loc in enumerate([ 0, 5, 10, 15]):
+    ax = axes.flat[k]
+    for i in np.arange(3):
+        hist_img = dataset.get_sample_raw(i)
+        idplots.show_tensor_image(hist_img, ax=ax, place=loc, multi=False) # thicker curve are historical data
+        for i in range(n_show):
+          gen_img = ft_samples[i]
+          idplots.show_tensor_image(gen_img, ax=ax, place=loc, multi=True)
+        
+    ax.set_title(f"FT gen vs Hist, loc={loc}")
+    ax.grid(visible=True, alpha=0.3)
+plt.tight_layout()
+plt.show()
+```
\ No newline at end of file
diff --git a/demo.ipynb b/demo.ipynb
new file mode 100644
index 0000000..7e4a566
--- /dev/null
+++ b/demo.ipynb
@@ -0,0 +1,438 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "6422c7a5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Spatial Setup with 51 locations, with a season start_date of Aug 01\n",
+      "Using device: cuda\n"
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from tqdm.auto import tqdm\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import datetime\n",
+    "import sys\n",
+    "from pathlib import Path\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torch.optim import Adam\n",
+    "\n",
+    "# InfluPaint modular imports\n",
+    "from influpaint.utils import SeasonAxis, plotting as idplots\n",
+    "from influpaint.batch.scenarios import get_training_scenario, create_scenario_objects\n",
+    "from influpaint.batch.config import copaint_config_library, create_folders, get_git_revision_short_hash\n",
+    "from influpaint.utils import ground_truth\n",
+    "from influpaint.datasets import loaders as training_datasets\n",
+    "from influpaint.batch.config import transform_library\n",
+    "# CoPaint imports\n",
+    "sys.path.append('CoPaint4influpaint')\n",
+    "from guided_diffusion import O_DDIMSampler\n",
+    "\n",
+    "# Configure plotting\n",
+    "sns.set_style(\"whitegrid\")\n",
+    "%matplotlib inline\n",
+    "\n",
+    "season_setup = SeasonAxis.for_flusight(remove_us=True, remove_territories=True)\n",
+    "image_size = 64\n",
+    "channels = 1\n",
+    "batch_size=512\n",
+    "epochs=50\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "print(f\"Using device: {device}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "855d1c22",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "created dataset with max [24573.12361303], full dataset has shape (3223, 1, 64, 64)\n",
+      "test passed: back and forth transformation are ok ✅\n"
+     ]
+    }
+   ],
+   "source": [
+    "scn_id = 868  # Choose your training scenario\n",
+    "experiment_name = \"demo_jan2026\"  # MLflow experiment name\n",
+    "scenario_spec = get_training_scenario(scn_id)\n",
+    "ddpm, dataset, transform, enrich, scaling_per_channel, data_mean, data_sd = create_scenario_objects(\n",
+    "            scenario_spec, season_setup, image_size, channels, batch_size, epochs, device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "8f82a4eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "created dataset with max [24573.12361303], full dataset has shape (3223, 1, 64, 64)\n",
+      "test passed: back and forth transformation are ok ✅\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dataset = training_datasets.FluDataset.from_xarray(\"training_datasets/TS_30S70M_2025-07-17.nc\",channels=channels,)\n",
+    "scaling_per_channel = np.array(dataset.max_per_feature) # one number per channel \n",
+    "scaling_per_channel = 80\n",
+    "\n",
+    "transforms_spec, transform_enrich = transform_library(\n",
+    "    scaling_per_channel,\n",
+    "    data_mean=dataset.flu_dyn.mean(),\n",
+    "    data_std=dataset.flu_dyn.std(),\n",
+    ")\n",
+    "transform = transforms_spec[scenario_spec.transform_name]\n",
+    "enrich = transform_enrich[scenario_spec.enrich_name]\n",
+    "dataset.add_transform(\n",
+    "    transform=transform[\"reg\"],\n",
+    "    transform_inv=transform[\"inv\"],\n",
+    "    transform_enrich=enrich,\n",
+    "    bypass_test=False,\n",
+    ")\n",
+    "\n",
+    "all_samples = np.array([sample.numpy() for sample in dataset]) #dataset is an iterable that yields tensors tranformed\n",
+    "plt.hist(all_samples.flatten());"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ea3a130",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "50"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "0a2b77fe",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/!\\ training on cuda\n",
+      "NVIDIA H100 NVL -- Allocated: 0.0GB, Cached: 0.1GB -- 92.0/93.1 (free/total)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/nas/longleaf/home/chadi/.local/lib/python3.10/site-packages/torch/nn/modules/conv.py:456: UserWarning: Applied workaround for CuDNN issue, install nvrtc.so (Triggered internally at ../aten/src/ATen/native/cudnn/Conv_v8.cpp:80.)\n",
+      "  return F.conv2d(input, weight, bias, self.stride,\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0    -- Step: 0    -- Loss: 1.137181\n",
+      "Epoch 0 completed - Avg Loss: 1.687238\n",
+      "Epoch: 1    -- Step: 0    -- Loss: 1.838632\n",
+      "Epoch 1 completed - Avg Loss: 1.243806\n",
+      "Epoch: 2    -- Step: 0    -- Loss: 1.074437\n",
+      "Epoch 2 completed - Avg Loss: 1.049016\n",
+      "Epoch: 3    -- Step: 0    -- Loss: 1.113329\n",
+      "Epoch 3 completed - Avg Loss: 1.035596\n",
+      "Epoch: 4    -- Step: 0    -- Loss: 1.002009\n",
+      "Epoch 4 completed - Avg Loss: 1.001870\n",
+      "Epoch: 5    -- Step: 0    -- Loss: 0.996559\n",
+      "Epoch 5 completed - Avg Loss: 0.993288\n",
+      "Epoch: 6    -- Step: 0    -- Loss: 0.987099\n",
+      "Epoch 6 completed - Avg Loss: 0.986741\n",
+      "Epoch: 7    -- Step: 0    -- Loss: 0.983238\n",
+      "Epoch 7 completed - Avg Loss: 0.978671\n",
+      "Epoch: 8    -- Step: 0    -- Loss: 0.973271\n",
+      "Epoch 8 completed - Avg Loss: 0.970560\n",
+      "Epoch: 9    -- Step: 0    -- Loss: 0.960710\n",
+      "Epoch 9 completed - Avg Loss: 0.954519\n",
+      "Epoch: 10   -- Step: 0    -- Loss: 0.938149\n",
+      "Epoch 10 completed - Avg Loss: 0.919003\n",
+      "Epoch: 11   -- Step: 0    -- Loss: 0.883664\n",
+      "Epoch 11 completed - Avg Loss: 0.816744\n",
+      "Epoch: 12   -- Step: 0    -- Loss: 0.706918\n",
+      "Epoch 12 completed - Avg Loss: 0.638752\n",
+      "Epoch: 13   -- Step: 0    -- Loss: 0.538011\n",
+      "Epoch 13 completed - Avg Loss: 0.483250\n",
+      "Epoch: 14   -- Step: 0    -- Loss: 0.403896\n",
+      "Epoch 14 completed - Avg Loss: 0.370550\n",
+      "Epoch: 15   -- Step: 0    -- Loss: 0.331049\n",
+      "Epoch 15 completed - Avg Loss: 0.298517\n",
+      "Epoch: 16   -- Step: 0    -- Loss: 0.265829\n",
+      "Epoch 16 completed - Avg Loss: 0.259145\n",
+      "Epoch: 17   -- Step: 0    -- Loss: 0.232619\n",
+      "Epoch 17 completed - Avg Loss: 0.233937\n",
+      "Epoch: 18   -- Step: 0    -- Loss: 0.219860\n",
+      "Epoch 18 completed - Avg Loss: 0.216197\n",
+      "Epoch: 19   -- Step: 0    -- Loss: 0.200356\n",
+      "Epoch 19 completed - Avg Loss: 0.195827\n",
+      "Epoch: 20   -- Step: 0    -- Loss: 0.202645\n",
+      "Epoch 20 completed - Avg Loss: 0.187779\n",
+      "Epoch: 21   -- Step: 0    -- Loss: 0.182391\n",
+      "Epoch 21 completed - Avg Loss: 0.180291\n",
+      "Epoch: 22   -- Step: 0    -- Loss: 0.169110\n",
+      "Epoch 22 completed - Avg Loss: 0.168342\n",
+      "Epoch: 23   -- Step: 0    -- Loss: 0.162155\n",
+      "Epoch 23 completed - Avg Loss: 0.163750\n",
+      "Epoch: 24   -- Step: 0    -- Loss: 0.169833\n",
+      "Epoch 24 completed - Avg Loss: 0.165801\n",
+      "Epoch: 25   -- Step: 0    -- Loss: 0.158586\n",
+      "Epoch 25 completed - Avg Loss: 0.162124\n",
+      "Epoch: 26   -- Step: 0    -- Loss: 0.151928\n",
+      "Epoch 26 completed - Avg Loss: 0.158762\n",
+      "Epoch: 27   -- Step: 0    -- Loss: 0.155903\n",
+      "Epoch 27 completed - Avg Loss: 0.154293\n",
+      "Epoch: 28   -- Step: 0    -- Loss: 0.154271\n",
+      "Epoch 28 completed - Avg Loss: 0.150157\n",
+      "Epoch: 29   -- Step: 0    -- Loss: 0.153486\n",
+      "Epoch 29 completed - Avg Loss: 0.147809\n",
+      "Epoch: 30   -- Step: 0    -- Loss: 0.131418\n",
+      "Epoch 30 completed - Avg Loss: 0.142186\n",
+      "Epoch: 31   -- Step: 0    -- Loss: 0.152905\n",
+      "Epoch 31 completed - Avg Loss: 0.144841\n",
+      "Epoch: 32   -- Step: 0    -- Loss: 0.153438\n",
+      "Epoch 32 completed - Avg Loss: 0.139092\n",
+      "Epoch: 33   -- Step: 0    -- Loss: 0.149069\n",
+      "Epoch 33 completed - Avg Loss: 0.141122\n",
+      "Epoch: 34   -- Step: 0    -- Loss: 0.126799\n",
+      "Epoch 34 completed - Avg Loss: 0.131570\n",
+      "Epoch: 35   -- Step: 0    -- Loss: 0.140485\n",
+      "Epoch 35 completed - Avg Loss: 0.134624\n",
+      "Epoch: 36   -- Step: 0    -- Loss: 0.132976\n",
+      "Epoch 36 completed - Avg Loss: 0.130670\n",
+      "Epoch: 37   -- Step: 0    -- Loss: 0.128151\n",
+      "Epoch 37 completed - Avg Loss: 0.124412\n",
+      "Epoch: 38   -- Step: 0    -- Loss: 0.123774\n",
+      "Epoch 38 completed - Avg Loss: 0.127964\n",
+      "Epoch: 39   -- Step: 0    -- Loss: 0.131725\n",
+      "Epoch 39 completed - Avg Loss: 0.128797\n",
+      "Epoch: 40   -- Step: 0    -- Loss: 0.121758\n",
+      "Epoch 40 completed - Avg Loss: 0.128353\n",
+      "Epoch: 41   -- Step: 0    -- Loss: 0.131800\n",
+      "Epoch 41 completed - Avg Loss: 0.125028\n",
+      "Epoch: 42   -- Step: 0    -- Loss: 0.125964\n",
+      "Epoch 42 completed - Avg Loss: 0.120048\n",
+      "Epoch: 43   -- Step: 0    -- Loss: 0.113806\n",
+      "Epoch 43 completed - Avg Loss: 0.119350\n",
+      "Epoch: 44   -- Step: 0    -- Loss: 0.121013\n",
+      "Epoch 44 completed - Avg Loss: 0.121824\n",
+      "Epoch: 45   -- Step: 0    -- Loss: 0.126616\n",
+      "Epoch 45 completed - Avg Loss: 0.119776\n",
+      "Epoch: 46   -- Step: 0    -- Loss: 0.114350\n",
+      "Epoch 46 completed - Avg Loss: 0.121396\n",
+      "Epoch: 47   -- Step: 0    -- Loss: 0.132377\n",
+      "Epoch 47 completed - Avg Loss: 0.119188\n",
+      "Epoch: 48   -- Step: 0    -- Loss: 0.104848\n",
+      "Epoch 48 completed - Avg Loss: 0.116367\n",
+      "Epoch: 49   -- Step: 0    -- Loss: 0.117690\n",
+      "Epoch 49 completed - Avg Loss: 0.116513\n",
+      "NVIDIA H100 NVL -- Allocated: 0.2GB, Cached: 32.6GB -- 58.3/93.1 (free/total)\n"
+     ]
+    }
+   ],
+   "source": [
+    "dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True)\n",
+    "losses = ddpm.train(dataloader, mlflow_logging=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "8d0ef982",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'demo.pth'"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "checkpoint_path = f\"demo.pth\"\n",
+    "ddpm.write_train_checkpoint(save_path=checkpoint_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6fadfe4",
+   "metadata": {},
+   "source": [
+    "you need to give something to a pytorch.Dataloader, it wants iterable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "3a410efb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "sampling loop time step: 100%|██████████| 500/500 [00:44<00:00, 11.30it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "ddpm.model.eval()\n",
+    "ddpm.model.to(device)\n",
+    "\n",
+    "ft_samples = ddpm.sample() # list of size n_diff_step.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "5cd25a7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(512, 1, 64, 64)"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ft_samples[0].shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad33c8e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2800x750 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_show = min(batch_size, 10)\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(2.8 * n_show, 7.5), dpi=100)\n",
+    "for k, loc in enumerate([ 0, 5, 10, 15]):\n",
+    "    ax = axes.flat[k]\n",
+    "    for i in np.arange(3):\n",
+    "        hist_img = dataset.get_sample_raw(i)\n",
+    "        idplots.show_tensor_image(hist_img, ax=ax, place=loc, multi=False) # thicker curve are historical data\n",
+    "    for i in np.arange(n_show):\n",
+    "        gen_img = dataset.apply_transform_inv(ft_samples[-1][i]) # -1 because i want the last step of the diffusion\n",
+    "        idplots.show_tensor_image(gen_img, ax=ax, place=loc, multi=True) # thinner curve are generation\n",
+    "        \n",
+    "    ax.set_title(f\"FT gen vs Hist, loc={loc}\")\n",
+    "    ax.grid(visible=True, alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "f2034e50",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2800x750 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_show = min(batch_size, 10)\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(2.8 * n_show, 7.5), dpi=100)\n",
+    "for k, loc in enumerate([ 0, 5, 10, 15]):\n",
+    "    ax = axes.flat[k]\n",
+    "    for i in np.arange(3):\n",
+    "        hist_img = dataset.get_sample_raw(i)\n",
+    "        idplots.show_tensor_image(hist_img, ax=ax, place=loc, multi=False) # thicker curve are historical data\n",
+    "    for i in np.arange(n_show):\n",
+    "        gen_img = dataset.apply_transform_inv(ft_samples[250][i]) # -1 because i want the last step of the diffusion\n",
+    "        idplots.show_tensor_image(gen_img, ax=ax, place=loc, multi=True) # thinner curve are generation\n",
+    "        \n",
+    "    ax.set_title(f\"FT gen vs Hist, loc={loc}\")\n",
+    "    ax.grid(visible=True, alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "diffusion_torch6",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/influpaint.ipynb b/influpaint.ipynb
index ce2643f..0c8da35 100644
--- a/influpaint.ipynb
+++ b/influpaint.ipynb
@@ -1742,16 +1742,7 @@
    "name": "python3"
   },
   "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "name": "python"
   },
   "toc-autonumbering": true,
   "toc-showcode": false,
diff --git a/influpaint/datasets/mixer.py b/influpaint/datasets/mixer.py
index d3cb6fc..20e798b 100644
--- a/influpaint/datasets/mixer.py
+++ b/influpaint/datasets/mixer.py
@@ -1,7 +1,7 @@
 """
 dataset_mixer.py - Epidemic Data Augmentation and Frame Construction
 
-Combines multiple epidemic surveillance datasets into a unified training corpus 
+Combines multiple epidemic surveillance datasets into a unified training corpus
 for diffusion models. Addresses common challenges in epidemic modeling:
 
 - **Dataset Rebalancing**: Uses multipliers to weight data sources
@@ -23,7 +23,7 @@
 all_datasets_df = pd.concat([fluview_df, nc_df, smh_traj_df])
 
 # Step 2: Configure dataset inclusion, weighting, and scaling
-config = { 
+config = {
     "fluview": {"proportion": 0.7, "total": 1000, "to_scale": True},     # 70% + scaling
     "smh_traj": {"proportion": 0.3, "total": 1000, "to_scale": False}    # 30% + no scaling
 }
@@ -32,7 +32,7 @@
 scaling_dist = np.array([1000, 2000, 3000, 5000, 8000, 12000])  # US peak values
 
 # Step 4: Build complete frames with configurable location handling and scaling
-frames = build_frames(all_datasets_df, config, season_axis, 
+frames = build_frames(all_datasets_df, config, season_axis,
                      fill_missing_locations="zeros",
                      scaling_distribution=scaling_dist)
 
@@ -41,7 +41,7 @@
     "fluview": {"multiplier": 2, "to_scale": True},      # Include twice + scaling
     "smh_traj": {"multiplier": 1, "to_scale": False}     # Include once + no scaling
 }
-frames = build_frames(all_datasets_df, config, season_axis, 
+frames = build_frames(all_datasets_df, config, season_axis,
                      scaling_distribution=scaling_dist)
 
 Peak Scaling:
@@ -57,12 +57,12 @@
 --------------
 Each frame is a complete epidemic season with:
 - All weeks (1-53) represented
-- All locations covered  
+- All locations covered
 - Consistent data structure for array conversion
 - Optional peak scaling applied
 - Full provenance tracking in 'origin' column
 
-Enables training on heterogeneous surveillance data while maintaining 
+Enables training on heterogeneous surveillance data while maintaining
 epidemiological structure and realistic intensity distributions.
 """
 
@@ -72,8 +72,9 @@
 from tqdm import tqdm
 
 
-def _validate_required_columns(df: pd.DataFrame, required_columns: list, 
-                              context: str) -> None:
+def _validate_required_columns(
+    df: pd.DataFrame, required_columns: list, context: str
+) -> None:
     """Validate that DataFrame contains all required columns."""
     missing_columns = [col for col in required_columns if col not in df.columns]
     if missing_columns:
@@ -84,7 +85,7 @@ def _validate_config_consistency(config: dict) -> tuple[bool, bool]:
     """Validate config consistency and return flags for approach types."""
     has_proportions = any("proportion" in cfg for cfg in config.values())
     has_multipliers = any("multiplier" in cfg for cfg in config.values())
-    
+
     if has_proportions and has_multipliers:
         raise ValueError(
             "Cannot mix 'proportion' and 'multiplier' configs. Choose one approach.\n\n"
@@ -97,56 +98,62 @@ def _validate_config_consistency(config: dict) -> tuple[bool, bool]:
             "multipliers = calculate_multipliers(data, total=1000, target_proportions={'fluview': 0.7})\n"
             "config = {name: {'multiplier': mult} for name, mult in multipliers.items()}"
         )
-    
+
     return has_proportions, has_multipliers
 
-def build_frames(all_datasets_df: pd.DataFrame, config: dict, season_axis: SeasonAxis, 
-                 fill_missing_locations: str = "error", scaling_distribution: np.ndarray = None) -> list:
+
+def build_frames(
+    all_datasets_df: pd.DataFrame,
+    config: dict,
+    season_axis: SeasonAxis,
+    fill_missing_locations: str = "error",
+    scaling_distribution: np.ndarray = None,
+) -> list:
     """
     Build complete epidemic frames from hierarchical dataset structure.
-    
-    Handles 4-level hierarchy: H1 → H2 → Season → Sample and creates complete 
+
+    Handles 4-level hierarchy: H1 → H2 → Season → Sample and creates complete
     frames while preserving dataset origins.
-    
+
     Args:
         all_datasets_df (pd.DataFrame): Combined dataset with required columns:
-            - datasetH1: Top-level dataset category (e.g., 'fluview', 'smh_traj')  
+            - datasetH1: Top-level dataset category (e.g., 'fluview', 'smh_traj')
             - datasetH2: Sub-dataset within H1 (e.g., 'round4_CADPH-FluCAT_A-2024-08-01')
             - fluseason: Flu season year
             - sample: Sample identifier within each H2/season combination
             - location_code, season_week, value, week_enddate: Epidemic data
-            
+
         config (dict): Configuration for dataset inclusion and weighting:
             - Keys: H1 dataset names (must exist in datasetH1 column)
             - Values: Either {"multiplier": int} or {"proportion": float, "total": int}
             - Optional: {"to_scale": bool} to enable frame scaling
-            
+
         season_axis (SeasonAxis): Season axis object providing location definitions
-        
+
         fill_missing_locations (str): Strategy for handling missing locations:
             - "error": Fail if any expected location is missing (default)
             - "zeros": Fill missing locations with zeros
             - "random": Fill missing locations with random other season data
             - "skip": Skip frames with missing locations
-            
+
         scaling_distribution (np.ndarray, optional): Array of values to draw from for scaling.
             Required if any dataset in config has "to_scale": True
-            
+
     Returns:
         list: Complete epidemic frames, where each frame contains:
             - All weeks (1-53) for all expected locations (based on season_axis)
             - Origin column tracking source: "H1/H2/season/sample"
             - Replicated datasets as specified by config
-            
+
     Example:
         config = {
             "fluview": {"multiplier": 1, "to_scale": True},
             "smh_traj": {"proportion": 0.7, "total": 1000, "to_scale": False}
         }
         scaling_dist = np.array([1000, 2000, 3000, 5000, 8000])  # Peak values to scale to
-        frames = build_frames(all_datasets_df, config, season_axis, 
+        frames = build_frames(all_datasets_df, config, season_axis,
                              fill_missing_locations="zeros", scaling_distribution=scaling_dist)
-        
+
     Notes:
         - If H1 dataset is included, ALL H2s and seasons within it are included
         - Minimum frames = sum(n_H2 * n_seasons) for each included H1
@@ -154,87 +161,114 @@ def build_frames(all_datasets_df: pd.DataFrame, config: dict, season_axis: Seaso
         - Location completeness is enforced based on season_axis.locations
     """
     # Validate input dataframe
-    required_columns = ['datasetH1', 'datasetH2', 'fluseason', 'sample', 
-                       'location_code', 'season_week', 'value', 'week_enddate']
+    required_columns = [
+        "datasetH1",
+        "datasetH2",
+        "fluseason",
+        "sample",
+        "location_code",
+        "season_week",
+        "value",
+        "week_enddate",
+    ]
     _validate_required_columns(all_datasets_df, required_columns, "Input dataframe")
-    
+
     # Validate config references existing H1 datasets
-    available_h1 = set(all_datasets_df['datasetH1'].unique())
+    available_h1 = set(all_datasets_df["datasetH1"].unique())
     config_h1 = set(config.keys())
     missing_h1 = config_h1 - available_h1
     if missing_h1:
         raise ValueError(f"Config references non-existent H1 datasets: {missing_h1}")
-    
+
     # Validate fill_missing_locations parameter
     valid_strategies = {"error", "zeros", "random", "skip"}
     if fill_missing_locations not in valid_strategies:
         raise ValueError(f"fill_missing_locations must be one of: {valid_strategies}")
-    
+
     # Validate scaling parameters
     needs_scaling = any(cfg.get("to_scale", False) for cfg in config.values())
     if needs_scaling and scaling_distribution is None:
-        raise ValueError("scaling_distribution must be provided when any dataset has to_scale=True")
+        raise ValueError(
+            "scaling_distribution must be provided when any dataset has to_scale=True"
+        )
     if scaling_distribution is not None and len(scaling_distribution) == 0:
         raise ValueError("scaling_distribution cannot be empty")
-    
+
     # Calculate multipliers for each H1 dataset
     h1_multipliers = _calculate_h1_multipliers(all_datasets_df, config)
-    
+
     # Pre-compute global lookup table for intelligent filling (do this once)
     global_lookup = None
     if fill_missing_locations == "random":
         print("Pre-computing intelligent fill lookup table...")
         global_lookup = _build_global_lookup_table(all_datasets_df)
-    
-    # Build frames for each included H1 dataset  
+
+    # Build frames for each included H1 dataset
     all_frames = []
     frame_summary = {}
-    
+
     print("Building frames...")
     for h1_name, multiplier in h1_multipliers.items():
         h1_config = config[h1_name]
         should_scale = h1_config.get("to_scale", False)
         scale_info = " with scaling" if should_scale else ""
         print(f"Processing {h1_name} (multiplier={multiplier}{scale_info})...")
-        h1_data = all_datasets_df[all_datasets_df['datasetH1'] == h1_name].copy()
-        
-        h1_frames = _build_h1_frames(h1_data, h1_name, multiplier, season_axis, fill_missing_locations, 
-                                   all_datasets_df, global_lookup, should_scale, scaling_distribution)
+        h1_data = all_datasets_df[all_datasets_df["datasetH1"] == h1_name].copy()
+
+        h1_frames = _build_h1_frames(
+            h1_data,
+            h1_name,
+            multiplier,
+            season_axis,
+            fill_missing_locations,
+            all_datasets_df,
+            global_lookup,
+            should_scale,
+            scaling_distribution,
+        )
         all_frames.extend(h1_frames)
-        
+
         # Build summary for this H1 dataset
         h2_counts = {}
         for frame in h1_frames:
-            if 'datasetH2' in frame.columns:
-                h2 = frame['datasetH2'].iloc[0]
+            if "datasetH2" in frame.columns:
+                h2 = frame["datasetH2"].iloc[0]
                 # Handle NaN values properly
                 if pd.isna(h2):
                     h2 = "<missing_datasetH2>"
                 h2_counts[h2] = h2_counts.get(h2, 0) + 1
-        
+
         frame_summary[h1_name] = {
-            'total_frames': len(h1_frames),
-            'multiplier': multiplier,
-            'h2_breakdown': h2_counts
+            "total_frames": len(h1_frames),
+            "multiplier": multiplier,
+            "h2_breakdown": h2_counts,
         }
-    
+
     # Print summary
     print(f"Created {len(all_frames)} total frames:")
     for h1_name, summary in frame_summary.items():
-        print(f"  {h1_name}: {summary['total_frames']} frames (multiplier={summary['multiplier']})")
-        #for h2, count in summary['h2_breakdown'].items():
+        print(
+            f"  {h1_name}: {summary['total_frames']} frames (multiplier={summary['multiplier']})"
+        )
+        # for h2, count in summary['h2_breakdown'].items():
         #    print(f"    {h2}: {count} frames")
-    
+
     # Clean up frames by removing unnecessary metadata columns
     cleaned_frames = []
-    essential_columns = ['location_code', 'season_week', 'value', 'week_enddate', 'origin']
-    
+    essential_columns = [
+        "location_code",
+        "season_week",
+        "value",
+        "week_enddate",
+        "origin",
+    ]
+
     for frame in all_frames:
         # Keep only essential columns that have actual data
         available_essential = [col for col in essential_columns if col in frame.columns]
         cleaned_frame = frame[available_essential].copy()
         cleaned_frames.append(cleaned_frame)
-    
+
     return cleaned_frames
 
 
@@ -242,7 +276,7 @@ def _calculate_h1_multipliers(all_datasets_df: pd.DataFrame, config: dict) -> di
     """Calculate multipliers for each H1 dataset based on config."""
     # Validate config consistency - no mixing approaches
     has_proportions, has_multipliers = _validate_config_consistency(config)
-    
+
     # Process configs based on consistent approach
     if has_proportions:
         return _calculate_proportional_multipliers(all_datasets_df, config)
@@ -250,412 +284,505 @@ def _calculate_h1_multipliers(all_datasets_df: pd.DataFrame, config: dict) -> di
         return _calculate_explicit_multipliers(config)
 
 
-def _calculate_proportional_multipliers(all_datasets_df: pd.DataFrame, config: dict) -> dict:
+def _calculate_proportional_multipliers(
+    all_datasets_df: pd.DataFrame, config: dict
+) -> dict:
     """Calculate multipliers from proportion-based config."""
     h1_multipliers = {}
     total_target = None
-    
+
     # Validate all configs have proportion + total
     for h1_name, h1_config in config.items():
         if "proportion" not in h1_config or "total" not in h1_config:
-            raise ValueError(f"Config for '{h1_name}' must have both 'proportion' and 'total'")
-        
+            raise ValueError(
+                f"Config for '{h1_name}' must have both 'proportion' and 'total'"
+            )
+
         if total_target is None:
             total_target = h1_config["total"]
         elif total_target != h1_config["total"]:
             raise ValueError("All proportion configs must have same 'total' value")
-    
+
     # Calculate base sample counts
     base_counts = {}
     for h1_name in config:
-        h1_data = all_datasets_df[all_datasets_df['datasetH1'] == h1_name]
-        base_count = len(h1_data.groupby(['datasetH2', 'fluseason', 'sample']))
+        h1_data = all_datasets_df[all_datasets_df["datasetH1"] == h1_name]
+        base_count = len(h1_data.groupby(["datasetH2", "fluseason", "sample"]))
         base_counts[h1_name] = base_count
-    
+
     # Calculate multipliers to achieve target proportions
     for h1_name, h1_config in config.items():
         target_samples = int(total_target * h1_config["proportion"])
         base_count = base_counts[h1_name]
         h1_multipliers[h1_name] = max(1, round(target_samples / base_count))
-    
+
     return h1_multipliers
 
 
 def _calculate_explicit_multipliers(config: dict) -> dict:
     """Extract explicit multipliers from config."""
     h1_multipliers = {}
-    
+
     for h1_name, h1_config in config.items():
         if "multiplier" not in h1_config:
             raise ValueError(f"Config for '{h1_name}' must have 'multiplier'")
         h1_multipliers[h1_name] = h1_config["multiplier"]
-    
+
     return h1_multipliers
 
 
-def _build_h1_frames(h1_data: pd.DataFrame, h1_name: str, multiplier: int, 
-                    season_axis: SeasonAxis, fill_missing_locations: str, 
-                    all_datasets_df: pd.DataFrame = None, global_lookup: dict = None,
-                    should_scale: bool = False, scaling_distribution: np.ndarray = None) -> list:
+def _build_h1_frames(
+    h1_data: pd.DataFrame,
+    h1_name: str,
+    multiplier: int,
+    season_axis: SeasonAxis,
+    fill_missing_locations: str,
+    all_datasets_df: pd.DataFrame = None,
+    global_lookup: dict = None,
+    should_scale: bool = False,
+    scaling_distribution: np.ndarray = None,
+) -> list:
     """Build frames for a single H1 dataset with replication."""
     frames = []
-    
+
     # Calculate total work for progress bar
     total_work = 0
     for copy_num in range(multiplier):
-        for (h2, season), group in h1_data.groupby(['datasetH2', 'fluseason']):
-            total_work += len(group['sample'].unique())
-    
+        for (h2, season), group in h1_data.groupby(["datasetH2", "fluseason"]):
+            total_work += len(group["sample"].unique())
+
     # Create replicated copies with progress bar
     pbar = tqdm(total=total_work, desc=f"  {h1_name} frames", leave=False)
-    
+
     for copy_num in range(multiplier):
         copy_suffix = f"_copy{copy_num}" if copy_num > 0 else ""
-        
+
         # Process each H2/season combination
-        for (h2, season), group in h1_data.groupby(['datasetH2', 'fluseason']):
+        for (h2, season), group in h1_data.groupby(["datasetH2", "fluseason"]):
             # Each sample in this H2/season becomes a separate frame
-            for sample_id, sample_data in group.groupby('sample'):
+            for sample_id, sample_data in group.groupby("sample"):
                 # Create origin identifier
                 origin = f"{h1_name}/{h2}/{season}/{sample_id}{copy_suffix}"
-                
+
                 # Build complete frame for this sample
                 frame = sample_data.copy()
-                frame['origin'] = origin
-                
+                frame["origin"] = origin
+
                 # Ensure complete weekly and location coverage
-                frame = _pad_frame_complete(frame, season_axis, fill_missing_locations, all_datasets_df, global_lookup)
-                
+                frame = _pad_frame_complete(
+                    frame,
+                    season_axis,
+                    fill_missing_locations,
+                    all_datasets_df,
+                    global_lookup,
+                )
+
                 # Skip frames with missing locations if strategy is "skip"
                 if frame is None:
                     pbar.update(1)
                     continue
-                
+
                 # Apply scaling if required for this H1 dataset
                 if should_scale and scaling_distribution is not None:
                     frame = _apply_frame_scaling(frame, scaling_distribution)
-                    
+
                 frames.append(frame)
                 pbar.update(1)
-    
+
     pbar.close()
     return frames
 
 
-def _pad_frame_complete(frame: pd.DataFrame, season_axis: SeasonAxis, 
-                       fill_missing_locations: str, all_datasets_df: pd.DataFrame = None, 
-                       global_lookup: dict = None) -> pd.DataFrame:
+def _pad_frame_complete(
+    frame: pd.DataFrame,
+    season_axis: SeasonAxis,
+    fill_missing_locations: str,
+    all_datasets_df: pd.DataFrame = None,
+    global_lookup: dict = None,
+) -> pd.DataFrame:
     """Ensure frame has complete weekly and location coverage."""
     expected_locations = set(season_axis.locations)
-    actual_locations = set(frame['location_code'].unique())
+    actual_locations = set(frame["location_code"].unique())
     missing_locations = expected_locations - actual_locations
-    
+
     # Handle missing locations
     if missing_locations:
-        frame = _handle_missing_locations(frame, missing_locations, actual_locations, 
-                                        fill_missing_locations, all_datasets_df, global_lookup)
+        frame = _handle_missing_locations(
+            frame,
+            missing_locations,
+            actual_locations,
+            fill_missing_locations,
+            all_datasets_df,
+            global_lookup,
+        )
         if frame is None:  # Skip strategy returned None
             return None
-    
+
     # Ensure complete weekly coverage for all locations
     complete_frames = []
     for location in expected_locations:
-        location_data = frame[frame['location_code'] == location].copy()
+        location_data = frame[frame["location_code"] == location].copy()
         if location_data.empty:
             continue
-            
+
         # Use existing padding logic for weekly completeness
         location_complete = _pad_single_location(location_data, location)
-        
+
         # Preserve other columns from original frame
         _preserve_columns(location_complete, frame, location_data)
         complete_frames.append(location_complete)
-    
+
     if not complete_frames:
         return None
-        
-    final_frame = pd.concat(complete_frames, ignore_index=True)
-    return final_frame.sort_values(['location_code', 'season_week']).reset_index(drop=True)
-
 
-def _handle_missing_locations(frame: pd.DataFrame, missing_locations: set, 
-                            actual_locations: set, strategy: str, 
-                            all_datasets_df: pd.DataFrame = None, global_lookup: dict = None) -> pd.DataFrame:
+    final_frame = pd.concat(complete_frames, ignore_index=True)
+    return final_frame.sort_values(["location_code", "season_week"]).reset_index(
+        drop=True
+    )
+
+
+def _handle_missing_locations(
+    frame: pd.DataFrame,
+    missing_locations: set,
+    actual_locations: set,
+    strategy: str,
+    all_datasets_df: pd.DataFrame = None,
+    global_lookup: dict = None,
+) -> pd.DataFrame:
     """Handle missing locations according to specified strategy."""
     if strategy == "error":
         # Get frame context for better error message
-        origin = frame['origin'].iloc[0] if 'origin' in frame.columns and not frame.empty else "unknown"
-        h1 = frame['datasetH1'].iloc[0] if 'datasetH1' in frame.columns and not frame.empty else "unknown"
-        h2 = frame['datasetH2'].iloc[0] if 'datasetH2' in frame.columns and not frame.empty else "unknown"
-        season = frame['fluseason'].iloc[0] if 'fluseason' in frame.columns and not frame.empty else "unknown"
-        sample = frame['sample'].iloc[0] if 'sample' in frame.columns and not frame.empty else "unknown"
-        
-        raise ValueError(f"Missing required locations: {missing_locations}\n"
-                        f"Frame: {origin} (H1={h1}, H2={h2}, season={season}, sample={sample})\n"
-                        f"Available locations: {actual_locations}")
+        origin = (
+            frame["origin"].iloc[0]
+            if "origin" in frame.columns and not frame.empty
+            else "unknown"
+        )
+        h1 = (
+            frame["datasetH1"].iloc[0]
+            if "datasetH1" in frame.columns and not frame.empty
+            else "unknown"
+        )
+        h2 = (
+            frame["datasetH2"].iloc[0]
+            if "datasetH2" in frame.columns and not frame.empty
+            else "unknown"
+        )
+        season = (
+            frame["fluseason"].iloc[0]
+            if "fluseason" in frame.columns and not frame.empty
+            else "unknown"
+        )
+        sample = (
+            frame["sample"].iloc[0]
+            if "sample" in frame.columns and not frame.empty
+            else "unknown"
+        )
+
+        raise ValueError(
+            f"Missing required locations: {missing_locations}\n"
+            f"Frame: {origin} (H1={h1}, H2={h2}, season={season}, sample={sample})\n"
+            f"Available locations: {actual_locations}"
+        )
     elif strategy == "skip":
         return None
     elif strategy == "zeros":
         return _fill_missing_with_zeros(frame, missing_locations)
     elif strategy == "random":
-        return _fill_missing_with_random(frame, missing_locations, actual_locations, all_datasets_df, global_lookup)
+        return _fill_missing_with_random(
+            frame, missing_locations, actual_locations, all_datasets_df, global_lookup
+        )
 
 
-def _fill_missing_with_zeros(frame: pd.DataFrame, missing_locations: set) -> pd.DataFrame:
+def _fill_missing_with_zeros(
+    frame: pd.DataFrame, missing_locations: set
+) -> pd.DataFrame:
     """Fill missing locations with zero values for all weeks."""
     if not missing_locations:
         return frame
-        
+
     # Batch create all missing rows at once
     missing_rows = []
-    
+
     # Get metadata once and modify origin to indicate synthetic data
-    origin = frame['origin'].iloc[0] if 'origin' in frame.columns and not frame.empty else None
+    origin = (
+        frame["origin"].iloc[0]
+        if "origin" in frame.columns and not frame.empty
+        else None
+    )
     if origin:
         origin = f"{origin}[filled_zeros]"
-    
+
     metadata = {}
     if not frame.empty:
-        for col in ['datasetH1', 'datasetH2', 'fluseason', 'sample']:
+        for col in ["datasetH1", "datasetH2", "fluseason", "sample"]:
             if col in frame.columns:
                 metadata[col] = frame[col].iloc[0]
-    
+
     # Create all missing rows in batch
     # Get a reference week_enddate from existing data if available
     ref_enddate = None
-    if not frame.empty and 'week_enddate' in frame.columns:
-        ref_enddate = frame['week_enddate'].iloc[0]
-    
+    if not frame.empty and "week_enddate" in frame.columns:
+        ref_enddate = frame["week_enddate"].iloc[0]
+
     for location in missing_locations:
         for week in range(1, 54):
             missing_row = {
-                'location_code': location,
-                'season_week': week,
-                'value': 0.0,
-                'origin': origin,
-                **metadata
+                "location_code": location,
+                "season_week": week,
+                "value": 0.0,
+                "origin": origin,
+                **metadata,
             }
-            
+
             # Add week_enddate if it exists in original frame
             if ref_enddate is not None:
-                missing_row['week_enddate'] = ref_enddate
-                
+                missing_row["week_enddate"] = ref_enddate
+
             missing_rows.append(missing_row)
-    
+
     # Single concat
     if missing_rows:
         missing_df = pd.DataFrame(missing_rows)
         frame = pd.concat([frame, missing_df], ignore_index=True)
-    
+
     return frame
 
 
-def _fill_missing_with_random(frame: pd.DataFrame, missing_locations: set, 
-                            actual_locations: set, all_datasets_df: pd.DataFrame = None, 
-                            global_lookup: dict = None) -> pd.DataFrame:
+def _fill_missing_with_random(
+    frame: pd.DataFrame,
+    missing_locations: set,
+    actual_locations: set,
+    all_datasets_df: pd.DataFrame = None,
+    global_lookup: dict = None,
+) -> pd.DataFrame:
     """
     Fill missing locations with intelligent randomized data from the full dataset.
-    
+
     **RANDOMIZATION BEHAVIOR**: Each multiplied frame is processed independently.
     When location filling is needed, the process uses np.random.choice() to ensure
-    different random choices across multiplied frames, providing excellent data 
+    different random choices across multiplied frames, providing excellent data
     augmentation for training.
-    
+
     For each missing location, the fill logic runs:
     - Uses np.random.choice() to pick a random year from available years
-    - Uses np.random.choice() to pick a random sample from available samples  
+    - Uses np.random.choice() to pick a random sample from available samples
     - This ensures different random choices across multiplied frames
-    
+
     Search hierarchy for missing location fill data:
     - **Priority 1**: Same H1 dataset, different year → random year + random sample
     - **Priority 2**: Same H1 dataset, different sample → random sample from same year
     - **Priority 3**: Different H1 dataset → random H1 + random year
-    
+
     **Each multiplied frame is processed independently:**
     1. Frame 1 processing: np.random.choice() selects random data for missing locations
     2. Frame 2 processing: np.random.choice() makes NEW random selections (independent)
     3. Frame N processing: Each gets its own random selections
-    
+
     This ensures different random choices across multiplied frames, providing
     excellent data augmentation for training.
-    
+
     Example: 10 copies of round5_SigSci-SWIFT_A-2024-08-01 with missing location 11:
     - Copy 1: filled with round4_USC-SIkJalpha_B-2023-08-14/sample_15
-    - Copy 2: filled with round5_NotreDame-FRED_D-2023-08-14/sample_8  
+    - Copy 2: filled with round5_NotreDame-FRED_D-2023-08-14/sample_8
     - Copy 3: filled with round4_MOBS_NEU-GLEAM_FLU_C-2023-08-14/sample_22
     - etc. (each gets different random fill data)
     """
     if not actual_locations:
         # Fallback to zeros if no existing data
         return _fill_missing_with_zeros(frame, missing_locations)
-    
+
     # Use pre-computed global lookup for super fast access
     for location in missing_locations:
-        fill_data, fill_source = _get_fill_data_from_global_lookup(frame, location, global_lookup, actual_locations)
-        
+        fill_data, fill_source = _get_fill_data_from_global_lookup(
+            frame, location, global_lookup, actual_locations
+        )
+
         if fill_data is not None:
             # Use the fill data
-            fill_data['location_code'] = location
+            fill_data["location_code"] = location
             # Always set the origin for filled data
-            original_origin = frame['origin'].iloc[0]
-            fill_data['origin'] = f"{original_origin}[filled_{fill_source}]"
+            original_origin = frame["origin"].iloc[0]
+            fill_data["origin"] = f"{original_origin}[filled_{fill_source}]"
             frame = pd.concat([frame, fill_data], ignore_index=True)
         else:
             # Fallback to zeros if no intelligent fill is possible
             frame = _fill_missing_with_zeros(frame, {location})
-    
+
     return frame
 
 
 def _build_global_lookup_table(all_datasets_df: pd.DataFrame) -> dict:
     """Pre-compute a global lookup table for all locations/years/samples - do this once."""
     print("  Building location data lookup...")
-    
+
     # Create a hierarchical lookup: location -> h1 -> priority -> data
     lookup = {}
-    
+
     # Group all data by location for fast access
-    location_groups = all_datasets_df.groupby('location_code')
-    
+    location_groups = all_datasets_df.groupby("location_code")
+
     for location, location_data in location_groups:
         lookup[location] = {}
-        
+
         # Group by H1 dataset
-        h1_groups = location_data.groupby('datasetH1')
-        
+        h1_groups = location_data.groupby("datasetH1")
+
         for h1_name, h1_data in h1_groups:
-            lookup[location][h1_name] = {
-                'by_year': {},
-                'by_sample': {}
-            }
-            
+            lookup[location][h1_name] = {"by_year": {}, "by_sample": {}}
+
             # Group by year for quick year-based lookups
-            year_groups = h1_data.groupby('fluseason')
+            year_groups = h1_data.groupby("fluseason")
             for year, year_data in year_groups:
                 # Pick first unique H2/sample combination for each year to avoid duplicates
-                unique_combos = year_data.groupby(['datasetH2', 'sample']).first().reset_index()
+                unique_combos = (
+                    year_data.groupby(["datasetH2", "sample"]).first().reset_index()
+                )
                 if not unique_combos.empty:
                     first_combo = unique_combos.iloc[0]
                     specific_data = year_data[
-                        (year_data['datasetH2'] == first_combo['datasetH2']) & 
-                        (year_data['sample'] == first_combo['sample'])
+                        (year_data["datasetH2"] == first_combo["datasetH2"])
+                        & (year_data["sample"] == first_combo["sample"])
                     ]
-                    lookup[location][h1_name]['by_year'][year] = {
-                        'data': specific_data[['season_week', 'value', 'week_enddate']].copy(),
-                        'h2': first_combo['datasetH2'],
-                        'sample': first_combo['sample']
+                    lookup[location][h1_name]["by_year"][year] = {
+                        "data": specific_data[
+                            ["season_week", "value", "week_enddate"]
+                        ].copy(),
+                        "h2": first_combo["datasetH2"],
+                        "sample": first_combo["sample"],
                     }
-            
+
             # Also store by sample for sample-based lookups
-            sample_groups = h1_data.groupby(['fluseason', 'sample'])
+            sample_groups = h1_data.groupby(["fluseason", "sample"])
             for (year, sample), sample_data in sample_groups:
                 key = f"{year}_{sample}"
-                lookup[location][h1_name]['by_sample'][key] = {
-                    'data': sample_data[['season_week', 'value', 'week_enddate']].copy(),
-                    'h2': sample_data['datasetH2'].iloc[0],
-                    'year': year,
-                    'sample': sample
+                lookup[location][h1_name]["by_sample"][key] = {
+                    "data": sample_data[
+                        ["season_week", "value", "week_enddate"]
+                    ].copy(),
+                    "h2": sample_data["datasetH2"].iloc[0],
+                    "year": year,
+                    "sample": sample,
                 }
-    
+
     print(f"  Lookup table built for {len(lookup)} locations")
     return lookup
 
 
-def _get_fill_data_from_global_lookup(frame: pd.DataFrame, location: str, 
-                                     global_lookup: dict, actual_locations: set) -> tuple:
+def _get_fill_data_from_global_lookup(
+    frame: pd.DataFrame, location: str, global_lookup: dict, actual_locations: set
+) -> tuple:
     """Get fill data using pre-computed global lookup with clear search hierarchy."""
-    
+
     # If no global lookup or location not found anywhere, error
     if global_lookup is None or location not in global_lookup:
-        raise ValueError(f"Location {location} not found anywhere in the dataset. Cannot fill missing location.")
-    
+        raise ValueError(
+            f"Location {location} not found anywhere in the dataset. Cannot fill missing location."
+        )
+
     # Get frame metadata
-    current_h1 = frame['datasetH1'].iloc[0] if 'datasetH1' in frame.columns else None
-    current_season = frame['fluseason'].iloc[0] if 'fluseason' in frame.columns else None
-    current_sample = frame['sample'].iloc[0] if 'sample' in frame.columns else None
-    
+    current_h1 = frame["datasetH1"].iloc[0] if "datasetH1" in frame.columns else None
+    current_season = (
+        frame["fluseason"].iloc[0] if "fluseason" in frame.columns else None
+    )
+    current_sample = frame["sample"].iloc[0] if "sample" in frame.columns else None
+
     location_lookup = global_lookup[location]
-    
+
     # Search hierarchy (in order of preference):
     search_strategies = [
         # 1. Same H1, different year
-        lambda: _find_same_h1_different_year(location_lookup, current_h1, current_season),
-        # 2. Same H1, different sample 
-        lambda: _find_same_h1_different_sample(location_lookup, current_h1, current_season, current_sample),
+        lambda: _find_same_h1_different_year(
+            location_lookup, current_h1, current_season
+        ),
+        # 2. Same H1, different sample
+        lambda: _find_same_h1_different_sample(
+            location_lookup, current_h1, current_season, current_sample
+        ),
         # 3. Different H1
-        lambda: _find_different_h1(location_lookup, current_h1)
+        lambda: _find_different_h1(location_lookup, current_h1),
     ]
-    
+
     # Try each strategy in order
     for strategy in search_strategies:
         result = strategy()
         if result is not None:
             return result
-    
+
     # If we get here, location exists but no valid data found
-    raise ValueError(f"Location {location} found in dataset but no valid fill data available.")
+    raise ValueError(
+        f"Location {location} found in dataset but no valid fill data available."
+    )
 
 
-def _find_same_h1_different_year(location_lookup: dict, current_h1: str, current_season: int) -> tuple:
+def _find_same_h1_different_year(
+    location_lookup: dict, current_h1: str, current_season: int
+) -> tuple:
     """Find same location from same H1 dataset but different year."""
     if current_h1 not in location_lookup:
         return None
-    
+
     h1_lookup = location_lookup[current_h1]
-    available_years = [year for year in h1_lookup['by_year'].keys() if year != current_season]
-    
+    available_years = [
+        year for year in h1_lookup["by_year"].keys() if year != current_season
+    ]
+
     if available_years:
         random_year = np.random.choice(available_years)
-        year_info = h1_lookup['by_year'][random_year]
-        data = year_info['data'].copy()
+        year_info = h1_lookup["by_year"][random_year]
+        data = year_info["data"].copy()
         source = f"same_location_year_{random_year}_sample_{year_info['sample']}"
         return data, source
-    
+
     return None
 
 
-def _find_same_h1_different_sample(location_lookup: dict, current_h1: str, 
-                                  current_season: int, current_sample: str) -> tuple:
+def _find_same_h1_different_sample(
+    location_lookup: dict, current_h1: str, current_season: int, current_sample: str
+) -> tuple:
     """Find same location from same H1 dataset but different sample."""
     if current_h1 not in location_lookup:
         return None
-    
+
     h1_lookup = location_lookup[current_h1]
     current_key = f"{current_season}_{current_sample}"
-    available_samples = [key for key, info in h1_lookup['by_sample'].items() 
-                       if key != current_key and info['year'] == current_season]
-    
+    available_samples = [
+        key
+        for key, info in h1_lookup["by_sample"].items()
+        if key != current_key and info["year"] == current_season
+    ]
+
     if available_samples:
         random_sample_key = np.random.choice(available_samples)
-        sample_info = h1_lookup['by_sample'][random_sample_key]
-        data = sample_info['data'].copy()
+        sample_info = h1_lookup["by_sample"][random_sample_key]
+        data = sample_info["data"].copy()
         source = f"same_location_sample_{sample_info['sample']}"
         return data, source
-    
+
     return None
 
 
 def _find_different_h1(location_lookup: dict, current_h1: str) -> tuple:
     """Find same location from different H1 dataset."""
     for h1_name, h1_lookup in location_lookup.items():
-        if h1_name != current_h1 and h1_lookup['by_year']:
-            available_years = list(h1_lookup['by_year'].keys())
+        if h1_name != current_h1 and h1_lookup["by_year"]:
+            available_years = list(h1_lookup["by_year"].keys())
             random_year = np.random.choice(available_years)
-            year_info = h1_lookup['by_year'][random_year]
-            data = year_info['data'].copy()
+            year_info = h1_lookup["by_year"][random_year]
+            data = year_info["data"].copy()
             source = f"same_location_{h1_name}_year_{random_year}"
             return data, source
-    
+
     return None
 
 
-def _preserve_columns(target_df: pd.DataFrame, source_df: pd.DataFrame, 
-                     location_data: pd.DataFrame) -> None:
+def _preserve_columns(
+    target_df: pd.DataFrame, source_df: pd.DataFrame, location_data: pd.DataFrame
+) -> None:
     """Preserve columns from source dataframe in target dataframe."""
     for col in source_df.columns:
         if col not in target_df.columns and not location_data.empty:
             target_df[col] = location_data[col].iloc[0]
-        elif col == 'origin' and col in target_df.columns and not location_data.empty:
+        elif col == "origin" and col in target_df.columns and not location_data.empty:
             # Special handling for origin: only overwrite if target has NaN values
             # This preserves intelligent filling origins while filling missing ones
             target_has_nan = target_df[col].isna().any()
@@ -668,39 +795,38 @@ def _preserve_columns(target_df: pd.DataFrame, source_df: pd.DataFrame,
 def _pad_single_location(frame: pd.DataFrame, location: str) -> pd.DataFrame:
     """
     Pads a location-specific epidemic time series to ensure complete weekly coverage.
-    
+
     Fills in missing weeks:
     - Weeks before first/after last observation: filled with zeros
     - Weeks between observations: filled using previous week's value
-    
+
     Args:
         frame (pd.DataFrame): DataFrame containing epidemic data for a single location
         location (str): Location identifier for the current frame
-    
+
     Returns:
         pd.DataFrame: Padded DataFrame with entries for all weeks 1-53
     """
     # Handle empty input
     if frame.empty:
         # Create empty frame for all weeks - metadata will be preserved by _preserve_columns later
-        missing_data = [{
-            "season_week": week,
-            "location_code": location,
-            "value": 0
-        } for week in range(1, 54)]
+        missing_data = [
+            {"season_week": week, "location_code": location, "value": 0}
+            for week in range(1, 54)
+        ]
         return pd.DataFrame(missing_data)
-        
+
     # Get min/max weeks if data exists
     min_week = frame["season_week"].min()
     max_week = frame["season_week"].max()
-        
+
     all_weeks = set(range(1, 54))
     missing_weeks = sorted(list(all_weeks - set(frame["season_week"])))
-    
+
     # Early return if no missing weeks
     if not missing_weeks:
         return frame.sort_values("season_week").reset_index(drop=True)
-    
+
     # Extract metadata from first row to preserve in missing rows
     metadata = {}
     if not frame.empty:
@@ -708,7 +834,7 @@ def _pad_single_location(frame: pd.DataFrame, location: str) -> pd.DataFrame:
         for col in frame.columns:
             if col not in ["season_week", "location_code", "value"]:
                 metadata[col] = first_row[col]
-        
+
     # Batch create missing rows for better performance
     missing_rows = []
     for week in missing_weeks:
@@ -717,17 +843,19 @@ def _pad_single_location(frame: pd.DataFrame, location: str) -> pd.DataFrame:
             new_value = 0  # External gaps filled with zeros
         else:
             # Internal gaps filled with previous week's value
-            previous_week = frame[frame["season_week"] == week-1]
-            new_value = previous_week["value"].values[0] if not previous_week.empty else 0
+            previous_week = frame[frame["season_week"] == week - 1]
+            new_value = (
+                previous_week["value"].values[0] if not previous_week.empty else 0
+            )
 
         missing_row = {
             "season_week": week,
             "location_code": location,
             "value": new_value,
-            **metadata  # Include all metadata from original frame
+            **metadata,  # Include all metadata from original frame
         }
         missing_rows.append(missing_row)
-    
+
     # Single concat instead of multiple
     if missing_rows:
         missing_df = pd.DataFrame(missing_rows)
@@ -736,35 +864,36 @@ def _pad_single_location(frame: pd.DataFrame, location: str) -> pd.DataFrame:
     return frame.sort_values("season_week").reset_index(drop=True)
 
 
-def _apply_frame_scaling(frame: pd.DataFrame, scaling_distribution: np.ndarray) -> pd.DataFrame:
+def _apply_frame_scaling(
+    frame: pd.DataFrame, scaling_distribution: np.ndarray
+) -> pd.DataFrame:
     """
     Apply scaling to a frame based on US peak sum scaling distribution.
-    
+
     Args:
         frame (pd.DataFrame): Complete frame with all locations and weeks
         scaling_distribution (np.ndarray): Array of peak values to scale to
-        
+
     Returns:
         pd.DataFrame: Scaled frame with updated origin tracking
     """
     # Calculate current US peak (maximum weekly sum across all locations)
-    us_weekly_sums = frame.groupby('season_week')['value'].sum()
+    us_weekly_sums = frame.groupby("season_week")["value"].sum()
     current_max = us_weekly_sums.max()
-    
+
     # Draw target peak from scaling distribution
     target_max = np.random.choice(scaling_distribution)
-    
+
     # Calculate scaling factor (handle zero peak case)
     scaling_factor = target_max / current_max if current_max > 0 else 1.0
-    
+
     # Apply scaling to all values in the frame
     frame = frame.copy()
-    frame['value'] *= scaling_factor
-    
+    frame["value"] *= scaling_factor
+
     # Update origin to track scaling
-    if 'origin' in frame.columns:
-        original_origin = frame['origin'].iloc[0]
-        frame['origin'] = f"{original_origin}[scaled_to_{target_max:.1f}]"
-    
-    return frame
+    if "origin" in frame.columns:
+        original_origin = frame["origin"].iloc[0]
+        frame["origin"] = f"{original_origin}[scaled_to_{target_max:.1f}]"
 
+    return frame
diff --git a/influpaint/datasets/read_datasources.py b/influpaint/datasets/read_datasources.py
index f60d429..77234e5 100644
--- a/influpaint/datasets/read_datasources.py
+++ b/influpaint/datasets/read_datasources.py
@@ -1,18 +1,21 @@
 import pandas as pd
 import numpy as np
-from helpers.delphi_epidata import Epidata
+
+# from helpers.delphi_epidata import Epidata
 from ..utils.season_axis import SeasonAxis
 import xarray as xr
 
 
-def extract_FluSMH_trajectories(base_path="/Users/chadi/Research/influpaint/Flusight", 
-                                        target="inc hosp", 
-                                        age_group="0-130",
-                                        min_locations=10,
-                                        season_setup=None):
+def extract_FluSMH_trajectories(
+    base_path="/Users/chadi/Research/influpaint/Flusight",
+    target="inc hosp",
+    age_group="0-130",
+    min_locations=10,
+    season_setup=None,
+):
     """
     Extract trajectories from flu scenario modeling hub archive data.
-    
+
     Parameters:
     -----------
     base_path : str
@@ -23,7 +26,7 @@ def extract_FluSMH_trajectories(base_path="/Users/chadi/Research/influpaint/Flus
         Age group to extract (default: "0-130")
     min_locations : int
         Minimum number of locations required (to filter out state-only models)
-        
+
     Returns:
     --------
     dict
@@ -33,169 +36,216 @@ def extract_FluSMH_trajectories(base_path="/Users/chadi/Research/influpaint/Flus
     import pandas as pd
     import numpy as np
     from pathlib import Path
-    
+
     trajectory_data = {}
-    
+
     # Process both rounds
     for round_num in [4, 5]:
-        round_path = Path(base_path) / f"flu-scenario-modeling-hub_archive-round{round_num}" / "data-processed"
-        
+        round_path = (
+            Path(base_path)
+            / f"flu-scenario-modeling-hub_archive-round{round_num}"
+            / "data-processed"
+        )
+
         if not round_path.exists():
             print(f"Warning: Round {round_num} path does not exist: {round_path}")
             continue
-            
+
         print(f"\n=== Processing Round {round_num} ===")
-        
+
         # Find all team-model directories
-        team_model_dirs = [d for d in round_path.iterdir() if d.is_dir() and not d.name.startswith('.')]
-        
+        team_model_dirs = [
+            d for d in round_path.iterdir() if d.is_dir() and not d.name.startswith(".")
+        ]
+
         for team_model_dir in team_model_dirs:
             team_model_name = team_model_dir.name
-            
+
             # Skip example models and non-team directories
-            if team_model_name in ['MyTeam-MyModel']:
+            if team_model_name in ["MyTeam-MyModel"]:
                 continue
-                
+
             print(f"Processing {team_model_name}...", end=" ")
-            
+
             # Find parquet files in this directory
-            parquet_files = list(team_model_dir.glob("*.parquet")) + list(team_model_dir.glob("*.gz.parquet"))
-            
+            parquet_files = list(team_model_dir.glob("*.parquet")) + list(
+                team_model_dir.glob("*.gz.parquet")
+            )
+
             if not parquet_files:
                 print(f"❌ No parquet files found")
                 continue
-            
+
             # Try to find a file with trajectories (sample output type)
             trajectory_file = None
             for parquet_file in parquet_files:
                 try:
                     # Quick check if this file has trajectories
-                    df_sample = pd.read_parquet(parquet_file, columns=['output_type'])
-                    if 'sample' in df_sample['output_type'].values:
+                    df_sample = pd.read_parquet(parquet_file, columns=["output_type"])
+                    if "sample" in df_sample["output_type"].values:
                         trajectory_file = parquet_file
                         break
                 except Exception:
                     continue
-                    
+
             if trajectory_file is None:
                 print(f"❌ No trajectory data found")
                 continue
-            
+
             try:
                 # Read the parquet file
                 df = pd.read_parquet(trajectory_file)
-                
+
                 # Filter for trajectories (sample output type)
                 trajectory_df = df[
-                    (df['output_type'] == 'sample') & 
-                    (df['target'] == target) & 
-                    (df['age_group'] == age_group)
+                    (df["output_type"] == "sample")
+                    & (df["target"] == target)
+                    & (df["age_group"] == age_group)
                 ].copy()
-                
+
                 if trajectory_df.empty:
-                    print(f"❌ No trajectories found for target='{target}', age_group='{age_group}'")
+                    print(
+                        f"❌ No trajectories found for target='{target}', age_group='{age_group}'"
+                    )
                     continue
-                
+
                 # Check if model covers enough locations (filter out state-only models)
-                unique_locations = trajectory_df['location'].unique()
+                unique_locations = trajectory_df["location"].unique()
                 if len(unique_locations) < min_locations:
-                    print(f"❌ Only {len(unique_locations)} locations (need ≥{min_locations})")
+                    print(
+                        f"❌ Only {len(unique_locations)} locations (need ≥{min_locations})"
+                    )
                     continue
-                
+
                 # Create composite trajectory ID from available columns
                 trajectory_id_parts = []
-                
+
                 # Add run_grouping if available
-                if 'run_grouping' in trajectory_df.columns:
-                    trajectory_id_parts.append(trajectory_df['run_grouping'].fillna('NA').astype(str))
-                
+                if "run_grouping" in trajectory_df.columns:
+                    trajectory_id_parts.append(
+                        trajectory_df["run_grouping"].fillna("NA").astype(str)
+                    )
+
                 # Add output_type_id if available and not all null
-                if 'output_type_id' in trajectory_df.columns and trajectory_df['output_type_id'].notna().any():
-                    trajectory_id_parts.append(trajectory_df['output_type_id'].fillna('NA').astype(str))
-                elif 'output_type_id' in trajectory_df.columns:
+                if (
+                    "output_type_id" in trajectory_df.columns
+                    and trajectory_df["output_type_id"].notna().any()
+                ):
+                    trajectory_id_parts.append(
+                        trajectory_df["output_type_id"].fillna("NA").astype(str)
+                    )
+                elif "output_type_id" in trajectory_df.columns:
                     # If output_type_id exists but is all null, add 'NA'
-                    trajectory_id_parts.append('NA')
-                
+                    trajectory_id_parts.append("NA")
+
                 # Add stochastic_run if available
-                if 'stochastic_run' in trajectory_df.columns:
-                    trajectory_id_parts.append(trajectory_df['stochastic_run'].fillna('NA').astype(str))
-                
+                if "stochastic_run" in trajectory_df.columns:
+                    trajectory_id_parts.append(
+                        trajectory_df["stochastic_run"].fillna("NA").astype(str)
+                    )
+
                 # Create composite trajectory ID
                 if trajectory_id_parts:
-                    trajectory_df['trajectory_id'] = trajectory_id_parts[0]
+                    trajectory_df["trajectory_id"] = trajectory_id_parts[0]
                     for part in trajectory_id_parts[1:]:
-                        trajectory_df['trajectory_id'] = trajectory_df['trajectory_id'] + '_' + part
-                    trajectory_id_col = 'trajectory_id'
+                        trajectory_df["trajectory_id"] = (
+                            trajectory_df["trajectory_id"] + "_" + part
+                        )
+                    trajectory_id_col = "trajectory_id"
                 else:
                     print(f"❌ No valid trajectory ID columns found")
                     continue
-                
+
                 # Convert trajectories to DataFrame format by scenario (optimized)
                 scenario_dfs = {}
-                
-                for scenario_id in trajectory_df['scenario_id'].unique():
-                    scenario_data = trajectory_df[trajectory_df['scenario_id'] == scenario_id].copy()
-                    
+
+                for scenario_id in trajectory_df["scenario_id"].unique():
+                    scenario_data = trajectory_df[
+                        trajectory_df["scenario_id"] == scenario_id
+                    ].copy()
+
                     # Vectorized processing - much faster than looping
                     # Create week_enddate from origin_date + horizon
-                    scenario_data['week_enddate'] = pd.to_datetime(scenario_data['origin_date']) + pd.to_timedelta(scenario_data['horizon'], unit='W')
-                    
+                    scenario_data["week_enddate"] = pd.to_datetime(
+                        scenario_data["origin_date"]
+                    ) + pd.to_timedelta(scenario_data["horizon"], unit="W")
+
                     # Add sample identifier (use the trajectory ID as sample)
-                    scenario_data['sample'] = scenario_data[trajectory_id_col].astype(str)
-                    
+                    scenario_data["sample"] = scenario_data[trajectory_id_col].astype(
+                        str
+                    )
+
                     # Rename location column to match expected format
-                    scenario_data = scenario_data.rename(columns={'location': 'location_code'})
-                    
+                    scenario_data = scenario_data.rename(
+                        columns={"location": "location_code"}
+                    )
+
                     # Select needed columns including trajectory ID components
-                    columns_to_keep = ['week_enddate', 'location_code', 'sample', 'value']
-                    
+                    columns_to_keep = [
+                        "week_enddate",
+                        "location_code",
+                        "sample",
+                        "value",
+                    ]
+
                     # Add trajectory ID components if they exist
-                    if 'run_grouping' in scenario_data.columns:
-                        columns_to_keep.append('run_grouping')
-                    if 'output_type_id' in scenario_data.columns:
-                        columns_to_keep.append('output_type_id')
-                    if 'stochastic_run' in scenario_data.columns:
-                        columns_to_keep.append('stochastic_run')
-                    
+                    if "run_grouping" in scenario_data.columns:
+                        columns_to_keep.append("run_grouping")
+                    if "output_type_id" in scenario_data.columns:
+                        columns_to_keep.append("output_type_id")
+                    if "stochastic_run" in scenario_data.columns:
+                        columns_to_keep.append("stochastic_run")
+
                     scenario_df = scenario_data[columns_to_keep].copy()
-                    
+
                     # Add season columns using season_setup if provided
                     if season_setup is not None:
                         from season_axis import add_season_columns
-                        scenario_df = add_season_columns(scenario_df, season_setup, do_fluseason_year=False)
-                    
+
+                        scenario_df = add_season_columns(
+                            scenario_df, season_setup, do_fluseason_year=False
+                        )
+
                     scenario_dfs[scenario_id] = scenario_df
-                    
-                    n_trajectories = scenario_df['sample'].nunique()
-                    n_timepoints = scenario_df.groupby('sample')['week_enddate'].nunique().mean()
-                
+
+                    n_trajectories = scenario_df["sample"].nunique()
+                    n_timepoints = (
+                        scenario_df.groupby("sample")["week_enddate"].nunique().mean()
+                    )
+
                 # Store scenario DataFrames
                 if scenario_dfs:
                     key = f"round{round_num}_{team_model_name}"
                     trajectory_data[key] = scenario_dfs
-                    
-                    total_trajectories = sum(df['sample'].nunique() for df in scenario_dfs.values())
-                    print(f"✅ {total_trajectories} trajectories across {len(scenario_dfs)} scenarios")
+
+                    total_trajectories = sum(
+                        df["sample"].nunique() for df in scenario_dfs.values()
+                    )
+                    print(
+                        f"✅ {total_trajectories} trajectories across {len(scenario_dfs)} scenarios"
+                    )
                 else:
                     print(f"❌ No valid trajectories extracted")
-                    
+
             except Exception as e:
                 print(f"❌ Error: {e}")
                 continue
-    
+
     print(f"\n=== Summary ===")
     print(f"Successfully processed {len(trajectory_data)} model-round combinations:")
     for key in sorted(trajectory_data.keys()):
         scenario_dfs = trajectory_data[key]
-        total_trajectories = sum(df['sample'].nunique() for df in scenario_dfs.values())
-        
+        total_trajectories = sum(df["sample"].nunique() for df in scenario_dfs.values())
+
         # Get unique locations and dates from first scenario (should be same across scenarios)
         first_scenario_df = next(iter(scenario_dfs.values()))
-        n_locations = first_scenario_df['location_code'].nunique()
-        n_dates = first_scenario_df['week_enddate'].nunique()
-        
-        print(f"  {key}: {len(scenario_dfs)} scenarios, {total_trajectories} trajectories, {n_locations} locations, {n_dates} dates")
-    
+        n_locations = first_scenario_df["location_code"].nunique()
+        n_dates = first_scenario_df["week_enddate"].nunique()
+
+        print(
+            f"  {key}: {len(scenario_dfs)} scenarios, {total_trajectories} trajectories, {n_locations} locations, {n_dates} dates"
+        )
+
     return trajectory_data
 
 
@@ -206,9 +256,9 @@ def get_from_epidata(
     value_col=None,
     write=True,
     download=True,
-    clean = True
+    clean=True,
 ):
-    """ 
+    """
     Read a dataset from epidata. Each dataset is a dataframe with columns:
     - 'week_enddate' (datetime)  the date of the saturday at the end of the week
     - 'location_code' (str) location name in the format used by the flusight data
@@ -220,6 +270,7 @@ def get_from_epidata(
     if dataset == "flusurv" or dataset == "fluview":
         if download:
             import epiweeks
+
             # by location otherwise queries is too big
             df_list = []
             if locations == "all":
@@ -296,12 +347,16 @@ def get_from_epidata(
             )
             # sum the values for the different regions of NY, selecting only new york:
             df_ny = df[df["location_tomerge"] == "NY"]
-            df_ny = df_ny.groupby(["week_enddate", "location_tomerge"]).sum(numeric_only=True).reset_index()
+            df_ny = (
+                df_ny.groupby(["week_enddate", "location_tomerge"])
+                .sum(numeric_only=True)
+                .reset_index()
+            )
             df = df[df["location_tomerge"] != "NY"]
             df = pd.concat([df, df_ny])
             print(" >> summing NY_albany and NY_rochester into NY")
             right_on = "abbreviation"
-        
+
         elif dataset == "fluview":
             df["location_tomerge"] = df["region"].str.upper()
             df["location_tomerge"] = df["location_tomerge"].str.replace(
@@ -311,24 +366,21 @@ def get_from_epidata(
                 "ny_minus_jfk".upper(), "NY"
             )
             right_on = "abbreviation"
-            
-
 
         elif "flusight" in dataset:
-            print(
-                "⚠️ ⚠️ ⚠️ If during season, make sure ./update_data.sh has been run"
-            )
+            print("⚠️ ⚠️ ⚠️ If during season, make sure ./update_data.sh has been run")
             df["location_tomerge"] = df["location"]
             df = df.drop(columns=["location_name"])
             right_on = "location_code"
 
         df = pd.merge(
             df,
-            season_setup.locations_df[["location_code", "location_name", "abbreviation"]],
+            season_setup.locations_df[
+                ["location_code", "location_name", "abbreviation"]
+            ],
             left_on="location_tomerge",
             right_on=right_on,
             how="outer",
-
         )
         df.drop(columns=["location_tomerge"], inplace=True)
 
@@ -342,11 +394,13 @@ def get_from_epidata(
 
     df["value"] = df[value_col]
 
-    print(f"RAW Dataset {dataset} has {len(df)} data points, with {len(df['location_code'].unique())} locations,"
-            f"and NA values: {df['value'].isna().sum()}, NA locations: {df['location_code'].isna().sum()}")
+    print(
+        f"RAW Dataset {dataset} has {len(df)} data points, with {len(df['location_code'].unique())} locations,"
+        f"and NA values: {df['value'].isna().sum()}, NA locations: {df['location_code'].isna().sum()}"
+    )
     # select only the columns we need
     if clean:
-        # remove 
+        # remove
         df = clean_dataset(df, season_setup)
 
     return df
@@ -358,8 +412,10 @@ def clean_dataset(df, season_setup):
     df = df[df["location_code"].isin(season_setup.locations)]
     # remove NaNs
     df = df.dropna(subset=["value"])
-    print(f" >>> after clean: Dataset {len(df)} data points, with {len(df['location_code'].unique())} locations,"
-            f"and NA values: {df['value'].isna().sum()}, NA locations: {df['location_code'].isna().sum()}")
+    print(
+        f" >>> after clean: Dataset {len(df)} data points, with {len(df['location_code'].unique())} locations,"
+        f"and NA values: {df['value'].isna().sum()}, NA locations: {df['location_code'].isna().sum()}"
+    )
     return df
 
 
@@ -385,5 +441,6 @@ def get_dataset_all_locations(dataset):
                 locations.append(flloc)
         return locations
     else:
-        raise NotImplementedError(f"Dataset {dataset} not implemented for getting all locations")
-    
\ No newline at end of file
+        raise NotImplementedError(
+            f"Dataset {dataset} not implemented for getting all locations"
+        )
diff --git a/influpaint/utils/converters.py b/influpaint/utils/converters.py
index e9d50ec..7282f3b 100644
--- a/influpaint/utils/converters.py
+++ b/influpaint/utils/converters.py
@@ -1,9 +1,9 @@
 import pandas as pd
 import numpy as np
-from helpers.delphi_epidata import Epidata
 from ..utils.season_axis import SeasonAxis
 import xarray as xr
 
+
 def padto64x64(x: np.ndarray) -> np.ndarray:
     return np.pad(
         x,
@@ -12,6 +12,7 @@ def padto64x64(x: np.ndarray) -> np.ndarray:
         constant_values=0,
     )
 
+
 def dataframe_to_xarray(
     df: pd.DataFrame,
     season_setup: SeasonAxis = None,
@@ -25,15 +26,17 @@ def dataframe_to_xarray(
     Convert a long form dataframe to an xarray. Dataframe must have columns:
     - location_code
     - value
-    The dataset is a xarray object stored as netcdf on disk. 
-    It has dimensions `(feature, date, place)` 
+    The dataset is a xarray object stored as netcdf on disk.
+    It has dimensions `(feature, date, place)`
     where date and place are padded to have dimension 64.
     - dates are Saturdays
     - places are location from Flusight data locations
     - samples are integers
     """
 
-    df_piv = df.reset_index(drop=False).pivot(columns="location_code", values=value_column, index=date_column)
+    df_piv = df.reset_index(drop=False).pivot(
+        columns="location_code", values=value_column, index=date_column
+    )
 
     if not isinstance(xarrax_features, list):
         xarrax_features = [xarrax_features]
@@ -72,9 +75,10 @@ def dataframe_to_xarray(
 
 
 def dataframe_to_arraylist(
-    df: pd.DataFrame, season_setup: SeasonAxis = None, value_column="value",
+    df: pd.DataFrame,
+    season_setup: SeasonAxis = None,
+    value_column="value",
 ) -> np.ndarray:
-
     samples = []
 
     df_piv = df.pivot(
@@ -83,9 +87,9 @@ def dataframe_to_arraylist(
         index=["fluseason", "season_week"],
     )
     for season in df_piv.index.unique(level="fluseason"):
-        array = df_piv.loc[season][
-            season_setup.locations
-        ].sort_index().to_numpy()  # make sure order is right w.r.t season_setup locations and the time is right
+        array = (
+            df_piv.loc[season][season_setup.locations].sort_index().to_numpy()
+        )  # make sure order is right w.r.t season_setup locations and the time is right
         # TODO: should give an error when dates are missing because it would be missaligned
 
         array[np.isnan(array)] = 0  # replace NaNs with 0
@@ -94,4 +98,4 @@ def dataframe_to_arraylist(
             np.array([padto64x64(array)])
         )  # pad to 64x64 and add a dimension for channel
 
-    return samples
\ No newline at end of file
+    return samples
diff --git a/influpaint/utils/ground_truth.py b/influpaint/utils/ground_truth.py
index 7b12757..a97a802 100644
--- a/influpaint/utils/ground_truth.py
+++ b/influpaint/utils/ground_truth.py
@@ -22,263 +22,530 @@
 
 def pad_dataframe(df, season_setup):
     # Make sure gt_df and gt_df_final have values (even if NaN) for all dates in the season
-    date_range = pd.date_range(start=df.week_enddate.min(), periods=52, freq='W-SAT')
+    date_range = pd.date_range(start=df.week_enddate.min(), periods=52, freq="W-SAT")
     locations = df.location_code.unique()
     # Create expanded dataframe with all combinations of dates and locations
-    expanded_df = pd.DataFrame([(d, l) for d in date_range for l in locations],
-                            columns=['week_enddate', 'location_code'])
+    expanded_df = pd.DataFrame(
+        [(d, l) for d in date_range for l in locations],
+        columns=["week_enddate", "location_code"],
+    )
 
     # Calculate the season columns
-    expanded_df['fluseason'] = expanded_df.week_enddate.apply(season_setup.get_fluseason_year)
-    expanded_df['fluseason_fraction'] = expanded_df.week_enddate.apply(season_setup.get_fluseason_fraction)
-    expanded_df['season_week'] = expanded_df.week_enddate.apply(season_setup.get_season_week)
+    expanded_df["fluseason"] = expanded_df.week_enddate.apply(
+        season_setup.get_fluseason_year
+    )
+    expanded_df["fluseason_fraction"] = expanded_df.week_enddate.apply(
+        season_setup.get_fluseason_fraction
+    )
+    expanded_df["season_week"] = expanded_df.week_enddate.apply(
+        season_setup.get_season_week
+    )
 
     # Merge with original data to get values where they exist
     padded_df = expanded_df.merge(
-        df[['week_enddate', 'location_code', 'value']], 
-        on=['week_enddate', 'location_code'], 
-        how='left'
+        df[["week_enddate", "location_code", "value"]],
+        on=["week_enddate", "location_code"],
+        how="left",
     )
     return padded_df
 
 
-class GroundTruth():
-    def __init__(self, season_first_year: str, 
-                data_date: datetime.datetime, 
-                mask_date: datetime.datetime, 
-                from_final_data:bool=False, 
-                channels=1, 
-                image_size=64, 
-                nogit=False, 
-                payload=None, 
-                payload_season_first_year=None,
-                dataset_coords: xr.core.coordinates.DataArrayCoordinates=None): 
+class GroundTruth:
+    def __init__(
+        self,
+        season_first_year: str,
+        gt_df: pd.DataFrame,
+        gt_df_final: pd.DataFrame,
+        mask_date: datetime.datetime,
+        season_setup: SeasonAxis,
+        channels=1,
+        image_size=64,
+        previous_data=None,
+        dataset_coords: xr.core.coordinates.DataArrayCoordinates = None,
+    ):
         self.season_first_year = season_first_year
-        self.data_date = data_date
-        self.mask_date = mask_date
+        self.mask_date = pd.to_datetime(mask_date)
         self.channels = channels
-        self.image_size=image_size
-
+        self.image_size = image_size
+        self.season_setup = season_setup
+
+        self.gt_df = gt_df
+        self.gt_df_final = gt_df_final
+
+        if previous_data is None:
+            previous_data = []
+        if isinstance(previous_data, list):
+            previous_data = (
+                pd.concat(previous_data, ignore_index=True)
+                if previous_data
+                else pd.DataFrame()
+            )
+        self.previous_data = previous_data
 
-        if not nogit: self.git_checkout_data_rev(target_date=None)
-
-        self.season_setup = SeasonAxis.for_flusight(remove_territories=True, remove_us=True)
-
-        flusight = read_datasources.get_from_epidata(dataset=f"flusight{self.season_first_year}", season_setup=self.season_setup, write=False)
-        flusight = self.season_setup.add_season_columns(flusight, do_fluseason_year=True)
-        gt_df_final = flusight[flusight["fluseason"] == int(self.season_first_year)]
+        if dataset_coords is not None:
+            # change the flusetup locations to be in the same order as flu_payload_array.coords["place"]
+            self.season_setup.reorder_locations(list(dataset_coords["place"].values))
 
-        if from_final_data:
-            gt_df = gt_df_final.copy()
-        else:
-            if not nogit: self.git_checkout_data_rev(target_date=data_date)
-            flusight = read_datasources.get_from_epidata(dataset=f"flusight{self.season_first_year}", season_setup=self.season_setup, write=False)
-            flusight = self.season_setup.add_season_columns(flusight, do_fluseason_year=True)
-            gt_df = flusight[flusight["fluseason"] == int(self.season_first_year)]   
-            if not nogit: self.git_checkout_data_rev(target_date=None)
-
-        
-        self.gt_df = gt_df[gt_df["location_code"].isin(self.season_setup.locations)]
-        self.gt_df_final = gt_df_final[gt_df_final["location_code"].isin(self.season_setup.locations)]
-        
-        # generates past data
-        past_data_1 = read_datasources.get_from_epidata(dataset=f"flusight2024", season_setup=self.season_setup, write=False)
-        past_data_2 = read_datasources.get_from_epidata(dataset=f"flusight2024", season_setup=self.season_setup, write=False)
-        
-        # Add season columns to past data
-        past_data_1 = self.season_setup.add_season_columns(past_data_1, do_fluseason_year=True)
-        past_data_2 = self.season_setup.add_season_columns(past_data_2, do_fluseason_year=True)
-        
-        self.previous_data = [past_data_1, past_data_2]
-        
+        self.gt_df = self.gt_df[
+            self.gt_df["location_code"].isin(self.season_setup.locations)
+        ]
+        self.gt_df_final = self.gt_df_final[
+            self.gt_df_final["location_code"].isin(self.season_setup.locations)
+        ]
 
+        if not self.previous_data.empty:
+            self.previous_data = self.season_setup.add_season_columns(
+                self.previous_data, do_fluseason_year=True
+            )
 
         self.gt_df = pad_dataframe(self.gt_df, self.season_setup)
         self.gt_df_final = pad_dataframe(self.gt_df_final, self.season_setup)
 
-        last_non_nan_datadate = self.gt_df.week_enddate[self.gt_df.value.notna()].max().to_pydatetime()
+        last_non_nan_datadate = (
+            self.gt_df.week_enddate[self.gt_df.value.notna()].max().to_pydatetime()
+        )
         # If the last data_point is not in the last week, we need to update the mask to be in the week after the last data point
         if self.mask_date > last_non_nan_datadate + datetime.timedelta(days=7):
             self.mask_date = last_non_nan_datadate + datetime.timedelta(days=2)
-            print(f" WARNING: mask_date is after last non-NaN data date, setting mask_date to {self.mask_date}")
-
-
-        if payload is not None:
-            if payload_season_first_year is None:
-                payload_season_first_year = season_first_year
-            import dataset_mixer
-            payload = self.season_setup.add_season_columns(payload, do_fluseason_year=True)
-            this_payload = payload[payload["fluseason"] == int(payload_season_first_year)]
-            self.gt_df = pd.concat([self.gt_df, this_payload], ignore_index=True)
-            self.gt_df_final = pd.concat([self.gt_df_final, this_payload], ignore_index=True)
-            self.previous_data.append(payload)
-            location_codes = self.gt_df.location_code.unique()
-            new_locations = pd.DataFrame({"location_code": sorted(location_codes)})
-            # Ensure location_code is of type string
-            new_locations['location_code'] = new_locations['location_code'].astype(str)
-            # Merge with season_setup.locations_df to get the location names
-            new_locations = new_locations.merge(self.season_setup.locations_df, 
-                                                on='location_code',
-                                                how='left')
-
-            # Fill missing location names with the location code
-            new_locations['location_name'] = new_locations['location_name'].fillna(new_locations['location_code'])
-            new_locations = new_locations[['location_code', 'location_name']]
-            self.season_setup.update_locations(new_locations)
-
-        if dataset_coords is not None:
-            # change the flusetup locations to be in the same order as flu_payload_array.coords["place"]
-            self.season_setup.reorder_locations(list(dataset_coords["place"].values))
-
-        # Concatenate all previous data and ensure it has season columns
-        self.previous_data = pd.concat(self.previous_data, ignore_index=True).drop_duplicates()
-        self.previous_data = self.season_setup.add_season_columns(self.previous_data, do_fluseason_year=True)
-
-        self.gt_xarr = converters.dataframe_to_xarray(self.gt_df, season_setup=self.season_setup, 
-            xarray_name = "gt_flusight_incidHosp", 
-            xarrax_features = "incidHosp")
-        
-        self.gt_final_xarr = converters.dataframe_to_xarray(self.gt_df_final, season_setup=self.season_setup, 
-            xarray_name = "gt_flusight_incidHos_final", 
-            xarrax_features = "incidHosp")
+            print(
+                f" WARNING: mask_date is after last non-NaN data date, setting mask_date to {self.mask_date}"
+            )
+
+        self.gt_xarr = converters.dataframe_to_xarray(
+            self.gt_df,
+            season_setup=self.season_setup,
+            xarray_name="gt_flusight_incidHosp",
+            xarrax_features="incidHosp",
+            pad=True,
+        )
+
+        self.gt_final_xarr = converters.dataframe_to_xarray(
+            self.gt_df_final,
+            season_setup=self.season_setup,
+            xarray_name="gt_flusight_incidHos_final",
+            xarrax_features="incidHosp",
+            pad=True,
+        )
 
         # Find the largest index of the data dates that are before the mask date
-        dates = pd.to_datetime(self.gt_xarr.coords['date'].values)
+        dates = pd.to_datetime(self.gt_xarr.coords["date"].values)
         self.inpaintfrom_idx = sum(dates < self.mask_date)
 
-        self.gt_keep_mask = np.ones((channels,image_size,image_size))
-        self.gt_keep_mask[:,self.inpaintfrom_idx:,:] = 0
-        
-        print(f"Masking, >> {self.inpaintfrom_idx} weeks already in data, inpainting the next ones")
+        self.gt_keep_mask = np.ones((channels, image_size, image_size))
+        self.gt_keep_mask[:, self.inpaintfrom_idx :, :] = 0
+
+        print(
+            f"Masking, >> {self.inpaintfrom_idx} weeks already in data, inpainting the next ones"
+        )
 
-    
-    def git_checkout_data_rev(self, target_date=None):
+    @staticmethod
+    def _git_checkout_repo_rev(repo_path, target_date=None, main_branch="main"):
         import pygit2
-        if self.season_first_year == "2023":
-            repo_path = "Flusight/2023-2024/FluSight-forecast-hub-official/"
-            main_branch = "main"
-        elif self.season_first_year == "2022":
-            repo_path = "Flusight/2022-2023/FluSight-forecast-hub-official/"
-            main_branch = "master"
-        elif self.season_first_year == "2024":
-            repo_path = "Flusight/2024-2025/FluSight-forecast-hub-official/"
-            main_branch = "main"
-        print(repo_path)
-
-        # Open the existing repository
+
         repo = pygit2.Repository(repo_path)
 
         if target_date is not None:
-            # Find the commit closest to the target date
             closest_commit = None
             for commit in repo.walk(repo.head.target, pygit2.GIT_SORT_TIME):
                 if commit.commit_time <= target_date.timestamp():
                     closest_commit = commit
                     break
 
-            # Check out the commit
             if closest_commit:
                 repo.checkout_tree(closest_commit.tree)
                 repo.set_head(closest_commit.id)
-                print(f"Checked out commit on {target_date} (SHA: {closest_commit.id}, {commit.commit_time}) for repo {repo_path}")
+                print(
+                    f"Checked out commit on {target_date} (SHA: {closest_commit.id}, {commit.commit_time}) for repo {repo_path}"
+                )
             else:
-                print("ERROR: No commit found for the specified date on repo {repo_path}.")
+                print(
+                    f"ERROR: No commit found for the specified date on repo {repo_path}."
+                )
         else:
-            repo.checkout("refs/heads/" + main_branch)      
+            repo.checkout("refs/heads/" + main_branch)
             print(f"Restored git repo {repo_path}")
 
+    @staticmethod
+    def _flusight_repo_info(season_first_year: str):
+        if season_first_year == "2023":
+            return "Flusight/2023-2024/FluSight-forecast-hub-official/", "main"
+        if season_first_year == "2022":
+            return "Flusight/2022-2023/FluSight-forecast-hub-official/", "master"
+        if season_first_year == "2024":
+            return "Flusight/2024-2025/FluSight-forecast-hub-official/", "main"
+        if season_first_year == "2025":
+            return "Flusight/2024-2025/FluSight-forecast-hub-official/", "main"
+        raise ValueError(f"Unsupported FluSight season_first_year: {season_first_year}")
+
+    @classmethod
+    def for_flusight(
+        cls,
+        season_first_year: str,
+        data_date: datetime.datetime,
+        mask_date: datetime.datetime,
+        from_final_data: bool = False,
+        channels=1,
+        image_size=64,
+        nogit=False,
+        payload=None,
+        payload_season_first_year=None,
+        dataset_coords: xr.core.coordinates.DataArrayCoordinates = None,
+    ):
+        data_date = pd.to_datetime(data_date)
+
+        season_setup = SeasonAxis.for_flusight(remove_us=True, remove_territories=True)
+
+        flusight = pd.read_parquet(
+            "https://raw.githubusercontent.com/CDCgov/rsv-forecast-hub/main/target-data/oracle-output.parquet",
+            engine="auto",
+        )
+        flusight = flusight.rename(columns={
+            "target_end_date": "week_enddate",
+            "location": "location_code",
+            "oracle_value": "value",
+        })
+        flusight["week_enddate"] = pd.to_datetime(flusight["week_enddate"])
+        flusight = flusight[flusight["target"] == "wk inc rsv hosp"]
+        flusight = flusight.drop_duplicates(subset=["week_enddate", "location_code"])
+
+        flusight = season_setup.add_season_columns(flusight, do_fluseason_year=True)
+        gt_df_final = flusight[flusight["fluseason"] == int(season_first_year)]
+        gt_df = gt_df_final.copy()
+        previous_data = []
+
+        return cls(
+            season_first_year=season_first_year,
+            gt_df=gt_df,
+            gt_df_final=gt_df_final,
+            mask_date=mask_date,
+            season_setup=season_setup,
+            channels=channels,
+            image_size=image_size,
+            previous_data=previous_data,
+            dataset_coords=dataset_coords,
+        )
+
+    @classmethod
+    def from_metrocast(
+        cls,
+        season_first_year: str,
+        data_date: datetime.datetime,
+        mask_date: datetime.datetime,
+        channels=1,
+        image_size=128,
+        nogit=False,
+        dataset_coords: xr.core.coordinates.DataArrayCoordinates = None,
+        repo_path="Flusight/metrocast/flu-metrocast",
+        data_path="Flusight/metrocast/flu-metrocast/target-data/latest-data.csv",
+        main_branch="main",
+    ):
+        data_date = pd.to_datetime(data_date)
+        if not nogit:
+            cls._git_checkout_repo_rev(
+                repo_path, target_date=None, main_branch=main_branch
+            )
+
+        season_setup = SeasonAxis.for_metrocast()
+
+        latest_df = pd.read_csv(data_path, parse_dates=["target_end_date"])
+        latest_df = latest_df.rename(
+            columns={
+                "target_end_date": "week_enddate",
+                "location": "location_code",
+                "observation": "value",
+            }
+        )
+        latest_df["location_code"] = latest_df["location_code"].astype(str).str.strip()
+        latest_df["target"] = latest_df["target"].astype(str).str.strip()
+
+        flu_df = latest_df[latest_df["target"] == "Flu ED visits pct"].copy()
+        ili_df = latest_df[latest_df["target"] == "ILI ED visits pct"].copy()
+
+        # Combine both targets: use Flu ED visits pct when available, fill gaps with ILI ED visits pct.
+        flu_key = flu_df[["week_enddate", "location_code"]].drop_duplicates()
+        ili_fill = ili_df.merge(
+            flu_key, on=["week_enddate", "location_code"], how="left", indicator=True
+        )
+        ili_fill = ili_fill[ili_fill["_merge"] == "left_only"].drop(columns="_merge")
+
+        flu_df["target_source"] = "Flu ED visits pct"
+        ili_fill["target_source"] = "ILI ED visits pct"
+        latest_df = pd.concat([flu_df, ili_fill], ignore_index=True)
+
+        full_df = season_setup.add_season_columns(latest_df, do_fluseason_year=True)
+        gt_df_final = full_df[full_df["fluseason"] == int(season_first_year)]
+
+        if not nogit:
+            cls._git_checkout_repo_rev(
+                repo_path, target_date=data_date, main_branch=main_branch
+            )
+            latest_df = pd.read_csv(data_path, parse_dates=["target_end_date"])
+            latest_df = latest_df.rename(
+                columns={
+                    "target_end_date": "week_enddate",
+                    "location": "location_code",
+                    "observation": "value",
+                }
+            )
+            latest_df["location_code"] = (
+                latest_df["location_code"].astype(str).str.strip()
+            )
+            latest_df["target"] = latest_df["target"].astype(str).str.strip()
+
+            flu_df = latest_df[latest_df["target"] == "Flu ED visits pct"].copy()
+            ili_df = latest_df[latest_df["target"] == "ILI ED visits pct"].copy()
+
+            flu_key = flu_df[["week_enddate", "location_code"]].drop_duplicates()
+            ili_fill = ili_df.merge(
+                flu_key,
+                on=["week_enddate", "location_code"],
+                how="left",
+                indicator=True,
+            )
+            ili_fill = ili_fill[ili_fill["_merge"] == "left_only"].drop(
+                columns="_merge"
+            )
+
+            flu_df["target_source"] = "Flu ED visits pct"
+            ili_fill["target_source"] = "ILI ED visits pct"
+            latest_df = pd.concat([flu_df, ili_fill], ignore_index=True)
+            cls._git_checkout_repo_rev(
+                repo_path, target_date=None, main_branch=main_branch
+            )
+        full_df = season_setup.add_season_columns(latest_df, do_fluseason_year=True)
+        gt_df = full_df[full_df["fluseason"] == int(season_first_year)]
+
+        previous_data = full_df.copy()
+
+        return cls(
+            season_first_year=season_first_year,
+            gt_df=gt_df,
+            gt_df_final=gt_df_final,
+            mask_date=mask_date,
+            season_setup=season_setup,
+            channels=channels,
+            image_size=image_size,
+            previous_data=previous_data,
+            dataset_coords=dataset_coords,
+        )
+
     def plot(self):
-        season_start_date = datetime.date(int(self.season_first_year), self.season_setup.season_start_month, self.season_setup.season_start_day)
-        fig, axes = plt.subplots(8, 8, sharex=True, figsize=(14,16))
-        gt_piv  = self.gt_df.pivot(index = "week_enddate", columns='location_code', values='value')
-        gt_piv_final = self.gt_df_final.pivot(index = "week_enddate", columns='location_code', values='value')
-        ax = axes.flat[0]
-        ax.plot(gt_piv[self.season_setup.locations].sum(axis=1), color="black", linewidth=2,label="datadate")
-        ax.plot(gt_piv_final[self.season_setup.locations].sum(axis=1), lw=1, color='r', ls='-.', label="final")
+        season_start_date = datetime.date(
+            int(self.season_first_year),
+            self.season_setup.season_start_month,
+            self.season_setup.season_start_day,
+        )
+        n_locations = len(self.season_setup.locations)
+        n_plots = n_locations + 1  # include US aggregate
+        n_cols = math.ceil(math.sqrt(n_plots))
+        n_rows = math.ceil(n_plots / n_cols)
+        fig, axes = plt.subplots(
+            n_rows,
+            n_cols,
+            sharex=True,
+            figsize=(max(8, n_cols * 2.2), max(8, n_rows * 2.0)),
+        )
+        gt_piv = self.gt_df.pivot(
+            index="week_enddate", columns="location_code", values="value"
+        )
+        gt_piv_final = self.gt_df_final.pivot(
+            index="week_enddate", columns="location_code", values="value"
+        )
+        axes_flat = np.atleast_1d(axes).flat
+        ax = axes_flat[0]
+        ax.plot(
+            gt_piv[self.season_setup.locations].sum(axis=1),
+            color="black",
+            linewidth=2,
+            label="datadate",
+        )
+        ax.plot(
+            gt_piv_final[self.season_setup.locations].sum(axis=1),
+            lw=1,
+            color="r",
+            ls="-.",
+            label="final",
+        )
         ax.legend()
         ax.set_ylim(0)
         ax.set_title("US")
         for idx, pl in enumerate(gt_piv.columns):
-            ax = axes.flat[idx+1]
-            ax.plot(gt_piv[pl], lw=2, color='k')
-            ax.plot(gt_piv_final[pl], lw=1, color='r', ls='-.')
+            if idx + 1 >= n_plots:
+                break
+            ax = axes_flat[idx + 1]
+            ax.plot(gt_piv[pl], lw=2, color="k")
+            ax.plot(gt_piv_final[pl], lw=1, color="r", ls="-.")
             na_mask = gt_piv.isna()
-            ax.plot(gt_piv[na_mask].index,
-                    gt_piv[na_mask],
-                    marker='o', 
-                    color="pink",
-                    fillstyle='full', 
-                    markeredgecolor='red', 
-                    markersize=5,
-                    markeredgewidth=1)
+            ax.plot(
+                gt_piv[na_mask].index,
+                gt_piv[na_mask],
+                marker="o",
+                color="pink",
+                fillstyle="full",
+                markeredgecolor="red",
+                markersize=5,
+                markeredgewidth=1,
+            )
             ax.set_title(self.season_setup.get_location_name(pl))
-            #ax.grid()
+            # ax.grid()
             ax.set_ylim(0)
-            ax.set_xlim(season_start_date, season_start_date + datetime.timedelta(days=365))
-            #ax.set_xticks(season_setup.get_dates(52).resample("M"))
-            #ax.plot(pd.date_range(season_setup.fluseason_startdate, season_setup.fluseason_startdate + datetime.timedelta(days=64*7), freq="W-SAT"), data.flu_dyn[-50:,0,:,idx].T, c='r', lw=.5, alpha=.2)
+            ax.set_xlim(
+                season_start_date, season_start_date + datetime.timedelta(days=365)
+            )
+            # ax.set_xticks(season_setup.get_dates(52).resample("M"))
+            # ax.plot(pd.date_range(season_setup.fluseason_startdate, season_setup.fluseason_startdate + datetime.timedelta(days=64*7), freq="W-SAT"), data.flu_dyn[-50:,0,:,idx].T, c='r', lw=.5, alpha=.2)
+        for extra_ax in list(axes_flat)[n_plots:]:
+            extra_ax.set_visible(False)
         fig.tight_layout()
         fig.autofmt_xdate()
 
+    def _get_historical_series(self, location_code):
+        if self.previous_data is None or self.previous_data.empty:
+            return []
+
+        if "season_week" not in self.previous_data.columns:
+            self.previous_data = self.season_setup.add_season_columns(
+                self.previous_data, do_fluseason_year=True
+            )
+
+        calendar = self.season_setup.get_season_calendar(int(self.season_first_year))
+        calendar = calendar[["season_week", "saturday"]]
+
+        hist = self.previous_data[
+            self.previous_data["location_code"] == location_code
+        ].copy()
+        if hist.empty:
+            return []
+
+        series = []
+        for hist_season in sorted(hist["fluseason"].dropna().unique()):
+            if int(hist_season) == int(self.season_first_year):
+                continue
+            season_data = hist[hist["fluseason"] == hist_season][
+                ["season_week", "value"]
+            ].dropna()
+            if season_data.empty:
+                continue
+            season_data = season_data.groupby("season_week", as_index=False)[
+                "value"
+            ].mean()
+            season_data = season_data.merge(
+                calendar, on="season_week", how="inner"
+            ).sort_values("season_week")
+            if season_data.empty:
+                continue
+            series.append(
+                (
+                    hist_season,
+                    pd.to_datetime(season_data["saturday"]).to_numpy(),
+                    season_data["value"].to_numpy(),
+                )
+            )
+        return series
+
     def plot_mask(self):
         # check that it stitch
-        fig, axes = plt.subplots(1, 4, figsize=(8,8), dpi=200, sharex=True, sharey=True)
+        fig, axes = plt.subplots(
+            1, 4, figsize=(8, 8), dpi=200, sharex=True, sharey=True
+        )
         import matplotlib as mpl
-        cmap_greys = mpl.colormaps.get_cmap('Greys')
+
+        cmap_greys = mpl.colormaps.get_cmap("Greys")
         cmap_rainbow = mpl.colormaps.get_cmap("rainbow")
-        cmap_greys.set_bad(color='red')
-        cmap_rainbow.set_bad(color='red')
+        cmap_greys.set_bad(color="red")
+        cmap_rainbow.set_bad(color="red")
         axes[0].imshow(self.gt_xarr.data[0], cmap=cmap_greys)
         axes[0].set_title("Current data rev", fontsize=8)
 
-        axes[1].imshow(self.gt_keep_mask[0], alpha=.3, cmap = cmap_rainbow)
+        axes[1].imshow(self.gt_keep_mask[0], alpha=0.3, cmap=cmap_rainbow)
         axes[1].set_title("Inpainting mask", fontsize=8)
-        
-
 
         axes[2].imshow(self.gt_xarr.data[0], cmap=cmap_greys)
-        axes[2].imshow(self.gt_keep_mask[0], alpha=.3, cmap = cmap_rainbow)
+        axes[2].imshow(self.gt_keep_mask[0], alpha=0.3, cmap=cmap_rainbow)
         axes[3].set_title("Current data rev", fontsize=8)
 
         axes[3].imshow(self.gt_final_xarr.data[0], cmap=cmap_greys)
-        axes[3].imshow(self.gt_keep_mask[0], alpha=.3, cmap = cmap_rainbow)
+        axes[3].imshow(self.gt_keep_mask[0], alpha=0.3, cmap=cmap_rainbow)
         axes[3].set_title("Final data", fontsize=8)
 
-    def export_forecasts(self, fluforecasts_ti, forecasts_national, directory=".", prefix="", forecast_date=None, save_plot=True, nochecks=False):
-        forecast_date_str=str(forecast_date)
+    def export_forecasts(
+        self,
+        fluforecasts_ti,
+        forecasts_national,
+        directory=".",
+        prefix="",
+        forecast_date=None,
+        save_plot=True,
+        nochecks=False,
+    ):
+        forecast_date_str = str(forecast_date)
         if forecast_date == None:
             forecast_date = self.mask_date
 
         # Calculate season start date for date range calculations
-        season_start_date = datetime.date(int(self.season_first_year), self.season_setup.season_start_month, self.season_setup.season_start_day)
+        season_start_date = datetime.date(
+            int(self.season_first_year),
+            self.season_setup.season_start_month,
+            self.season_setup.season_start_day,
+        )
 
-        target_dates = pd.date_range(forecast_date, forecast_date + datetime.timedelta(days=4*7), freq="W-SAT")
+        target_dates = pd.date_range(
+            forecast_date, forecast_date + datetime.timedelta(days=4 * 7), freq="W-SAT"
+        )
 
-        target_dict= dict(zip(
-            target_dates, 
-            [f"{n} wk ahead inc flu hosp" for n in range(1,5)]))
+        target_dict = dict(
+            zip(target_dates, [f"{n} wk ahead inc flu hosp" for n in range(1, 5)])
+        )
 
         print(target_dates)
-        #pd.DataFrame(colums=["forecast_date","target_end_date","location","type","quantile","value","target"])
-        df_list=[]
+        # pd.DataFrame(colums=["forecast_date","target_end_date","location","type","quantile","value","target"])
+        df_list = []
         for qt in myutils.flusight_quantiles:
-            a =  pd.DataFrame(np.quantile(fluforecasts_ti[:,:,:,:len(self.season_setup.locations)], qt, axis=0)[0], 
-                    columns= self.season_setup.locations, index=pd.date_range(season_start_date, season_start_date + datetime.timedelta(days=64*7), freq="W-SAT")).loc[target_dates]
-            #a["US"] = a.sum(axis=1)
-            a["US"] = pd.DataFrame(np.quantile(forecasts_national, qt, axis=0)[0],
-                    columns= ["US"], index=pd.date_range(season_start_date, season_start_date + datetime.timedelta(days=64*7), freq="W-SAT")).loc[target_dates]
-
-            a = a.reset_index().rename(columns={'index': 'target_end_date'})
-            a = pd.melt(a,id_vars="target_end_date",var_name="location")
-            a["quantile"] = '{:<.3f}'.format(qt)
-            
+            a = pd.DataFrame(
+                np.quantile(
+                    fluforecasts_ti[:, :, :, : len(self.season_setup.locations)],
+                    qt,
+                    axis=0,
+                )[0],
+                columns=self.season_setup.locations,
+                index=pd.date_range(
+                    season_start_date,
+                    season_start_date + datetime.timedelta(days=self.image_size * 7),
+                    freq="W-SAT",
+                ),
+            ).loc[target_dates]
+            # a["US"] = a.sum(axis=1)
+            a["US"] = pd.DataFrame(
+                np.quantile(forecasts_national, qt, axis=0)[0],
+                columns=["US"],
+                index=pd.date_range(
+                    season_start_date,
+                    season_start_date + datetime.timedelta(days=self.image_size * 7),
+                    freq="W-SAT",
+                ),
+            ).loc[target_dates]
+
+            a = a.reset_index().rename(columns={"index": "target_end_date"})
+            a = pd.melt(a, id_vars="target_end_date", var_name="location")
+            a["quantile"] = "{:<.3f}".format(qt)
+
             df_list.append(a)
 
         df = pd.concat(df_list)
         df["forecast_date"] = forecast_date_str
         df["type"] = "quantile"
         df["target"] = df["target_end_date"].map(target_dict)
-        df = df[["forecast_date","target_end_date","location","type","quantile","value","target"]]
+        df = df[
+            [
+                "forecast_date",
+                "target_end_date",
+                "location",
+                "type",
+                "quantile",
+                "value",
+                "target",
+            ]
+        ]
         df
 
         for col in df.columns:
@@ -286,65 +553,88 @@ def export_forecasts(self, fluforecasts_ti, forecasts_national, directory=".", p
             print(df[col].unique())
 
         if not nochecks:
-            assert sum(df["value"]<0) == 0
+            assert sum(df["value"] < 0) == 0
             assert sum(df["value"].isna()) == 0
 
         # check for Error when validating format: Entries in `value` must be non-decreasing as quantiles increase:
         for tg in target_dates:
-            old_vals = np.zeros(len(self.season_setup.locations)+1)
-            for dfd in df_list:  # very important to not call this df: it overwrites in namesapce the exported df
-                new_vals = dfd[dfd["target_end_date"]==tg]["value"].to_numpy()
-                if not (new_vals-old_vals >= 0).all():
-                    num_negative = sum((new_vals-old_vals) < 0)
-                    print(f" !!!! Quantile validation failed: {num_negative} negative values on {tg}")
+            old_vals = np.zeros(len(self.season_setup.locations) + 1)
+            for dfd in df_list:  # avoid naming this df; it would shadow the exported df
+                new_vals = dfd[dfd["target_end_date"] == tg]["value"].to_numpy()
+                if not (new_vals - old_vals >= 0).all():
+                    num_negative = sum((new_vals - old_vals) < 0)
+                    print(
+                        f" !!!! Quantile validation failed: {num_negative} negative values on {tg}"
+                    )
                 else:
                     pass
-                    #print(f"""ok for {dfd["quantile"].unique()}, {tg}""")
+                    # print(f"""ok for {dfd["quantile"].unique()}, {tg}""")
                 old_vals = new_vals
 
         df.to_csv(f"{directory}/{prefix}-{forecast_date_str}.csv", index=False)
 
         if save_plot:
-            self.plot_forecasts(fluforecasts_ti, forecasts_national, directory=directory, prefix=prefix, forecast_date=forecast_date)
-        
-    def plot_forecasts(self, fluforecasts_ti, forecasts_national, directory=".", prefix="", forecast_date=None):
-        forecast_date_str=str(forecast_date)
+            self.plot_forecasts(
+                fluforecasts_ti,
+                forecasts_national,
+                directory=directory,
+                prefix=prefix,
+                forecast_date=forecast_date,
+            )
+
+    def plot_forecasts(
+        self,
+        fluforecasts_ti,
+        forecasts_national,
+        directory=".",
+        prefix="",
+        forecast_date=None,
+        mode="flusight",
+    ):
+        forecast_date_str = str(forecast_date)
         if forecast_date == None:
             forecast_date = self.mask_date
-        idx_now = self.inpaintfrom_idx-1
-        idx_horizon = idx_now+4
-
-        plot_specs = {"all" : {
-                                "quantiles_idx":range(11),
-                                "color":"lightcoral",
-                                },
-                        "50-95" : {
-                                "quantiles_idx":[1, 6],
-                                "color":"darkblue"
-                                }
-                    }
+        if forecasts_national is None:
+            if mode == "metrocast":
+                forecasts_national = fluforecasts_ti.sum(axis=-1)
+            else:
+                raise ValueError("forecasts_national is required for mode='flusight'")
+        idx_now = self.inpaintfrom_idx - 1
+        idx_horizon = idx_now + 4
+
+        plot_specs = {
+            "all": {
+                "quantiles_idx": range(11),
+                "color": "lightcoral",
+            },
+            "50-95": {"quantiles_idx": [1, 6], "color": "darkblue"},
+        }
 
         color_gt = "black"
-        color_past='grey'
+        color_past = "grey"
+        y_label = "New Hosp. Admissions" if mode != "metrocast" else "ED visits pct"
+        national_title = "National" if mode != "metrocast" else "Aggregate"
+        median_q = (
+            0.5 if 0.5 in myutils.flusight_quantiles else myutils.flusight_quantiles[12]
+        )
 
         nplace_toplot = len(self.season_setup.locations)
-        #nplace_toplot = 3 # less plots for faster iteration
+        # nplace_toplot = 3 # less plots for faster iteration
         plot_past_median = False
         if plot_past_median:
-            plotrange=slice(None)
+            plotrange = slice(None)
         else:
-            plotrange=slice(self.inpaintfrom_idx,-1)
+            plotrange = slice(self.inpaintfrom_idx, -1)
 
-
-        #if self.season_first_year == "2023" or self.season_first_year == "2024":
-        #    gt2022 = GroundTruth(season_first_year="2022", 
+        # if self.season_first_year == "2023" or self.season_first_year == "2024":
+        #    gt2022 = GroundTruth(season_first_year="2022",
         #                    data_date=datetime.datetime.combine(datetime.date(2023,7,15), datetime.datetime.min.time()),
         #                    mask_date=datetime.datetime.today(),
         #                    channels=self.channels,
         #                    image_size=self.image_size,
         #                    payload=pd.read_csv("custom_datasets/nc_payload_gt.csv", parse_dates=["week_enddate"]))
-        #if self.season_first_year == "2024":
-        #    gt2023 = GroundTruth(season_first_year="2023", 
+        # if self.season_first_year == "2024":
+        #    gt2023 = GroundTruth(season_first_year="2023",
         #        data_date=datetime.datetime.combine(datetime.date(2023,7,15), datetime.datetime.min.time()),
         #        mask_date=datetime.datetime.today(),
         #        channels=self.channels,
@@ -352,219 +642,408 @@ def plot_forecasts(self, fluforecasts_ti, forecasts_national, directory=".", pre
         #        payload=pd.read_csv("custom_datasets/nc_payload_gt.csv", parse_dates=["week_enddate"]))
 
         for plot_title, plot_spec in plot_specs.items():
-            #print(f"doing {plot_title}...")
-            fig, axes = plt.subplots(nplace_toplot+1, 2, figsize=(10,nplace_toplot*3.5), dpi=200)
+            # print(f"doing {plot_title}...")
+            fig, axes = plt.subplots(
+                nplace_toplot + 1, 2, figsize=(10, nplace_toplot * 3.5), dpi=200
+            )
             for iax in range(2):
                 ax = axes[0][iax]
-    
-                x = np.arange(64)
+
+                x = np.arange(self.image_size)
                 if iax == 0:
                     x_lims_idx = (0, 51)
-                    x_lims = (pd.to_datetime(self.gt_xarr["date"][x_lims_idx[0]].values), 
-                            pd.to_datetime(self.gt_xarr["date"][x_lims_idx[1]].values))
+                    x_lims = (
+                        pd.to_datetime(self.gt_xarr["date"][x_lims_idx[0]].values),
+                        pd.to_datetime(self.gt_xarr["date"][x_lims_idx[1]].values),
+                    )
                 elif iax == 1:
-                    x_lims_idx = (idx_now-3, idx_horizon)
-                    x_lims = (pd.to_datetime(self.gt_xarr["date"][x_lims_idx[0]].values), 
-                            pd.to_datetime(self.gt_xarr["date"][x_lims_idx[1]].values))
+                    x_lims_idx = (idx_now - 3, idx_horizon)
+                    x_lims = (
+                        pd.to_datetime(self.gt_xarr["date"][x_lims_idx[0]].values),
+                        pd.to_datetime(self.gt_xarr["date"][x_lims_idx[1]].values),
+                    )
                 # US WIDE: quantiles and median, US-wide
                 for iqt in plot_spec["quantiles_idx"]:
-                    #print(f"up: {flusight_quantile_pairs[iqt,0]} - lo: {flusight_quantile_pairs[iqt,1]}")
+                    # print(f"up: {flusight_quantile_pairs[iqt,0]} - lo: {flusight_quantile_pairs[iqt,1]}")
                     # TODO: not exactly true that it is the sum of quantiles (sum of quantile is not quantile of sum)
-                    ylo = np.quantile(forecasts_national, myutils.flusight_quantile_pairs[iqt,0], axis=0)[0]
-                    yup = np.quantile(forecasts_national, myutils.flusight_quantile_pairs[iqt,1], axis=0)[0]
-                    ax.fill_between(self.gt_xarr["date"][plotrange], 
-                                    ylo[plotrange], 
-                                    yup[plotrange], 
-                                    alpha=.1, 
-                                    color=plot_spec["color"])
-    
+                    ylo = np.quantile(
+                        forecasts_national,
+                        myutils.flusight_quantile_pairs[iqt, 0],
+                        axis=0,
+                    )[0]
+                    yup = np.quantile(
+                        forecasts_national,
+                        myutils.flusight_quantile_pairs[iqt, 1],
+                        axis=0,
+                    )[0]
+                    ax.fill_between(
+                        self.gt_xarr["date"][plotrange],
+                        ylo[plotrange],
+                        yup[plotrange],
+                        alpha=0.1,
+                        color=plot_spec["color"],
+                    )
+
                     # widest quantile pair is the first one. We take the up quantile of it + a few % as x_lim
                     if iqt == plot_spec["quantiles_idx"][0]:
                         if plot_past_median:
-                            max_y_value = max(yup[x_lims_idx[0]:x_lims_idx[1]])
+                            max_y_value = max(yup[x_lims_idx[0] : x_lims_idx[1]])
                         else:
-                            max_y_value = max(yup[self.inpaintfrom_idx:x_lims_idx[1]])
-                        max_y_value = max(max_y_value, self.gt_xarr.data[0,:self.inpaintfrom_idx].sum(axis=1)[x_lims_idx[0]:x_lims_idx[1]].max())
-                        max_y_value = max_y_value + max_y_value*.05 # 10% more
-    
+                            max_y_value = max(yup[self.inpaintfrom_idx : x_lims_idx[1]])
+                        max_y_value = max(
+                            max_y_value,
+                            self.gt_xarr.data[0, : self.inpaintfrom_idx]
+                            .sum(axis=1)[x_lims_idx[0] : x_lims_idx[1]]
+                            .max(),
+                        )
+                        max_y_value = max_y_value + max_y_value * 0.05  # 10% more
+
                 # median
-                ax.plot(self.gt_xarr["date"][plotrange],
-                        np.quantile(forecasts_national, myutils.flusight_quantiles[12], axis=0)[0][plotrange], color=plot_spec["color"], marker='.', label='forecast median')
-    
+                ax.plot(
+                    self.gt_xarr["date"][plotrange],
+                    np.quantile(forecasts_national, median_q, axis=0)[0][plotrange],
+                    color=plot_spec["color"],
+                    marker=".",
+                    label="forecast median",
+                )
+
                 # ground truth
-                ax.plot(self.gt_xarr["date"][:self.inpaintfrom_idx],
-                        self.gt_xarr.data[0,:self.inpaintfrom_idx].sum(axis=1), color=color_gt, marker = '.', lw=.5, label='ground-truth')
-                ax.plot(self.gt_xarr["date"][self.inpaintfrom_idx:],
-                        self.gt_xarr.data[0,self.inpaintfrom_idx:].sum(axis=1), 
-                        color='red', 
-                        marker = '.', 
-                        lw=.1, 
-                        label='ground-truth',
-                        markersize=.4)
-
-                #if self.season_first_year == "2023" or self.season_first_year == "2024":
+                ax.plot(
+                    self.gt_xarr["date"][: self.inpaintfrom_idx],
+                    self.gt_xarr.data[0, : self.inpaintfrom_idx].sum(axis=1),
+                    color=color_gt,
+                    marker=".",
+                    lw=0.5,
+                    label="ground-truth",
+                )
+                ax.plot(
+                    self.gt_xarr["date"][self.inpaintfrom_idx :],
+                    self.gt_xarr.data[0, self.inpaintfrom_idx :].sum(axis=1),
+                    color="red",
+                    marker=".",
+                    lw=0.1,
+                    label="ground-truth",
+                    markersize=0.4,
+                )
+
+                # if self.season_first_year == "2023" or self.season_first_year == "2024":
                 #    ax.plot(gt2022.gt_xarr.data[0,:].sum(axis=1), color=color_past, ls='dashed', lw=.5, label='2022 ground-truth')
-                #if self.season_first_year == "2024":
+                # if self.season_first_year == "2024":
                 #    ax.plot(gt2022.gt_xarr.data[0,:].sum(axis=1), color=color_past, ls='dashdot', lw=.5, label='2023 ground-truth')
 
-                if iax==0:
+                if iax == 0:
                     ax.legend(fontsize=8)
-    
-                #ax.set_xticks(np.arange(0,53,13))
 
+                # ax.set_xticks(np.arange(0,53,13))
 
                 ax.set_xlim(x_lims)
                 ax.set_ylim(bottom=0, top=max_y_value)
-                ax.axvline(self.gt_xarr["date"][idx_now].values, c='k', lw=1, ls='-.')
+                ax.axvline(self.gt_xarr["date"][idx_now].values, c="k", lw=1, ls="-.")
                 if iax == 0:
-                    ax.axvline(self.gt_xarr["date"][idx_horizon].values, c='k', lw=1, ls='-.')
-                ax.set_title("National")
+                    ax.axvline(
+                        self.gt_xarr["date"][idx_horizon].values, c="k", lw=1, ls="-."
+                    )
+                ax.set_title(national_title)
 
-                sns.despine(ax = ax, trim = True, offset=4)
+                sns.despine(ax=ax, trim=True, offset=4)
 
                 # INDIVDIDUAL STATES: quantiles, median and ground-truth
                 max_y_value = np.zeros(nplace_toplot)
                 for iqt in plot_spec["quantiles_idx"]:
-                    yup = np.quantile(fluforecasts_ti, myutils.flusight_quantile_pairs[iqt,0], axis=0)[0]
-                    ylo = np.quantile(fluforecasts_ti, myutils.flusight_quantile_pairs[iqt,1], axis=0)[0]
+                    yup = np.quantile(
+                        fluforecasts_ti, myutils.flusight_quantile_pairs[iqt, 0], axis=0
+                    )[0]
+                    ylo = np.quantile(
+                        fluforecasts_ti, myutils.flusight_quantile_pairs[iqt, 1], axis=0
+                    )[0]
 
                     # widest quantile pair is the first one. We take the up quantile of it + a few % as x_lim
                     if iqt == plot_spec["quantiles_idx"][0]:
                         for ipl in range(nplace_toplot):
                             if plot_past_median:
-                                max_y_value[ipl] = max(ylo[x_lims_idx[0]:x_lims_idx[1], ipl])
+                                max_y_value[ipl] = max(
+                                    ylo[x_lims_idx[0] : x_lims_idx[1], ipl]
+                                )
                             else:
-                                max_y_value[ipl] = max(ylo[self.inpaintfrom_idx:x_lims_idx[1], ipl])
-                            #max_y_value[ipl] =  max(ylo[x_lims[:x_lims[1], ipl])
-                            max_y_value[ipl] = max(max_y_value[ipl], self.gt_xarr.data[0,:self.inpaintfrom_idx, ipl][x_lims_idx[0]:x_lims_idx[1]].max())
-                            max_y_value[ipl] = max_y_value[ipl] + max_y_value[ipl]*.05 # 10% more for the y_max value
+                                max_y_value[ipl] = max(
+                                    ylo[self.inpaintfrom_idx : x_lims_idx[1], ipl]
+                                )
+                            # max_y_value[ipl] =  max(ylo[x_lims[:x_lims[1], ipl])
+                            max_y_value[ipl] = max(
+                                max_y_value[ipl],
+                                self.gt_xarr.data[0, : self.inpaintfrom_idx, ipl][
+                                    x_lims_idx[0] : x_lims_idx[1]
+                                ].max(),
+                            )
+                            max_y_value[ipl] = (
+                                max_y_value[ipl] + max_y_value[ipl] * 0.05
+                            )  # 10% more for the y_max value
 
                     for ipl in range(nplace_toplot):
-                        ax = axes[ipl+1][iax]
-                        ax.fill_between(self.gt_xarr["date"][plotrange],  (yup[:,ipl])[plotrange], (ylo[:,ipl])[plotrange], alpha=.1, color=plot_spec["color"])
+                        ax = axes[ipl + 1][iax]
+                        ax.fill_between(
+                            self.gt_xarr["date"][plotrange],
+                            (yup[:, ipl])[plotrange],
+                            (ylo[:, ipl])[plotrange],
+                            alpha=0.1,
+                            color=plot_spec["color"],
+                        )
 
                 # median line and ground truth for states
                 for ipl in range(nplace_toplot):
-                    location_name=self.season_setup.get_location_name(self.season_setup.locations[ipl])
-                    ax = axes[ipl+1][iax]
+                    location_name = self.season_setup.get_location_name(
+                        self.season_setup.locations[ipl]
+                    )
+                    ax = axes[ipl + 1][iax]
                     # median
-                    ax.plot(self.gt_xarr["date"][plotrange],
-                            np.quantile(fluforecasts_ti, myutils.flusight_quantiles[12], axis=0)[0,:,ipl][plotrange], color=plot_spec["color"], marker = '.', lw=.5)
+                    ax.plot(
+                        self.gt_xarr["date"][plotrange],
+                        np.quantile(fluforecasts_ti, median_q, axis=0)[0, :, ipl][
+                            plotrange
+                        ],
+                        color=plot_spec["color"],
+                        marker=".",
+                        lw=0.5,
+                    )
                     # ground truth
-                    ax.plot(self.gt_xarr["date"][:self.inpaintfrom_idx],
-                            self.gt_xarr.data[0,:self.inpaintfrom_idx, ipl], color=color_gt, marker = '.', lw=.5)
-                    ax.plot(self.gt_xarr["date"][self.inpaintfrom_idx:],
-                            self.gt_xarr.data[0,self.inpaintfrom_idx:, ipl], color='red', marker = '.', lw=.1, markersize=.4)
-
-                    # TODO I'm here
-                    
-                    this_hist_data = self.previous_data[self.previous_data["location_code"]==self.season_setup.locations[ipl]]
-                    for hist_season in this_hist_data["fluseason"].unique():
-                        if int(hist_season) != int(self.season_first_year):
-                            hist_data = this_hist_data[this_hist_data["fluseason"]==hist_season]
-                            hist_data = hist_data.pivot(index = "season_week", columns='location_code', values='value').sort_index()
-                            thisthing = hist_data[self.season_setup.locations[ipl]]
-                            # TODO MATCH HERE !!!!
-                            ax.plot(self.gt_xarr["date"][0:len(thisthing)], thisthing, color=color_past, ls='dashed', lw=.5, label=f"{hist_season}")
-
-                    ax.axvline(self.gt_xarr["date"][idx_now].values, c='k', lw=1, ls='-.')
+                    ax.plot(
+                        self.gt_xarr["date"][: self.inpaintfrom_idx],
+                        self.gt_xarr.data[0, : self.inpaintfrom_idx, ipl],
+                        color=color_gt,
+                        marker=".",
+                        lw=0.5,
+                    )
+                    ax.plot(
+                        self.gt_xarr["date"][self.inpaintfrom_idx :],
+                        self.gt_xarr.data[0, self.inpaintfrom_idx :, ipl],
+                        color="red",
+                        marker=".",
+                        lw=0.1,
+                        markersize=0.4,
+                    )
+
+                    for (
+                        hist_season,
+                        hist_dates,
+                        hist_values,
+                    ) in self._get_historical_series(self.season_setup.locations[ipl]):
+                        ax.plot(
+                            hist_dates,
+                            hist_values,
+                            color=color_past,
+                            ls="dashed",
+                            lw=0.5,
+                            label=f"{hist_season}",
+                        )
+
+                    ax.axvline(
+                        self.gt_xarr["date"][idx_now].values, c="k", lw=1, ls="-."
+                    )
                     if iax == 0:
-                        ax.axvline(self.gt_xarr["date"][idx_horizon].values, c='k', lw=1, ls='-.')
+                        ax.axvline(
+                            self.gt_xarr["date"][idx_horizon].values,
+                            c="k",
+                            lw=1,
+                            ls="-.",
+                        )
                     ax.set_xlim(x_lims)
                     ax.set_ylim(bottom=0, top=max_y_value[ipl])
-                    if iax==0: ax.set_ylabel("New Hosp. Admissions")
+                    if iax == 0:
+                        ax.set_ylabel(y_label)
                     ax.set_title(location_name)
                     # rotate the x axis labels
-                    ax.tick_params(axis='x', rotation=45)
-                    #print the tick label as 12 J-22
+                    ax.tick_params(axis="x", rotation=45)
+                    # print the tick label as 12 J-22
                     import matplotlib.dates as mdates
-                    ax.xaxis.set_major_formatter(mdates.DateFormatter('%d %b-%y'))
 
-                    sns.despine(ax = ax, trim = True, offset=4)
-            fig.tight_layout()
-            plt.savefig(f"{directory}/{prefix}-{forecast_date_str}-plot{plot_title}.pdf")
+                    ax.xaxis.set_major_formatter(mdates.DateFormatter("%d %b-%y"))
 
-    def export_forecasts_2023(self, fluforecasts_ti, forecasts_national, directory=".", prefix="", forecast_date=None, save_plot=True, nochecks=False, rate_trend=True):
-        forecast_date_str=str(forecast_date)
+                    sns.despine(ax=ax, trim=True, offset=4)
+            fig.tight_layout()
+            plt.savefig(
+                f"{directory}/{prefix}-{forecast_date_str}-plot{plot_title}.pdf"
+            )
+
+    def export_forecasts_2023(
+        self,
+        fluforecasts_ti,
+        forecasts_national=None,
+        directory=".",
+        prefix="",
+        forecast_date=None,
+        save_plot=True,
+        nochecks=False,
+        rate_trend=True,
+        mode="flusight",
+    ):
+        forecast_date_str = str(forecast_date)
         if forecast_date == None:
             forecast_date = self.mask_date
-        season_start_date = datetime.date(int(self.season_first_year), self.season_setup.season_start_month, self.season_setup.season_start_day)
-
-        target_dates = pd.date_range(forecast_date, forecast_date + datetime.timedelta(days=3*7), freq="W-SAT")
-
-        target_dict= dict(zip(
-            target_dates, 
-            [f"{n}" for n in range(0,4)]))
-
-        df_list=[]
+        season_start_date = datetime.date(
+            int(self.season_first_year),
+            self.season_setup.season_start_month,
+            self.season_setup.season_start_day,
+        )
+
+        reference_date = pd.to_datetime(forecast_date).date()
+        reference_date_str = str(reference_date)
+        base_index = pd.date_range(
+            season_start_date,
+            season_start_date + datetime.timedelta(days=self.image_size * 7),
+            freq="W-SAT",
+        )
+        target_dates = [
+            reference_date + datetime.timedelta(days=7 * h) for h in range(4)
+        ]
+        target_dates = pd.to_datetime(target_dates)
+        horizon_map = {pd.to_datetime(d): h for h, d in enumerate(target_dates)}
+
+        df_list = []
         for qt in myutils.flusight_quantiles:
-            a =  pd.DataFrame(np.quantile(fluforecasts_ti[:,:,:,:len(self.season_setup.locations)], qt, axis=0)[0], 
-                    columns= self.season_setup.locations, index=pd.date_range(season_start_date, season_start_date + datetime.timedelta(days=64*7), freq="W-SAT")).loc[target_dates]
-            #a["US"] = a.sum(axis=1)
-            a["US"] = pd.DataFrame(np.quantile(forecasts_national, qt, axis=0)[0],
-                    columns= ["US"], index=pd.date_range(season_start_date, season_start_date + datetime.timedelta(days=64*7), freq="W-SAT")).loc[target_dates]
-
-            a = a.reset_index().rename(columns={'index': 'target_end_date'})
-            a = pd.melt(a,id_vars="target_end_date",var_name="location")
-            a["output_type_id"] = "{:.3f}".format(qt).rstrip('0').rstrip('.')# " #'{:<.3f}'.format(qt)
-            
+            a = pd.DataFrame(
+                np.quantile(
+                    fluforecasts_ti[:, :, :, : len(self.season_setup.locations)],
+                    qt,
+                    axis=0,
+                )[0],
+                columns=self.season_setup.locations,
+                index=base_index,
+            ).loc[target_dates]
+
+            a = a.reset_index().rename(columns={"index": "target_end_date"})
+            a = pd.melt(a, id_vars="target_end_date", var_name="location")
+            a["output_type_id"] = "{:.3f}".format(qt).rstrip("0").rstrip(".")
             df_list.append(a)
 
-        df = pd.concat(df_list)
+        df = pd.concat(df_list, ignore_index=True)
+
+        if mode == "metrocast":
+            df["reference_date"] = reference_date_str
+            df["output_type"] = "quantile"
+            df["horizon"] = df["target_end_date"].map(horizon_map)
+            df["target"] = np.where(
+                df["location"] == "nyc", "ILI ED visits pct", "Flu ED visits pct"
+            )
+            df = df[
+                [
+                    "reference_date",
+                    "target",
+                    "horizon",
+                    "target_end_date",
+                    "location",
+                    "output_type",
+                    "output_type_id",
+                    "value",
+                ]
+            ]
+
+            if not nochecks:
+                assert sum(df["value"] < 0) == 0
+                assert sum(df["value"].isna()) == 0
+
+            df.to_csv(f"{directory}/{reference_date_str}-{prefix}.csv", index=False)
+            if save_plot:
+                if forecasts_national is None:
+                    forecasts_national = fluforecasts_ti.sum(axis=-1)
+                self.plot_forecasts(
+                    fluforecasts_ti,
+                    forecasts_national,
+                    directory=directory,
+                    prefix=prefix,
+                    forecast_date=forecast_date,
+                    mode=mode,
+                )
+            return
+
+        if forecasts_national is None:
+            raise ValueError("forecasts_national is required for mode='flusight'")
+
+        target_dict = {d: f"{h}" for d, h in horizon_map.items()}
+        updated_df_list = []
+        for qt, dfd in zip(myutils.flusight_quantiles, df_list):
+            us_vals = pd.DataFrame(
+                np.quantile(forecasts_national, qt, axis=0)[0],
+                columns=["US"],
+                index=base_index,
+            ).loc[target_dates]
+            us_vals = us_vals.reset_index().rename(columns={"index": "target_end_date"})
+            us_vals = pd.melt(us_vals, id_vars="target_end_date", var_name="location")
+            us_vals["output_type_id"] = "{:.3f}".format(qt).rstrip("0").rstrip(".")
+            dfd = pd.concat([dfd, us_vals], ignore_index=True)
+            updated_df_list.append(dfd)
+
+        df = pd.concat(updated_df_list, ignore_index=True)
         df["reference_date"] = forecast_date_str
         df["target"] = "wk inc flu hosp"
         df["horizon"] = df["target_end_date"].map(target_dict)
         df["output_type"] = "quantile"
-        df = df[["reference_date","target","horizon","target_end_date","location","output_type","output_type_id","value"]]
+        df = df[
+            [
+                "reference_date",
+                "target",
+                "horizon",
+                "target_end_date",
+                "location",
+                "output_type",
+                "output_type_id",
+                "value",
+            ]
+        ]
         df
 
-        # Suppress verbose output for column information  
+        # Suppress verbose output for column information
         # for col in df.columns:
         #     print(col)
         #     print(df[col].unique())
 
         if not nochecks:
-            assert sum(df["value"]<0) == 0
+            assert sum(df["value"] < 0) == 0
             assert sum(df["value"].isna()) == 0
 
         # check for Error when validating format: Entries in `value` must be non-decreasing as quantiles increase:
         for tg in target_dates:
-            old_vals = np.zeros(len(self.season_setup.locations)+1)
-            for dfd in df_list:  # very important to not call this df: it overwrites in namesapce the exported df
-                new_vals = dfd[dfd["target_end_date"]==tg]["value"].to_numpy()
-                if not (new_vals-old_vals >= 0).all():
-                    num_negative = sum((new_vals-old_vals) < 0)
-                    print(f" !!!! Quantile validation failed: {num_negative} negative values on {tg}")
+            old_vals = np.zeros(len(self.season_setup.locations) + 1)
+            for dfd in updated_df_list:  # very important to not call this df: it overwrites in namesapce the exported df
+                new_vals = dfd[dfd["target_end_date"] == tg]["value"].to_numpy()
+                if not (new_vals - old_vals >= 0).all():
+                    num_negative = sum((new_vals - old_vals) < 0)
+                    print(
+                        f" !!!! Quantile validation failed: {num_negative} negative values on {tg}"
+                    )
                 else:
                     pass
-                    #print(f"""ok for {dfd["quantile"].unique()}, {tg}""")
+                    # print(f"""ok for {dfd["quantile"].unique()}, {tg}""")
                 old_vals = new_vals
 
-#        if rate_trend:
-#            df_list=[]
-#            for sim_id in np.arange(fluforecasts_ti.shape[0]):
-#            #for qt in myutils.flusight_quantiles:
-#                a =  pd.DataFrame(fluforecasts_ti[:,:,:,:len(self.season_setup.locations)], 
-#                        columns= self.season_setup.locations, index=pd.date_range(self.season_setup.fluseason_startdate, self.season_setup.fluseason_startdate + datetime.timedelta(days=64*7), freq="W-SAT")).loc[target_dates]
-#                a["US"] = pd.DataFrame(forecasts_national[sim_id],
-#                        columns= ["US"], index=pd.date_range(self.season_setup.fluseason_startdate, self.season_setup.fluseason_startdate + datetime.timedelta(days=64*7), freq="W-SAT")).loc[target_dates]
-#
-#                a = a.reset_index().rename(columns={'index': 'target_end_date'})
-#                a = pd.melt(a,id_vars="target_end_date",var_name="location")
-#
-#                
-#                df_list.append(a)
-#
-#            df2 = pd.concat(df_list)
-#            df2["reference_date"] = forecast_date_str
-#            df2["target"] = "wk flu hosp rate change"
-#            df2["horizon"] = df["target_end_date"].map(target_dict)
-#            df2["output_type"] = "pmf"
-#            df2 = df2[["reference_date","target","horizon","target_end_date","location","output_type","output_type_id","value"]]
-
+        #        if rate_trend:
+        #            df_list=[]
+        #            for sim_id in np.arange(fluforecasts_ti.shape[0]):
+        #            #for qt in myutils.flusight_quantiles:
+        #                a =  pd.DataFrame(fluforecasts_ti[:,:,:,:len(self.season_setup.locations)],
+        #                        columns= self.season_setup.locations, index=pd.date_range(self.season_setup.fluseason_startdate, self.season_setup.fluseason_startdate + datetime.timedelta(days=64*7), freq="W-SAT")).loc[target_dates]
+        #                a["US"] = pd.DataFrame(forecasts_national[sim_id],
+        #                        columns= ["US"], index=pd.date_range(self.season_setup.fluseason_startdate, self.season_setup.fluseason_startdate + datetime.timedelta(days=64*7), freq="W-SAT")).loc[target_dates]
+        #
+        #                a = a.reset_index().rename(columns={'index': 'target_end_date'})
+        #                a = pd.melt(a,id_vars="target_end_date",var_name="location")
+        #
+        #
+        #                df_list.append(a)
+        #
+        #            df2 = pd.concat(df_list)
+        #            df2["reference_date"] = forecast_date_str
+        #            df2["target"] = "wk flu hosp rate change"
+        #            df2["horizon"] = df["target_end_date"].map(target_dict)
+        #            df2["output_type"] = "pmf"
+        #            df2 = df2[["reference_date","target","horizon","target_end_date","location","output_type","output_type_id","value"]]
 
         df.to_csv(f"{directory}/{forecast_date_str}-{prefix}.csv", index=False)
 
         if save_plot:
-            self.plot_forecasts(fluforecasts_ti, forecasts_national, directory=directory, prefix=prefix, forecast_date=forecast_date)
-        
+            self.plot_forecasts(
+                fluforecasts_ti,
+                forecasts_national,
+                directory=directory,
+                prefix=prefix,
+                forecast_date=forecast_date,
+            )
diff --git a/influpaint_ipynb.ipynb b/influpaint_ipynb.ipynb
new file mode 100644
index 0000000..9993433
--- /dev/null
+++ b/influpaint_ipynb.ipynb
@@ -0,0 +1,623 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b3df745",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# -*- coding: utf-8 -*-\n",
+    "# ---\n",
+    "# jupyter:\n",
+    "#   jupytext:\n",
+    "#     cell_metadata_filter: -all\n",
+    "#     custom_cell_magics: kql\n",
+    "#     text_representation:\n",
+    "#       extension: .py\n",
+    "#       format_name: percent\n",
+    "#       format_version: '1.3'\n",
+    "#       jupytext_version: 1.11.2\n",
+    "#   kernelspec:\n",
+    "#     display_name: diffusion_torch6\n",
+    "#     language: python\n",
+    "#     name: python3\n",
+    "# ---\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# # InfluPaint Interactive Forecasting\n",
+    "#\n",
+    "# This notebook provides an interactive interface for generating flu forecasts using trained diffusion models.\n",
+    "# It uses the new modular structure from `influpaint/batch/` while maintaining the exploratory nature of notebooks.\n",
+    "#\n",
+    "# **Workflow:**\n",
+    "# 1. Select a training scenario and load the trained model\n",
+    "# 2. Configure inpainting parameters (date, config, batch size)\n",
+    "# 3. Prepare ground truth data with masking\n",
+    "# 4. Run CoPaint inpainting to generate forecasts\n",
+    "# 5. Visualize and export results\n",
+    "#\n",
+    "# **Key differences from the old notebook:**\n",
+    "# - Uses scenario-based model/dataset selection\n",
+    "# - Integrates with MLflow for experiment tracking\n",
+    "# - Cleaner separation between model loading and inference\n",
+    "# - Supports both MLflow and filesystem model loading\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Setup: Imports and Configuration\n",
+    "\n",
+    "# %%\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from tqdm.auto import tqdm\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import datetime\n",
+    "import sys\n",
+    "from pathlib import Path\n",
+    "\n",
+    "# InfluPaint modular imports\n",
+    "from influpaint.utils import SeasonAxis, plotting as idplots\n",
+    "from influpaint.batch.scenarios import get_training_scenario, create_scenario_objects\n",
+    "from influpaint.batch.config import copaint_config_library, create_folders, get_git_revision_short_hash\n",
+    "from influpaint.utils import ground_truth\n",
+    "\n",
+    "# CoPaint imports\n",
+    "sys.path.append('CoPaint4influpaint')\n",
+    "from guided_diffusion import O_DDIMSampler\n",
+    "\n",
+    "# Configure plotting\n",
+    "sns.set_style(\"whitegrid\")\n",
+    "# %matplotlib inline\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Configuration Parameters\n",
+    "#\n",
+    "# Set the key parameters for this forecasting run:\n",
+    "# - **scenario_id**: Which training scenario to use (see scenarios.py)\n",
+    "# - **forecast_date**: The date to forecast from (mask date)\n",
+    "# - **config_name**: CoPaint configuration (e.g., 'celebahq_noTT', 'celebahq_try1')\n",
+    "# - **model_source**: Either auto-find from experiment, MLflow run_id, or filesystem path\n",
+    "# - **device**: 'cuda' or 'cpu'\n",
+    "\n",
+    "# %%\n",
+    "# === USER CONFIGURATION ===\n",
+    "scenario_id = 868  # Choose your training scenario\n",
+    "forecast_date = \"2026-01-24\"  # YYYY-MM-DD format\n",
+    "config_name = \"celebahq_noTTJ5\"  # CoPaint config name\n",
+    "batch_size = 512\n",
+    "image_size = 64\n",
+    "channels = 1\n",
+    "\n",
+    "# Model source: Choose ONE of the following options\n",
+    "# Option 1: Auto-find model from MLflow experiment (recommended - same as mask_experiments)\n",
+    "experiment_name = \"paper-2025-07-22_training\"  # MLflow experiment name\n",
+    "run_id = None\n",
+    "model_path = None\n",
+    "\n",
+    "# Option 2: Specify MLflow run_id directly (uncomment to use)\n",
+    "# experiment_name = None\n",
+    "# run_id = \"abc123def456\"  # Your MLflow run ID\n",
+    "# model_path = None\n",
+    "\n",
+    "# Option 3: Load from filesystem (uncomment to use)\n",
+    "# experiment_name = None\n",
+    "# run_id = None\n",
+    "# model_path = \"/path/to/model.pth\"\n",
+    "\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "print(f\"Device: {device}\")\n",
+    "if device == \"cuda\":\n",
+    "    from influpaint.utils.helpers import cuda_mem_info\n",
+    "    print(cuda_mem_info())\n",
+    "    torch.cuda.empty_cache()\n",
+    "    print(cuda_mem_info())\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Load Scenario and Create Model/Dataset\n",
+    "#\n",
+    "# The scenario system provides a unified way to specify:\n",
+    "# - Model architecture (DDPM + UNet)\n",
+    "# - Dataset source and composition\n",
+    "# - Transformations and data augmentation\n",
+    "#\n",
+    "# All of these are bundled into a single scenario_id.\n",
+    "\n",
+    "# %%\n",
+    "# Get scenario specification\n",
+    "scenario_spec = get_training_scenario(scenario_id)\n",
+    "print(f\"Scenario {scenario_id}: {scenario_spec.scenario_string}\")\n",
+    "print(f\"  DDPM: {scenario_spec.ddpm_name}\")\n",
+    "print(f\"  UNet: {scenario_spec.unet_name}\")\n",
+    "print(f\"  Dataset: {scenario_spec.dataset_name}\")\n",
+    "print(f\"  Transform: {scenario_spec.transform_name}\")\n",
+    "print(f\"  Enrich: {scenario_spec.enrich_name}\")\n",
+    "\n",
+    "# Create season setup for Flusight geography\n",
+    "season_setup = SeasonAxis.for_flusight(remove_us=True, remove_territories=True)\n",
+    "\n",
+    "# Create model, dataset, and transforms using scenario helper\n",
+    "print(\"\\nCreating model, dataset, and transforms...\")\n",
+    "ddpm, dataset, transform, enrich, scaling_per_channel, data_mean, data_sd = create_scenario_objects(\n",
+    "    scenario_spec,\n",
+    "    season_setup,\n",
+    "    image_size,\n",
+    "    channels,\n",
+    "    batch_size,\n",
+    "    epochs=1,  # Not used for inference\n",
+    "    device=device\n",
+    ")\n",
+    "\n",
+    "print(f\"Dataset size: {len(dataset)} samples\")\n",
+    "print(f\"Scaling per channel: {scaling_per_channel}\")\n",
+    "print(f\"Data mean: {data_mean:.2f}, std: {data_sd:.2f}\")\n",
+    "print(f\"Timesteps: {ddpm.timesteps}\")\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Load Trained Model\n",
+    "#\n",
+    "# Load the trained model weights using one of three methods:\n",
+    "# - **Auto-find from experiment** (recommended): Searches MLflow experiment for matching scenario_id\n",
+    "# - **MLflow run_id**: Specify run_id to load from MLflow tracking server directly\n",
+    "# - **Filesystem**: Specify model_path to load a .pth checkpoint directly\n",
+    "\n",
+    "# %%\n",
+    "# Import model loading utilities (same as mask_experiments)\n",
+    "from influpaint.batch.inpainting import load_model\n",
+    "from influpaint.batch.generate_inpainting_jobs import get_finished_models\n",
+    "\n",
+    "# Determine run_id if using experiment_name\n",
+    "if experiment_name:\n",
+    "    print(f\"Finding run ID for scenario {scenario_id} in experiment '{experiment_name}'...\")\n",
+    "    finished_models = get_finished_models(experiment_name)\n",
+    "\n",
+    "    # Find the specific model for this scenario\n",
+    "    target_model = None\n",
+    "    for model in finished_models:\n",
+    "        if model['scenario_id'] == scenario_id:\n",
+    "            target_model = model\n",
+    "            break\n",
+    "\n",
+    "    if target_model is None:\n",
+    "        raise ValueError(f\"No finished model found for scenario {scenario_id} in experiment '{experiment_name}'\")\n",
+    "\n",
+    "    run_id = target_model['run_id']\n",
+    "    print(f\"✓ Found run ID: {run_id}\")\n",
+    "    print(f\"  Model scenario: {target_model['scenario_string']}\")\n",
+    "    model_source = f\"mlflow_experiment:{experiment_name}/scenario:{scenario_id}\"\n",
+    "\n",
+    "elif run_id:\n",
+    "    print(f\"Using specified run_id: {run_id}\")\n",
+    "    model_source = f\"mlflow_run:{run_id}\"\n",
+    "\n",
+    "elif model_path:\n",
+    "    print(f\"Using model from filesystem: {model_path}\")\n",
+    "    model_source = f\"filesystem:{model_path}\"\n",
+    "\n",
+    "else:\n",
+    "    raise ValueError(\"Must provide either experiment_name, run_id, or model_path\")\n",
+    "\n",
+    "# Load the model using the unified load_model function\n",
+    "print(\"Loading model checkpoint...\")\n",
+    "load_model(ddpm, run_id=run_id, model_path=model_path)\n",
+    "print(f\"✓ Model loaded from: {model_source}\")\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Prepare Ground Truth for Inpainting\n",
+    "#\n",
+    "# Create the ground truth data and mask for the forecast date:\n",
+    "# - Automatically determines flu season year from forecast_date\n",
+    "# - Loads surveillance data up to the mask_date\n",
+    "# - Creates a binary mask (1 = known, 0 = to be inferred)\n",
+    "\n",
+    "# %%\n",
+    "# Parse forecast date\n",
+    "forecast_dt = pd.to_datetime(forecast_date)\n",
+    "print(f\"Forecast date: {forecast_dt.date()}\")\n",
+    "\n",
+    "# Determine flu season year dynamically\n",
+    "season_first_year = str(season_setup.get_fluseason_year(forecast_dt))\n",
+    "print(f\"Detected flu season: {season_first_year}-{int(season_first_year)+1}\")\n",
+    "\n",
+    "# Create ground truth object\n",
+    "gt1 = ground_truth.GroundTruth.for_flusight(\n",
+    "    season_first_year=season_first_year,\n",
+    "    data_date=datetime.datetime.today(),\n",
+    "    mask_date=forecast_dt,\n",
+    "    channels=channels,\n",
+    "    image_size=image_size,\n",
+    "    nogit=True  # Skip git operations for interactive use\n",
+    ")\n",
+    "fig, ax = plt.subplots(figsize=(8, 4))\n",
+    "gt1.plot_mask()\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"Ground truth shape: {gt1.gt_xarr.shape}\")\n",
+    "print(f\"Inpainting from week: {gt1.inpaintfrom_idx}\")\n",
+    "print(f\"Known weeks: 1-{gt1.inpaintfrom_idx-1}, Forecast weeks: {gt1.inpaintfrom_idx}-52\")\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ### Visualize Ground Truth and Mask\n",
+    "\n",
+    "# %%\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n",
+    "\n",
+    "# Plot mask\n",
+    "ax = axes[0]\n",
+    "gt1.plot_mask()\n",
+    "ax.set_title(f\"Mask (known weeks: 1-{gt1.inpaintfrom_idx-1})\")\n",
+    "\n",
+    "# Plot ground truth\n",
+    "ax = axes[1]\n",
+    "gt1.plot()\n",
+    "ax.set_title(\"Ground Truth Data\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Configure CoPaint Sampler\n",
+    "#\n",
+    "# CoPaint provides several configuration presets that control the inpainting process:\n",
+    "# - Time travel (jump diffusion)\n",
+    "# - Optimization steps\n",
+    "# - Learning rates\n",
+    "#\n",
+    "# Common configs:\n",
+    "# - `celebahq_noTT`: No time travel, optimized for stable results\n",
+    "# - `celebahq_try1`: With time travel, more exploratory\n",
+    "\n",
+    "# %%\n",
+    "# Get available configs\n",
+    "available_configs = copaint_config_library(ddpm.timesteps)\n",
+    "print(f\"Available CoPaint configs: {list(available_configs.keys())}\")\n",
+    "\n",
+    "# Select config\n",
+    "if config_name not in available_configs:\n",
+    "    raise ValueError(f\"Config '{config_name}' not found. Available: {list(available_configs.keys())}\")\n",
+    "\n",
+    "conf = available_configs[config_name]\n",
+    "print(f\"\\nUsing CoPaint config: {config_name}\")\n",
+    "\n",
+    "# Create sampler\n",
+    "sampler = O_DDIMSampler(\n",
+    "    use_timesteps=np.arange(ddpm.timesteps),\n",
+    "    conf=conf,\n",
+    "    betas=ddpm.betas,\n",
+    "    model_mean_type=None,\n",
+    "    model_var_type=None,\n",
+    "    loss_type=None\n",
+    ")\n",
+    "\n",
+    "print(\"✓ Sampler created\")\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Run Inpainting\n",
+    "#\n",
+    "# Generate forecast samples by running the CoPaint inpainting algorithm.\n",
+    "# This will take several minutes depending on:\n",
+    "# - Number of timesteps (typically 200-500)\n",
+    "# - Batch size\n",
+    "# - GPU/CPU performance\n",
+    "\n",
+    "# %%\n",
+    "# Prepare ground truth tensors\n",
+    "gt_transformed = dataset.apply_transform(np.nan_to_num(gt1.gt_xarr.data, nan=0.0))\n",
+    "gt_keep_mask = torch.from_numpy(gt1.gt_keep_mask).type(torch.FloatTensor).to(device)\n",
+    "gt_tensor = torch.from_numpy(gt_transformed).type(torch.FloatTensor).to(device)\n",
+    "\n",
+    "print(f\"Running CoPaint inpainting with {batch_size} samples...\")\n",
+    "print(f\"This may take several minutes...\")\n",
+    "\n",
+    "# Run sampling\n",
+    "result = sampler.p_sample_loop(\n",
+    "    model_fn=ddpm.model,\n",
+    "    shape=(batch_size, channels, image_size, image_size),\n",
+    "    conf=conf,\n",
+    "    model_kwargs={\n",
+    "        \"gt\": gt_tensor.repeat(batch_size, 1, 1, 1),\n",
+    "        \"gt_keep_mask\": gt_keep_mask.repeat(batch_size, 1, 1, 1),\n",
+    "        \"mymodel\": True,\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "# Extract results\n",
+    "fluforecasts = np.array(result['sample'].cpu())\n",
+    "fluforecasts_ti = dataset.apply_transform_inv(fluforecasts)\n",
+    "forecasts_national = fluforecasts_ti.sum(axis=-1)\n",
+    "\n",
+    "print(f\"✓ Generated {len(fluforecasts)} forecast samples\")\n",
+    "print(f\"Forecast array shape: {fluforecasts_ti.shape}\")\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Visualize Results: National Forecast\n",
+    "\n",
+    "# %%\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(14, 4), dpi=100)\n",
+    "\n",
+    "for iax in range(2):\n",
+    "    ax = axes[iax]\n",
+    "\n",
+    "    # Plot quantile bands\n",
+    "    from influpaint.utils.helpers import flusight_quantile_pairs\n",
+    "    for iqt in range(11):\n",
+    "        ax.fill_between(\n",
+    "            np.arange(64),\n",
+    "            np.quantile(forecasts_national, flusight_quantile_pairs[iqt, 0], axis=0)[0],\n",
+    "            np.quantile(forecasts_national, flusight_quantile_pairs[iqt, 1], axis=0)[0],\n",
+    "            alpha=0.1, color='darkred'\n",
+    "        )\n",
+    "\n",
+    "    # Plot median\n",
+    "    ax.plot(np.arange(64),\n",
+    "            np.quantile(forecasts_national, 0.5, axis=0)[0],\n",
+    "            color='r', lw=2, label='Median forecast')\n",
+    "\n",
+    "    # Plot ground truth\n",
+    "    ax.plot(gt1.gt_xarr.data[0, :gt1.inpaintfrom_idx].sum(axis=1),\n",
+    "            color='k', marker='.', ls='', markersize=8, label='Observed data')\n",
+    "\n",
+    "    # Mark forecast start\n",
+    "    ax.axvline(gt1.inpaintfrom_idx - 1, c='k', ls='--', lw=1.5, alpha=0.5)\n",
+    "\n",
+    "    if iax == 0:\n",
+    "        # Full season view\n",
+    "        ax.set_xlim(0, 52)\n",
+    "        ax.set_ylim(bottom=0, auto=True)\n",
+    "        ax.set_title(\"National Forecast - Full Season\")\n",
+    "    else:\n",
+    "        # Zoomed view around forecast start\n",
+    "        ax.set_xlim(gt1.inpaintfrom_idx - 4, gt1.inpaintfrom_idx + 4)\n",
+    "        ax.set_ylim(bottom=0, auto=True)\n",
+    "        ax.set_title(\"National Forecast - Forecast Window\")\n",
+    "\n",
+    "    ax.grid(visible=True, alpha=0.3)\n",
+    "    ax.set_xlabel(\"Season Week\")\n",
+    "    ax.set_ylabel(\"Hospitalizations\")\n",
+    "    ax.legend(loc='upper left')\n",
+    "    sns.despine(ax=ax)\n",
+    "\n",
+    "fig.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Visualize Results: State-Level Forecasts\n",
+    "#\n",
+    "# Plot forecasts for individual states to inspect spatial patterns.\n",
+    "\n",
+    "# %%\n",
+    "def plot_state_forecasts(fluforecasts_ti, gt1, season_setup, states_to_plot=None, n_samples=50):\n",
+    "    \"\"\"Plot forecasts for selected states\"\"\"\n",
+    "\n",
+    "    if states_to_plot is None:\n",
+    "        # Default: plot first 6 states\n",
+    "        states_to_plot = list(range(6))\n",
+    "\n",
+    "    n_states = len(states_to_plot)\n",
+    "    fig, axes = plt.subplots(2, 3, figsize=(15, 8), sharex=True)\n",
+    "\n",
+    "    for idx, place_idx in enumerate(states_to_plot):\n",
+    "        if idx >= 6:\n",
+    "            break\n",
+    "\n",
+    "        ax = axes.flat[idx]\n",
+    "        location_name = season_setup.get_location_name(season_setup.locations[place_idx])\n",
+    "\n",
+    "        # Plot sample trajectories\n",
+    "        for i in range(min(n_samples, batch_size)):\n",
+    "            ax.plot(fluforecasts_ti[i, 0, :, place_idx],\n",
+    "                   lw=0.3, alpha=0.1, color='lightcoral')\n",
+    "\n",
+    "        # Plot median forecast\n",
+    "        median_forecast = np.median(fluforecasts_ti[:, 0, :, place_idx], axis=0)\n",
+    "        ax.plot(median_forecast, color='red', lw=2, label='Median')\n",
+    "\n",
+    "        # Plot ground truth\n",
+    "        ax.plot(gt1.gt_xarr.data[0, :gt1.inpaintfrom_idx, place_idx],\n",
+    "               color='k', marker='.', ls='', markersize=6, label='Observed')\n",
+    "\n",
+    "        # Mark forecast start\n",
+    "        ax.axvline(gt1.inpaintfrom_idx - 1, c='k', ls='--', lw=1, alpha=0.5)\n",
+    "\n",
+    "        ax.set_xlim(0, 52)\n",
+    "        ax.set_ylim(bottom=0, auto=True)\n",
+    "        ax.set_title(location_name)\n",
+    "        ax.grid(visible=True, alpha=0.3)\n",
+    "\n",
+    "        if idx >= 3:\n",
+    "            ax.set_xlabel('Season Week')\n",
+    "        if idx % 3 == 0:\n",
+    "            ax.set_ylabel('Hospitalizations')\n",
+    "\n",
+    "        sns.despine(ax=ax)\n",
+    "\n",
+    "    axes.flat[0].legend(loc='upper left')\n",
+    "    fig.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "# Plot forecasts for selected states\n",
+    "plot_state_forecasts(fluforecasts_ti, gt1, season_setup)\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Summary Statistics\n",
+    "\n",
+    "# %%\n",
+    "print(\"=== Forecast Summary Statistics ===\")\n",
+    "print(f\"Number of samples: {len(forecasts_national)}\")\n",
+    "print(f\"\\nNational peak hospitalizations:\")\n",
+    "print(f\"  Median: {np.median(forecasts_national.max(axis=1)):.0f}\")\n",
+    "print(f\"  Mean: {np.mean(forecasts_national.max(axis=1)):.0f}\")\n",
+    "print(f\"  10th percentile: {np.percentile(forecasts_national.max(axis=1), 10):.0f}\")\n",
+    "print(f\"  90th percentile: {np.percentile(forecasts_national.max(axis=1), 90):.0f}\")\n",
+    "\n",
+    "print(f\"\\nForecast horizon: {image_size - gt1.inpaintfrom_idx + 1} weeks\")\n",
+    "print(f\"Known weeks: 1-{gt1.inpaintfrom_idx - 1}\")\n",
+    "print(f\"Forecast weeks: {gt1.inpaintfrom_idx}-{image_size}\")\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Export Results\n",
+    "#\n",
+    "# Save forecasts in FluSight-compatible format and create visualizations.\n",
+    "# This will create:\n",
+    "# - CSV files with quantile forecasts for each location\n",
+    "# - Summary plots\n",
+    "# - Optionally save to MLflow\n",
+    "#\n",
+    "# **IMPORTANT**: Before exporting, we recreate the ground truth object to pull the latest surveillance data.\n",
+    "\n",
+    "# %%\n",
+    "# Determine next Saturday for submission\n",
+    "today = datetime.datetime.today()\n",
+    "days_until_saturday = (5 - today.weekday()) % 7\n",
+    "next_saturday = today + datetime.timedelta(days=days_until_saturday)\n",
+    "submission_date = next_saturday.date()\n",
+    "\n",
+    "print(f\"Next Saturday (submission date): {submission_date}\")\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ### Update Ground Truth with Latest Data\n",
+    "#\n",
+    "# This is critical! We need to recreate gt1 with today's date to fetch the latest surveillance data\n",
+    "# from the FluSight hub. This ensures our forecast CSV files have the most recent observed data.\n",
+    "\n",
+    "# %%\n",
+    "print(\"Updating ground truth with latest surveillance data...\")\n",
+    "print(f\"Original gt1 created with mask_date: {forecast_date}\")\n",
+    "\n",
+    "# Recreate ground truth with current date to get latest data\n",
+    "from importlib import reload\n",
+    "ground_truth = reload(ground_truth)\n",
+    "\n",
+    "# Determine season for submission\n",
+    "submission_dt = pd.to_datetime(submission_date)\n",
+    "season_first_year_submission = str(season_setup.get_fluseason_year(submission_dt))\n",
+    "\n",
+    "gt1 = ground_truth.GroundTruth.for_flusight(\n",
+    "    season_first_year=season_first_year_submission,\n",
+    "    data_date=datetime.datetime.today(),\n",
+    "    mask_date=datetime.datetime.today(),  # Use today to get all available data\n",
+    "    channels=channels,\n",
+    "    image_size=image_size,\n",
+    "    nogit=True\n",
+    ")\n",
+    "\n",
+    "print(f\"✓ Ground truth updated for season {season_first_year_submission}-{int(season_first_year_submission)+1}\")\n",
+    "print(f\"  Data available through week: {gt1.inpaintfrom_idx - 1}\")\n",
+    "print(f\"  This will be included in the forecast CSV files\")\n",
+    "\n",
+    "# %%\n",
+    "# Create output directory\n",
+    "output_dir = Path(\"operational_output\") / str(submission_date)\n",
+    "output_dir.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "# Export using ground truth helper\n",
+    "team_abbrv = \"UNC_IDD-InfluPaint\"\n",
+    "gt1.export_forecasts_2023(\n",
+    "    fluforecasts_ti=fluforecasts_ti,\n",
+    "    forecasts_national=forecasts_national,\n",
+    "    directory=str(output_dir),\n",
+    "    prefix=f\"{team_abbrv}\",\n",
+    "    forecast_date=submission_date,\n",
+    "    save_plot=True,\n",
+    "    nochecks=True\n",
+    ")\n",
+    "\n",
+    "print(f\"✓ Forecasts exported to: {output_dir}\")\n",
+    "print(f\"  - CSV files: {len(list(output_dir.glob('*.csv')))} files\")\n",
+    "print(f\"  - Plots: {len(list(output_dir.glob('*.png')))} + {len(list(output_dir.glob('*.pdf')))} files\")\n",
+    "\n",
+    "# %%\n",
+    "len(np.zeros(len(gt1.season_setup.locations)+1))\n",
+    "\n",
+    "# %%\n",
+    "gt1.season_setup.locations\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Optional: Save Raw Arrays\n",
+    "#\n",
+    "# Save the raw forecast arrays for further analysis.\n",
+    "\n",
+    "# %%\n",
+    "save_raw_arrays = True  # Set to True to save\n",
+    "\n",
+    "if save_raw_arrays:\n",
+    "    np.save(output_dir / f\"{submission_date}_fluforecasts_raw.npy\", fluforecasts)\n",
+    "    np.save(output_dir / f\"{submission_date}_fluforecasts_transformed_inv.npy\", fluforecasts_ti)\n",
+    "    np.save(output_dir / f\"{submission_date}_forecasts_national.npy\", forecasts_national)\n",
+    "    print(f\"✓ Saved raw arrays to {output_dir}\")\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Optional: Log to MLflow\n",
+    "#\n",
+    "# Track this forecasting run in MLflow for reproducibility.\n",
+    "\n",
+    "# %%\n",
+    "log_to_mlflow = False  # Set to True to enable MLflow logging\n",
+    "\n",
+    "if log_to_mlflow:\n",
+    "    import mlflow\n",
+    "\n",
+    "    experiment_name = \"influpaint_interactive_forecasts\"\n",
+    "    mlflow.set_experiment(experiment_name)\n",
+    "\n",
+    "    with mlflow.start_run(run_name=f\"forecast_{forecast_date}_{config_name}\"):\n",
+    "        # Log parameters\n",
+    "        mlflow.log_params({\n",
+    "            \"scenario_id\": scenario_id,\n",
+    "            \"scenario_string\": scenario_spec.scenario_string,\n",
+    "            \"forecast_date\": forecast_date,\n",
+    "            \"config_name\": config_name,\n",
+    "            \"batch_size\": batch_size,\n",
+    "            \"model_source\": model_source,\n",
+    "            \"timesteps\": ddpm.timesteps,\n",
+    "            \"device\": device,\n",
+    "        })\n",
+    "\n",
+    "        # Log metrics\n",
+    "        mlflow.log_metrics({\n",
+    "            \"num_samples\": len(forecasts_national),\n",
+    "            \"forecast_horizon_weeks\": image_size - gt1.inpaintfrom_idx + 1,\n",
+    "            \"national_peak_median\": float(np.median(forecasts_national.max(axis=1))),\n",
+    "            \"national_peak_mean\": float(np.mean(forecasts_national.max(axis=1))),\n",
+    "        })\n",
+    "\n",
+    "        # Log artifacts\n",
+    "        mlflow.log_artifacts(str(output_dir), \"forecasts\")\n",
+    "\n",
+    "        print(f\"✓ Logged to MLflow experiment: {experiment_name}\")\n",
+    "\n",
+    "# %%\n",
+    "submission_date\n",
+    "\n",
+    "# %% [markdown]\n",
+    "# ## Session Complete\n",
+    "#\n",
+    "# Forecasts have been generated and exported. You can now:\n",
+    "# - Review the plots in the output directory\n",
+    "# - Submit the CSV files to FluSight\n",
+    "# - Run additional analyses on the raw forecast arrays\n",
+    "# - Try different configs or forecast dates by modifying the configuration cell\n",
+    "\n",
+    "# %%\n",
+    "print(\"=\" * 60)\n",
+    "print(\"SESSION SUMMARY\")\n",
+    "print(\"=\" * 60)\n",
+    "print(f\"Scenario: {scenario_spec.scenario_string}\")\n",
+    "print(f\"Forecast date: {forecast_date}\")\n",
+    "print(f\"Config: {config_name}\")\n",
+    "print(f\"Samples generated: {len(forecasts_national)}\")\n",
+    "print(f\"Output directory: {output_dir}\")\n",
+    "print(f\"Model source: {model_source}\")\n",
+    "print(\"=\" * 60)"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/rsv_inpaint.py b/rsv_inpaint.py
new file mode 100644
index 0000000..bc84fad
--- /dev/null
+++ b/rsv_inpaint.py
@@ -0,0 +1,398 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+from tqdm.auto import tqdm
+import torch
+import numpy as np
+import pandas as pd
+import datetime
+import sys
+from pathlib import Path
+
+# InfluPaint modular imports
+from influpaint.utils import SeasonAxis, plotting as idplots
+from influpaint.batch.scenarios import get_training_scenario, create_scenario_objects
+from influpaint.batch.config import (
+    copaint_config_library,
+    create_folders,
+    get_git_revision_short_hash,
+)
+from influpaint.utils import ground_truth
+
+
+# CoPaint imports
+sys.path.append("CoPaint4influpaint")
+from guided_diffusion import O_DDIMSampler
+
+# Configure plotting
+sns.set_style("whitegrid")
+
+
+# === USER CONFIGURATION ===
+scenario_id = 868  # Choose your training scenario
+forecast_date = "2026-01-24"  # YYYY-MM-DD format
+config_name = "celebahq_noTTJ5"  # CoPaint config name
+batch_size = 512
+image_size = 64
+channels = 1
+
+# Model source: Choose ONE of the following options
+# Option 1: Auto-find model from MLflow experiment (recommended - same as mask_experiments)
+# experiment_name = "paper-2025-07-22_training"  # MLflow experiment name
+# run_id = None
+# model_path = None
+
+# Option 2: Specify MLflow run_id directly (uncomment to use)
+# experiment_name = None
+# run_id = "abc123def456"  # Your MLflow run ID
+# model_path = None
+
+# Option 3: Load from filesystem (uncomment to use)
+experiment_name = None
+run_id = None
+model_path = "rsv.pth"
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Device: {device}")
+if device == "cuda":
+    from influpaint.utils.helpers import cuda_mem_info
+
+    print(cuda_mem_info())
+    torch.cuda.empty_cache()
+    print(cuda_mem_info())
+
+
+scenario_spec = get_training_scenario(scenario_id)
+print(f"Scenario {scenario_id}: {scenario_spec.scenario_string}")
+print(f"  DDPM: {scenario_spec.ddpm_name}")
+print(f"  UNet: {scenario_spec.unet_name}")
+print(f"  Dataset: {scenario_spec.dataset_name}")
+print(f"  Transform: {scenario_spec.transform_name}")
+print(f"  Enrich: {scenario_spec.enrich_name}")
+
+# Create season setup for Flusight geography
+season_setup = SeasonAxis.for_flusight(remove_us=True, remove_territories=True)
+
+# Create model, dataset, and transforms using scenario helper
+print("\nCreating model, dataset, and transforms...")
+ddpm, dataset, transform, enrich, scaling_per_channel, data_mean, data_sd = (
+    create_scenario_objects(
+        scenario_spec,
+        season_setup,
+        image_size,
+        channels,
+        batch_size,
+        epochs=1,  # Not used for inference
+        device=device,
+    )
+)
+
+print(f"Dataset size: {len(dataset)} samples")
+print(f"Scaling per channel: {scaling_per_channel}")
+print(f"Data mean: {data_mean:.2f}, std: {data_sd:.2f}")
+print(f"Timesteps: {ddpm.timesteps}")
+
+
+from influpaint.batch.inpainting import load_model
+from influpaint.batch.generate_inpainting_jobs import get_finished_models
+
+# Determine run_id if using experiment_name
+if experiment_name:
+    print(
+        f"Finding run ID for scenario {scenario_id} in experiment '{experiment_name}'..."
+    )
+    finished_models = get_finished_models(experiment_name)
+
+    # Find the specific model for this scenario
+    target_model = None
+    for model in finished_models:
+        if model["scenario_id"] == scenario_id:
+            target_model = model
+            break
+
+    if target_model is None:
+        raise ValueError(
+            f"No finished model found for scenario {scenario_id} in experiment '{experiment_name}'"
+        )
+
+    run_id = target_model["run_id"]
+    print(f"✓ Found run ID: {run_id}")
+    print(f"  Model scenario: {target_model['scenario_string']}")
+    model_source = f"mlflow_experiment:{experiment_name}/scenario:{scenario_id}"
+
+elif run_id:
+    print(f"Using specified run_id: {run_id}")
+    model_source = f"mlflow_run:{run_id}"
+
+elif model_path:
+    print(f"Using model from filesystem: {model_path}")
+    model_source = f"filesystem:{model_path}"
+
+else:
+    raise ValueError("Must provide either experiment_name, run_id, or model_path")
+
+# Load the model using the unified load_model function
+print("Loading model checkpoint...")
+load_model(ddpm, run_id=run_id, model_path=model_path)
+print(f"✓ Model loaded from: {model_source}")
+
+
+forecast_dt = pd.to_datetime(forecast_date)
+print(f"Forecast date: {forecast_dt.date()}")
+
+# Determine flu season year dynamically
+season_first_year = str(season_setup.get_fluseason_year(forecast_dt))
+print(f"Detected flu season: {season_first_year}-{int(season_first_year) + 1}")
+
+# Create ground truth object
+gt1 = ground_truth.GroundTruth.for_flusight(
+    season_first_year=season_first_year,
+    data_date=datetime.datetime.today(),
+    mask_date=forecast_dt,
+    channels=channels,
+    image_size=image_size,
+    nogit=True,  # Skip git operations for interactive use
+)
+fig, ax = plt.subplots(figsize=(8, 4))
+gt1.plot_mask()
+plt.show()
+
+print(f"Ground truth shape: {gt1.gt_xarr.shape}")
+print(f"Inpainting from week: {gt1.inpaintfrom_idx}")
+print(
+    f"Known weeks: 1-{gt1.inpaintfrom_idx - 1}, Forecast weeks: {gt1.inpaintfrom_idx}-52"
+)
+
+
+# === Configure CoPaint Sampler ===
+available_configs = copaint_config_library(ddpm.timesteps)
+print(f"Available CoPaint configs: {list(available_configs.keys())}")
+
+if config_name not in available_configs:
+    raise ValueError(
+        f"Config '{config_name}' not found. Available: {list(available_configs.keys())}"
+    )
+
+conf = available_configs[config_name]
+print(f"\nUsing CoPaint config: {config_name}")
+
+sampler = O_DDIMSampler(
+    use_timesteps=np.arange(ddpm.timesteps),
+    conf=conf,
+    betas=ddpm.betas,
+    model_mean_type=None,
+    model_var_type=None,
+    loss_type=None,
+)
+print("Sampler created")
+
+
+# === Run Inpainting ===
+gt_transformed = dataset.apply_transform(np.nan_to_num(gt1.gt_xarr.data, nan=0.0))
+gt_keep_mask = torch.from_numpy(gt1.gt_keep_mask).type(torch.FloatTensor).to(device)
+gt_tensor = torch.from_numpy(gt_transformed).type(torch.FloatTensor).to(device)
+
+print(f"Running CoPaint inpainting with {batch_size} samples...")
+
+result = sampler.p_sample_loop(
+    model_fn=ddpm.model,
+    shape=(batch_size, channels, image_size, image_size),
+    conf=conf,
+    model_kwargs={
+        "gt": gt_tensor.repeat(batch_size, 1, 1, 1),
+        "gt_keep_mask": gt_keep_mask.repeat(batch_size, 1, 1, 1),
+        "mymodel": True,
+    },
+)
+
+fluforecasts = np.array(result["sample"].cpu())
+fluforecasts_ti = dataset.apply_transform_inv(fluforecasts)
+forecasts_national = fluforecasts_ti.sum(axis=-1)
+
+print(f"Generated {len(fluforecasts)} forecast samples")
+print(f"Forecast array shape: {fluforecasts_ti.shape}")
+
+
+# === Visualize National Forecast ===
+from influpaint.utils.helpers import flusight_quantile_pairs
+
+fig, axes = plt.subplots(1, 2, figsize=(14, 4), dpi=100)
+
+for iax in range(2):
+    ax = axes[iax]
+
+    for iqt in range(11):
+        ax.fill_between(
+            np.arange(64),
+            np.quantile(forecasts_national, flusight_quantile_pairs[iqt, 0], axis=0)[0],
+            np.quantile(forecasts_national, flusight_quantile_pairs[iqt, 1], axis=0)[0],
+            alpha=0.1,
+            color="darkred",
+        )
+
+    ax.plot(
+        np.arange(64),
+        np.quantile(forecasts_national, 0.5, axis=0)[0],
+        color="r",
+        lw=2,
+        label="Median forecast",
+    )
+    ax.plot(
+        gt1.gt_xarr.data[0, : gt1.inpaintfrom_idx].sum(axis=1),
+        color="k",
+        marker=".",
+        ls="",
+        markersize=8,
+        label="Observed data",
+    )
+    ax.axvline(gt1.inpaintfrom_idx - 1, c="k", ls="--", lw=1.5, alpha=0.5)
+
+    if iax == 0:
+        ax.set_xlim(0, 52)
+        ax.set_ylim(bottom=0, auto=True)
+        ax.set_title("National Forecast - Full Season")
+    else:
+        ax.set_xlim(gt1.inpaintfrom_idx - 4, gt1.inpaintfrom_idx + 4)
+        ax.set_ylim(bottom=0, auto=True)
+        ax.set_title("National Forecast - Forecast Window")
+
+    ax.grid(visible=True, alpha=0.3)
+    ax.set_xlabel("Season Week")
+    ax.set_ylabel("Hospitalizations")
+    ax.legend(loc="upper left")
+    sns.despine(ax=ax)
+
+fig.tight_layout()
+plt.show()
+
+
+# === Visualize State Forecasts ===
+def plot_state_forecasts(
+    fluforecasts_ti, gt1, season_setup, states_to_plot=None, n_samples=50
+):
+    if states_to_plot is None:
+        states_to_plot = list(range(6))
+
+    fig, axes = plt.subplots(2, 3, figsize=(15, 8), sharex=True)
+
+    for idx, place_idx in enumerate(states_to_plot):
+        if idx >= 6:
+            break
+
+        ax = axes.flat[idx]
+        location_name = season_setup.get_location_name(
+            season_setup.locations[place_idx]
+        )
+
+        for i in range(min(n_samples, batch_size)):
+            ax.plot(
+                fluforecasts_ti[i, 0, :, place_idx],
+                lw=0.3,
+                alpha=0.1,
+                color="lightcoral",
+            )
+
+        median_forecast = np.median(fluforecasts_ti[:, 0, :, place_idx], axis=0)
+        ax.plot(median_forecast, color="red", lw=2, label="Median")
+        ax.plot(
+            gt1.gt_xarr.data[0, : gt1.inpaintfrom_idx, place_idx],
+            color="k",
+            marker=".",
+            ls="",
+            markersize=6,
+            label="Observed",
+        )
+        ax.axvline(gt1.inpaintfrom_idx - 1, c="k", ls="--", lw=1, alpha=0.5)
+        ax.set_xlim(0, 52)
+        ax.set_ylim(bottom=0, auto=True)
+        ax.set_title(location_name)
+        ax.grid(visible=True, alpha=0.3)
+
+        if idx >= 3:
+            ax.set_xlabel("Season Week")
+        if idx % 3 == 0:
+            ax.set_ylabel("Hospitalizations")
+        sns.despine(ax=ax)
+
+    axes.flat[0].legend(loc="upper left")
+    fig.tight_layout()
+    plt.show()
+
+
+plot_state_forecasts(fluforecasts_ti, gt1, season_setup)
+
+
+# === Summary Statistics ===
+print("=== Forecast Summary Statistics ===")
+print(f"Number of samples: {len(forecasts_national)}")
+print(f"\nNational peak hospitalizations:")
+print(f"  Median: {np.median(forecasts_national.max(axis=1)):.0f}")
+print(f"  Mean: {np.mean(forecasts_national.max(axis=1)):.0f}")
+print(f"  10th percentile: {np.percentile(forecasts_national.max(axis=1), 10):.0f}")
+print(f"  90th percentile: {np.percentile(forecasts_national.max(axis=1), 90):.0f}")
+print(f"\nForecast horizon: {image_size - gt1.inpaintfrom_idx + 1} weeks")
+
+
+# === Export Results ===
+today = datetime.datetime.today()
+days_until_saturday = (5 - today.weekday()) % 7
+next_saturday = today + datetime.timedelta(days=days_until_saturday)
+submission_date = next_saturday.date()
+print(f"Next Saturday (submission date): {submission_date}")
+
+# Update ground truth with latest surveillance data
+print("Updating ground truth with latest surveillance data...")
+from importlib import reload
+
+ground_truth = reload(ground_truth)
+
+submission_dt = pd.to_datetime(submission_date)
+season_first_year_submission = str(season_setup.get_fluseason_year(submission_dt))
+
+gt1 = ground_truth.GroundTruth.for_flusight(
+    season_first_year=season_first_year_submission,
+    data_date=datetime.datetime.today(),
+    mask_date=datetime.datetime.today(),
+    channels=channels,
+    image_size=image_size,
+    nogit=True,
+)
+print(
+    f"Ground truth updated for season {season_first_year_submission}-{int(season_first_year_submission) + 1}"
+)
+
+output_dir = Path("operational_output") / str(submission_date)
+output_dir.mkdir(parents=True, exist_ok=True)
+
+team_abbrv = "UNC_IDD-InfluPaint"
+gt1.export_forecasts_2023(
+    fluforecasts_ti=fluforecasts_ti,
+    forecasts_national=forecasts_national,
+    directory=str(output_dir),
+    prefix=f"{team_abbrv}",
+    forecast_date=submission_date,
+    save_plot=True,
+    nochecks=True,
+)
+print(f"Forecasts exported to: {output_dir}")
+
+
+# === Save Raw Arrays ===
+np.save(output_dir / f"{submission_date}_fluforecasts_raw.npy", fluforecasts)
+np.save(
+    output_dir / f"{submission_date}_fluforecasts_transformed_inv.npy", fluforecasts_ti
+)
+np.save(output_dir / f"{submission_date}_forecasts_national.npy", forecasts_national)
+print(f"Saved raw arrays to {output_dir}")
+
+
+# === Session Summary ===
+print("=" * 60)
+print("SESSION SUMMARY")
+print("=" * 60)
+print(f"Scenario: {scenario_spec.scenario_string}")
+print(f"Forecast date: {forecast_date}")
+print(f"Config: {config_name}")
+print(f"Samples generated: {len(forecasts_national)}")
+print(f"Output directory: {output_dir}")
+print(f"Model source: {model_source}")
+print("=" * 60)