From d2e143c6190f62be0370a898a1aab02d9aa3e6b6 Mon Sep 17 00:00:00 2001 From: psferguson Date: Mon, 15 Jun 2026 13:15:49 -0700 Subject: [PATCH 01/29] multisurvey plan --- docs/source/roman_multisurvey_plan.md | 204 ++++++++++++++++++++++++++ notebooks/roman_dc2_combine_plan.md | 128 ++++++++++++++++ 2 files changed, 332 insertions(+) create mode 100644 docs/source/roman_multisurvey_plan.md create mode 100644 notebooks/roman_dc2_combine_plan.md diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md new file mode 100644 index 0000000..7532592 --- /dev/null +++ b/docs/source/roman_multisurvey_plan.md @@ -0,0 +1,204 @@ +# Multi-survey (Roman + Rubin) injection — design & roadmap + +```{warning} +This is a **living design document** for in-progress work, not a description of +shipped behaviour. It records the agreed design, the phased rollout, and — most +importantly — the **behaviour changes that need discussion** before we rely on +them. Sections marked *(future)* are designed but not yet implemented. +``` + +## Motivation + +`streamobs` was built for **single-survey** stream injection (LSST). We want to +inject mock streams that carry **both Roman and Rubin/LSST photometric columns** +in one catalog, where each band draws its photometric errors and detection +probability from its **own** survey magnitude-limit (maglim) HEALPix maps. + +A working prototype of this idea exists outside the package (the +`rubin_roman_object_classification` proposal code: survey-indexed dictionaries, +`{survey}_{band}` columns, and a "sample masses once, interpolate per survey" +photometry step). The goal here is to bring that capability **into** `streamobs` +properly, reusing the package's existing {class}`~streamobs.surveys.Survey` / +maglim-map machinery (which the prototype lacked), rather than maintaining a +parallel codebase. + +Two science realities drive specific features: + +- The Roman DC2 characterization (see *Roman DC2 Survey Files*) found the **true + photometric scatter is ~2× the reported catalog error**. So the error model + needs a *sample* model (true scatter, used to draw observed magnitudes) + distinct from a *catalog* model (the reported `magerr`). +- We need a **realistic background** (field stars + galaxies, with star/galaxy + misclassification) **without** loading the heavy DC2 mock catalogs at runtime + — using lightweight binned colour–magnitude distributions vs. maglim, and + optionally TRILEGAL for the stellar component. *(Designed below; future work.)* + +## Locked design decisions + +1. **Multi-survey via a `MultiSurveyInjector` orchestrator** that holds + `{survey_name: Survey}` and delegates per-survey work to the existing, + unchanged `Survey` per-band API. Not a composite `Survey`; not manual + re-runs. +2. **Column convention.** Multi-survey outputs use `{survey}_{band}_true`, + `{survey}_{band}_obs`, and `{survey}_{band}_err` (e.g. `roman_f158_obs`, + `lsst_r_err`). The single-survey `StreamInjector` **keeps emitting the legacy + names** `mag_{band}_obs` / `magerr_{band}` / `flag_observed` unchanged. +3. **Sample-vs-catalog error split, backward-compatible by default.** `Survey` + gains the *structure* for two error models — `log_photo_error_sample` (drives + the noise draw) and `log_photo_error_catalog` (written as `magerr`) — but + **defaults to one relation for both** (`report_error_factor = 1.0` ⇒ catalog + == sample ⇒ existing outputs unchanged). Separating them is opt-in: set a + factor, or supply a second CSV. +4. **Sample stellar masses once, interpolate per survey.** This is a correctness + requirement (see below) and the engine of the whole feature. +5. **Backward compatibility is by column-schema + public API**, not internal + coupling. Downstream consumers read pre-generated CSVs by column name + (`mag_g_obs`/`mag_r_obs`/`flag_observed`) and use the + `StreamInjector(survey).inject(df, bands=[...])` API. Both are preserved; + multi-survey support is purely additive. + +## Behaviour changes for discussion + +```{important} +These are deliberate changes from current behaviour. They are flagged here for +review **before** we depend on them — they are not silently adopted. +``` + +### `nstars` becomes "exactly N stars" (was an emergent IMF count) + +Today {meth}`~streamobs.model.IsochroneModel.sample` converts `nstars` into a +total stellar mass and lets `ugali`'s `iso.simulate()` return a *random-length* +IMF realization — so the number of stars returned is stochastic and generally +**≠ `nstars`**. + +The multi-survey requirement (the *same physical star* must get consistent Roman +**and** Rubin magnitudes) forces us instead to draw a fixed set of initial +masses once and interpolate each survey's magnitudes from them: + +```python +init_mass, mass_pdf, *_ = base_iso.sample(mass_min=mass_min, mass_steps=mass_steps) +sampled_masses = rng.choice(init_mass[sel], size=nstars, p=imf_pdf) # exactly nstars +# then, per survey: mag_band = np.interp(sampled_masses, init_mass, mag_band) + dist_mod +``` + +This returns *exactly* `nstars` stars. It is almost certainly the right +semantics for injection (you control N, and it is shared across surveys), but it +changes what `StreamModel.sample(size)` returns and could shift normalization in +any analysis that relied on the old emergent count. **Open for discussion.** + +### Where Roman Vega→AB conversion lives + +`ugali` appears to deliver Roman isochrone magnitudes in **Vega**, while our +catalogs are **AB**; the prototype corrects this after `isochrone_factory` with a +`ROMAN_ZEROPOINTS[...]["diff"]` table. + +**Current plan (do both, in order):** + +1. **This branch:** implement the correction in `streamobs` as a single isolated + shim — `IsochroneModel._apply_vega_to_ab`, gated by a per-survey `vega_to_ab` + config flag — so the feature works now without blocking on an upstream + release. It is structured so that if `ugali` later returns AB natively we just + set `vega_to_ab: false` and the shim becomes a no-op / is removed. +2. **Off the critical path:** pursue native AB support (or an explicit + photometric-system flag) in `ugali` itself, since `ugali` owns the isochrone + photometric system and every downstream user would benefit. + +*(If we decide to commit to the `ugali`-native route up front, the shim in +Phase 3 is dropped.)* + +## Phased rollout + +Phases 1–4 are the current branch; Phases 5–6 are designed here but deferred. + +### Phase 1 — Sample vs. catalog error models on `Survey` + +- `Survey`: replace the single `log_photo_error` field with + `log_photo_error_sample`, `log_photo_error_catalog`, and + `report_error_factor: float = 1.0`; keep a `log_photo_error` property alias. +- `Survey.get_photo_error(band, mag, maglim, kind="sample")`: `kind` selects the + interpolator; `kind="catalog"` falls back to sample if no catalog model is + loaded. Default reproduces today's numbers exactly. +- `SurveyFactory`: resolve the sample file (or legacy `log_photo_error`); load an + explicit `log_photo_error_catalog` file if given, else derive the catalog model + from the sample table via a `scale` argument on `set_photo_error` + (subtract `log10(report_error_factor)`). +- `StreamInjector.inject`: draw noise with the **sample** error; write the + **catalog** error as `magerr`; S/N cut uses the catalog error. + +### Phase 2 — De-hardcode the injector to arbitrary bands + +- New `streamobs/columns.py` with `obs_col` / `err_col` / `true_col` / + `flag_col(band, survey=None)` helpers (`survey=None` ⇒ legacy names). +- `observed.py`: remove the `bands in {"r","g"}` hard block; generalize the + valid-flux check, the S/N cut (default to the survey's `completeness_band`), + and the detection-flag logic to arbitrary bands. Existing per-band nside + handling already supports Roman nside=1024 vs. LSST nside=128. + +### Phase 3 — Multi-band / multi-survey `IsochroneModel` + +- `IsochroneModel` accepts either today's single-survey config or a multi-survey + form (`surveys: {name: {survey, band_1, band_2, vega_to_ab}}`), building a dict + of `ugali` isochrones. +- New `sample_masses(...)` (shared mass draw) and a `sample(...)` that returns + `{(survey, band): apparent_mag}` by interpolating those masses per survey; a + `sample_legacy()` wrapper preserves the `(mag_g, mag_r)` return for existing + callers. +- `_apply_vega_to_ab` shim (see above). `StreamModel.sample`/`complete_catalog` + derive their magnitude columns from the isochrone's bands rather than the + literal `mag_g`/`mag_r`. + +### Phase 4 — `MultiSurveyInjector` + +- Refactor the per-band body of `StreamInjector.inject` into a shared + `_inject_one_survey(...)` helper. +- `MultiSurveyInjector(surveys).inject(data, survey_bands, ...)`: + (1) one shared sky placement; (2) one shared true-magnitude fill (masses + sampled once); (3) a per-survey loop writing `{survey}_{band}_obs/_err` and + `{survey}_flag_observed` using each survey's own `completeness_band` and maglim + maps. Per-survey RNG via `rng.spawn(...)` for order-independent reproducibility. +- A *scene* config (`config/scenes/roman_rubin_demo.yaml`) lists the surveys, + bands, per-survey isochrones, and shared stream geometry. + +### Phase 5 *(future)* — Lightweight background + galaxy misclassification + +- New `streamobs/background.py`: a `CMDDistribution` (binned colour–magnitude + distribution vs. maglim, stored raw so one file serves any isochrone) and a + `BackgroundGenerator` that, per HEALPix pixel, looks up the local maglim, + selects the nearest-maglim CMD slice, scales counts linearly by pixel area, + Poisson-draws the count, samples multi-band magnitudes, places objects + uniformly within the pixel, and optionally applies a matched filter. +- Independent, pluggable `StellarBackground` / `GalaxyBackground` models. +- Galaxy misclassification: a new `Survey.get_galaxy_misclassification` curve and + an `is_galaxy`-aware `detect_flag`, so misclassified galaxies leak into the + stellar sample (and `perfect_galstarsep=True` ⇒ no leakage). A build script + reads DC2 truth+det **once, offline** to emit the lightweight files; the + runtime never loads DC2. + +### Phase 6 *(future)* — TRILEGAL + docs + +- `TrilegalStellarBackground` implementing the same interface, **lazy** (reads a + user-provided TRILEGAL table or a `fetch` callable; never imported at module + import). Documentation polish for the `{survey}_{band}` outputs, the error + split, and scenes. + +## Development fixtures (this branch) + +Survey data files (maglim maps, efficiency / photo-error CSVs) are **not** +committed — they are downloaded into the git-ignored `data/surveys//`. +To keep this branch self-contained and testable without the real Roman/Rubin +data, we add **dummy surveys**: small committed configs +(`config/surveys/*_dummy.yaml`) plus a generator that synthesizes tiny HEALPix +maglim maps and CSV tables at test time. The real `roman_dc2.yaml` is **not** +recreated here, so it can land cleanly when the `roman_hlwas` work merges. + +## Key files + +| File | Phase | Role | +|---|---|---| +| `streamobs/surveys.py` | 1 | sample/catalog error fields, `get_photo_error(kind=)`, loader | +| `streamobs/columns.py` | 2 | NEW — column-name helpers | +| `streamobs/observed.py` | 1,2,4 | error wiring; de-hardcode bands; `_inject_one_survey`; `MultiSurveyInjector` | +| `streamobs/model.py` | 3 | multi-band `IsochroneModel`; band-generalized `StreamModel` | +| `streamobs/multisurvey.py` | 4 | NEW — orchestrator (or a class in `observed.py`) | +| `config/scenes/roman_rubin_demo.yaml` | 4 | NEW — multi-survey scene | +| `streamobs/background.py` | 5 *(future)* | NEW — lightweight background | diff --git a/notebooks/roman_dc2_combine_plan.md b/notebooks/roman_dc2_combine_plan.md new file mode 100644 index 0000000..153a7ae --- /dev/null +++ b/notebooks/roman_dc2_combine_plan.md @@ -0,0 +1,128 @@ +# Roman DC2 mock: plan to build a single truth catalog with observations + +**Status:** PLAN ONLY — not executed yet. +**Source:** Troxel et al. 2023, *A Joint Roman + Rubin Synthetic Wide-Field Imaging Survey* +([arXiv:2209.06829](https://arxiv.org/abs/2209.06829)). +**Data:** `/astro/store/shire/stream_team/stream_finding/data/roman_mock` +(symlinked as `data/surveys/roman_dc2/`). ~20 deg², **1039 coadd tiles**, tiles named by +center `{ra}_{dec}` in degrees (e.g. `50.93_-38.8`). +**Python:** `/astro/store/shiren/conda-envs/stream_team/envs/streamobs/bin/python` +(astropy 7.2, numpy, pandas, healpy; no fitsio). + +--- + +## 1. What the files actually are (verified by inspection) + +| File(s) | Count | Granularity | Key columns | Notes | +|---|---|---|---|---| +| `det/dc2_det_{tile}.fits.gz` | 2078 | per coadd, **one row per detection** | `number`, `alphawin_j2000`,`deltawin_j2000` (RA/Dec **deg**), `flux_auto`,`fluxerr_auto`, `mag_auto`, `mag_auto_{Y106,J129,H158,F184}` (+magerr,flux,fluxerr), `flags`, `class_star`, shape moments | SExtractor on the coadd. ~21k rows/tile. | +| `truth/dc2_index_{tile}.fits.gz` | 1479 (1039 real + 440 empty) | per coadd, **one row per object** | `ind` (truth ID), `ra`,`dec` (**deg**), `mag_{Y106,J129,H158,F184}`, `dered_{...}`, `gal_star` (**1=star, 0=gal**), `sca`,`dither`,`x`,`y`,`stamp`,`start_row` | **THE truth product to use.** 440 files are 53-byte empty placeholders (tiles with no objects). | +| `truth/coadd/dc2_index_{tile}.fits.gz` | 1481 | — | — | **Byte-identical** to `truth/dc2_index_{tile}` (confirmed via `filecmp`). Ignore one of them. | +| `truth/dc2_index_star.fits.gz` | 1 | **per (object × SCA exposure)** | `ind,sca,dither,x,y,ra,dec,mag,stamp,xmin,xmax,ymin,ymax,dudx,dudy,dvdx,dvdy,start_row` | 414 MB, ~6.36M rows. RA/Dec in **RADIANS**. Single-epoch index; **not needed** for coadd matching. | +| `truth/dc2_index.fits.gz` | 1 | **per (object × SCA exposure)** | same 18 cols as star index | **78 GB.** All objects (gal+star). Header `NAXIS2=0` (streaming FITS — astropy reads 0 rows; see §5). **Not needed for this task.** | +| `truth/dc2_coaddlist.fits.gz` | 1 | per coadd tile | `tilename,coadd_i,coadd_j,coadd_ra,coadd_dec,d_ra,d_dec,input_list` | 1838 rows; `input_list` = contributing exposures. Optional metadata. | + +### The key realization +**We do NOT need the 78 GB `dc2_index.fits` (nor the star index) for this.** +The per-coadd `truth/dc2_index_{tile}.fits.gz` files already carry, per object: +truth RA/Dec (deg), truth mags in all 4 Roman bands, dereddening, and the star/galaxy +flag. They are tile-for-tile aligned with the `det/dc2_det_{tile}.fits.gz` files. So the +whole job reduces to **per-tile positional matching** — tractable and parallel. + +The big index is only needed if you later want single-epoch (per-SCA) info: which exposures +saw an object, its pixel position/postage stamp, etc. + +--- + +## 2. The combine = per-tile positional match (truth ← det) + +Following the paper's matching recipe: + +For each of the **1039 real coadd tiles** (intersection of det-tile names and non-empty truth-tile names): + +1. **Load truth tile** → table of objects (ind, ra, dec, mag_*, dered_*, gal_star, ...). +2. **Load det tile** → detections (alphawin_j2000, deltawin_j2000, mag_auto_*, flux_auto, fluxerr_auto, flags, class_star). +3. **Cut det**: `S/N = flux_auto / fluxerr_auto > 5` (paper's threshold; removes only ~0.05%). + Optionally also `flags == 0` (stricter; the paper removes ~32% via flags — leave this as a toggle, default OFF). +4. **Match** truth → det by sky position with **1.0 arcsec** radius + (`astropy.coordinates.SkyCoord.match_to_catalog_sky`, or a KD-tree on a local tangent plane). + - Paper's rule: among matches within 1″, when ambiguous take the closest **in magnitude** + among the up-to-3 nearest. v1 can just take the **nearest neighbor within 1″**; add the + mag-tiebreak as a refinement. +5. **Left-join on truth**: every truth row is kept. Attach the matched det columns + (prefixed `det_`) when a match exists; else NaN. Add `detected` (bool) and `match_sep_arcsec`. +6. **Tag** each row with `tile` (the `{ra}_{dec}` string). +7. **Concatenate** all tiles → one catalog. Write to **parquet** (fast, typed) — and/or FITS. + +Output is then a single **truth-complete** catalog: one row per true object across the +footprint, with observed (detected) quantities where they exist. From it you can trivially +derive detection efficiency / completeness vs. magnitude, color, `gal_star`, etc., which is +exactly what stream-injection / selection-function work needs. + +### Output schema (proposed) +``` +ind, tile, ra, dec, gal_star, +mag_Y106, mag_J129, mag_H158, mag_F184, # truth +dered_Y106, dered_J129, dered_H158, dered_F184, # truth +detected (bool), match_sep_arcsec, +det_number, det_ra, det_dec, +det_mag_auto, det_mag_auto_Y106..F184, +det_flux_auto, det_fluxerr_auto, det_sn, +det_flags, det_class_star +``` +(`mag_* == 0.0` in truth means "no flux in that band" → treat as NaN on load.) + +--- + +## 3. Column subset for the big index (`dc2_index.fits`, 78 GB) — if you still want it + +You offered to pre-subset it. **For the coadd truth+det catalog you can skip it entirely** +(use the per-tile truth files). If you do subset it (e.g. for per-SCA / single-epoch studies), +the 18 columns are: + +| keep? | column | type | meaning | +|---|---|---|---| +| ✅ | `ind` | int64 | object ID — links to input truth catalog (join key across files) | +| ✅ | `ra`,`dec` | float64 | sky position (**radians** in this file) | +| ✅ | `mag` | float64 | true magnitude (in that exposure's band) | +| ✅ | `sca` | int64 | Roman detector (1–18) | +| ✅ | `dither` | int64 | exposure / pointing ID | +| ➖ | `x`,`y` | float64 | pixel position on the SCA | +| ➖ | `stamp`,`start_row` | int64 | postage-stamp pointers into the image-stamp file | +| ❌ | `xmin,xmax,ymin,ymax` | int64 | stamp bounding box | +| ❌ | `dudx,dudy,dvdx,dvdy` | float64 | local WCS Jacobian | + +Minimal useful subset: **`ind, sca, dither, ra, dec, mag`** (6 of 18 → ~⅓ the size). +Add `x,y,stamp,start_row` if you need to find/cut postage stamps. Note: a single object +appears in **many rows** here (once per SCA exposure it lands on), so you must group by `ind`. + +--- + +## 4. Decisions to confirm before coding + +1. **Stars only, or all objects?** streamobs is stellar streams → likely `gal_star==1`. + But keeping galaxies lets us model the contaminating background. → *propose: keep all, + carry `gal_star`, filter downstream.* +2. **flags cut?** S/N>5 only (your call), or also `flags==0` (drops ~32%, removes + blends/edges). → *propose: S/N>5 default, `flags==0` as an option.* +3. **Match radius / tie-break:** 1.0″ nearest-neighbor (v1) vs. paper's mag-tiebreak FoF. → *propose: 1.0″ NN first, refine if needed.* +4. **Output format/location:** parquet under `data/surveys/roman_dc2/` (+ optional FITS). +5. **Galaxy de-blending:** the paper notes 20–30% of Rubin objects split into multiple + Roman objects; with a 1″ radius a det can match several truths — we keep the truth-centric + left join (each truth → its nearest det), so this is handled implicitly. Flag if needed. + +--- + +## 5. Implementation notes / gotchas + +- **Read gzipped FITS**: `with gzip.open(path,'rb') as f: Table(astropy.io.fits.open(io.BytesIO(f.read()))[1].data)`. + (astropy's direct `.fits.gz` open chokes on the big NAXIS2=0 files; the per-tile files open fine.) +- **`NAXIS2=0` streaming files** (star/master index only): astropy returns 0 rows. To read: + skip the primary + extension headers (2880-byte blocks to `END`), then + `np.frombuffer(rest, dtype=<144-byte big-endian dtype>)`; n_rows = data_bytes // 144. +- **Units**: per-tile truth + det are **degrees**; star/master index are **radians**. +- **Missing mags**: truth `mag_* == 0.0` and det un-matched → use NaN. +- **Parallelism**: 1039 independent tiles. Natural fan-out — one worker per tile, then concat. + (Good candidate for a Workflow run, or simple multiprocessing / joblib.) +- **Sanity check tile** `50.93_-38.8`: 34378 truth objects (175 stars, 34203 gals); + 21382 detections, 21372 with S/N>5; truth & det RA/Dec ranges overlap as expected. From 8bab5a4446ac35dfcb719426569e16fc575f5057 Mon Sep 17 00:00:00 2001 From: psferguson Date: Mon, 15 Jun 2026 13:49:46 -0700 Subject: [PATCH 02/29] phase 1 of refactor --- .gitignore | 5 ++ docs/source/roman_multisurvey_plan.md | 62 +++++++++----- streamobs/observed.py | 18 ++-- streamobs/surveys.py | 115 ++++++++++++++++++++++---- 4 files changed, 159 insertions(+), 41 deletions(-) diff --git a/.gitignore b/.gitignore index a998a36..9e4f7a0 100644 --- a/.gitignore +++ b/.gitignore @@ -132,3 +132,8 @@ dmypy.json data/surveys/* data/others/* .DS_Store + +# External reference repos (design references only, not part of streamobs) +/survey_systematics_in_LSST_streams/ +/rubin_roman_object_classification/ +/lsst_dc2_scratch/ diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md index 7532592..884ed6d 100644 --- a/docs/source/roman_multisurvey_plan.md +++ b/docs/source/roman_multisurvey_plan.md @@ -44,11 +44,21 @@ Two science realities drive specific features: `lsst_r_err`). The single-survey `StreamInjector` **keeps emitting the legacy names** `mag_{band}_obs` / `magerr_{band}` / `flag_observed` unchanged. 3. **Sample-vs-catalog error split, backward-compatible by default.** `Survey` - gains the *structure* for two error models — `log_photo_error_sample` (drives - the noise draw) and `log_photo_error_catalog` (written as `magerr`) — but - **defaults to one relation for both** (`report_error_factor = 1.0` ⇒ catalog - == sample ⇒ existing outputs unchanged). Separating them is opt-in: set a - factor, or supply a second CSV. + holds two error curves, both functions of `delta_mag = mag − maglim`: + - `log_photo_error_catalog` — the survey's **reported** error curve (the + existing `photoerror_*.csv`). Written as `magerr` and drives the S/N cut. + Always present; loaded from the `log_photo_error_catalog` key or the legacy + `log_photo_error` key. + - `log_photo_error_sample` — an **optional second** curve giving the **true + scatter** of observed−true magnitudes; drives the noise draw. Config key + `log_photo_error_sample`. + + If no sample curve is supplied, the noise draw falls back to the catalog + curve ⇒ existing outputs unchanged. Separating them is opt-in: supply the + second CSV. (Earlier drafts proposed a scalar `report_error_factor` / + inflation curve to *derive* one from the other; superseded by two independent + curves, which is more general and matches the Roman DC2 products that measure + the true scatter directly.) 4. **Sample stellar masses once, interpolate per survey.** This is a correctness requirement (see below) and the engine of the whole feature. 5. **Backward compatibility is by column-schema + public API**, not internal @@ -110,20 +120,34 @@ Phase 3 is dropped.)* Phases 1–4 are the current branch; Phases 5–6 are designed here but deferred. -### Phase 1 — Sample vs. catalog error models on `Survey` - -- `Survey`: replace the single `log_photo_error` field with - `log_photo_error_sample`, `log_photo_error_catalog`, and - `report_error_factor: float = 1.0`; keep a `log_photo_error` property alias. -- `Survey.get_photo_error(band, mag, maglim, kind="sample")`: `kind` selects the - interpolator; `kind="catalog"` falls back to sample if no catalog model is - loaded. Default reproduces today's numbers exactly. -- `SurveyFactory`: resolve the sample file (or legacy `log_photo_error`); load an - explicit `log_photo_error_catalog` file if given, else derive the catalog model - from the sample table via a `scale` argument on `set_photo_error` - (subtract `log10(report_error_factor)`). -- `StreamInjector.inject`: draw noise with the **sample** error; write the - **catalog** error as `magerr`; S/N cut uses the catalog error. +### Phase 1 — Sample vs. catalog error models on `Survey` ✅ *(implemented)* + +Two independent error curves, both vs `delta_mag = mag − maglim`: + +- ✅ `Survey`: replaced the single `log_photo_error` field with + `log_photo_error_catalog` (reported error, the base curve) and + `log_photo_error_sample` (optional true-scatter curve). Kept a read/write + `log_photo_error` property aliasing the **catalog** model (the legacy field's + meaning — back-compat for existing tests and any code that sets it). +- ✅ `Survey.get_photo_error(band, mag, maglim, kind="catalog")`: `kind` selects + the curve via `_resolve_log_photo_error`. `kind="catalog"` returns the reported + error; `kind="sample"` returns the true-scatter curve, falling back to the + catalog curve when no sample curve is loaded. Default `kind="catalog"` + reproduces today's numbers exactly. +- ✅ `SurveyFactory._load_survey_data`: loads the catalog curve from + `log_photo_error_catalog` (or the legacy `log_photo_error`) key, and an + optional sample curve from the `log_photo_error_sample` key. No factor / + inflation logic — both curves are read directly via `set_photo_error`. +- ✅ `StreamInjector.inject`: draws noise with the **sample** error + (`kind="sample"`); writes the **catalog** error as `magerr` and runs the S/N + cut on it (`kind="catalog"`). + +**Backward compatibility verified (94 passing tests from the test branch):** with +only the legacy `log_photo_error` curve and no `log_photo_error_sample`, the +sample draw falls back to the catalog curve, so the noise draw, `magerr`, and the +S/N cut are bit-for-bit identical to the previous single-curve behaviour. To opt +in, add `log_photo_error_sample: ` (the measured true-scatter curve) to a +survey's `survey_files`. ### Phase 2 — De-hardcode the injector to arbitrary bands diff --git a/streamobs/observed.py b/streamobs/observed.py index b7838ea..7a718dc 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -175,17 +175,23 @@ def inject(self, data, bands=["r", "g"], **kwargs): else: pix_maglim = pix - # Calculate photometric errors + # Calculate photometric errors. The *sample* error (true scatter) + # drives the noise draw; the *catalog* error (reported) is written + # as magerr and used for the S/N cut. When no sample curve is loaded, + # the sample error falls back to the catalog error, so the two are + # identical (outputs unchanged from the single-curve behaviour). + maglim_vals = self.survey.get_maglim(band, pixel=pix_maglim) + mag_err_sample = self.survey.get_photo_error( + band, apparent_mag_true, maglim_vals, kind="sample" + ) mag_err = self.survey.get_photo_error( - band, - apparent_mag_true, - self.survey.get_maglim(band, pixel=pix_maglim), + band, apparent_mag_true, maglim_vals, kind="catalog" ) - # Sample measured magnitudes + # Sample measured magnitudes using the sample (true-scatter) error mag_obs = self.sample_measured_magnitudes( apparent_mag_true, - mag_err, + mag_err_sample, rng=rng, seed=seed, **kwargs, diff --git a/streamobs/surveys.py b/streamobs/surveys.py index 588a324..903dc9c 100644 --- a/streamobs/surveys.py +++ b/streamobs/surveys.py @@ -57,9 +57,20 @@ class Survey: Magnitude difference for saturation threshold in the initial functions. completeness_band : str, optional Band used to derive completeness function (e.g., 'r'). - log_photo_error : callable, optional - Photometric error model f(delta_mag) -> log10(mag_error). - Same function used for all bands, obtained from r band. + log_photo_error_catalog : callable, optional + *Catalog* (reported) photometric error model f(delta_mag) -> log10(mag_error), + where ``delta_mag = mag - maglim``. This is the survey's reported error + curve (e.g. ``photoerror_r.csv``); it is written as ``magerr`` and drives + the S/N cut. Loaded from the ``log_photo_error_catalog`` config key, or the + legacy ``log_photo_error`` key. Always present for a configured survey. + log_photo_error_sample : callable, optional + *Sample* photometric error model f(delta_mag) -> log10(mag_error): the true + scatter of observed-minus-true magnitudes, used to draw the observed + magnitudes. Optional second curve (config key ``log_photo_error_sample``). + If not provided, the noise draw falls back to the catalog model, which + reproduces the previous single-curve behaviour exactly. + log_photo_error : callable + Read/write alias for ``log_photo_error_catalog`` (backward compatibility). Examples -------- @@ -109,7 +120,8 @@ class Survey: completeness: Optional[Callable] = None completeness_band: Optional[str] = None delta_saturation: Optional[float] = None - log_photo_error: Optional[Callable] = None + log_photo_error_catalog: Optional[Callable] = None + log_photo_error_sample: Optional[Callable] = None # Band-independent maps ebv_map: Optional[np.ndarray] = None @@ -128,6 +140,41 @@ def __post_init__(self): if self.sys_error is None: self.sys_error = {} + @property + def log_photo_error(self) -> Optional[Callable]: + """Backward-compatible alias for the *catalog* (reported) error model.""" + return self.log_photo_error_catalog + + @log_photo_error.setter + def log_photo_error(self, func: Optional[Callable]): + self.log_photo_error_catalog = func + + def _resolve_log_photo_error(self, kind: str = "catalog") -> Optional[Callable]: + """ + Select the log photometric-error interpolator. + + Parameters + ---------- + kind : str + ``"catalog"`` returns the catalog model: the reported error curve, + written as ``magerr`` and used for the S/N cut. ``"sample"`` returns + the sample model: the true scatter (observed-minus-true) that drives + the noise draw, falling back to the catalog model when no sample curve + is loaded (which reproduces the previous single-curve behaviour). + + Returns + ------- + callable or None + The selected ``f(delta_mag) -> log10(mag_error)`` interpolator. + """ + if kind == "catalog": + return self.log_photo_error_catalog + elif kind == "sample": + if self.log_photo_error_sample is not None: + return self.log_photo_error_sample + return self.log_photo_error_catalog + raise ValueError(f"kind must be 'sample' or 'catalog', got '{kind}'") + @classmethod def load( cls, @@ -232,7 +279,7 @@ def get_extinction(self, band: str, pixel: int = None) -> float: return extinction[pixel] def get_photo_error( - self, band: str, magnitude: float, maglim: float, **kwargs + self, band: str, magnitude: float, maglim: float, kind: str = "catalog", **kwargs ) -> float: """ Get photometric error estimate. @@ -245,6 +292,11 @@ def get_photo_error( True apparent magnitude(s). maglim : float or np.ndarray Magnitude limit(s) at the position(s). + kind : str, optional + Which error model to evaluate: ``"catalog"`` (reported error, written + as ``magerr`` and used for S/N cuts) or ``"sample"`` (true scatter, + used to draw the observed magnitudes). ``"sample"`` falls back to the + catalog model if no sample curve is loaded. Default is ``"catalog"``. **kwargs Additional keyword arguments: @@ -260,10 +312,11 @@ def get_photo_error( Raises ------ ValueError - If photo error model is not loaded. + If the requested photo error model is not loaded. """ - if self.log_photo_error is None: - raise ValueError("Photo error model not loaded") + log_photo_error = self._resolve_log_photo_error(kind) + if log_photo_error is None: + raise ValueError(f"Photo error model ('{kind}') not loaded") delta_saturation = kwargs.get("delta_saturation", self.delta_saturation) @@ -275,13 +328,13 @@ def get_photo_error( np.where( ((delta_mag) <= delta_saturation) & (magnitude >= self.saturation[band]), - self.log_photo_error(delta_saturation), - self.log_photo_error(delta_mag), + log_photo_error(delta_saturation), + log_photo_error(delta_mag), ) ) mag_err_stat = np.where( magnitude < self.saturation[band], - 10 ** self.log_photo_error(delta_saturation - 1), + 10 ** log_photo_error(delta_saturation - 1), mag_err_stat, ) # saturation at the bright end @@ -1094,16 +1147,46 @@ def _load_survey_data(cls, survey: Survey, config: dict, **kwargs): if verbose: print("No classification efficiency file found, skipping.") - # Load photometric error model (same for all bands) + # Load photometric error model(s), same for all bands. Two curves: + # - catalog : reported error vs delta_mag (the survey's photoerror file). + # Written as magerr and used for the S/N cut. Always loaded. + # - sample : optional second curve giving the true scatter of + # observed-minus-true magnitudes; drives the noise draw. + # Backward compatible: with no sample curve, the noise draw falls back to + # the catalog curve, reproducing the previous single-curve behaviour. if verbose: print("\nLoading photometric error model...") - if "log_photo_error" in survey_config: - # Use default saturation if not band-specific + + # Catalog (reported) error model: prefer explicit 'log_photo_error_catalog', + # else the legacy 'log_photo_error' key. + catalog_key = ( + "log_photo_error_catalog" + if "log_photo_error_catalog" in survey_config + else "log_photo_error" + ) + if catalog_key in survey_config: + cls._load_file( + survey, + survey_config, + "log_photo_error_catalog", + "Photometric error model (catalog / reported)", + lambda f: cls.set_photo_error( + f, delta_saturation=survey.delta_saturation + ), + data_path_survey, + data_path_others, + filename=survey_config.get(catalog_key), + **kwargs, + ) + + # Optional sample (true-scatter) error model. If absent, the noise draw + # falls back to the catalog model (get_photo_error(kind="sample")). + if "log_photo_error_sample" in survey_config: cls._load_file( survey, survey_config, - "log_photo_error", - "Photometric error model", + "log_photo_error_sample", + "Photometric error model (sample / true scatter)", lambda f: cls.set_photo_error( f, delta_saturation=survey.delta_saturation ), From 9e6a90fcdf9aebeded62a9e85ba79a0bc7b70860 Mon Sep 17 00:00:00 2001 From: psferguson Date: Mon, 15 Jun 2026 13:58:38 -0700 Subject: [PATCH 03/29] phase 2 --- docs/source/roman_multisurvey_plan.md | 39 +++++++++++++++++++----- streamobs/columns.py | 36 ++++++++++++++++++++++ streamobs/observed.py | 44 +++++++++++++++------------ 3 files changed, 91 insertions(+), 28 deletions(-) create mode 100644 streamobs/columns.py diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md index 884ed6d..11cdde7 100644 --- a/docs/source/roman_multisurvey_plan.md +++ b/docs/source/roman_multisurvey_plan.md @@ -74,6 +74,18 @@ These are deliberate changes from current behaviour. They are flagged here for review **before** we depend on them — they are not silently adopted. ``` +### S/N detection cut now applies to *all* injected bands *(Phase 2, adopted)* + +Previously the injector applied its SNR ≥ 5 cut to a single hard-coded band +(`detection_mag_cut=["g"]`). Now the default is **every band passed to +`inject()`** — a star must have SNR ≥ 5 in *all* injected bands to be flagged +observed. For the default LSST `bands=["r", "g"]` this is stricter than before +(it adds the r-band SNR requirement on top of g), so detection counts drop +relative to the old default. Rationale: it generalizes cleanly to any band set +and makes "observed" mean "detected in everything you asked for". Callers can +restore any prior behaviour by passing `detection_mag_cut=[...]` explicitly +(e.g. `["g"]` for the old LSST default). **Adopted, but flagged for review.** + ### `nstars` becomes "exactly N stars" (was an emergent IMF count) Today {meth}`~streamobs.model.IsochroneModel.sample` converts `nstars` into a @@ -149,14 +161,25 @@ S/N cut are bit-for-bit identical to the previous single-curve behaviour. To opt in, add `log_photo_error_sample: ` (the measured true-scatter curve) to a survey's `survey_files`. -### Phase 2 — De-hardcode the injector to arbitrary bands - -- New `streamobs/columns.py` with `obs_col` / `err_col` / `true_col` / - `flag_col(band, survey=None)` helpers (`survey=None` ⇒ legacy names). -- `observed.py`: remove the `bands in {"r","g"}` hard block; generalize the - valid-flux check, the S/N cut (default to the survey's `completeness_band`), - and the detection-flag logic to arbitrary bands. Existing per-band nside - handling already supports Roman nside=1024 vs. LSST nside=128. +### Phase 2 — De-hardcode the injector to arbitrary bands ✅ *(implemented)* + +- ✅ New `streamobs/columns.py` with `true_col` / `obs_col` / `err_col` helpers + `(band, survey=None)` and `flag_col(survey=None)` (`survey=None` ⇒ legacy + names `mag_` / `mag__obs` / `magerr_` / `flag_observed`; + a survey name ⇒ the `__…` multi-survey convention for Phase 4). +- ✅ `observed.py`: removed the `bands in {"r","g"}` hard block; the true-mag + read, the observed/err columns, the valid-flux check (now ANDs over every + injected band), the S/N cut, the per-survey detection flag, and the stored + flag all route through the `columns.py` helpers and the survey's + `completeness_band`. Existing per-band nside handling already supports Roman + nside=1024 vs. LSST nside=128. +- ⚠️ The S/N-cut default changed from the hard-coded `["g"]` to **all injected + bands** — see *Behaviour changes for discussion* above. + +**Validated:** single-band (`bands=["r"]`) and arbitrary band sets now inject +without the old hard block; legacy column names and the `inject(df, bands=[...])` +API are unchanged; the test-branch suite stays green (94 passing; the lone +`des_yr6` photo-error failure is pre-existing and unrelated). ### Phase 3 — Multi-band / multi-survey `IsochroneModel` diff --git a/streamobs/columns.py b/streamobs/columns.py new file mode 100644 index 0000000..45b522b --- /dev/null +++ b/streamobs/columns.py @@ -0,0 +1,36 @@ +""" +Column-name helpers for injected catalogs. + +These centralize the naming convention so the injector is not hard-coded to +specific bands (``mag_r_obs``, ``magerr_g``, ...). Two conventions are +supported, selected by the ``survey`` argument: + +- **Legacy / single-survey** (``survey=None``): ``mag_`` (true), + ``mag__obs`` (observed), ``magerr_`` (error), ``flag_observed``. + This is what :class:`~streamobs.observed.StreamInjector` emits and what + downstream consumers already read, so it is preserved unchanged. +- **Multi-survey** (``survey="roman"``, ``"lsst"``, ...): ``__true``, + ``__obs``, ``__err``, ``_flag_observed``. + Used by the (future) ``MultiSurveyInjector`` so each band's columns are + namespaced by survey. +""" + + +def true_col(band, survey=None): + """Column holding the *true* (noiseless) apparent magnitude for ``band``.""" + return f"{survey}_{band}_true" if survey else f"mag_{band}" + + +def obs_col(band, survey=None): + """Column holding the *observed* (noisy) magnitude for ``band``.""" + return f"{survey}_{band}_obs" if survey else f"mag_{band}_obs" + + +def err_col(band, survey=None): + """Column holding the reported magnitude error for ``band``.""" + return f"{survey}_{band}_err" if survey else f"magerr_{band}" + + +def flag_col(survey=None): + """Column holding the detection flag (band-independent).""" + return f"{survey}_flag_observed" if survey else "flag_observed" diff --git a/streamobs/observed.py b/streamobs/observed.py index 7a718dc..4c71f8c 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -10,6 +10,7 @@ import numpy as np import pandas as pd +from .columns import err_col, flag_col, obs_col, true_col from .model import StreamModel from .plotting import plot_stream_in_mask from .surveys import Survey @@ -100,7 +101,8 @@ def inject(self, data, bands=["r", "g"], **kwargs): nside : int, optional HEALPix nside parameter. Default is 4096. detection_mag_cut : list of str, optional - Bands to apply SNR detection cut. Default is ['g']. + Bands to apply the SNR detection cut to. Default is all injected + bands (every band in ``bands`` must have SNR >= 5). save : bool, optional Whether to save the output data. Default is False. folder : str or Path, optional @@ -152,9 +154,6 @@ def inject(self, data, bands=["r", "g"], **kwargs): # Process each band for band in bands: - if band not in ["r", "g"]: - raise ValueError("Currently only 'r' and 'g' bands are supported.") - # Get extinction for this band nside_ebv = hp.get_nside(self.survey.ebv_map) if nside_ebv != nside: @@ -164,7 +163,7 @@ def inject(self, data, bands=["r", "g"], **kwargs): extinction_band = self.survey.get_extinction(band, pixel=pix_ebv) # Calculate true apparent magnitudes (including extinction) - apparent_mag_true = data["mag_" + band] + extinction_band + apparent_mag_true = data[true_col(band)] + extinction_band # Get magnitude limits nside_maglim = hp.get_nside(self.survey.maglim_maps[band]) @@ -216,8 +215,8 @@ def inject(self, data, bands=["r", "g"], **kwargs): # Add new columns new_columns = pd.DataFrame( { - "mag_" + band + "_obs": mag_obs, - "magerr_" + band: mag_err, + obs_col(band): mag_obs, + err_col(band): mag_err, } ) @@ -260,10 +259,13 @@ def inject(self, data, bands=["r", "g"], **kwargs): ) # Build combined detection flags - # Start with flux validity check (not BAD_MAG) - flag_valid_flux = data["mag_r_obs"] != "BAD_MAG" - if "g" in bands: - flag_valid_flux &= data["mag_g_obs"] != "BAD_MAG" + # Start with flux validity check (not BAD_MAG) across all injected bands + flag_valid_flux = None + for band in bands: + band_valid = data[obs_col(band)] != "BAD_MAG" + flag_valid_flux = ( + band_valid if flag_valid_flux is None else flag_valid_flux & band_valid + ) # Combine with completeness flag_observed = ( @@ -278,8 +280,8 @@ def inject(self, data, bands=["r", "g"], **kwargs): else flag_valid_flux ) - # Apply SNR cuts - detection_mag_cut = kwargs.get("detection_mag_cut", ["g"]) + # Apply SNR cuts. Default: require SNR >= SNR_min in every injected band. + detection_mag_cut = kwargs.get("detection_mag_cut", list(bands)) SNR_min = 5.0 for band in detection_mag_cut: @@ -291,18 +293,20 @@ def inject(self, data, bands=["r", "g"], **kwargs): continue if verbose: print(f"Applying detection cut on {band}-band with SNR >= {SNR_min}") - SNR = 1.0 / data["magerr_" + band] + SNR = 1.0 / data[err_col(band)] flag_observed &= SNR >= SNR_min if perfect_galstarsep: flag_perfect &= SNR >= SNR_min - # Force SNR cut on r-band for perfect gal/star separation (because it's not included in the detection efficiency functions, while it is for the completeness functions) + # Force SNR cut on the completeness band for perfect gal/star separation + # (the SNR cut is baked into the completeness functions but not into the + # detection-only efficiency functions used for the perfect flag). if perfect_galstarsep: - SNR_r = 1.0 / data["magerr_r"] - flag_perfect &= SNR_r >= SNR_min + SNR_compl = 1.0 / data[err_col(self.survey.completeness_band)] + flag_perfect &= SNR_compl >= SNR_min # Store flags in DataFrame - data["flag_observed"] = flag_observed + data[flag_col()] = flag_observed if perfect_galstarsep: data["flag_perfect_galstarsep"] = flag_perfect @@ -438,7 +442,7 @@ def complete_data(self, data, bands=["r", "g"], **kwargs): >>> data2 = injector.complete_data(df2, gc_frame='last') # Reuses frame from data1 """ - required_columns = ["ra", "dec"] + [f"mag_{band}" for band in bands] + required_columns = ["ra", "dec"] + [true_col(band) for band in bands] rng = kwargs.pop("rng", None) seed = kwargs.pop("seed", None) @@ -470,7 +474,7 @@ def complete_data(self, data, bands=["r", "g"], **kwargs): # Sample missing magnitudes if needed mag_bands_missing = [ - f"mag_{band}" for band in bands if f"mag_{band}" not in data.columns + true_col(band) for band in bands if true_col(band) not in data.columns ] if mag_bands_missing: stream_config = kwargs.get("stream_config", None) From e298dcf234d0e32768c19f73f7320d9fc03b8de0 Mon Sep 17 00:00:00 2001 From: psferguson Date: Mon, 15 Jun 2026 15:06:38 -0700 Subject: [PATCH 04/29] phase 3 --- docs/source/roman_multisurvey_plan.md | 42 ++-- streamobs/model.py | 294 ++++++++++++++++++++++---- 2 files changed, 277 insertions(+), 59 deletions(-) diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md index 11cdde7..6a10a47 100644 --- a/docs/source/roman_multisurvey_plan.md +++ b/docs/source/roman_multisurvey_plan.md @@ -181,18 +181,36 @@ without the old hard block; legacy column names and the `inject(df, bands=[...]) API are unchanged; the test-branch suite stays green (94 passing; the lone `des_yr6` photo-error failure is pre-existing and unrelated). -### Phase 3 — Multi-band / multi-survey `IsochroneModel` - -- `IsochroneModel` accepts either today's single-survey config or a multi-survey - form (`surveys: {name: {survey, band_1, band_2, vega_to_ab}}`), building a dict - of `ugali` isochrones. -- New `sample_masses(...)` (shared mass draw) and a `sample(...)` that returns - `{(survey, band): apparent_mag}` by interpolating those masses per survey; a - `sample_legacy()` wrapper preserves the `(mag_g, mag_r)` return for existing - callers. -- `_apply_vega_to_ab` shim (see above). `StreamModel.sample`/`complete_catalog` - derive their magnitude columns from the isochrone's bands rather than the - literal `mag_g`/`mag_r`. +### Phase 3 — Multi-band / multi-survey `IsochroneModel` ✅ *(implemented)* + +- ✅ `IsochroneModel.create_isochrone` accepts either today's single-survey + config or a multi-survey form (`surveys: {name: {survey, band_1, band_2, + vega_to_ab}}` plus shared `name`/`age`/`z`/... at top level), building one + `ugali` isochrone per survey (`self.isos`, `self.survey_bands`). +- ✅ New `sample_masses(...)` draws the initial masses *once* from the primary + isochrone's IMF (exactly `nstars`), and `sample_multisurvey(...)` interpolates + those shared masses into every survey's bands → `{(survey, band): + apparent_mag}` (same physical star, consistent across surveys). The legacy + `sample(nstars, dm)` still returns the `(mag_band_1, mag_band_2)` tuple (the + primary survey's two bands) so existing callers are unchanged. +- ✅ `_apply_vega_to_ab(survey, band, mag)` shim — gated by a per-survey + `vega_to_ab: {band: offset}` mapping (`AB = Vega + offset`); a no-op when + absent. Applied in both the single- and multi-survey paths. +- ✅ `StreamModel.sample`/`complete_catalog` derive their magnitude columns from + the isochrone via `_iso_mag_columns()` / `_sample_iso_mags()`: legacy + `mag_g`/`mag_r` for a single-survey isochrone, `__true` for a + multi-survey one. Naming routes through `columns.true_col`. + +**Note on the chosen API:** the plan originally named the dict-returning method +`sample` and a tuple `sample_legacy`; to avoid `sample()` changing return *type* +by config (a foot-gun for existing callers), the implementation keeps `sample()` +as the `(mag_1, mag_2)` tuple and adds `sample_multisurvey()` for the dict. +`StreamModel` dispatches on `isochrone.multi_survey`. + +**Validated:** single-survey model tests unchanged (test branch green, 94 +passing); a two-isochrone multi-survey config produces consistent shared-mass +magnitudes, the Vega→AB offset shifts only the configured band, and +`StreamModel.sample` emits the `__true` columns. ### Phase 4 — `MultiSurveyInjector` diff --git a/streamobs/model.py b/streamobs/model.py index d620912..59511bc 100644 --- a/streamobs/model.py +++ b/streamobs/model.py @@ -9,6 +9,7 @@ import numpy as np import pandas as pd +from streamobs.columns import true_col from streamobs.functions import function_factory from streamobs.samplers import sampler_factory @@ -115,7 +116,10 @@ def sample(self, size): ------- pandas.DataFrame Columns include: ``phi1``, ``phi2``, ``dist``, ``mu1``, ``mu2``, - ``rv``, ``mag_g``, ``mag_r`` (some may be None if the sub-model is absent). + ``rv``, and the isochrone magnitude columns. For a single-survey + isochrone these are the legacy ``mag_g`` / ``mag_r`` (its two bands); + for a multi-survey isochrone they are ``__true`` per + survey/band. Some may be None if the sub-model is absent. """ # Sample phi1 and phi2 @@ -128,13 +132,6 @@ def sample(self, size): else: dist = None - # Sample magnitudes from isochrone - if self.isochrone: - - mag_g, mag_r = self.isochrone.sample(size, dist) - else: - mag_g, mag_r = None, None - # Sample kinematics if self.velocity: mu1, mu2, rv = self.velocity.sample(phi1) @@ -150,12 +147,45 @@ def sample(self, size): "mu1": mu1, "mu2": mu2, "rv": rv, - "mag_g": mag_g, - "mag_r": mag_r, } ) + + # Sample magnitudes from isochrone (band-/survey-general columns) + if self.isochrone: + mag_data = self._sample_iso_mags(size, dist) + else: + mag_data = {"mag_g": None, "mag_r": None} # legacy placeholder + for col, vals in mag_data.items(): + df[col] = vals + return df + def _iso_mag_columns(self): + """Names of the magnitude columns produced by the isochrone model. + + Single-survey ⇒ legacy ``[mag_, mag_]``; multi-survey ⇒ + ``[__true, ...]`` for every survey/band; no isochrone ⇒ []. + """ + iso = self.isochrone + if iso is None: + return [] + if getattr(iso, "multi_survey", False): + cols = [] + for name in iso.surveys: + band_1, band_2 = iso.survey_bands[name] + cols += [true_col(band_1, name), true_col(band_2, name)] + return cols + return [true_col(iso.band_1), true_col(iso.band_2)] + + def _sample_iso_mags(self, n, dist): + """Sample isochrone magnitudes as a ``{column_name: values}`` dict.""" + iso = self.isochrone + if getattr(iso, "multi_survey", False): + mags = iso.sample_multisurvey(n, dist) + return {true_col(band, name): vals for (name, band), vals in mags.items()} + mag_1, mag_2 = iso.sample(n, dist) + return {true_col(iso.band_1): mag_1, true_col(iso.band_2): mag_2} + def complete_catalog( self, catalog, @@ -222,7 +252,10 @@ def complete_catalog( """ # Supported outputs and capability filtering # Columns this method can fill using the configured model - all_cols = ("phi1", "phi2", "dist", "mag_g", "mag_r", "mu1", "mu2", "rv") + # Magnitude columns are band-/survey-general (legacy mag_g/mag_r for a + # single-survey isochrone; __true for multi-survey). + mag_cols = self._iso_mag_columns() + all_cols = ("phi1", "phi2", "dist") + tuple(mag_cols) + ("mu1", "mu2", "rv") target_cols = ( list(all_cols) if columns_to_add is None @@ -236,11 +269,6 @@ def complete_catalog( if unknown: warnings.warn(f"Ignoring unknown columns: {unknown}") - if self.isochrone is None: - removed = [c for c in target_cols if c in ("mag_g", "mag_r")] - target_cols = [c for c in target_cols if c not in ("mag_g", "mag_r")] - if removed: - self._info(verbose, "Isochrone model not defined; skipping magnitudes.") if self.velocity is None: removed = [c for c in target_cols if c in ("mu1", "mu2", "rv")] target_cols = [c for c in target_cols if c not in ("mu1", "mu2", "rv")] @@ -282,8 +310,8 @@ def complete_catalog( # dist (needs phi1) if "dist" in target_cols or ( - any(c in target_cols for c in ("mag_g", "mag_r")) - and any(c not in df.columns for c in ("mag_g", "mag_r")) + any(c in target_cols for c in mag_cols) + and any(c not in df.columns for c in mag_cols) ): idx = self._missing_idx(df, "dist") if len(idx) > 0: @@ -298,10 +326,11 @@ def complete_catalog( self._info(verbose, f"Filled {len(idx)} dist values.") # magnitudes (need dist and isochrone) - if any(c in target_cols for c in ("mag_g", "mag_r")): - if "mag_g" in df.columns and "mag_r" in df.columns: + if any(c in target_cols for c in mag_cols): + if all(c in df.columns for c in mag_cols): self._info( - verbose, "'mag_g' and 'mag_r' already exist; no sampling performed." + verbose, + f"{mag_cols} already exist; no sampling performed.", ) else: # Verify distance modulus availability @@ -310,15 +339,14 @@ def complete_catalog( "dist is required to sample apparent magnitudes; include 'dist' in `columns_to_add` or provide it in catalog" ) dist_vals = df["dist"].to_numpy() - mag_g, mag_r = self.isochrone.sample(N, dist_vals) - # Add both magnitudes to keep colors consistent across rows - if "mag_g" in df.columns or "mag_r" in df.columns: + # Sample all bands together to keep colors consistent across rows + if any(c in df.columns for c in mag_cols): self._info( verbose, - "Overwriting existing mag_g and/or mag_r to keep colors consistent.", + "Overwriting existing magnitude columns to keep colors consistent.", ) - df["mag_g"] = mag_g - df["mag_r"] = mag_r + for col, vals in self._sample_iso_mags(N, dist_vals).items(): + df[col] = vals self._info(verbose, f"Filled magnitudes for {N} rows.") # velocities (need phi1 and velocity model) @@ -549,31 +577,192 @@ class DistanceModel(ConfigurableModel): class IsochroneModel(ConfigurableModel): - """Isochrone wrapper using ``ugali`` for CMD sampling.""" + """Isochrone wrapper using ``ugali`` for CMD sampling. + + Two configuration forms are supported: + + - **Single-survey** (legacy): the isochrone section carries the ``ugali`` + factory keys directly (``name``, ``survey``, ``age``, ``z``, ``band_1``, + ``band_2``, ...). :meth:`sample` returns ``(mag_band_1, mag_band_2)`` and + reproduces the previous behaviour exactly. + - **Multi-survey**: a ``surveys`` mapping + ``{survey_name: {survey, band_1, band_2, vega_to_ab}}`` plus shared keys + (``name``, ``age``, ``z``, ...) at the top level. One ``ugali`` isochrone + is built per survey from the *same* stellar population, so a single shared + draw of initial masses (:meth:`sample_masses`) is interpolated into every + survey's bands — giving the same physical star consistent magnitudes + across surveys. :meth:`sample_multisurvey` returns + ``{(survey, band): apparent_mag}``. + """ + + # Defaults for the shared isochrone mass grid (see ugali Isochrone.sample) + _MASS_MIN = 0.1 + _MASS_STEPS = 1000 def __init__(self, config, **kwargs): super().__init__(config, **kwargs) def create_isochrone(self, config): - """Construct the underlying ``ugali`` isochrone from configuration. + """Construct the underlying ``ugali`` isochrone(s) from configuration. Parameters ---------- config : dict - Isochrone factory configuration. + Isochrone factory configuration. A ``surveys`` key selects the + multi-survey form; otherwise the single-survey (legacy) form is used. """ + self.multi_survey = "surveys" in config + if self.multi_survey: + self._create_multisurvey_isochrones(config) + else: + self._create_single_isochrone(config) + + def _build_iso(self, factory_config): + """Build one ``ugali`` isochrone with its distance modulus reset to 0.""" import ugali.isochrone - self.iso = ugali.isochrone.factory(**config) - self.iso.params["distance_modulus"].set_bounds([0, 50]) + iso = ugali.isochrone.factory(**factory_config) + iso.params["distance_modulus"].set_bounds([0, 50]) + iso.distance_modulus = 0 + return iso + + def _create_single_isochrone(self, config): + """Build a single isochrone from a legacy (flat) isochrone config.""" if "distance_modulus" in config: warnings.warn( - 'Please use the "distance_modulus" section of the configuration file, instead of the isochrone section, to define a distance module.' + 'Please use the "distance_modulus" section of the configuration ' + "file, instead of the isochrone section, to define a distance modulus." ) - self.iso.distance_modulus = 0 + factory_config = {k: v for k, v in config.items() if k != "vega_to_ab"} + self.iso = self._build_iso(factory_config) + self.survey_name = config.get("survey") + self.band_1 = config.get("band_1") + self.band_2 = config.get("band_2") + # Unified bookkeeping so the shared helpers work in both modes. + self.surveys = [self.survey_name] + self.isos = {self.survey_name: self.iso} + self.survey_bands = {self.survey_name: (self.band_1, self.band_2)} + self._vega_to_ab = {self.survey_name: config.get("vega_to_ab")} + + def _create_multisurvey_isochrones(self, config): + """Build one isochrone per survey, sharing the top-level stellar params.""" + shared = {k: v for k, v in config.items() if k != "surveys"} + self.isos = {} + self.survey_bands = {} + self._vega_to_ab = {} + self.surveys = [] + for name, scfg in config["surveys"].items(): + factory_config = { + **shared, + **{k: v for k, v in scfg.items() if k != "vega_to_ab"}, + } + self.isos[name] = self._build_iso(factory_config) + self.survey_bands[name] = (scfg.get("band_1"), scfg.get("band_2")) + self._vega_to_ab[name] = scfg.get("vega_to_ab") + self.surveys.append(name) + # Primary isochrone drives the shared mass draw and the legacy sample(). + self.survey_name = self.surveys[0] + self.iso = self.isos[self.survey_name] + self.band_1, self.band_2 = self.survey_bands[self.survey_name] + + def sample_masses(self, nstars, rng=None, mass_min=None, mass_steps=None): + """Draw ``nstars`` initial stellar masses from the shared isochrone IMF. + + The masses are drawn once from the primary isochrone's mass PDF and are + meant to be interpolated into each survey's bands, so the same physical + star gets consistent magnitudes across surveys. - def sample(self, nstars, distance_modulus, **kwargs): - """Simulate magnitudes in g and r bands. + Parameters + ---------- + nstars : int + Number of stars to draw (returns exactly this many). + rng : numpy.random.Generator, optional + Random number generator (a default one is created if omitted). + mass_min, mass_steps : float, int, optional + Passed to the ``ugali`` isochrone sampler. + + Returns + ------- + numpy.ndarray + Initial masses, shape ``(nstars,)``. + """ + rng = np.random.default_rng() if rng is None else rng + mass_min = self._MASS_MIN if mass_min is None else mass_min + mass_steps = self._MASS_STEPS if mass_steps is None else mass_steps + grid = self.iso.sample(mass_min=mass_min, mass_steps=mass_steps) + mass_init, mass_pdf = grid[0], grid[1] + pdf = mass_pdf / mass_pdf.sum() + return rng.choice(mass_init, size=int(nstars), p=pdf) + + def _absolute_mags(self, iso, masses, mass_min=None, mass_steps=None): + """Interpolate a survey isochrone's absolute mags at given init masses.""" + mass_min = self._MASS_MIN if mass_min is None else mass_min + mass_steps = self._MASS_STEPS if mass_steps is None else mass_steps + grid = iso.sample(mass_min=mass_min, mass_steps=mass_steps) + mass_init, mag_1, mag_2 = grid[0], grid[3], grid[4] + order = np.argsort(mass_init) + mass_init = mass_init[order] + return ( + np.interp(masses, mass_init, mag_1[order]), + np.interp(masses, mass_init, mag_2[order]), + ) + + def _apply_vega_to_ab(self, survey, band, mag): + """Apply an optional per-band Vega->AB offset (``AB = Vega + offset``). + + ``vega_to_ab`` in the config is a ``{band: offset}`` mapping; if absent + or empty, the magnitudes are returned unchanged. This is the isolated + shim that lets multi-survey injection work while ``ugali`` still returns + some bands in Vega; it becomes a no-op once bands are natively AB. + """ + spec = self._vega_to_ab.get(survey) + if not spec: + return mag + if isinstance(spec, dict): + return mag + spec.get(band, 0.0) + warnings.warn( + f"vega_to_ab for survey '{survey}' is set but is not a " + "{band: offset} mapping; no Vega->AB correction applied." + ) + return mag + + @staticmethod + def _add_distance_modulus(abs_mag, distance_modulus): + """Add a scalar or per-star distance modulus to absolute magnitudes.""" + if distance_modulus is None: + return abs_mag + return abs_mag + np.asarray(distance_modulus, dtype=float) + + def sample_multisurvey(self, nstars, distance_modulus, rng=None, **kwargs): + """Sample apparent magnitudes for every ``(survey, band)``. + + A single shared draw of initial masses (see :meth:`sample_masses`) is + interpolated into each survey's bands, so the same physical star is + consistent across surveys. + + Returns + ------- + dict + ``{(survey_name, band): apparent_magnitude_array}``. + """ + masses = self.sample_masses( + nstars, + rng=rng, + mass_min=kwargs.get("mass_min"), + mass_steps=kwargs.get("mass_steps"), + ) + out = {} + for name in self.surveys: + band_1, band_2 = self.survey_bands[name] + abs_1, abs_2 = self._absolute_mags(self.isos[name], masses) + abs_1 = self._apply_vega_to_ab(name, band_1, abs_1) + abs_2 = self._apply_vega_to_ab(name, band_2, abs_2) + out[(name, band_1)] = self._add_distance_modulus(abs_1, distance_modulus) + out[(name, band_2)] = self._add_distance_modulus(abs_2, distance_modulus) + return out + + def sample(self, nstars, distance_modulus, rng=None, **kwargs): + """Simulate magnitudes in the two bands of the (primary) isochrone. Parameters ---------- @@ -585,23 +774,34 @@ def sample(self, nstars, distance_modulus, **kwargs): Returns ------- tuple of numpy.ndarray - ``(mag_g, mag_r)`` arrays. + ``(mag_band_1, mag_band_2)`` arrays. For a multi-survey isochrone + this returns the primary survey's two bands; use + :meth:`sample_multisurvey` to get every survey's bands. """ + if getattr(self, "multi_survey", False): + mags = self.sample_multisurvey( + nstars, distance_modulus, rng=rng, **kwargs + ) + return ( + mags[(self.survey_name, self.band_1)], + mags[(self.survey_name, self.band_2)], + ) + + # Single-survey: preserve the existing ugali.simulate-based behaviour. stellar_mass = nstars * self.iso.stellar_mass() + mag_1, mag_2 = self.iso.simulate( + stellar_mass, distance_modulus=self.iso.distance_modulus + ) if np.isscalar(distance_modulus): - mag_g, mag_r = self.iso.simulate( - stellar_mass, distance_modulus=self.iso.distance_modulus - ) - mag_g, mag_r = [ - mag + np.ones_like(mag) * distance_modulus for mag in (mag_g, mag_r) + mag_1, mag_2 = [ + mag + np.ones_like(mag) * distance_modulus for mag in (mag_1, mag_2) ] else: - mag_g, mag_r = self.iso.simulate( - stellar_mass, distance_modulus=self.iso.distance_modulus - ) - mag_g, mag_r = [mag + distance_modulus for mag in (mag_g, mag_r)] + mag_1, mag_2 = [mag + distance_modulus for mag in (mag_1, mag_2)] - return mag_g, mag_r + mag_1 = self._apply_vega_to_ab(self.survey_name, self.band_1, mag_1) + mag_2 = self._apply_vega_to_ab(self.survey_name, self.band_2, mag_2) + return mag_1, mag_2 def _dist_to_modulus(self, distance): """ From d28d6daff4ebaedf5bfbf08dc3e72043b1b339c4 Mon Sep 17 00:00:00 2001 From: psferguson Date: Mon, 15 Jun 2026 16:40:38 -0700 Subject: [PATCH 05/29] phase 4 and notebook black/isort --- config/scenes/roman_rubin_demo.yaml | 78 +++ docs/source/index.rst | 6 + docs/source/roman_multisurvey_plan.md | 133 +++--- notebooks/multisurvey_phases_demo.ipynb | 607 ++++++++++++++++++++++++ scripts/build_multisurvey_demo_nb.py | 299 ++++++++++++ streamobs/columns.py | 32 +- streamobs/model.py | 122 ++--- streamobs/observed.py | 273 ++++++++++- streamobs/plotting.py | 26 +- streamobs/samplers.py | 16 +- streamobs/surveys.py | 7 +- streamobs/utils.py | 1 + tests/test_functions.py | 177 +++++-- 13 files changed, 1563 insertions(+), 214 deletions(-) create mode 100644 config/scenes/roman_rubin_demo.yaml create mode 100644 notebooks/multisurvey_phases_demo.ipynb create mode 100644 scripts/build_multisurvey_demo_nb.py diff --git a/config/scenes/roman_rubin_demo.yaml b/config/scenes/roman_rubin_demo.yaml new file mode 100644 index 0000000..b8c9fc3 --- /dev/null +++ b/config/scenes/roman_rubin_demo.yaml @@ -0,0 +1,78 @@ +# Multi-survey demo scene: a single toy stream observed by BOTH Rubin/LSST and +# Roman. Consumed by `streamobs.observed.MultiSurveyInjector` (Phase 4). +# +# Usage (see notebooks/multisurvey_phases_demo.ipynb): +# +# import yaml, pandas as pd +# from streamobs.observed import MultiSurveyInjector +# scene = yaml.safe_load(open("config/scenes/roman_rubin_demo.yaml")) +# msi = MultiSurveyInjector(scene["surveys"]) +# df = pd.DataFrame(index=range(int(scene["stream"]["nstars"]))) +# out = msi.inject(df, scene["survey_bands"], +# stream_config=scene["stream"], seed=42) +# +# The same physical stars carry both `lsst__*` and `roman__*` +# columns; each band's errors / detection come from that survey's own maps. + +# Surveys to inject. The mapping KEY is the column namespace (lsst_r_obs, ...). +# Each value is a StreamInjector spec: a survey-name string here (loaded via +# Survey.load); could also be a {name, release} once the loader supports it. +surveys: + lsst: lsst + roman: roman + +# Bands to inject per survey. Each survey's `completeness_band` must appear here. +# NOTE: a band label is used BOTH as the ugali isochrone field name AND as the +# key into that survey's maglim/photo-error/extinction maps, so the two must +# agree. ugali's Roman fields are upper-case (F106, F158, ...); the Roman +# Survey's maps must therefore be keyed with the same upper-case labels. +survey_bands: + lsst: [r, g] + roman: [F106, F158] + +# Shared stream geometry + a MULTI-SURVEY isochrone. The isochrone draws one set +# of initial masses (exactly `nstars`) and interpolates them into every survey's +# bands, so a star's LSST and Roman magnitudes describe the same object. +stream: + nstars: 5.0e+3 + + density: + type: Uniform + xmin: -9.0 + xmax: +9.0 + + track: + center: + type: Constant + value: 0.0 + spread: + type: Constant + value: 0.2 + sampler: Gaussian + + distance_modulus: + center: + type: Line + slope: 0.1 + intercept: 16.5 + spread: + type: Constant + value: 0.0001 + sampler: Uniform + + isochrone: + # Shared stellar population (one age/metallicity for both surveys). + name: Marigo2017 + age: 12.0 + z: 0.0006 + surveys: + lsst: + survey: lsst + band_1: g + band_2: r + roman: + survey: roman + band_1: F106 + band_2: F158 + # Roman bands are AUTOMATICALLY converted Vega->AB by IsochroneModel + # (streamobs.model.ROMAN_VEGA_TO_AB); no per-config flag is needed. diff --git a/docs/source/index.rst b/docs/source/index.rst index dffb5ee..8d87f08 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -108,6 +108,12 @@ Documentation Contents data modules +.. toctree:: + :maxdepth: 2 + :caption: Design Notes + + roman_multisurvey_plan + Indices and Tables ================== diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md index 6a10a47..19f5de3 100644 --- a/docs/source/roman_multisurvey_plan.md +++ b/docs/source/roman_multisurvey_plan.md @@ -39,10 +39,16 @@ Two science realities drive specific features: `{survey_name: Survey}` and delegates per-survey work to the existing, unchanged `Survey` per-band API. Not a composite `Survey`; not manual re-runs. -2. **Column convention.** Multi-survey outputs use `{survey}_{band}_true`, - `{survey}_{band}_obs`, and `{survey}_{band}_err` (e.g. `roman_f158_obs`, - `lsst_r_err`). The single-survey `StreamInjector` **keeps emitting the legacy - names** `mag_{band}_obs` / `magerr_{band}` / `flag_observed` unchanged. +2. **Column convention (uniform `_true`/`_obs`/`_err`).** A single naming scheme + is used everywhere: `{band}_true` / `{band}_obs` / `{band}_err` / + `flag_observed` single-survey, and `{survey}_{band}_true` / + `{survey}_{band}_obs` / `{survey}_{band}_err` / `{survey}_flag_observed` + multi-survey (e.g. `roman_f158_obs`, `lsst_r_err`). The single- and + multi-survey forms differ only by the optional survey prefix. + **This intentionally drops the historical `mag_{band}` / `mag_{band}_obs` / + `magerr_{band}` names — it is *not* backward compatible** with catalogs or + downstream readers expecting those columns (decision made deliberately to + keep one convention; see decision 5). 3. **Sample-vs-catalog error split, backward-compatible by default.** `Survey` holds two error curves, both functions of `delta_mag = mag − maglim`: - `log_photo_error_catalog` — the survey's **reported** error curve (the @@ -61,11 +67,13 @@ Two science realities drive specific features: the true scatter directly.) 4. **Sample stellar masses once, interpolate per survey.** This is a correctness requirement (see below) and the engine of the whole feature. -5. **Backward compatibility is by column-schema + public API**, not internal - coupling. Downstream consumers read pre-generated CSVs by column name - (`mag_g_obs`/`mag_r_obs`/`flag_observed`) and use the - `StreamInjector(survey).inject(df, bands=[...])` API. Both are preserved; - multi-survey support is purely additive. +5. **Public API preserved; column schema deliberately changed.** The + `StreamInjector(survey).inject(df, bands=[...])` API is unchanged. The + **column names are not** — we adopt the uniform `{band}_true/_obs/_err` + scheme (decision 2) *instead of* preserving the historical + `mag_g_obs`/`mag_r_obs`/`magerr_g` names. Downstream consumers that read those + columns must be updated. This is an accepted break in exchange for one + convention across single- and multi-survey output. ## Behaviour changes for discussion @@ -86,12 +94,22 @@ and makes "observed" mean "detected in everything you asked for". Callers can restore any prior behaviour by passing `detection_mag_cut=[...]` explicitly (e.g. `["g"]` for the old LSST default). **Adopted, but flagged for review.** -### `nstars` becomes "exactly N stars" (was an emergent IMF count) +### `nstars` becomes "exactly N stars" (was an emergent IMF count) *(adopted, but flagged for review)* -Today {meth}`~streamobs.model.IsochroneModel.sample` converts `nstars` into a -total stellar mass and lets `ugali`'s `iso.simulate()` return a *random-length* -IMF realization — so the number of stars returned is stochastic and generally -**≠ `nstars`**. +```{important} +**Adopted (Phase 4).** {meth}`~streamobs.model.IsochroneModel.sample` now draws +*exactly* `nstars` (the shared-mass path described below), for **both** +single-survey and multi-survey isochrones. The single-survey +`ugali.simulate()` emergent-count path has been removed. This flag is **left in +place for review** because it changes what `StreamModel.sample(size)` returns +for existing single-survey configs — see the discussion below before relying on +the new normalization. +``` + +Previously {meth}`~streamobs.model.IsochroneModel.sample` converted `nstars` +into a total stellar mass and let `ugali`'s `iso.simulate()` return a +*random-length* IMF realization — so the number of stars returned was stochastic +and generally **≠ `nstars`**. The multi-survey requirement (the *same physical star* must get consistent Roman **and** Rubin magnitudes) forces us instead to draw a fixed set of initial @@ -108,25 +126,23 @@ semantics for injection (you control N, and it is shared across surveys), but it changes what `StreamModel.sample(size)` returns and could shift normalization in any analysis that relied on the old emergent count. **Open for discussion.** -### Where Roman Vega→AB conversion lives - -`ugali` appears to deliver Roman isochrone magnitudes in **Vega**, while our -catalogs are **AB**; the prototype corrects this after `isochrone_factory` with a -`ROMAN_ZEROPOINTS[...]["diff"]` table. +### Roman Vega→AB conversion is automatic and unconditional -**Current plan (do both, in order):** +`ugali` delivers Roman isochrone magnitudes in **Vega**, while our catalogs are +**AB**. `IsochroneModel` corrects this **unconditionally** for every Roman band +using the module-level table `streamobs.model.ROMAN_VEGA_TO_AB` (AB = Vega + +offset). The per-band offsets are the mode of the by-chip Roman zeropoints +(`Roman_zeropoints_20240301.ecsv`), the same values the +`rubin_roman_object_classification` prototype used: -1. **This branch:** implement the correction in `streamobs` as a single isolated - shim — `IsochroneModel._apply_vega_to_ab`, gated by a per-survey `vega_to_ab` - config flag — so the feature works now without blocking on an upstream - release. It is structured so that if `ugali` later returns AB natively we just - set `vega_to_ab: false` and the shim becomes a no-op / is removed. -2. **Off the critical path:** pursue native AB support (or an explicit - photometric-system flag) in `ugali` itself, since `ugali` owns the isochrone - photometric system and every downstream user would benefit. +| band | F062 | F087 | F106 | F129 | F146 | F158 | F184 | F213 | +|---|---|---|---|---|---|---|---|---| +| AB − Vega | 0.153 | 0.481 | 0.660 | 1.051 | 1.164 | 1.315 | 1.556 | 1.837 | -*(If we decide to commit to the `ugali`-native route up front, the shim in -Phase 3 is dropped.)* +There is **no config flag** — Roman bands are always converted, non-Roman bands +pass through unchanged. The code carries a `TODO` flagging that this conversion +ideally belongs in `ugali` itself (so isochrones are returned natively in AB); +when that lands the table can be removed. ## Phased rollout @@ -184,22 +200,22 @@ API are unchanged; the test-branch suite stays green (94 passing; the lone ### Phase 3 — Multi-band / multi-survey `IsochroneModel` ✅ *(implemented)* - ✅ `IsochroneModel.create_isochrone` accepts either today's single-survey - config or a multi-survey form (`surveys: {name: {survey, band_1, band_2, - vega_to_ab}}` plus shared `name`/`age`/`z`/... at top level), building one - `ugali` isochrone per survey (`self.isos`, `self.survey_bands`). + config or a multi-survey form (`surveys: {name: {survey, band_1, band_2}}` + plus shared `name`/`age`/`z`/... at top level), building one `ugali` isochrone + per survey (`self.isos`, `self.survey_bands`). - ✅ New `sample_masses(...)` draws the initial masses *once* from the primary isochrone's IMF (exactly `nstars`), and `sample_multisurvey(...)` interpolates those shared masses into every survey's bands → `{(survey, band): apparent_mag}` (same physical star, consistent across surveys). The legacy `sample(nstars, dm)` still returns the `(mag_band_1, mag_band_2)` tuple (the primary survey's two bands) so existing callers are unchanged. -- ✅ `_apply_vega_to_ab(survey, band, mag)` shim — gated by a per-survey - `vega_to_ab: {band: offset}` mapping (`AB = Vega + offset`); a no-op when - absent. Applied in both the single- and multi-survey paths. +- ✅ `_to_ab(band, mag)` converts Roman bands Vega→AB **unconditionally** using + the `ROMAN_VEGA_TO_AB` table (no config flag; non-Roman bands pass through). + Applied in the shared `sample_multisurvey` path. See the Vega→AB section above. - ✅ `StreamModel.sample`/`complete_catalog` derive their magnitude columns from - the isochrone via `_iso_mag_columns()` / `_sample_iso_mags()`: legacy - `mag_g`/`mag_r` for a single-survey isochrone, `__true` for a - multi-survey one. Naming routes through `columns.true_col`. + the isochrone via `_iso_mag_columns()` / `_sample_iso_mags()`: `_true` + for a single-survey isochrone, `__true` for a multi-survey one. + Naming routes through `columns.true_col`. **Note on the chosen API:** the plan originally named the dict-returning method `sample` and a tuple `sample_legacy`; to avoid `sample()` changing return *type* @@ -209,20 +225,31 @@ as the `(mag_1, mag_2)` tuple and adds `sample_multisurvey()` for the dict. **Validated:** single-survey model tests unchanged (test branch green, 94 passing); a two-isochrone multi-survey config produces consistent shared-mass -magnitudes, the Vega→AB offset shifts only the configured band, and -`StreamModel.sample` emits the `__true` columns. - -### Phase 4 — `MultiSurveyInjector` - -- Refactor the per-band body of `StreamInjector.inject` into a shared - `_inject_one_survey(...)` helper. -- `MultiSurveyInjector(surveys).inject(data, survey_bands, ...)`: - (1) one shared sky placement; (2) one shared true-magnitude fill (masses - sampled once); (3) a per-survey loop writing `{survey}_{band}_obs/_err` and - `{survey}_flag_observed` using each survey's own `completeness_band` and maglim - maps. Per-survey RNG via `rng.spawn(...)` for order-independent reproducibility. -- A *scene* config (`config/scenes/roman_rubin_demo.yaml`) lists the surveys, - bands, per-survey isochrones, and shared stream geometry. +magnitudes, Roman bands are converted Vega→AB by the fixed `ROMAN_VEGA_TO_AB` +offsets, and `StreamModel.sample` emits the `__true` columns. + +### Phase 4 — `MultiSurveyInjector` ✅ *(implemented)* + +- ✅ The per-band body of `StreamInjector.inject` is extracted into a shared + `StreamInjector._inject_one_survey(data, bands, survey_namespace=None, ...)` + helper. It assumes positions and true magnitudes are already present and only + does the observed/err draw, detection flags, and S/N cut, routing every column + name through `columns.py` (`survey_namespace=None` ⇒ legacy names). `inject` + now just completes the data and delegates to it, so single-survey behaviour is + unchanged. +- ✅ `MultiSurveyInjector(surveys).inject(data, survey_bands, stream_config=...)`: + (1) one shared sky placement; (2) one shared true-magnitude fill via a + multi-survey isochrone (masses sampled once → every survey's + `__true`); (3) a per-survey loop calling each survey's + `_inject_one_survey` with `survey_namespace=`, writing + `__obs/_err` and `_flag_observed` from that survey's own + `completeness_band` and maglim maps. Per-survey RNG via `rng.spawn(...)` for + order-independent reproducibility. `columns.perfect_flag_col` namespaces the + optional `perfect_galstarsep` flag. +- ✅ A *scene* config (`config/scenes/roman_rubin_demo.yaml`) lists the surveys, + per-survey bands, the multi-survey isochrone, and shared stream geometry. +- ✅ `notebooks/multisurvey_phases_demo.ipynb` walks through Phases 1–4 end to + end. ### Phase 5 *(future)* — Lightweight background + galaxy misclassification diff --git a/notebooks/multisurvey_phases_demo.ipynb b/notebooks/multisurvey_phases_demo.ipynb new file mode 100644 index 0000000..a8f0dbb --- /dev/null +++ b/notebooks/multisurvey_phases_demo.ipynb @@ -0,0 +1,607 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "956da58f", + "metadata": {}, + "source": [ + "# Multi-survey injection — Phases 1-4 demo\n", + "\n", + "This notebook walks through the `roman_multisurvey` refactor that lets `streamobs`\n", + "inject a single stream carrying **both Roman and Rubin/LSST** photometry, where\n", + "each band draws its errors and detection probability from its *own* survey.\n", + "\n", + "| Phase | What changed |\n", + "|---|---|\n", + "| **1** | `Survey` holds two error curves — a *catalog* (reported `magerr`, drives the S/N cut) and an optional *sample* (true scatter, drives the noise draw). `get_photo_error(..., kind=)` selects between them. |\n", + "| **2** | The injector is de-hardcoded off `{r, g}`; column names route through `streamobs.columns`, using a **uniform** `_true/_obs/_err` scheme (`_…` when namespaced). The S/N cut now applies to **all** injected bands. |\n", + "| **3** | `IsochroneModel` is multi-band / multi-survey: masses are drawn **once** (exactly `nstars`) and interpolated into every survey's bands, so the *same physical star* is consistent across surveys. Roman bands are auto-converted Vega→AB. |\n", + "| **4** | `MultiSurveyInjector` orchestrates one shared sky placement + one shared true-mag fill, then a per-survey loop writing `__obs/_err` and `_flag_observed`. |\n", + "\n", + "See `docs/source/roman_multisurvey_plan.md` for the full design.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1d385c8b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:33:47.506938Z", + "iopub.status.busy": "2026-06-15T23:33:47.506845Z", + "iopub.status.idle": "2026-06-15T23:33:57.035573Z", + "shell.execute_reply": "2026-06-15T23:33:57.034912Z" + } + }, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import numpy as np\n", + "import pandas as pd\n", + "import healpy as hp\n", + "import yaml\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from streamobs.surveys import Survey\n", + "from streamobs.model import StreamModel, IsochroneModel\n", + "from streamobs.observed import StreamInjector, MultiSurveyInjector\n", + "from streamobs import columns as C\n", + "\n", + "import os\n", + "# Resolve the repo root whether the notebook runs from repo root or notebooks/.\n", + "REPO = \"..\" if os.path.exists(\"../config/scenes/roman_rubin_demo.yaml\") else \".\"\n", + "rng = np.random.default_rng(42)\n" + ] + }, + { + "cell_type": "markdown", + "id": "5dd03468", + "metadata": {}, + "source": [ + "## A runnable stub survey\n", + "\n", + "The real Roman/Rubin maglim maps and CSV tables are **not committed** to this\n", + "branch (they live in the git-ignored `data/surveys/`). So that this notebook\n", + "runs end-to-end, we use a tiny `StubSurvey` that:\n", + "\n", + "* keeps the **real** `Survey.get_photo_error` (so the Phase-1 two-curve split is\n", + " genuine) and `get_maglim`,\n", + "* supplies analytic `log_photo_error_*` curves and a logistic completeness.\n", + "\n", + "The **isochrones are real** (`Marigo2017` via `ugali`). To run against real\n", + "surveys, just replace `StubSurvey(...)` with `Survey.load(\"lsst\", release=...)`\n", + "etc. — the injector code is identical.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8ed0d733", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:33:57.037569Z", + "iopub.status.busy": "2026-06-15T23:33:57.037358Z", + "iopub.status.idle": "2026-06-15T23:33:57.041674Z", + "shell.execute_reply": "2026-06-15T23:33:57.041252Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "StubSurvey ready\n" + ] + } + ], + "source": [ + "NSIDE = 1 # whole-sky single-pixel maps; enough for a synthetic demo\n", + "\n", + "class StubSurvey(Survey):\n", + " \"\"\"Minimal Survey: real photo-error machinery, analytic completeness/maps.\"\"\"\n", + "\n", + " def __init__(self, name, bands, completeness_band, maglim=27.0,\n", + " sample_inflation=1.9):\n", + " self.name = name\n", + " self.bands = list(bands)\n", + " self.completeness_band = completeness_band\n", + " self.saturation = {b: 16.0 for b in bands}\n", + " self.sys_error = {b: 0.005 for b in bands}\n", + " self.delta_saturation = -10.0\n", + " self.coeff_extinc = {b: 0.0 for b in bands}\n", + " self.ebv_map = np.zeros(hp.nside2npix(NSIDE))\n", + " self.maglim_maps = {b: np.full(hp.nside2npix(NSIDE), maglim) for b in bands}\n", + " self.coverage = np.ones(hp.nside2npix(NSIDE)) # footprint = whole sky\n", + " # Phase 1: two error curves, both functions of delta_mag = mag - maglim.\n", + " # Catalog = reported error; sample = true scatter (here ~inflation x larger,\n", + " # echoing the Roman DC2 finding that true scatter ~2x reported magerr).\n", + " self.log_photo_error_catalog = lambda dm: np.log10(\n", + " 0.01 + 0.10 * np.exp(np.clip(dm, -30, 5)))\n", + " self.log_photo_error_sample = lambda dm: np.log10(\n", + " sample_inflation * (0.01 + 0.10 * np.exp(np.clip(dm, -30, 5))))\n", + "\n", + " # analytic rolloff: ~1 when bright (mag << maglim), 0.5 at maglim, ->0 fainter\n", + " def get_completeness(self, band, mag, maglim):\n", + " return 1.0 / (1.0 + np.exp((np.asarray(mag) - np.asarray(maglim)) / 0.25))\n", + "\n", + " def get_detection_efficiency(self, band, mag, maglim):\n", + " return self.get_completeness(band, mag, maglim)\n", + "\n", + " def get_extinction(self, band, pixel=None):\n", + " return np.zeros(np.size(pixel))\n", + "\n", + "print(\"StubSurvey ready\")" + ] + }, + { + "cell_type": "markdown", + "id": "aa861d61", + "metadata": {}, + "source": [ + "## Phase 1 — sample vs. catalog photometric error\n", + "\n", + "`Survey` now carries two curves. `get_photo_error(kind=\"catalog\")` is the\n", + "reported error that becomes `magerr` and drives the S/N cut;\n", + "`get_photo_error(kind=\"sample\")` is the *true* scatter used to draw the observed\n", + "magnitude. When no sample curve is loaded, `sample` transparently falls back to\n", + "`catalog`, so legacy single-curve behaviour is bit-for-bit preserved.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "63de7e59", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:33:57.042872Z", + "iopub.status.busy": "2026-06-15T23:33:57.042761Z", + "iopub.status.idle": "2026-06-15T23:33:57.234295Z", + "shell.execute_reply": "2026-06-15T23:33:57.233794Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "no sample curve -> sample falls back to catalog: True\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sv = StubSurvey(\"lsst\", [\"g\", \"r\"], completeness_band=\"r\", maglim=26.5)\n", + "mags = np.linspace(20, 28, 200)\n", + "maglim = np.full_like(mags, 26.5)\n", + "err_cat = sv.get_photo_error(\"r\", mags, maglim, kind=\"catalog\")\n", + "err_smp = sv.get_photo_error(\"r\", mags, maglim, kind=\"sample\")\n", + "\n", + "# A survey with NO sample curve -> sample falls back to catalog (identical)\n", + "sv_legacy = StubSurvey(\"lsst\", [\"g\", \"r\"], \"r\", maglim=26.5)\n", + "sv_legacy.log_photo_error_sample = None\n", + "err_fallback = sv_legacy.get_photo_error(\"r\", mags, maglim, kind=\"sample\")\n", + "assert np.allclose(err_fallback, sv_legacy.get_photo_error(\"r\", mags, maglim, kind=\"catalog\"))\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "ax.plot(mags, err_cat, label='catalog (reported magerr, drives S/N cut)')\n", + "ax.plot(mags, err_smp, label='sample (true scatter, drives noise draw)')\n", + "ax.axvline(26.5, ls=':', c='k', lw=1, label='maglim')\n", + "ax.set_xlabel('magnitude'); ax.set_ylabel('photometric error [mag]')\n", + "ax.set_title('Phase 1: two error curves on Survey'); ax.legend(); fig.tight_layout()\n", + "print(\"no sample curve -> sample falls back to catalog:\",\n", + " np.allclose(err_fallback, err_cat))" + ] + }, + { + "cell_type": "markdown", + "id": "86c9e1fd", + "metadata": {}, + "source": [ + "## Phase 2 — arbitrary bands + `columns.py`\n", + "\n", + "The injector no longer hard-codes `{r, g}`. Column names come from\n", + "`streamobs.columns`, using one **uniform** convention: `_true` /\n", + "`_obs` / `_err` / `flag_observed` single-survey, and the same with a\n", + "`_` prefix multi-survey. (This intentionally drops the historical\n", + "`mag_` / `magerr_` names — not backward compatible.) Below we inject\n", + "Roman NIR bands `F106`/`F158` through the *single-survey* `StreamInjector` —\n", + "impossible under the old `{r,g}` block.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c54f0211", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:33:57.235495Z", + "iopub.status.busy": "2026-06-15T23:33:57.235382Z", + "iopub.status.idle": "2026-06-15T23:33:57.248981Z", + "shell.execute_reply": "2026-06-15T23:33:57.248544Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "single-survey: r_true r_obs r_err flag_observed\n", + "multi-survey : roman_F158_true roman_F158_obs roman_F158_err roman_flag_observed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "injected NIR-only bands -> columns: ['F106_obs', 'F106_err', 'F158_obs', 'F158_err', 'flag_observed']\n", + "detected: 1281 / 1500\n" + ] + } + ], + "source": [ + "print(\"single-survey:\", C.true_col(\"r\"), C.obs_col(\"r\"), C.err_col(\"r\"), C.flag_col())\n", + "print(\"multi-survey :\", C.true_col(\"F158\", \"roman\"), C.obs_col(\"F158\", \"roman\"),\n", + " C.err_col(\"F158\", \"roman\"), C.flag_col(\"roman\"))\n", + "\n", + "roman_sv = StubSurvey(\"roman\", [\"F106\", \"F158\"], completeness_band=\"F158\", maglim=27.0)\n", + "inj = StreamInjector(roman_sv)\n", + "N = 1500\n", + "df = pd.DataFrame({\n", + " \"ra\": rng.uniform(10, 20, N),\n", + " \"dec\": rng.uniform(-5, 5, N),\n", + " \"F106_true\": rng.uniform(20, 28, N),\n", + " \"F158_true\": rng.uniform(20, 28, N),\n", + "})\n", + "out = inj.inject(df, bands=[\"F106\", \"F158\"], seed=1, verbose=False)\n", + "print(\"\\ninjected NIR-only bands -> columns:\",\n", + " [c for c in out.columns if c.endswith((\"_obs\", \"_err\")) or c == \"flag_observed\"])\n", + "print(\"detected:\", int(out.flag_observed.sum()), \"/\", len(out))" + ] + }, + { + "cell_type": "markdown", + "id": "4eae6753", + "metadata": {}, + "source": [ + "## Phase 3 — multi-band / multi-survey isochrone (exactly `nstars`)\n", + "\n", + "`IsochroneModel.sample` now draws **exactly** `nstars` (a fixed mass set), for\n", + "both single- and multi-survey configs. First, the single-survey path:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cdcb361c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:33:57.250040Z", + "iopub.status.busy": "2026-06-15T23:33:57.249928Z", + "iopub.status.idle": "2026-06-15T23:33:59.883954Z", + "shell.execute_reply": "2026-06-15T23:33:59.883368Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "single-survey StreamModel.sample returns EXACTLY nstars (5000, 1234) -> OK\n" + ] + } + ], + "source": [ + "single_cfg = {\n", + " \"density\": {\"type\": \"Uniform\", \"xmin\": -9.0, \"xmax\": 9.0},\n", + " \"track\": {\"center\": {\"type\": \"Constant\", \"value\": 0.0},\n", + " \"spread\": {\"type\": \"Constant\", \"value\": 0.2}, \"sampler\": \"Gaussian\"},\n", + " \"distance_modulus\": {\"center\": {\"type\": \"Line\", \"slope\": 0.1, \"intercept\": 16.5},\n", + " \"spread\": {\"type\": \"Constant\", \"value\": 1e-4}, \"sampler\": \"Uniform\"},\n", + " \"isochrone\": {\"name\": \"Marigo2017\", \"survey\": \"lsst\", \"age\": 12.0, \"z\": 0.0006,\n", + " \"band_1\": \"g\", \"band_2\": \"r\"},\n", + "}\n", + "sm = StreamModel(single_cfg)\n", + "for n in (5000, 1234):\n", + " assert len(sm.sample(n)) == n\n", + "print(\"single-survey StreamModel.sample returns EXACTLY nstars (5000, 1234) -> OK\")" + ] + }, + { + "cell_type": "markdown", + "id": "e414d472", + "metadata": {}, + "source": [ + "Now the multi-survey scene. One mass draw feeds both surveys, so a star's\n", + "LSST and Roman magnitudes describe the *same object*." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dbc7de53", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:33:59.885548Z", + "iopub.status.busy": "2026-06-15T23:33:59.885425Z", + "iopub.status.idle": "2026-06-15T23:34:00.223968Z", + "shell.execute_reply": "2026-06-15T23:34:00.223395Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "multi-survey true columns: ['lsst_g_true', 'lsst_r_true', 'roman_F106_true', 'roman_F158_true']\n", + "rows: 4000\n", + "corr(lsst_r, roman_F158) = 0.996 (shared masses => tightly correlated)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scene = yaml.safe_load(open(f\"{REPO}/config/scenes/roman_rubin_demo.yaml\"))\n", + "sm_ms = StreamModel(scene[\"stream\"])\n", + "df_ms = sm_ms.sample(4000)\n", + "true_cols = sorted(c for c in df_ms.columns if c.endswith(\"_true\"))\n", + "print(\"multi-survey true columns:\", true_cols)\n", + "print(\"rows:\", len(df_ms))\n", + "\n", + "rho = np.corrcoef(df_ms[\"lsst_r_true\"], df_ms[\"roman_F158_true\"])[0, 1]\n", + "print(f\"corr(lsst_r, roman_F158) = {rho:.3f} (shared masses => tightly correlated)\")\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(10, 4.2), sharey=True)\n", + "axes[0].scatter(df_ms.lsst_g_true - df_ms.lsst_r_true, df_ms.lsst_r_true, s=3, alpha=.3)\n", + "axes[0].set_xlabel(\"g - r\"); axes[0].set_ylabel(\"r\"); axes[0].set_title(\"Rubin/LSST CMD\")\n", + "axes[0].invert_yaxis()\n", + "axes[1].scatter(df_ms.roman_F106_true - df_ms.roman_F158_true, df_ms.roman_F158_true, s=3, alpha=.3, c=\"C3\")\n", + "axes[1].set_xlabel(\"F106 - F158\"); axes[1].set_ylabel(\"F158\"); axes[1].set_title(\"Roman CMD\")\n", + "axes[1].invert_yaxis()\n", + "fig.suptitle(\"Phase 3: same physical stars, two surveys\"); fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "2f39058a", + "metadata": {}, + "source": [ + "Roman isochrone magnitudes are **always** converted Vega→AB (no config\n", + "flag) using the fixed `ROMAN_VEGA_TO_AB` table, sourced from the\n", + "`rubin_roman_object_classification` prototype. Non-Roman bands pass through\n", + "unchanged. (A `TODO` in the code notes this ideally belongs in `ugali`.)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5468d5aa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:34:00.225519Z", + "iopub.status.busy": "2026-06-15T23:34:00.225397Z", + "iopub.status.idle": "2026-06-15T23:34:00.266916Z", + "shell.execute_reply": "2026-06-15T23:34:00.266455Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Roman Vega->AB offsets (AB = Vega + diff):\n", + " F062: +0.153\n", + " F087: +0.481\n", + " F106: +0.66\n", + " F129: +1.051\n", + " F146: +1.164\n", + " F158: +1.315\n", + " F184: +1.556\n", + " F213: +1.837\n", + "\n", + "F158 shift: [1.315 1.315] (always +1.315)\n", + "r shift: [0. 0.] (0 -> non-Roman pass-through)\n" + ] + } + ], + "source": [ + "from streamobs.model import ROMAN_VEGA_TO_AB\n", + "print(\"Roman Vega->AB offsets (AB = Vega + diff):\")\n", + "for b, v in ROMAN_VEGA_TO_AB.items():\n", + " print(f\" {b}: +{v}\")\n", + "\n", + "iso = StreamModel(scene[\"stream\"]).isochrone # multi-survey isochrone\n", + "x = np.array([20.0, 21.0])\n", + "print(\"\\nF158 shift:\", (iso._to_ab(\"F158\", x) - x), \" (always +1.315)\")\n", + "print(\"r shift:\", (iso._to_ab(\"r\", x) - x), \" (0 -> non-Roman pass-through)\")" + ] + }, + { + "cell_type": "markdown", + "id": "82017106", + "metadata": {}, + "source": [ + "## Phase 4 — `MultiSurveyInjector`\n", + "\n", + "One orchestrator, one shared sky placement and shared masses, then per-survey\n", + "observed columns and flags. Per-survey RNGs come from `rng.spawn(...)`, so the\n", + "result is reproducible and independent of survey order.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9b63b52a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:34:00.268030Z", + "iopub.status.busy": "2026-06-15T23:34:00.267909Z", + "iopub.status.idle": "2026-06-15T23:34:00.376660Z", + "shell.execute_reply": "2026-06-15T23:34:00.376201Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "columns produced:\n", + " lsst: ['lsst_flag_observed', 'lsst_g_err', 'lsst_g_obs', 'lsst_g_true', 'lsst_r_err', 'lsst_r_obs', 'lsst_r_true']\n", + " roman: ['roman_F106_err', 'roman_F106_obs', 'roman_F106_true', 'roman_F158_err', 'roman_F158_obs', 'roman_F158_true', 'roman_flag_observed']\n", + "\n", + "shared sky placement: ra/dec present = True\n", + "lsst detected: 1066 / 4000\n", + "roman detected: 3110 / 4000\n" + ] + } + ], + "source": [ + "lsst_sv = StubSurvey(\"lsst\", [\"g\", \"r\"], completeness_band=\"r\", maglim=26.0)\n", + "roman_sv = StubSurvey(\"roman\", [\"F106\", \"F158\"], completeness_band=\"F158\", maglim=27.0)\n", + "msi = MultiSurveyInjector({\"lsst\": StreamInjector(lsst_sv),\n", + " \"roman\": StreamInjector(roman_sv)}, primary=\"lsst\")\n", + "\n", + "# Input carries only stream coordinates; everything else is sampled once.\n", + "N = 4000\n", + "stream_in = pd.DataFrame({\"phi1\": rng.uniform(-9, 9, N), \"phi2\": np.zeros(N)})\n", + "cat = msi.inject(stream_in.copy(), scene[\"survey_bands\"],\n", + " stream_config=scene[\"stream\"], seed=7, verbose=False)\n", + "\n", + "print(\"columns produced:\")\n", + "for grp in (\"lsst\", \"roman\"):\n", + " print(f\" {grp}:\", sorted(c for c in cat.columns if c.startswith(grp + \"_\")))\n", + "print(f\"\\nshared sky placement: ra/dec present = {('ra' in cat) and ('dec' in cat)}\")\n", + "print(f\"lsst detected: {int(cat.lsst_flag_observed.sum()):5d} / {len(cat)}\")\n", + "print(f\"roman detected: {int(cat.roman_flag_observed.sum()):5d} / {len(cat)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5aabf327", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:34:00.377871Z", + "iopub.status.busy": "2026-06-15T23:34:00.377760Z", + "iopub.status.idle": "2026-06-15T23:34:00.445055Z", + "shell.execute_reply": "2026-06-15T23:34:00.444545Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "same seed -> identical obs & flags: True\n", + "different seed -> different noise draw: True\n" + ] + } + ], + "source": [ + "# Reproducible from seed (given the same true-mag draw)\n", + "base = sm_ms.sample(3000)\n", + "base[\"ra\"] = rng.uniform(10, 20, len(base)); base[\"dec\"] = rng.uniform(-5, 5, len(base))\n", + "a = msi.inject(base.copy(), scene[\"survey_bands\"], seed=11, verbose=False)\n", + "b = msi.inject(base.copy(), scene[\"survey_bands\"], seed=11, verbose=False)\n", + "c = msi.inject(base.copy(), scene[\"survey_bands\"], seed=22, verbose=False)\n", + "print(\"same seed -> identical obs & flags:\",\n", + " a.roman_F158_obs.equals(b.roman_F158_obs) and a.lsst_flag_observed.equals(b.lsst_flag_observed))\n", + "print(\"different seed -> different noise draw:\", not a.roman_F158_obs.equals(c.roman_F158_obs))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "171f7526", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-15T23:34:00.446054Z", + "iopub.status.busy": "2026-06-15T23:34:00.445937Z", + "iopub.status.idle": "2026-06-15T23:34:00.516601Z", + "shell.execute_reply": "2026-06-15T23:34:00.516250Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAGGCAYAAADrfDCjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbnlJREFUeJzt3Qd8U1X7B/Cn6Upb2lL2bMveVEBUQEAUQXArrygqQ1QUB4II4kJw4AJB/QOvr4riRGUoigwRkCUoqyxlU0YLlNG9c/+f36E3JumgabOa/L6fT5rkJrn35N6b5Ok55znHT9M0TYiIiIjIZxjcXQAiIiIici0GgEREREQ+hgEgERERkY9hAEhERETkYxgAEhEREfkYBoBEREREPoYBIBEREZGPYQBIRERE5GMYABIRERH5GAaA5BSffvqp+Pn5mS8BAQHSoEEDGTZsmJw4caLI8/76669KeyR+/fVX8/tMTk52d3HIjV5++WV1HjjLhg0b1DYuXLhQ5LFrrrlGXdxh27Zt0rNnT4mMjFTvf/r06W4pB4l89dVXFd7/7jyXyHUCXLgt8kFz5syRli1bSlZWlvz+++8yZcoUWbNmjezcuVPCwsKksktPT5eHHnpI6tWrJydPnnR3ccjLIQCcNGmSDB06VKpWrWr12MyZM91WrgceeEAyMjLkm2++kaioKImNjXVbWXwdAsBdu3bJU0895e6ikIdjAEhO1bZtW7n88svV7V69eklBQYG88sorsmjRIrn33nsr/d5/9tln1Q/ejTfeKK+++qpUBgjGQ0JC3LLtzMxMCQ0Ndcu2vV3r1q3dtm0EHPhHqF+/fpc894xGo1NrSYmobNgETC511VVXqeujR49aLU9LS5NHH31UatSoIdWrV5c77rijSI3avHnzpE+fPlK3bl0VwLRq1UoFYKh5sHTo0CG5++67Va1ccHCw1K5dW6677jrZvn17kfV16dJF1URWqVJF+vbtq5qyymrt2rXy4YcfykcffST+/v5SUWhyQcCM9WI/4T3Wr19fXnzxRRU4W8rNzVUBJ2pX8R5r1qypmtfPnDlj9TzUxNx0002yYMEC6dChg/rxRQ1SSb777ju58sorVVMeArXGjRur2h3bJvsjR45YvW716tVqOa5t3w9qfrt27arWh3XddtttEhMTIyaTqcj2se2OHTua72uapmq2LrvsMrU/EGwPGDBAHWMd/qFAF4Njx44VWR+2h/MpOzu7xPfsivOlrK/dtGmT3HzzzarMOFZNmjQx1+Sg6feZZ55Rtxs1amTudqDv8+Ka7c6dOycjR45U51FQUJA6ns8//7zk5ORYPQ/refzxx+Xzzz9Xnyscq7i4OPnpp59KfV/6+ZCfny+zZs0yl8nyseXLl6vjgHMU68W2cezfeust8/lbq1YtGTx4sBw/ftxq/fo5tHHjRnUO4RzAOY2WBfj555/V+YL1tmvXTpYuXVqm45GQkCD33Xef2i62j/c8depUq3MS5zjK/84778i0adPUPsexw3H8448/iqwT3VhuueUWqVatmjp2+Lx9++23ZSoP9snkyZNVOfBaHH/8w4waX93//d//SY8ePVSZcR7h/WIf5uXlWe0v7BN8v1p2wdHhs4/PGMoYERGh9t3HH3+sPmeXUtZzCd0Thg8frraB/YV/jvEZQzlwDpMH0YicYM6cOfhG0f7880+r5TNmzFDLP/zwQ6vnNW7cWHviiSe0ZcuWaR999JEWFRWl9erVy+q1r7zyivbuu+9qP//8s7Z69Wpt9uzZWqNGjYo8r0WLFlrTpk21zz//XFuzZo02f/587emnn9ZWrVplfs5rr72m+fn5aQ888ID2008/aQsWLNC6dOmihYWFabt3777k+8vMzNSaNWumPfPMM+r+xIkT1fs4c+aM1fOwTSzH45fSs2dPrXr16lq9evW09957T+2LJ598Ur3+scceMz+voKBAu+GGG1RZJ02apK1YsULts/r162utW7dWZdPFxMRodevWVfv3k08+UeXZvHlzsdvfsGGD2id33323tmTJEu23335Tx+f+++83P0c/XocPHy72fVruY7yfatWqaQ0bNtTef/999RiOxw8//KCei3Jb2rt3r1qO96576KGHtMDAQHX8li5dqn311Vday5Yttdq1a2tJSUnqOadOndKCg4O1559/3mp9Z8+e1UJCQszHqCSOPF/088BSWV+L94f32r59e+3TTz9V+x/HDMcDjh07pj4jWD/WsXHjRnVJSUkx729cdFlZWWpd2M4777yjLV++XHvxxRe1gIAArX///lZlxDpjY2O1K664Qvv222/V8b/mmmvUcw8ePFjivjt9+rQqA14/YMAAc5kszxWclw8//LD2yy+/aN9//72Wn5+v7uOxxx9/XL1vfJZr1qypzhXLz5D+mcAx+vjjj9Vn4qabblKvxbnfrl077euvv1blveqqq9R5cOLEiVKPN8qMMmF72C62j3JgnY8++qj5eTjH9f2Cz9uiRYvUBdvE99OFCxfMz8WxCgoK0rp3767NmzdPrXPo0KHq9dgPpcnLy1PfYdjXY8eOVe/lxx9/1J577jn13nSjR4/WZs2apdaN7eG7sEaNGtqwYcPMz8H51K1bN61OnTrmY6EfD0CZsB/x2cMF36n4jGBfWirvuYTvpquvvlozGo3aG2+8oZ6HdeO7sqzfg+Q6DADJKfQv/z/++EN9waWlpakfP3zphoeHm3+89eeNHDnS6vVvvfWWWp6YmFjs+k0mk1ovfrDxvB07dqjlycnJ6v706dNLLFtCQoL64sKPqSWUEV+cd9111yXfHwIEBFV6sFVSAIhA1d/fv8gXbHHwhYt1IECyhCDIYDBoR48eVffxo4DnIVCxhGAby2fOnGkVAGL7//zzzyW3jy92vN7yh82WvQEglq1cudLquThuCOAGDRpktXzcuHHqRxTHEPTAYurUqVbPQyCEHy08XzdkyBCtVq1aWk5OjnnZm2++qfabbVktOfp8sQ0A7XltkyZN1AU/tiV5++23i93/xf1oI7jBcxHQWcJ+wXL8OOtwH8ckNTXVvAyfUey/KVOmlFgey9db/pNiea4MHjy42EDf9jO/adMmtRyBj+V7wrK//vrLKrDHOY1zwDLY2759e5F/IIrz7LPPqudhe5YQ/CFQ1z8regCIgA9Bqw7/QGG5ZXCGf0o6dOigzm1LCFbxDxgCo5LMnTtXre9///ufVlZYH7aF12JfnDt3zvzYjTfeqD73ZV3H5MmTVZCN79SKnkv45xz3EahawjnEANDzsAmYnApNmYGBgRIeHq6aIuvUqSO//PKLamazhKYTS+3bty/SVIxmhEGDBql1oMkV60XmIezdu1ddo9kBzWZvv/22arZBM5ttU+OyZctUkxWanHCtX9D0gvVZNmMWZ/PmzSrL7r///e8l+9JhfVj3Sy+9VKb9hf1kuy/wnvEe0JQKaJZDAgCaCi3Lj2ZS7Bvb8mNfNm/e3HwfzcmWr9P3T+fOndX1XXfdpZquLLO1ywtNttdee63VMjTXovkNzdIpKSnmMqH58dZbb1XNX/r7RLMRnmtZXrxHNE9avs9Ro0bJ6dOnVRM24D2hSRLNT6UlJDj7fCnra/ft2ycHDx5UTWd4zBF+++031VSIJnNLSCCBlStXWi1HkyPOPx0+o2hutO2uYa8777zT6v6qVausyqG74oorVBOobbnQ5aNTp05WxwzlwvmOZnsdXguXKi/2C/pLYnuWUB7EsnjcEs4hyy4ett9NBw4ckL///tvcp9nyOPfv318SExPln3/+KbE8+D7EMbfsalEcnJv4bsDnQ//+w3mFzw7On7LAe+vdu7fq4qGvA99NZ8+eVZ+fip5LSPDTv0Ms3XPPPWUqH7kWA0Byqrlz58qff/6pvrzQpy8+Pl66detW5Hn6j74O/XL0TuN6tm337t1VHyn0fcMPJ9aLIMLyeQgY8GWEPlboH4M+Luh79OSTT6p+hnDq1ClzwIMvQMsL+mpdaigXfFGjjyKSW9DfBRe9j1lqaqp5O+VhGxgDAh7Al7RefmwT/XBsy5+UlFSk/PgBtYT+bZav0X940L8IyTl6wIJhe9D/6uuvvy73+7Hdtg7bxD5D1qgeKOGHEv0YdXif+EHGPrF9n+iDZfk+0d8K5wf6SenBI/pwoV9baZx9vpT1tXrfTexzR8H5gnPHNuECwROCcP18KukzqH8O9c+Wo84BfbvFnRsI6GzLhYDPFs592+VYBqX199S3X9K2LctX1u8m/RiPHTu2yDFGnzko7RzBsce2DQZDqX0WcX7jn7IZM2aofsL4/tPP97IcI/zjij7U8L///U/Wr1+v1oF+fJdaR1nPJVzjvu2xKe57jdyPWcDkVPivXM8Crgj8B4oAEoGfXusHxY2HhgQDdGwG/GeM2ix0PkbixOzZs1WiCXz//ffqufbavXu3uui1TZZQm4TaKdsEgrLSf0wsIaiz/CHSE2VK6vBuWYsDtl/aqLm0DFL1/QGogcMFHbsRZGHYHtRAohYNnd/12inbjt8l/cCVlO2p18CgM/+IESPUNX4E9R8ovVx4PX7s9B9dS7bLELT95z//ka1bt8oHH3ygaj2vv/56uRRnni9lfS2CTrBNgqgInCP4hwlBtOVxQE0PgnzL4+5MtueAfh4j4LcNePEZd3a5sH1s25aedGbv9vXnT5gwQf1jWJwWLVqUeuzXrVunap5LCgLxjxmS3fAPr+V5ZM/3DP7ZQlCKf44sa5mxbkedS3ge7iNhxDII1L/DyLMwAKRKQf/Ssf3RRzBTGgQBL7zwgsyfP18FBoDaHvyXiiY32+apstCbsCwh4/Gzzz5TX6bIkisvBGY//vijVTMwxvXCDwNq6ABN6fgyR9MPMvrsVdqPkQ77GYE2mppRO4caXASAenMqanIt14My2wu1fcj8xo/f4sWLZcyYMVZNbXifb7zxhqr1sG1SKs7tt98u0dHR8vTTT6umqHfffdfu4UYcfb6U9bXYLv55+OSTT9R+KC7gLa72qTSo6UUwi3MS+8ayVl5/3B30LgFffPGFudsBoDYKXTn0GilnwfvGPzY4vpYZ59gvOF/QFG4PfA6aNWsmO3bskNdff93u8mDoHNSy4zukpGbg4r7/EIyhJq+stbb6gPyWnzE8D10vHHUu4TsDNemo3cZnW6fX9JNnYQBIlQKGgEB/skceeUQmTpyo/pP98ssv1ZeuJQQmaPZDTRC+lNEshNpDLMeQMYAgBkMu4IcG/QpvuOEGtW7UvqGZBH1dShsqpbgR8vW+XGjetqxBQCCCL0f0sylLP0D8B40vTjT5IChYsmSJ+pLHMgQ3gCFL8N7Rvwh931CThv2B2iMEp6jBs/ySLiuUD+tAeVEzg9pVNDdZ9rXEDzZ+8NDchf/0sd8WLlyogjh7oV8Qgh1co0bRtk8Y9uXDDz+sAkUMsYEAGMcGtTfYHobBsPyRwQ/bY489JuPHj1fPs11fcZx9vtjzWjTnoV8n+s2OHj1aHW+cBwjAcbwB7xlwXIYMGaKODY6Hba0voBkf68Tz0ByO12K/IUjBuYO+YO6A8uK4vv/+++ofGwRAKB+GO2rYsKF6786E9SNwQd8+HBvUqGHoFAw3hPPJsr9sWeEfUbwPBPw47/BPIGrBENAi0CyutUCH8x814PhuQ19BBKCoDUSNG1pQ8HlHTTbOTTx33LhxqpkbfVzPnz9fZH04zqgpxOPoO4l9jFYYvF/0c0WNPvY/mmsxxE1J/2yU51zC+Y3PLf4JQ3cYbB9D+OiBYmnN3OQG7s5CId8aBqaszysuqxTDlGD4jNDQUJVN/OCDD2pbt261GmoBQ4JgqANk5WHIgipVqqjhCzBkgmUmH2BIBwy/EBERoYaPQOYchrL49ddf7X6/jhoGpk2bNipz+PLLL1dlQgYhsiJtswtxH1m7cXFxasgFvE+85xEjRmj79+83Pw/vCVmBZYEs7X79+qkhMpCNi6xaDPGwdu1aq+ft27dP69Onj9pvOA7IcNWz/2yzgPF+SoNMYLwOQ1eUBEOhXHnllep4IvMTmbLILLXMDNUdOXJEre+RRx4p03t29PlS3DAwZX2tnvmMYxAZGameh/eK4T8sTZgwQQ0VhAxdy31um7mpZ8xiX+A8QjYytovXZ2dnXzKLF/B8ZFhXJAu4uO8AZKAig7R58+Zq6BsMZ3LfffepDG9LJZ1DJZ3XJb0PW8iox7mH7FdsH8PMIMPaMltXzwLG8uK2Y/uZxkgEyOrG5wbrRJb3tddeqzJoLwWZ3y+99JIaLgWfPZQLr8V3nm7x4sXmzzs+oxjeCEPr2H7ukBGMc6tq1aoqq9nyfMRnCe8V5xZGMUB2LoaFsc0sr8i5hO1jaBpsH9/V119/vRoNAtvAMGDkOfzwxx2BJxEVrVlEXzrMqkDlg1ol9AXEPmzTpg13I5EHQDcWZEkj8QStOeQZ2ARMRJUe+igePnxYNemhCZzBH5F7oD8j+u2imRhNvkgmwzBL6MLB4M+zMAAkokoPfR6RaYihMpC5S0Tugf6oSPrAcF3IXMaQO+gXWVnmSvclbAImIiIi8jFMySEiIiLyMQwAiYiIiHwMA0AiIiIiH+NzSSAYYBNT/qCjqr2zBBARERF5KozshxmlLjW/tE8GgAj+MNo8ERERkTc6duxYkbm2xdcDQH3KJOyciIgIdxeHiIiIyCEwBR8quYqbHlJ8PQDUm30R/DEAJCIiIm9Tli5uTAIhIiIi8jEMAImIiIh8DANAIiIiIh/DAJCIiIjIxzAAJCIiIvIxDACJiIiIfAwDQCIiIiIf49YA8Pfff5ebb75ZTVmCMWsWLVp0ydesWbNGOnXqJEajURo3biyzZ892SVmJiIiIvIVbA8CMjAyJi4uTDz74oEzPP3z4sPTv31+6d+8u27Ztk+eee06efPJJmT9/vniaE/uOyOYFy9U118f9x3OFnw1P/C7IS0qSjD82qWtHcPT6iMiJNA+BoixcuLDU54wbN05r2bKl1bIRI0ZoV111VZm3k5KSoraFa2dZ9tZ/tV0tWml7WrRU17jP9XH/8VzhZ8OTvgvOf/edtqdVa7UuXON+RTh6fURkP3tiHD/8EQ+AJuCFCxfKbbfdVuJzevToIR06dJAZM2aYl+E1d911l2RmZkpgYGCR1+Tk5KiL7Tx5KSkpTpkKDv+VX7ilvxjk392KWyeqNxRTQNHyXYohP0/qnz0mlpO6cH3esf88uWxcX+XZf+kNG4sxxCiBAQYJ9PcTf0wBdYlZoLTcXMnZ+3eR5cGtWopfUJDdZSt2fQY/iV2wQEJatrR7fURUPohxIiMjyxTjVKq5gJOSkqR27dpWy3A/Pz9fkpOTpW7dukVeM2XKFJk0aZLLynhi1z4Jtwj+AN/FDc4ec9g2uD7v3X+eXDauzzP3X/ixQ+b7eYWX8iouKCw3kyZHbrtdgmJjJaRTRwnt2FFCOnSUoEaxZZqnlIicq1IFgGD7xaFXYJb0hTJhwgQZM2ZMkRpAZ6nftrlcED+rGkCT+MmJB0dLaM0adq8v80yy1P/oXa7PC/efJ5eN66s8+++H64dKsiFEzmflSWZOfpnWFZGTIU9t/67IusJeeEmq17P+J7ss8s+fl6QXXsAXcpHHco8cUZeU+QvUff9q1SSkQwcJ7dhBQjp2FGObNmIoR60jEflQAFinTh1VC2jp9OnTEhAQINWrVy/2NcHBweriKvWbx8ru4U9JvU+mi7+mSYGfn5x84CnpM/ahcq9zuaZxfV66/zy5bFxf5dh/zz3zsPnxrNwCOZWaLUmp2RevU6xvn0rNUbfzTZr4iSZP7vjevK734gbIsC7XS2yT4r9LL8VPM0niSxNFTCYRg0HqTp4k4b17S+b27ZK1dZtkbt0i2Tt3ScG5c5K+cqW6qNcFBYmxfTsJ7dBRQjp2kNAOHcS/alX1GJJJco8claDYGAmsU6fc+42IiqpUfQDHjx8vixcvlj179piXPfroo7J9+3bZuHGjw9vHK9oX8OTu/VKvTTMVFHJ93H88V/jZ8ITvApNJkz2JqXLzB+ukeuYFqZueLIlVasj50ChZ92wvqRsZUu6yqYDtaIIExUQXG7Chr2D2nj2SuWWrZG7bKllbtkrB+fNFnhfUtIn4V42SrC1bLtYqFgaUVQcMKHfZiHxBqh0xjlsDwPT0dDlw4IC6jeSOadOmSa9evaRatWoSHR2tmm9PnDghc+fONQ8D07ZtWxkxYoQ89NBDKuh75JFH5Ouvv5Y777zTowJAIiJPNu/PBJmwYCe66ilv3tlOBnaOdmkZ8POD5uGsrVslc+vFgBD3S1L1/vukSpeuEtKurQTUrOnSshJVBpUmAFy9erUK+GwNGTJEPv30Uxk6dKgcOXJEPc9yIOjRo0fL7t271QDSqBVEEFhWDACJiC7acvSc3DlrowQYRP55tb/4G9yfnJF/7pycnzdPkme8V+rzAurUkZB27cTYrp2EtG+n+hL6h4e7rJxEnqjSBIDuwACQiOiiApMmrV5aKrn5Jvn9mV4SXT3UI3YNmpIPXHvdxf6EOj8/Ce/bV3IPHpCcAweLTTgJatToYjDY9mJQGNyypRgs+oCzTyF5u1RvHQaGiIgcBzV+jaqHyT+n0uRQcrrHBIDoP4g+f7ZJJXofwIL0DMnes1sllWTt3CnZO3dK3okTknv4sLqk/PDjxRUFBIixeXOVZKLl5EjKoh/Yp5CoEGsAiYh82COfb5Glu5Nk4s2tZVi3RuJJLpVUYtt0jEAwSwWF8eaM4xIZDNL0t5XMLiavwhpAIiIqk0Y1w9T1oTMZHrfHEPSVdfiXgGrVpErPnuoC6N2Ud+KkZO/aKanLlkvaL79Yv8BkUsElh5chX8UmYCIiH9aoxsUA8HCy5wWAFR1aLKhBfXUJuewySVu2zLpPIQLMaOdNCkDk6QzuLgAREblPk5reGQAW16cQzb6WUhYudFuZiNyNASARkQ9rVKOKuj5xIUuy8wrEWyGBBH3+oj/7TGo9M1YtS37vfUldscLdRSNyCwaAREQ+LCo0UCJDAtXtI2e9txZQrwkMu/IKqT58uETdf79adnL8s5L9zz/uLhqRyzEAJCLyYegrp/cD9MREEGepPX6chHXtIlpmphx/dKTKIibyJQwAiYh8XGMvTQQpjV9AgNSfNk0CY6Il7+RJOfHkKDVXMZGvYABIROTjGnvwUDDO5F+1qjScOVMMYWGS+ddfkvT66+4uEpHLMAAkIvJxeiLI4eR08TXBTZpIvanvqKnmLnwzT85//bW7i0TkEgwAiYh8nLkPoA81AVsKv+YaqfX0GHU76bXXJeOPTe4uEpHTMQAkIvJxsTUuzgF8ITNPzmf4Zj+4asOHS8TNN4vk58uJUaMk99gxdxeJyKkYABIR+bjQoACpG2n06VpAZEPXfWWyGNu1k4KUFDk+cqQUpPvmviDfwACQiIjMiSC+lAlsy2A0SoMP3peAmjUlZ/8BOTlunGg208cReQsGgEREZDEnsO8lglgKrF1bBYF+QUGS/ttvcua999xdJCKnYABIRETmTGBfGwqmOCFxcao5GM7O/q+kLlni7iIRORwDQCIi8snBoEsTeeutUm34A+r2yeeel6xdu91dJCKHYgBIRERWfQBNJo17RERqjRkjYT17iJadLccff1zyz5zhfiGvwQCQiIikftUQCfT3k5x8kySmZnOPIDPY31/qv/OOBDVuLPlJSXL8iSfFxOniyEswACQiIgnwN0h0tYvjAR5mP0Az//BwaTjz/8QQESFZ27dL0sSXRdNYQ0qVHwNAIiKyTgTx8UxgW0GxsVL/3WkiBoOkLFwo5z77zN1FIqowBoBERGTVD5CZwEVV6dZNaj87Xt0+/dbbkr52Hc8aqtQYABIRkcJM4NJF3X+/RN55h4jJJCfGjJGMzX+qeYPzkpJ4BlGlE+DuAhARkacNBs2hYEqaLq7OxImSe+iwZG3bJgmDB198wGCQupMnSdUBA1x5uIgqhDWARESkNCpsAj5+PlNy8gu4V4r70QwKktovvmC90GSSxJcmsiaQKhUGgEREpNSsEixVggMEwwAmnM3kXimBKTWtmIUmyT2awH1GlQYDQCIiMjdx6s3Ah9gMXKKg2BjV7Gv9a2qQoJhonklUaTAAJCKiYmcEoeIF1qmj+vyJn595WZ1Jk9RyosqCASARERVNBOFg0KVCwkfjn38SCQxU942tWvEsokqFASAREZn92wTMwaAvJbhxYwm/7jp1O/WXJTyLqFJhAEhERGaNC2cDYRNw2UT066euU3/5hVPEUaXCAJCIiIoMBZOcnispWXncM5dQpWcPMYSGSv7JRDVXMFFlwQCQiIjMMAxMrfBgdfsIE0Eu/SNqNEoVczPwLzyTqNJgAEhERFY4I4h9IvpfbAZO+2WpaAUcQJsqBwaARERU7FAwh84wEaQsqnTrJoaICMk/c0Yyt2zh2USVAgNAIiKywsGg7eMXFCThvXur22wGpsqCASAREVlhJrD9Ivr3V9dpy5aLlp/PM4o8HgNAIiIqNhMYQ8Fomsa9UwZhV10p/lFRUnDunGRs2sR9Rh6PASAREVlpGBUq/gY/ycwtkNNpOdw7ZeAXECDhffqo22wGpsqAASAREVkJCjBIw6gQdfsgE0HsbwZevkK03FyeVeTRGAASEVERHArGfqGXdxL/mjXElJoq6Rs28Kwij8YAkIiIimhcs3BKuDMZ3Dtl5OfvLxF9b1C3U5dwbmDybAwAiYioCNYAVqwZOH3lb2LKYf9J8lxuDwBnzpwpjRo1EqPRKJ06dZK1a9eW+vwvv/xS4uLiJDQ0VOrWrSvDhg2Ts2fPuqy8RES+oHGNwsGgOR2cXUIui5OAunXFlJEh6b//7pyDQ1TZA8B58+bJU089Jc8//7xs27ZNunfvLv369ZOEhIRin79u3ToZPHiwDB8+XHbv3i3fffed/Pnnn/Lggw+6vOxERL4wFEzCuUzJKzC5uziVhp/BIBH9Lk4Nx2Zg8mRuDQCnTZumgjkEcK1atZLp06dLw4YNZdasWcU+/48//pDY2Fh58sknVa3h1VdfLSNGjJC//vrL5WUnIvJmtcONEhLoLwUmTY6dy3R3cSoVPQBMX71GTJncd+SZ3BYA5ubmypYtW6RP4bhJOtzfUEL2VNeuXeX48eOyZMkSNTjpqVOn5Pvvv5cbb7zRRaUmIvINBoMf+wGWk7FtGwls2FC0rCxJX73asQeGqLIHgMnJyVJQUCC1a9e2Wo77SUlJJQaA6AM4cOBACQoKkjp16kjVqlXl/fffL3E7OTk5kpqaanUhIiL7ZgShsvPz8zMng6QwG5g8lMETPiiWULNnu0y3Z88e1fz70ksvqdrDpUuXyuHDh+WRRx4pcf1TpkyRyMhI8wVNzEREVPZEkIMcCsZuEf0vNgNn/L5WCtLTebqRx3FbAFijRg3x9/cvUtt3+vTpIrWClsFct27d5JlnnpH27dtL3759VRbxJ598IomJicW+ZsKECZKSkmK+HDt2zCnvh4jIe4eCYQBjr+DmzSWocWM1I0j6ypVOODpElTQARBMuhn1ZsWKF1XLcR1NvcTIzM8VgsC4ygkgoacLy4OBgiYiIsLoQEZEdg0GzCdhubAYmT+fWJuAxY8bIRx99pGrw9u7dK6NHj1ZDwOhNuqi9w7AvuptvvlkWLFigsoQPHTok69evV03CV1xxhdSrV8+N74SIyPs0qn6xBvBUao5k5OS7uziVtxl4/QYpuHDB3cUhshIgboRkDgziPHnyZNWE27ZtW5XhGxMTox7HMssxAYcOHSppaWnywQcfyNNPP60SQK699lp588033fguiIi8U2RooFQPC5KzGbmqFrBt/Uh3F6lSCW7cWIJbtJCcf/6R1BUrJOo//3F3kYjM/LSS2k69FLKAkQyC/oBsDiYiKt2AWRvkr6Pn5b17OsgtcWxpsVfyfz+UM+++K2Fdu0j0J5/wdCOPiXHcngVMRESVIBGEmcAVawb+Y5Pkc9pS8iAMAImIqAyJIMwELo+ghg3F2LatiMkkqcuW8Uwjj8EAkIiIyjAUDAeDLi99UOi0Jb/wTCOPwQCQiIhK1LhwNpBDZzJKHG6LShfR7wZ1nblli+SdOsXdRR6BASAREZUoulqoYHKmtJx8SU7P5Z4qh8C6dSWkY0cMWCtpS5dyH5JHYABIREQlMgb6S/2qIeo2m4HLL6LfxWSQVDYDk4dgAEhERKViIkjFhfftg+lBJGvHDsk9foJnHLkdA0AiIipV48JEkENMBCm3wFq1JPSKK9TttKVMBiH3YwBIRERlygRGIgiVH5uByZMwACQiolJxKBgHNgP7+0v2nj2Se+QIzzpyKwaARERUpqFgjp7NkAITh4Ipr4CoKAnr0kXdTv2FzcDkXgwAiYioVPUiQyQowCB5BZqcOJ/FvVUBbAYmT8EAkIiISv+hMPhJo+p6IginhKuI8N7XiQQGSs7+/epC5C4MAImI6JKYCOIY/pGRUuXqq9VtNgOTOzEAJCKiS2pU2A+Qg0FXXET/fweF5vR65C4MAImIqMxjATIArLgqva4Vv+BglQmcs3cvzz5yCwaARERU5kxgBoAV518lTKr07KlusxmY3IUBIBERXVKjGlXU9YkLWZKVW8A9VkFsBiZ3YwBIRESXFBUaKJEhger2kbOcEaSiUAPoFxoqeSdOSHZ8PM9AcrkAe19QUFAgn376qaxcuVJOnz4tJpPJ6vHffvvNkeUjIiIP4OfnpzKBtx+7oJqBW9WNcHeRKjVDSIiE9+olqT//rJJBQuLi3F0k8jF21wCOGjVKXRAItm3bVuLi4qwuRETkndgP0EnNwEuXimZTmULkcTWA33zzjXz77bfSv39/55SIiIg8OhP40Bk2ATtCWPfuYggPl/xTpyRr61YJvfxyh6yXyCk1gEFBQdK0aVN7X0ZERF6SCMLZQBzDEBQk4dddp26jGZjIowPAp59+WmbMmMHBK4mIfHQ2EA4F44Rm4GXLRMvPd+CaiRzcBLxu3TpZtWqV/PLLL9KmTRsJDLyYFaZbsGCBvaskIqJKFABeyMyT8xm5EhUW5O4iVXphXbqo6eEKzp6VzD//VPeJPDIArFq1qtx+++3OKQ0REXmskCB/qRdplJMp2XIoOUM6MQCsML/AQAnv00cufPedagZmAEgeGwDOmTPHOSUhIqJKMScwAkA0A3eKiXJ3cbxCxI39VQCYtny51HnpRRUUEnnsQNBnzpxRzcHr169Xt4mIyHeagQ+dSXd3UbxGaOfO4l+jhhSkpMjZOZ9KXlKSu4tEPsDuADAjI0MeeOABqVu3rvTo0UO6d+8u9erVk+HDh0tmZqZzSklERB6VCcxEEMfx8/eX4CZN1O0z06bJgWuvkwvff+/ALRA5IAAcM2aMrFmzRhYvXiwXLlxQlx9++EEtQ4YwERF5Lw4G7Xio8cvcvPnfBSaTJL40kTWB5Fl9AOfPny/ff/+9XHPNNeZlGBQ6JCRE7rrrLpk1a5ajy0hERB42GDRqAE0mTQwGP3cXqdLLPXJURNOsF5pMkns0QQLr1HFXscjL2V0DiGbe2rVrF1leq1YtNgETEXm5+lVDJNDfT3LyTXIyJcvdxfEKQbExIgabn2ODQYJiot1VJPIBdgeAXbp0kYkTJ0p2drZ5WVZWlkyaNEk9RkRE3ivA3yDR1ULVbfYDdAzU8tWdPEnEr7A21c9P3WftH3lUEzBmAbnhhhukQYMGEhcXJ35+frJ9+3YxGo2ybNky55SSiIg8KhHk4JkMFQB2b1bT3cXxClUHDBBTTo6ceuVVCW7RQt0n8qgAsG3btrJ//3754osv5O+//1ZTwt19991y7733qn6ARETk3ZrUDJNf92IomAx3F8WrVOnRQ06JSM7Bg2LKzVVzBRN5TAAICPQeeughx5eGiIg8HucEdo7ABg3EPypKCs6fl5y9eyUkLs5JWyIqYwD4448/Sr9+/dS8v7hdmltuuYX7lYjIFwaDTuZg0I6ELlUh7dtL+po1krUjngEguT8AvO222yQpKUll+uJ2aSdvQUGBI8tHREQeOB0cHD+fJTn5BRIc4O/uInkNY1xhABgf7+6ikJcrUwBoMpmKvU1ERL6nZpVgqRIcIOk5+ZJwNlOa1Q53d5G8Rki79uo6aycDQPKwYWDmzp0rOTk5RZbn5uaqx4iIyLuhtUefEeRQMhNBHCmkfTt1nXc0QfLPn3fouokqFAAOGzZMUlJSiixPS0tTjxERkfdjIohz+EdGSlBsrLqdvXOnk7ZCVI4AEMO+4L8/W8ePH5fIyEjuUyIiX0oEOcNEEEcLiStsBt7BZmDygGFgOnTooAI/XK677joJCPj3pUj8OHz4sBogmoiIvB9rAJ3H2K69pPzwI/sBkmcEgHr2L2b96Nu3r1SpUsX8WFBQkMTGxsqdd97pnFISEZFHaVLz4m8Ap4NzXg1gdvzOElvdiFwWAGL+X0Cgh5k/goODK7xxIiKqnGILm4CT03MlJStPIkMC3V0kr2Fs0UL8goKk4MIFyUtIkKCYGHcXibyQ3X0AW7durWoBbW3atEn++usvuwswc+ZMadSokZpLuFOnTrJ27dpSn48M5Oeff15iYmJUENqkSRP55JNP7N4uERGVH4aBqRV+sSKAtYCOheDP2KqVus3xAMljAsDHHntMjh07VmT5iRMn1GP2mDdvnjz11FMqoNu2bZt0795dzTiSkJBQ4mvuuusuWblypXz88cfyzz//yNdffy0tW7a0920QEZHD+gEyEcTRjO0LE0HimQlMHjIX8J49e6Rjx47FJongMXtMmzZNhg8fLg8++KC6P336dFm2bJnMmjVLpkyZUuT5S5culTVr1sihQ4ekWrVq5iZpIiJyPYwFuOnwOTl8hmMBOhqmhMMogFnxOxy+bqJy1QCi2fXUqVNFlicmJlplBl8KBo7esmWL9OnTx2o57m/YsKHY12Ae4ssvv1zeeustqV+/vjRv3lzGjh0rWVlZPJpERC7WuMbFRBAOBu28RJCcPXvFlJvrhC2Qr7O7BvD666+XCRMmyA8//GAe9+/ChQvy3HPPqcfKKjk5WQ0fU7t2bavluI95h4uDmr9169ap/oILFy5U6xg5cqScO3euxH6A6DNoOXNJampqmctIREQl41AwzhPYsKH4V62qEkFy/v5b1QgSubUGcOrUqaoPIJIwevXqpS5I4kDQhsfsZZveXlrKO+YhxmNffvmlXHHFFdK/f3/VjPzpp5+WWAuIpmQEqvqlYcOGdpeRiIiKalQ4HRySQPDdTY6D3zpj4bRw7AdIHhEAouk1Pj5eNcMiIxiZuzNmzJCdO3faFVzVqFFD/P39i9T2nT59ukitoK5u3bpq+5YzjrRq1Up98WAmkuKgthJT1+mX4hJYiIjIfg2jQsXf4CeZuQVyKrXoHPFUMSHt49Q1+wGSRzQBQ1hYmDz88MMV2jAGj0bwuGLFCrn99tvNy3H/1ltvLfY13bp1k++++07S09PNA1Hv27dPDAaDNGjQoMQ+ixyzkIjI8YICDNIwKkSOnM2UQ8npUifSyN3sjAGhOSUceUoACMj4xXAtSOawdMstt5R5HWPGjJH7779fJXZ06dJFPvzwQ7XORx55xFx7h+Fl5s6dq+4PGjRIXnnlFRk2bJhMmjRJ9QF85pln5IEHHpCQkJDyvhUiIiqnxjWrqAAQzcBdm9TgfnSgkHYXm4Bzjx5VfQHRJ5DIbQEgEjFQY4cmX/RR0Pt96P32kNhRVgMHDpSzZ8/K5MmTVRZx27ZtZcmSJap/IWCZ5ZiAqPVDDeETTzyhgsbq1aurcQFfffVVe98GERE5MhGEQ8E4HAK+wJhoyTuaIFk7d0mV7lc7fiPks+wOAEeNGqWSPn799Vdp3LixbN68WQVxTz/9tLzzzjt2FwBZvLgUB8kdtjDoM4JAIiLynACQQ8E4rx+gCgDjdzAAJPcmgWzcuFHV2NWsWVP1vcPl6quvVtm2Tz75pGNLR0REHq2xeTYQDgbtDPrwL5wSjtweAKKJV0/AQCbvyZMn1W0022JqNiIi8q0+gJBwLlPyCkzuLo5XJ4JwqB1yawCIfnoYBgauvPJKNRzM+vXrVa0gmoSJiMh31I4IlpBAfykwaXLsXKa7i+N1glu2FL/AQJUEklfCcGdELgkAX3jhBTUgMyD54ujRo9K9e3eVvPHee++VqxBERFQ5IQGQM4I4jyEoSIJbtVK3szgcDLkzCaRv377m26jxw3AwmIotKiqqxBk8iIjIu2cE2ZOYKofOZMh1F2MVcnA/wOz4eJUIEnnTjdy35PoawPz8fAkICJBdu3ZZLa9WrRqDPyIiH08EYSawc3BAaHJ7AIjgD8ke9oz1R0RE3q2xeU7gdHcXxasHhM7eu1c0m8kXiFzaBxAzdKDZl4iIqFGNi5nAHArGOQJjYsQ/MlIFf9n/7OMJR+7pA4hEjwMHDki9evVUbSDmBba0detWx5SMiIgqhUbVL/4OnErNkfScfKkSXO5ZRqkY6F9vbN9eMtauVf0AQ9q15X6iCrP7U3rbbbdVfKtEROQ1IkMDpXpYkJzNyJUjyRnStn6ku4vklc3ACACRDCL33uvu4pCvBICo9Xv44YfFaDTKsGHDpEGDBmoGECIiIsBQMAgAkQjCANB5iSBZ8Tt5wpFDlCmKGzNmjKSmpqrbmAc4OTnZMVsnIiLvSgQ5wynhnAFNwJB7+LAUpKQ4ZRvkW8pUA4j+fvPnz5f+/furqWiOHz8u2dnZxT43Ojra0WUkIqJKkwjCTGBnCIiKksDoaMlLSJCsnbukytXdnLId8h0BZc38feKJJ+Txxx9XnVE7d+5c5DkIDPEYh4ghIvI9+mwgHAvQuf0AVQAYv4MBILkmAET/v3vuuUdN+9a+fXv59ddfpXr16hXfOhEReV0TsF4hQI7vB5j688+SzX6A5Mos4PDwcGnbtq3MmTNHunXrJsHBwY7YPhEReYGY6qHqOi0nX3afTGUiiJOmhIOs+HgG2VRhdqfyDhkyhMEfERFZWbTthPn2zR+sk3l/JnAPOVhwq1YigYFScO6c5J34d38TlQfHciEiogpJTMmSCQv+HZ5E00SeW7BLLSfHMQQHi7FFC3U7a8cO7lqqEAaARERUIZgCzqRZLyvQNDmSnMk966RmYPYDpIpiAEhERBXOADbY5Hz4+/lJbI2L/QLJGQNCx3O3UoUwACQiogqpGxkiU+5oZxUEvn5HW7WcnDMgdPaePaLl5XH3knOzgDETSFlNmzat/KUhIqJKaWDnaGkYFSqDPtokYUH+ctflDd1dJK8UFBMjhogIMaWmSvY/+ySkbRt3F4m8OQDctm2b1f0tW7aoAZ9bFHZG3bdvn/j7+0unTp2cU0oiIvJ4HWOiBMP/ZeQWyLmMXKlehcOFOZqfwaAGhM5Yv16yd8YzACTnBoCrVq2yquHDmICfffaZREVFqWXnz5+XYcOGSffu3ctfEiIiqtSMgf5SN8IoJ1Oy5cjZTAaATuwHiAAwa0e8RN1zj7M2Q17O7j6AU6dOlSlTppiDP8DtV199VT1GRES+K7pwQOiEcxnuLorX9wNkIgi5NABMTU2VU6dOFVl++vRpSUtLq1BhiIiocoutfnFKOA4B4/yhYHIPHZKC1FQnbom8md0B4O23366ae7///ns5fvy4uuD28OHD5Y477nBOKYmIqJLVAHIMQGcJqFZNAhs0ULezd+1y2nbIu5V5LmDd7NmzZezYsXLfffdJXmEKekBAgAoA3377bWeUkYiIKlsN4Fk2ATu7FjDv+HHVDBzWtatTt0Xeye4awNDQUJk5c6acPXtWZQdv3bpVzp07p5aFhV384BMRkW+KrlZYA3iWNYAuGRB6BweEJhcPBJ2YmKguzZs3V4GfhskfiYjIp8UUNgGfzciVtGwOVOwsxnb/JoLw95dcEgCi5u+6665TgV///v1VEAgPPvigPP300+UqBBEReYdwY6BUDwtSt4+yFtBpjK1bof+VFJw9K/knTzpvQ+S17A4AR48eLYGBgZKQkKCag3UDBw6UpUuXOrp8RERUSWsBGQA6j8FoFGPhZAwcDoZcEgAuX75c3nzzTWlQmIGka9asmRw9erRchSAiIu8RU5gIcpRjAToV+wGSSwPAjIwMq5o/XXJysgQHc9ofIiJfZ64BTGYiiKv6ARI5PQDs0aOHzJ0713zfz89PTCaTGgKmV69edheAiIi8NABkDaBLagCz9+wRrXBYNiKnjQOIQO+aa66Rv/76S3Jzc2XcuHGye/duNRTM+vXr7V0dERF5axMwk0CcKig2Vgzh4WJKS5Oc/fvF2Lq1czdIvl0D2Lp1a4mPj5crrrhCrr/+etUkjBlAMCZgkyZNnFNKIiKqNGIKxwJMTMmW7LwCdxfHa/kZDBLSrp26zWZgcnoNILJ/GzZsKJMmTSr2sejoaLsLQURE3qNaWJCEBwdIWk6+HDuXKc1qh7u7SF7L2L6dZGzYoAaEjrr7bncXh7y5BrBRo0Zy5syZYscHxGNEROTb0Dc8pgaHgnGFkPZx6jprJxNByMkBIEYcx4fbVnp6uhiNRntXR0REXiimGucEdmUiSO7BQ1KQnu6SbZKPNQGPGTNGXSP4e/HFF62GgikoKJBNmzbJZZdd5pxSEhFRpcLBoF0joHp1CaxfX/JOnJDsnTslrEsXF22ZfCYARJKHXgO4c+dOCQq6ONUP4HZcXJyMHTvWOaUkIqJKOhQMxwJ0RT9ABIDoB8gAkBweAK5atUpdDxs2TGbMmCERERFl3ggREfmWf4eCyXB3UXyiH2DaL0sla+dOdxeFvLkP4PTp0yU/P7/IcowDmJqa6qhyERGRF9QAnjifJXkFJncXxzemhIvfoVrpiJwSAN59993yzTffFFn+7bffqseIiIhqhxslOMAg+SZNTl7I4g5xIjUAtL+/FJxJlvzERO5rck4AiGSP4qZ8w+wgeMxeM2fOVMPHIIO4U6dOsnbt2jK9DrOOBAQEMPGEiMgDGQx+El04IDRnBHHyvjYaJbhFc3WbA0KT0wLAnJycYpuA8/LyJCvLvv/y5s2bJ0899ZQ8//zzKsmke/fu0q9fPzWgdGlSUlJk8ODBct1119lbfCIichH2A3SdkPZ6MzD7AZKTAsDOnTvLhx9+WGT57NmzVQ2ePaZNmybDhw+XBx98UFq1aqX6F2KWkVmzZpX6uhEjRsigQYOkC9PdiYg8FoeCccOA0PE7XLhV8qmp4F577TXp3bu37Nixw1wDt3LlSvnzzz9l+fLlZV5Pbm6ubNmyRZ599lmr5X369JENGzaU+Lo5c+bIwYMH5YsvvpBXX321TDWWuOiYqEJE5BqxhYkgR85yKBhnC2l/cU7g7N17RMvPF78Au3/eycfYXQPYrVs32bhxozRo0EAlfixevFiaNm0q8fHxqgm3rJKTk9UA0rVr17ZajvtJSUnFvmb//v0qYPzyyy9V/7+ymDJlikRGRpovqGEkIiLniy4cCibhHIeCcbagxo3FUKWKaFlZkrN/v9O3R5Vfuf5FwIwfX331lUMKYDutXElTzSFYRLPvpEmTpHnzi51dy2LChAnmWUz0GkAGgURErqsBRBKIyaSpxBByDj+DQYzt2krmxj9UP0Bjq1bc1eTYGkBAE+wLL7ygArLTp0+rZUuXLpXdu3eXeR01atQQf3//IrV9WJ9trSCkpaXJX3/9JY8//riq/cNl8uTJqikat3/77bditxMcHKwGrba8EBGR89WrGiL+Bj/JyTfJ6bR/u+KQc7AfIDk1AFyzZo20a9dODfkyf/58SS+cfBpNwBMnTizzejB9HJJGVqxYYbUc97t27Vrk+QjcMAXd9u3bzZdHHnlEWrRooW5feeWV9r4VIiJyokB/gzSIClG3j3BGENf1A4yPd/7GyPcCQPTBQ/IFAjXL+YAxNiD6BtoDTbMfffSRfPLJJ7J3714ZPXq0GgIGgZ3efIvhXlRBDQZp27at1aVWrVpq/EDcDgu72NeEiIg8byiYBCaCuGwomJwDB6WgsHKGyGF9AFELV1z/v5o1a8rZs2ftWtfAgQPVa9CUm5iYqAK5JUuWSExMjHocyy41JiAREXmumMLBoFkD6HwBNWtKQL26kn8yUbJ37Zawq9gyRg6sAaxataoKzGxhIOf69evbuzoZOXKkHDlyRA3VgmFhevToYX7s008/ldWrV5f42pdfflk1/xIRkWfiWIDu6gfIZmBycACIxI/x48er5A1k65pMJjUt29ixY83NtURERFazgXAoGJcIaXexHyAHhCaHB4AYCDo6OlrV9iEBpHXr1qrWDokbyAwmIiIqMhRMcqYa5oucKyTuYj/A7B3x3N/k2D6AgYGBaiDmV155RbZu3apqADt06CDNmjWzd1VEROTlGhb2AUzLyZfzmXlSLezf5EFyPGObNiL+/pJ/5ozknzolgXXqcDeTY2oAkbCRmZkpjRs3lgEDBshdd92lgr+srCz1GBERkc4Y6C91I43qNhNBnM8QEiLBhZMlZO1gP0ByYACImTj0sf8sISjEY0RERJaiC2sBORSMa7AfIDklACxpqjbMyFGtWjV7V0dERF4utjARhDWAru8HSFThPoBRUVEq8MMFc/FaBoGYpxe1gvoAzkRERLrowkQQ1gC6dkDorN27RcvPF78Au7v7kw8o81kxffp0Vfv3wAMPqKbeyMhI82OYESQ2Nla6dOnirHISEVElxRpA1wpq3FgMYWFiysiQCwsXSZXuVzMZhMofAA4ZMkRdN2rUSLp16yYB/I+CiIjsGAw64Vwm95cL+Pn7S0CtWpJ7+LAkvfgi5lKVupMnSdUBA7j/qfx9AHv27ClHjx5VY/7dc889cvr0abV86dKlsnv3bntXR0REPtIEnJyeK+k5+e4ujtfLS0qS3CNH/l1gMkniSxPVcqJyB4Br1qyRdu3ayaZNm2TBggXmjOD4+HiZOHGivasjIiIvF2EMlOqF4/8dPZvh7uJ4vdwjR5Gxab3QZJLcownuKhJ5QwD47LPPyquvviorVqxQff90vXr1ko0bNzq6fERE5EW1gEfPshnY2YJiY1SzrxWDQYJiop2+bfLiAHDnzp1y++23F1les2ZNOXv2rKPKRUREXpgIwgDQ+TD7B/r8mRX2AeSsIFShALBq1aqSmJhYZPm2bdvU/MBEREQlDQbNJmDXQMJHWPer1e3qDz/MBBCqeAA4aNAgGT9+vCQlJamxADEX8Pr162Xs2LEyePBge1dHREQ+ILYGm4BdLbTzFeraKiGEqLwB4GuvvSbR0dGqtg8JIK1bt5YePXpI165dVWYwERGRrehqehMwk0BcJaR9O3WdHc8ZQagou4cHDwwMlC+//FImT56smn1RA9ihQwdp1qyZvasiIiIfEVuYBJKYmi3ZeQViDPR3d5G8nrFNGxE/P8k7eVLyk5MloEYNdxeJPEi554dp0qSJuhAREV1KtbAgqRIcoMYBPH4+U5rWCudOczL/8HA1K0juwYOStXOnhPfqxX1O9gWAY8aMkbKaNm1amZ9LRES+AX3GMSPI7pOpciSZAaCrhLRrpwLA7J27GACS/QEgmnotbdmyRQoKCqRFixbq/r59+8Tf3186depUltUREZEP0gPAo5wSzmWM7dtJyqJFqgaQyO4AcNWqVVY1fOHh4fLZZ59JVFSUWnb+/HkZNmyYdO/evSyrIyIiHxRjHguQiSCuEtKuvTkRRNM0VRNLVK4s4KlTp8qUKVPMwR/gNmYHwWNERETFiTGPBcjZQFzF2KK5+AUGSkFKiuQdO8YTk8ofAKampsqpU6eKLD99+rSkpaXZuzoiIvIRrAF0Pb+gIAlu3UrdzopnMzBVIADENHBo7v3+++/l+PHj6oLbw4cPlzvuuMPe1RERkQ/1AYTj57Mkv8Dk7uL4XjPwTo4HSBUYBmb27Nlq1o/77rtP8vLyLq4kIEAFgG+//ba9qyMiIh9RJ8IoQQEGyc03yckL2RJdGBCS8weEPs8aQKpoABgaGiozZ85Uwd7BgwdVp9KmTZtKWNjFzr1ERETFMRj8VD/A/afT5ei5DAaALmJsVzgjyJ49ouXlqT6BRHY3AesQ8LVv317i4uIY/BERkV3NwEeYCOIyQTExYoiIEC0nR3L273fdhsk7A0AiIqLyJoIkcCgYl/EzGCSkbVt1m4kgpGMASERELsMaQPc2A2cxEYQKMQAkIiI31AByLEBXJ4JANoeCoUIMAImIyPWDQZ/LUEmE5NoawJwDB6QgnTOxEANAIiJyofpRIeJv8JPsPJOcTsvhvneRwFq1JKBOHRFNk+w9u7nfiTWARETkOoH+BqlfNUTdPpLMmihXCtGHg9nJGUGIASAREbkpEYRzAruWsbAfIDOBCdgHkIiI3BMAnmMNoDumhGMmMAEDQCIicqnYwkxgDgbtWsa2bUT8/CT/ZKLknznj4q2Tp2EASERELhVdmAnMoWBcy79KFQlq0ljdztq5y8VbJ0/DAJCIiFwqtoZeA8ihYFyNzcCkYwBIRERuqQFMy86XC5l53PsuxAGhSccAkIiIXMoY6C91IozmWkBy4b43J4Ls5EDcPo4BIBERuS0TOOEcp4RzJWPzZuIXFCSm1FTJO3rUpdsmz8IAkIiI3BYAHklmAOhKCP6MrVqp20wE8W0MAImIyOViCoeC4ViArmdsz/EAiQEgERG5AWcDcR8mghCwBpCIiNw2GDSng3PjnMB79oiWxyxsX+X2AHDmzJnSqFEjMRqN0qlTJ1m7dm2Jz12wYIFcf/31UrNmTYmIiJAuXbrIsmXLXFpeIiKquOjCPoDJ6TmSnpPPXepCgTExYoiIEC03V7L37eO+91FuDQDnzZsnTz31lDz//POybds26d69u/Tr108SEhKKff7vv/+uAsAlS5bIli1bpFevXnLzzTer1xIRUeURYQyUamFB6jZnBHEtPz+/f2sBd+508dbJU7g1AJw2bZoMHz5cHnzwQWnVqpVMnz5dGjZsKLNmzSr2+Xh83Lhx0rlzZ2nWrJm8/vrr6nrx4sUuLzsRETlmQOijHAvQ5YztLwaAWfEMAH2V2wLA3NxcVYvXp08fq+W4v2HDhjKtw2QySVpamlSrVq3E5+Tk5EhqaqrVhYiI3C9WHwrmLIeCcdeUcNk7412+bfLxADA5OVkKCgqkdu3aVstxPykpqUzrmDp1qmRkZMhdd91V4nOmTJkikZGR5gtqGImIyP2iCxNBEs5xNhBXC2nXVl3nHDgoBenc/77I4Al9ESxpmlZkWXG+/vprefnll1U/wlq1apX4vAkTJkhKSor5cuzYMYeUm4iIHFQDyMGgXS6gZk0JqFsXP7qSvXu36wtAvhsA1qhRQ/z9/YvU9p0+fbpIraAtBH3oO/jtt99K7969S31ucHCwyhi2vBARkftxOjj3+jcRhM3AvshtAWBQUJAa9mXFihVWy3G/a9eupdb8DR06VL766iu58cYbXVBSIiJy5mwgJ1OyJCe/gDvZTQNCMxHENwW4c+NjxoyR+++/Xy6//HI1pt+HH36ohoB55JFHzM23J06ckLlz55qDv8GDB8uMGTPkqquuMtcehoSEqP59RERUeVQPC5KwIH/JyC2QY+eypGmtKu4ukk8xFiaCZHEoGJ/k1j6AAwcOVEO7TJ48WS677DI1zh/G+IuJiVGPJyYmWo0J+N///lfy8/Plsccek7p165ovo0aNcuO7ICKi8kB/b/OcwBwKxuWMbdrgIEh+YqLknT7t+gKQ79YAwsiRI9WlOJ9++qnV/dWrV7uoVERE5AqxNUJlT2Iqp4RzA/8qYRLctInk7D8g2bt2SeC117qjGOSrWcBEROS7oquxBtAjmoHjmQjiaxgAEhGR24eCOXqOg0G7MxEkmzOC+BwGgERE5DbRegDI2UDcwlg4FEzWrl2imUzuKQS5BQNAIiJym9jCJJDj5zMlv4ABiKsZmzcXv6AgMaWmSu7Roy7fPrkPA0AiInKbOhFGCQowSF6BJokp2TwSLuYXGCjG1q3V7WwOB+NTGAASEZHbGAx+El2NzcDuZOSA0D6JASAREblVTGEAeIRjAbpFiHlAaGYC+xIGgERE5Fb6YNAJzAR2ayZwzp69ouXmuqcQ5HIMAImIyK1iCjOBjyRn8Ei4QWB0tBgiI0XLy5Psfft5DHyE22cC8VQFBQWSl5fn7mIQURkFBgaKv78/91clDgA5FIz7puQLaddOMtatk+yd8RLSto2bSkKuxADQhqZpkpSUJBcuXHDpgSCiiqtatarUqVNH/aBR5WGeD/hchvoO5vFzTzMwAsCs+J0Sdc89bigBuRoDQBt68FerVi0JDQ3lFxFRJYCgITMzU04XTmhft25ddxeJ7FC/aoj4G/wkO88kp9NypHaEkfvPXQNCMxHEZzAAtGn21YO/6tWru++oEJHdQkJC1DWCQHyG2RxceWAcwHpVjXLsXJZqBmYA6HpoAobcg4ekID1d/KtUcUMpyJWYBGJB7/OHmj8iqnz0zy7771beGUE4FIx7BNSoIYH16qE6XbJ37XZTKciVGAAWg/1PiConfnYrfyJIAucEdhs2A/sWBoDkUe6//355/fXXxRPExsbK9OnTrYKLRYsWibfYuXOnNGjQQDIyOPQGuV9MNdYAesp4gNnxO91dFHIBBoBeYujQoXLbbbeV+Pi2bdvkpptuUn2jjEajCm4GDhwoycnJ5ufMnz9frrzySomMjJTw8HBp06aNPP300+qxa665RgVAJV2wvoqKj4+Xn3/+WZ544gnxRImJidKvXz+HrnPHjh1yzz33SMOGDVUftlatWsmMGTOKTXJ45513pHnz5hIcHKyef6lA+fz58yqgxvHEBbcts9vbtWsnV1xxhbz77rsOfU9EFaoB5GDQHlADyADQFzAJxAegU3zv3r3l5ptvlmXLlqmhMg4fPiw//vijypyEX3/9Ve6++24VVNxyyy0qqNuzZ4+sXLlSPb5gwQLJLRwh/tixYypwwGsQJEJZO9yjbxbGayvOBx98IP/5z39U8OmJMLyIo23ZskVq1qwpX3zxhQrqNmzYIA8//LDan48//rj5eaNGjZLly5erIBCBW0pKilXwXpxBgwbJ8ePHZenSpeo+1osgcPHixebnDBs2TB555BGZMGECkybII4aC4WDQ7hOC73ODQfKTkiTv1GkJrF3LjaUhp9N8TEpKioa3jWtbWVlZ2p49e9S1I5y8kKmtP3BGXTvbkCFDtFtvvbXYxxYuXKgFBARoeXl5Jb5+1KhR2jXXXFOmbR0+fFjtw23btl3yuRMnTtTi4uK0jz/+WGvUqJHm5+enmUymIs8rKCjQqlatqv30009Wy2NiYrRXXnlFu//++7WwsDAtOjpaW7RokXb69GntlltuUcvatm2r/fnnn+bXJCcna3fffbdWv359LSQkRD3+1VdfWa03NTVVGzRokBYaGqrVqVNHmzZtmtazZ0+1Hyy3/e6775rv4z1jX1rug3nz5mlXX321ZjQatcsvv1z7559/tM2bN2udOnVSZevbt68qqz1Gjhyp9erVy3wf5ySO399//13mdeA1KN8ff/xhXrZx40a1zHI9OTk5WnBwsLZy5UrNGzj6M0yuk5mTr8WM/0ldzmfkcNe7ycGbbtb2tGippf76K4+Bl8U4ttgEfOkAWTJz8+2+fL7xiHR74zcZ9L9N6hr37V3HxZjDMTVX+fn5snDhwhLXiefs3r1bdu3aJY524MAB+fbbb1UT8/bt20ts/kXz5OWXX17kMTRRduvWTTVj33jjjaoWa/DgwXLffffJ1q1bpWnTpuq+/t6ys7OlU6dO8tNPP6n3o9d8bdq0ybzOMWPGyPr161Ut6IoVK2Tt2rVqXfaaOHGivPDCC+q1AQEBqjl33LhxqhkX6zx48KC89NJLdq0TtXvVqlUz30eNXePGjdX7adSokWpuf/DBB+XcuXMlrmPjxo2q2RdN+rqrrrpKLUMtoy4oKEji4uJUWYncKSTIX2pHBKvbR5gI4jbGwn6AGBCavBubgC8hK69AWr+0rEI72aSJvPjDbnWxx57JfSU0qOKHCD/8zz33nGoSRHMfmm+vvfZaFTTVrl1bPQf97hAEoHkxJiZGvaZPnz5y7733qj5nFYGm488//1w1dZbkyJEjqgkSfRRt9e/fX0aMGKFuI5iaNWuWdO7cWTUXw/jx46VLly5y6tQpFcjWr19fxo4da3493huaQb/77jsVEKWlpclnn30mX331lVx33XXqOXPmzJF6GALBTthO3759zc20CADRbI6AFYYPHy6ffvppmdeHwA3BMvpC6g4dOiRHjx5V5Z87d64ar3L06NEyYMAA+e2330oc0Ly4fYlleMwS9hf2P5EnNAOfSs2Ro2cz5LKGVd1dHJ8U0q69pMxfoKaEI+/GGkAf8dprr6kf/tmzZ0vr1q3VdcuWLVUmKISFhamgA7V1qNGqUqWKSgBBsKj3EywvBJSlBX+QlZWlAs3ihvFo3769+bYesCJQtV2mzwKBAAnvF6/DgN54L+g/l5CQYA6o0BcR702HmrEWLVrY/d7KUja9XJeCGthbb71VBbnXX3+9ebnJZJKcnBwV/HXv3l0l5Hz88ceyatUq+eeff0pcX3H7srhptpB8UtFjTOQIMdU4J7CnZAJn7dwlmsnk7uKQE7EG8BJCAv1VTZw9klKypfe0NarmT2fwE/l1TE+pE2m0a9uOhGAItWa4TJkyRTp06KCSClAbpmvSpIm6oInx+eefV1mn8+bNU8kC5YXg8lJq1KihghDUFqJZ0pJl0ogevBS3DIESTJ06VTUbYwgXBGPY/lNPPWVOYtGbim0DofI0uZelbHq5SoOEG9TKPvTQQyoAt4RpzdC8jGOhQ7YwIKgtLnBFTShqRG2dOXPGHKjq0JSMY07kbrE1CucEZhOw2wQ3ayZ+wcFiSkuT3CNHJbhxI/cVhpyKNYCXgB9wNMPac2lcs4pMuaOd+BcGBLjGfSy3Zz3OHNQWQRZ+9EsbAw59zTCzgivGibvsssvMgVBFoSkbNWnoI4j+beg/t3//fvPjeN8I0jZv3mxelpqaavUcV0LNX69evWTIkCGq5tIWmpPRhxP9CXX79u0z164WB03i6Eto+R7RBxLLunbtavVc9JPEPwNE7hZtrgHk2JTu4hcYKMbWrdVtNgN7N9YAOsnAztHSo3lNOZKcKbE1QqVu5MV5Sp0JP+62SRZIJkCCxTfffKOGeUEtEmq6kFiwZMkS1fcNXn75ZVUDh/52CCqQkPHee++pplLL5khnQRNxx44dZd26deZgsLyQFIKEEyQ7REVFybRp01Tzt15rhmFmEGw988wzav+gXxySOQwGg8tnktCDP/S3RGKK3j8P/SH1ZnMM4YN988ADD6haTdQoPvbYY+q46LWCCPTQpxP9D9GnD+/1hhtuUDWK//3vf9VzkAyDsSAtawzR9+/EiRNqG0SeMx0cuyS4uxk4a9s2lQgSeeutbi0LOQ9rAJ0IQV+XJtVdEvzB6tWrVU2O5QX9ydDnDzV56NOH4AoJHkg0+Oijj1R2LPTs2VP1jUMQgb6BGPAYwQj6zpWnb1x5IED58ssvK7yeF198UQVMSM5Afzk0h9oOko2gELVkCIgQ/KCWDUETBsl2JSR2oFkW7xtNvfoFSS46BKYI2NFM3qNHD5UJjbIiqNcheEd/QMs5cLFONIEjuMQF/RWRjGPp66+/Vo+VVJNI5ErRhYNBJ6fnSEZOPne+mxjbXezbzAGhvZsfxoIRH4KmPnT4R21ZRESE1WMYPgQDJGOoDVcHAnRx/yPYRGCD4MyV0MyNmjP0H0Tmri9AYkmzZs1UEKhnLVd2/AxXfh0mL5fzmXmy5Mnu0rqe9Xc0uUZuQoIc7NNXNQc33/KXGGz6ZVPljHFssQaQPAaCbmS6XmqGC0fAmIIIfNCvDmP4YbgbQN9BX4GhZZDo4y3BH3nXjCAJ59gP0F0CGzYU/8hI0fLyJKeUkQaocmMfQPIoaIp2FWRAo9kUCTEYOBrJI2hm9RXoP2iZWUzkKXMCbz92gf0A3Qh9oY3t20vG2rWSFR8vIRZDW5H3YABIPgn9IzEPLxF5Zg0gh4JxLwR9CACzMSPIxQYS8jJsAiYiIg8cDJpNwB4xJVzhZAHkfRgAEhGRx8CwWcAaQPfSm31zDx2SgrQ0N5eGnIEBIBEReYzoahebgE+mZElOfoG7i+OzAqpXl8D69dXt7N32zWNPlQMDQCIi8hg1qgRJWJC/YICy4+ez3F0cn2ZuBkY/QPI6DACJiMijMlCjzYkg7AfoTiGFA0JzSjjvxACQiIg8SmzhjCDsB+heIe3aqmvWAHonBoBE5YQxBDHNXJoHdJD+9NNPpWrVqub7mNu5onMqe5oBAwaoKfzId6aEYwDoXsbWrTEXpeSfOiV5p065uTTkaAwAvcTQoUNV0wkuAQEBEh0dLY8++qicP39eKivM46u/J8tLfv7FOUIXLFig5vvF4M1Yvn379jKt4+6777Z6zr59+9QMIFgPps7BzBirVq26ZPkwi8Zjjz0m4eHh4mnGjh0rK1eudPh6p0yZouYpxnuuVauWmmMZgbCl4o4ZLm+//Xap654/f76atzo4OFhdL1y40OpxzGv92muvqamOyLvFsgnYIxjCwiS4aVN1O5vDwXgdBoBe5IYbbpDExEQ5cuSIfPTRR7J48WIZOXKkVGYPPfSQek+WFwS4+vy9CNbeeOMNu9bx3//+1+rxG2+8UQWVv/32mxocGjVnN910kyQlJZW4zuPHj8uPP/4ow4YNE09UpUoVqV69usPXu2bNGhX0/vHHH7JixQq13/r06aOOhc72eH3yyScqALzzzjtLXO/GjRtl4MCBcv/998uOHTvU9V133SWbNm0yP6d9+/YSGxsrX375pcPfF3nqWICZ7i6Kz2MiiPdiAOhEeUlJkvHHJnXtCqg5QZNkgwYN1I8yflCXL19uftxkMsnkyZPV43guAp2lS5eaH0fgiB/qb7/9Vrp37y4hISGqtgc1ZH/++adcfvnlKrBAoHnmzBnz6/DY9ddfr2rQMAk1pnPD/LqWsF4EpbfffruEhoZKs2bNVAB1KXgu3pPlRYcgAbVCvXv3tmsdKKMO8w4fOHBAnn32WRVgoFwIKDMzM2V3KUMfYB/FxcWpfWnbDPvTTz9JixYt1HbRbIng6LPPPlPBS1RUlDzxxBNSUPDv8BZffPGF2reoVUP5Bg0aJKdPn7baHvYVyoZj0qtXL7U+7NMLFy4UWz7bJmDUEKO27vXXX5fatWurck6aNEkFcM8884xUq1ZNvRcEa6XB+YJ1tWnTRr3/OXPmSEJCgtWsKrbH64cfflBlbty4cYnrnT59ujqHJkyYIC1btlTX1113nVpu6ZZbblFzOJN3i6lxMQnk2PlMKTBp7i6OT9MTQbJ2xru7KORgDAAvQdM0MWVm2n0599VXcuDa6yRh6FB1jfv2rgPbLq9Dhw6pH+vAwEDzshkzZsjUqVPVHLjx8fGq+RQ/qPv377d67cSJE+WFF15QQRxq2+655x4ZN26cej3myz148KAKvHToAzdkyBD1GGqGEKj079+/SN84BByo1cG28fi9994r586dE2dDjRGCUwQtaBq1LBdqyVq1aiVz585VgRoCItQQIkjC/MAl+f3331XQZguB43vvvSfffPON2v+rV6+WO+64Q5YsWaIun3/+uXz44Yfy/fffm1+Tm5srr7zyiqr5WrRokRw+fFgFWZaBOQJJBHBo5h4xYoRqfrYXajhPnjypyo6+dAgSUdOJoBQ1bY888oi6HDt2rMzrTElJUdcIIItz6tQp+fnnn2X48OGlrgc1gPinxRLOzw0bNlgtu+KKK2Tz5s2Sk5NT5jJS5VMnwihB/gbJK9Dk5AUOBeNOIYVDwWTv3CWayeTWspCDaT4mJSUFUZW6tpWVlaXt2bNHXesKMjK0PS1auuWCbZfVkCFDNH9/fy0sLEwzGo3qPeIybdo083Pq1aunvfbaa1av69y5szZy5Eh1+/Dhw+o1H330kfnxr7/+Wi1buXKledmUKVO0Fi1alFiW/Px8LTw8XFu8eLF5GdbxwgsvmO+np6drfn5+2i+//FLienr27KkFBgaq96RfxowZU+R5erm3bdtW5LEPP/xQW7FihbZz5071XmJjY7XevXtbPef48eNap06dVHmwD7GfiluXpbi4OG3y5MlWy+bMmaPKceDAAfOyESNGaKGhoVpaWpp5Wd++fdXykmzevFmtR3/N+PHjtbZt21o95/nnn1fPOX/+vHnbkZGR5scnTpyoymh5fsTExGgFBQXmZTiG3bt3tzpu2MfYT2VhMpm0m2++Wbv66qtLfM6bb76pRUVFWX2mioPj/OWXX1otw/2goCCrZTt27FDv+8iRI8Wup7jPMFVO176zSosZ/5O2dt8ZdxfFp5lyc7W9cZep36TsgwfdXRyqQIxj62JnKvIKaGabNWuWqoVCcyuabtHcCOg4j9of9JmzhPuoebKEplAdasKgXeG0QPoyyyZK3EaNIGqYUOOD5k2UAU2DJa03LCxMNXnaNnXaQi2hZW2XZaZrWaD/n65t27aqdhI1d6jd7Nixo6plRT9JJDSgBhNNrNh3qBlD03bdunWLXW9WVpYYjcYiy9Hs26RJE6t9haZfNJ1bLrN839u2bVO1cajdQ40omuoB+w/JEEiyQFO8bU2YvVADajAYrMqBfaLz9/dXNaKXOia6xx9/XNXmrlu3rsTnoEkZx7C4fWULTdqWcGxsl+H4AM4v8v5EkINnMuTouQy5Wmq4uzg+yy8wUGUDZ23dKlnx8RJcSlcOqlwYAF6CX0iItNj6b/+mskC6/KEbb0Knu38XGgzS+OefJLAwoCrrtu2BoKppYcYWmiEREKLZFc2L9vzIWjYb64/ZLtODFEBzJfoEor9WTEyM6l/YpUsX1bRZ0nqLW09x0F9Pf0+OgKAP5UCzN24jaEWfPWRLIwMYZs6cqRIc0M8OfQOLgybl4jKsi3uPpb1vNDuj6RMX9AWsWbOmCvzQ/Knvv+KOUXm6B9hbttLgHwv0S0RzsmU/SEsIqBG8zps375LrQ19B26QbBKL6PyA6vcsA9hN5Nw4F41nzAiMAzMaMILfd5u7ikLf0AcSPbaNGjVQNAfpc4UfjUlmIeB6ej07ls2fPdmr58INoCA216xLcqJHUnTxJBX2KwaDuY7k967H90bcX+vKhvx9q/hDc1KtXr0htDfpYoQ9cReCYPfnkk6pfH2qZEAAiucITIbEjLy/PXLOn1yRZ1ozp90sLhDp06CB79uypcHn+/vtvta+QeILEGyRA2NbAYRlqIy399ddf4g4IPFHzhyF4EDzjs1uSjz/+WH1WkSxyKfiHAUG3JSQwde3a1WrZrl27VMCJAJy8G4eC8cBMYA4F41XcGgCiZuCpp55STXxoBsMPYL9+/Yo0HerQOR5BBp6H5z/33HMq8MD4YZ6m6oAB0vS3lRL92WfqGvddDWPgISBD5icg2/PNN99U+x01M6jdQrPjqFGjKrQd1NAhuWHv3r0qmQBNfnpTnTOhNgjl1wMxvCfc12uSkKyCrGcES0ikQBLGf/7zHxW86U3hCDyQBIEkFjSFo9kc+wnnGoaHKQlq6JC4YJnNWx4YrzEoKEjef/99lbiDWjXLGltA0gcCxfHjx6vyIQMZGcdQ0X8S7IUhYFBT+dVXX6kmfOxrXNAkbgldDr777jt58MEHi13P4MGDVaavDucgAj6cn3ivuP7111/V94PtPxu2ySLknVgD6DlCCrvvZP/9t5hsWnao8nJrAIhMRGQH4kcCtVBoQmzYsKHqx1Yc1PbhBxPPw/PxugceeEDVcnmiwDp1JOzKK9S1u4wZM0b+97//qcxOBMtPP/20uqBPH7JU9eFFKgL9vNAcisAKQ7NgO+hT52woO7apB2oY4Bn39VphBFYYDBnBGoZlQbkQPCCwQH83QE0S9kN6erpce+21qn8gakkxdElpNVf4RwTNp1hXRaApE8EcgiX090NNoO35jFo2ZA2j1g39KPH50PtForbVlbBtZP7inwvUouoX22ZeZEGjthAZ5MXBP3kYI1CHmj68BsPK4D1in2CdV155pfk52dnZanBoy36d5P01gIfOZMjJC47p85mYkiUbDiara66v7AIbNBB/9L/Oy5Otsz6TE/uOOGT/YT2bFyx3yPocua7KsD5H8EMmiDs2jP5N6DCPHz6MDWdZE4BaHDT12urRo4f6gcdwJDr8IGBoETTl2fZnKg5qJtCvDD9iep8vyx8Y1PzoTdJEl+q+gEBx2bJlLt9RmBEDga49Q7ZUdv/3f/+n9rfl2Ja2+Bn2Hl/+cVSeX7RL3UY990M9Gsu1Lcv/j+Vvf5+W/609JPjFQ8X5Q925Prs8MEgiky62zpnETw5cc6vU63dduY/HyV9WStPVP4hBtAqvz5HrcsX6Tgx/Svo887A4Q2kxjsckgaDfE5rPbDt5435JMzBgeXHPx9htWF9xGZsYL8xyzDBOI0WO8vDDD6uaT4wr6Ozp4BBsIhMYWbrr169X06qhL54vwT94aCon74cauhd/uBj8AWopPvz9kLo4AoJArq/samRdkM8Kgz9AINN89SIRXMqpucXtiq7PketyxfrqfTJdTtzaR+o3jxWfzgIuS1bqpZ5f3HLLuUuRCUvkaBgkuzwDMpcHspZfffVV1e8R3SDQjG/Zh85XAm7yDYeTM6S4CUDqVTVKaJD9P1uZufly8kI211fO/dfwaEKx/cWSw6IkL9D+biiBeTlSI+O8Q9bnyHW5an3+miYnd+/33QAQfa/QD6ssQz9caqgI/BCXNO8pfiTRD86yBhD9DIkqk3fffVddiHxBoxphYvATqyDQ389P5j/aVepGhpSrRrHbG79xfeXcfyf2xciFZe+r2itdgZ+fNP76q3IFMegHd+GW/g5ZnyPX5cr11WtTsb73lToJBB30MUSE7dAPuG879MOlhopAx/2S+v+hkzzawS0vRETkuRCkTLmjnQr6ANev39G2XMEL11fx/YfAB/3WELgArk8+8FS5a7AcuT5PLpsz1ucVSSCALD9kjaIzO4I7zJGKjFWM1YYBhVF7d+LECTVPKyBBAzMXYFgMZAJiGA7MXYrJ4e+8884ybZNJIETei0kg3gU1d0eSMyW2Rmi5gxeuz3H7D7VZaLpE7ZUjAhhHrs+Ty+aM9TkiCcStAaDeuf2tt95SQ0IguEMzF7J99RkmMH7b6tWrzc9HdvDo0aNVkIiBjTE2GoLAsipLAIipu1wxjh0RORbGI8R3BjP5icgXpVamANCTdg6ykjHQLsawK6lPIRF5rrNnz6p+wc2bNzeP9UhE5CtSK8MwMJ4IPxhVq1Y1T8WFcQpdPdMCEdkP/8diLFB8dvEZZvBHRFQ6BoDFZBqD7XysROT5EPzpn2EiIioZA0AbqPHDgNJoBs7Lyytl1xGRJ8FIAKz5IyIqGwaAJcAPCX9MiIiIyBu5bRxAIiIiInIPBoBEREREPoYBIBEREZGP8bk+gPqwhxgrh4iIiMhb6LFNWYZ49rkAMC0tTV03bNjQ3UUhIiIickqsgwGhS+NzM4GYTCY5efKkhIeHl2uQZ0TXCB6PHTt2yVG2qfLh8fVePLbei8fWe/HY2gchHYI/TJVrMJTey8/nagCxQxo0aFDh9SD4YwDovXh8vRePrffisfVePLZld6maPx2TQIiIiIh8DANAIiIiIh/DANBOwcHBMnHiRHVN3ofH13vx2HovHlvvxWPrPD6XBEJERETk61gDSERERORjGAASERER+RgGgEREREQ+hgFgMaZMmSKdO3dWg0XXqlVLbrvtNvnnn3+snoOuky+//LIabDEkJESuueYa2b17t6uOGznx+Obl5cn48eOlXbt2EhYWpo7x4MGD1QDiVPk/u5ZGjBihBoSfPn26S8tJzju2e/fulVtuuUWNhYbnXnXVVZKQkMBd7gXHNz09XR5//HE1li9+d1u1aiWzZs1yW5krOwaAxVizZo089thj8scff8iKFSskPz9f+vTpIxkZGebnvPXWWzJt2jT54IMP5M8//5Q6derI9ddfb55qjirv8c3MzJStW7fKiy++qK4XLFgg+/btUz8qVPk/u7pFixbJpk2bVIBP3nFsDx48KFdffbW0bNlSVq9eLTt27FCfY6PR6Nayk2OO7+jRo2Xp0qXyxRdfqEAf95944gn54YcfuIvLA1nAVLrTp08jU1pbs2aNum8ymbQ6depob7zxhvk52dnZWmRkpDZ79mzuzkp+fIuzefNm9ZyjR4+6tGzknGN7/PhxrX79+tquXbu0mJgY7d133+Wu9oJjO3DgQO2+++5za7nIece3TZs22uTJk62e17FjR+2FF17gbi8H1gCWQUpKirquVq2auj58+LAkJSWp/04sxyrq2bOnbNiwoVyBOHnO8S3pOWgqrFq1qgtLRs44tpgP/P7775dnnnlG2rRpw53sJccWx/Xnn3+W5s2bS9++fVUz4pVXXqlqesk7Pruo3f3xxx/lxIkTqhvWqlWrVOsMjjfZjwHgJeAkGzNmjDrx2rZtq5Yh+IPatWtbPRf39ceo8h5fW9nZ2fLss8/KoEGDOP+zFxzbN998UwICAuTJJ590a/nIscf29OnTqo/YG2+8ITfccIMsX75cbr/9drnjjjtU8yJV/s/ue++9J61bt1Z9AIOCgtRxnjlzpnoe2S+gHK/xKehwGh8fL+vWrSvyGGqEbE9a22VUeY+vnhBy9913q9oFfNFQ5T62W7ZskRkzZqi+nfysetexxWcUbr31VtU3DC677DLVKjN79mzVQkOV+3sZASD6CKIWMCYmRn7//XcZOXKk1K1bV3r37u228lZa5Wk39hWPP/641qBBA+3QoUNWyw8ePKj6JmzdutVq+S233KINHjzYxaUkRx9fXW5urnbbbbdp7du315KTk7mjveDYoq+fn5+f5u/vb77gs2wwGFRfQKq8xzYnJ0cLCAjQXnnlFavl48aN07p27eriUpKjj29mZqYWGBio/fTTT1bLhw8frvXt25c7vBzYBFx8UKz+A0H252+//SaNGjWyehz3kfWLTCVdbm6uambo2rWr86N2curx1Wv+7rrrLtm/f7/8+uuvUr16de51Lzi26PuHmoXt27ebL8gCRn/AZcuWua3cVPFjiyZBDCNiO3QI+oihtogq9/HFdzIuBoN12OLv72+u/SX7sAm4GEhF/+qrr1RqOcYk0vv1YVwpjD2EpqOnnnpKXn/9dWnWrJm64HZoaKjqJ0aV+/hi+IEBAwaoZsKffvpJCgoKzM9Bh2T80FDlPLYI5G2D+cDAQPUPXYsWLdxUanLEsQUE8gMHDpQePXpIr1691JAhixcvVkPCUOU+vhEREaoZH8cY9xHUo9Jl7ty5akg2KofyVBt6O+yW4i5z5swxPwdDwUycOFENBxMcHKz16NFD27lzp1vLTY45vocPHy7xOatWreJuruSfXVscBsa7ju3HH3+sNW3aVDMajVpcXJy2aNEit5WZHHt8ExMTtaFDh2r16tVTx7dFixba1KlT1e8x2c8Pf8oTOBIRERFR5cQ+gEREREQ+hgEgERERkY9hAEhERETkYxgAEhEREfkYBoBEREREPoYBIBEREZGPYQBIRERE5GMYABIRERH5GAaARESVyJEjR9R0lJjH2Bmw7kWLFjll3UTkORgAEpFHueaaa9Rc21S8hg0bSmJiorRt21bdxzy3CNouXLjAXUZEZRZQ9qcSEXkGzGBZUFAgAQG+9xXm7+8vderUcXcxiKiSYw0gEXmMoUOHypo1a2TGjBmqVgsXNHnqtVzLli2Tyy+/XIKDg2Xt2rXq+bfddpvVOlB7iFpEy2DxrbfeksaNG0tISIjExcXJ999/X2o5YmNj5dVXX5XBgwdLlSpVJCYmRn744Qc5c+aM3HrrrWpZu3bt5K+//jK/5uzZs3LPPfdIgwYNJDQ0VD3+9ddfW603LS1N7r33XgkLC5O6devKu+++W6TGE9t+/fXX5YEHHpDw8HCJjo6WDz/8sNgmYNzu1auXWh4VFaWWY5/o65k+fbrV9i+77DJ5+eWXzff3798vPXr0EKPRKK1bt5YVK1YU2RcnTpyQgQMHqvVXr15dvX9sl4gqNwaAROQxEPh16dJFHnroIdXMiQuaPHXjxo2TKVOmyN69e6V9+/ZlWucLL7wgc+bMkVmzZsnu3btl9OjRct9996lAszQIzrp16ybbtm2TG2+8Ue6//34VEOK1W7dulaZNm6r7CDAhOztbOnXqJD/99JPs2rVLHn74YfWaTZs2mdc5ZswYWb9+vfz4448q2EIQi3XZmjp1qgp0se2RI0fKo48+Kn///XeR52HfzJ8/X93+559/1P7CPiwLk8kkd9xxh6pR/OOPP2T27Nkyfvx4q+dkZmaqABMB7++//y7r1q1Tt2+44QbJzc0t03aIyENpREQepGfPntqoUaOslq1atQpRlrZo0SKr5UOGDNFuvfVWq2V4LdYB6enpmtFo1DZs2GD1nOHDh2v33HNPiWWIiYnR7rvvPvP9xMREtf0XX3zRvGzjxo1qGR4rSf/+/bWnn35a3U5NTdUCAwO17777zvz4hQsXtNDQUKv3a7ttk8mk1apVS5s1a5a6f/jwYbXdbdu2We2b8+fPF3kP7777rtWyuLg4beLEier2smXLNH9/f+3YsWPmx3/55Re1roULF6r7H3/8sdaiRQtVBl1OTo4WEhKiXk9ElZfvdaAhokoLtWL22LNnj6qZu/76662Wo/aqQ4cOpb7Wsoaxdu3a6hrNurbLTp8+rfrkoU/iG2+8IfPmzVPNpjk5OeqC5l44dOiQ5OXlyRVXXGFeR2RkpLRo0aLUbaNZF+vHdhwJtahoXkaTtQ61r5a2bNkiBw4cUE3RlrBPDx486NDyEJFrMQAkokpDD6Z0BoPB3ASrQ5Bl2cwJP//8s9SvX9/qeehHWJrAwECrIKykZfo20GyLZmP0u0OgiLKib5/eVKqXU3+dzrb8ttvRX6Nvp6wutW+K265t2bBNNGt/+eWXRZ5bs2ZNu8pDRJ6FASAReZSgoCBVm1YWCELQ384SkiP0AAqJDQj0EhISpGfPnuJM6M+HBAn0EdSDJyRZtGrVSt1v0qSJKtfmzZvN/RpTU1PVcypSNuwvsN1n2DfoE6jDtg4fPmy+j32D/XLy5EmpV6+eWrZx40ardXTs2FHVaNaqVUsiIiLKXUYi8jxMAiEij4LsVSROINM0OTm51Jqva6+9VmXizp07VwVSEydOtAoI0XQ5duxYlfjx2WefqWZLJFb83//9n7rvSEgKQWLHhg0bVPPqiBEjJCkpyaosQ4YMkWeeeUZWrVqlElKQ6YuaOtuaN3sgQxmvR/IJspTT09PN++bzzz9XgSn2CbaNhA9d7969VfMzEll27Nihnvf8889brRsZyzVq1FCBLR5HAInkmVGjRsnx48fLXWYicj8GgETkURCwIVBBDRVqsVBLVZK+ffvKiy++qLKDO3furIZZQUBj6ZVXXpGXXnpJZQ+jNg6vWbx4sTRq1Mih5UY5UGOG9WNoF/Tbsx2iZtq0aaqf3U033aQCMGQZo0wYhqW80LQ9adIkefbZZ1W/xMcff1wtnzBhghriBdvq37+/KgtqIXUIPBcuXKj6KaJf4oMPPiivvfaa1boxnA2yf9FXEBnDKCuC1qysLNYIElVyfsgEcXchiIh8UUZGhgrg0H9w+PDh7i4OEfkQ9gEkInIRND9jPD/UuKWkpMjkyZPVcjSxEhG5EgNAIiIXeuedd9SgzUjeQIYt+tahnx0RkSuxCZiIiIjIxzAJhIiIiMjHMAAkIiIi8jEMAImIiIh8DANAIiIiIh/DAJCIiIjIxzAAJCIiIvIxDACJiIiIfAwDQCIiIiIfwwCQiIiISHzL/wOvLZqRTy7qmAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Detection efficiency vs magnitude, per survey (Roman is deeper here: maglim 27 vs 26)\n", + "fig, ax = plt.subplots(figsize=(6.5, 4))\n", + "for col, flag, lab, cc in [(\"lsst_r_true\", \"lsst_flag_observed\", \"LSST r (maglim 26.0)\", \"C0\"),\n", + " (\"roman_F158_true\", \"roman_flag_observed\", \"Roman F158 (maglim 27.0)\", \"C3\")]:\n", + " m = cat[col].to_numpy(float); f = cat[flag].to_numpy(bool)\n", + " bins = np.linspace(20, 29, 28); idx = np.digitize(m, bins)\n", + " eff = [f[idx == i].mean() if (idx == i).any() else np.nan for i in range(1, len(bins))]\n", + " ax.plot(0.5 * (bins[1:] + bins[:-1]), eff, marker=\"o\", ms=3, label=lab, c=cc)\n", + "ax.set_xlabel(\"true magnitude\"); ax.set_ylabel(\"detected fraction\")\n", + "ax.set_title(\"Phase 4: per-survey selection from one catalog\"); ax.legend(); fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "9e34ac16", + "metadata": {}, + "source": [ + "## Notes for real runs\n", + "\n", + "* Swap `StubSurvey(...)` for `Survey.load(\"lsst\", release=\"dc2\")` and the real\n", + " Roman survey once its config/maps land — the injector code is unchanged.\n", + "* A band label is used **both** as the ugali isochrone field name and as the key\n", + " into a survey's maglim/photo-error maps, so they must agree (ugali's Roman\n", + " fields are upper-case: `F106`, `F158`, ...).\n", + "* **`nstars` is now exactly N** (was an emergent IMF count). This is adopted but\n", + " intentionally still **flagged for review** in the plan doc, because it changes\n", + " what `StreamModel.sample(size)` returns for existing single-survey configs.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "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.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/scripts/build_multisurvey_demo_nb.py b/scripts/build_multisurvey_demo_nb.py new file mode 100644 index 0000000..ca7f0fc --- /dev/null +++ b/scripts/build_multisurvey_demo_nb.py @@ -0,0 +1,299 @@ +#!/usr/bin/env python +"""Build notebooks/multisurvey_phases_demo.ipynb (Phases 1-4 showcase). + +Local helper to (re)generate the demo notebook from a single source of truth. +Run it from the repo root inside the `streamobs` conda env, then execute with +`jupyter nbconvert --to notebook --execute --inplace`. +""" + +import nbformat as nbf +from nbformat.v4 import new_code_cell, new_markdown_cell, new_notebook + +cells = [] +md = lambda s: cells.append(new_markdown_cell(s)) +co = lambda s: cells.append(new_code_cell(s)) + +md(r"""# Multi-survey injection — Phases 1-4 demo + +This notebook walks through the `roman_multisurvey` refactor that lets `streamobs` +inject a single stream carrying **both Roman and Rubin/LSST** photometry, where +each band draws its errors and detection probability from its *own* survey. + +| Phase | What changed | +|---|---| +| **1** | `Survey` holds two error curves — a *catalog* (reported `magerr`, drives the S/N cut) and an optional *sample* (true scatter, drives the noise draw). `get_photo_error(..., kind=)` selects between them. | +| **2** | The injector is de-hardcoded off `{r, g}`; column names route through `streamobs.columns`, using a **uniform** `_true/_obs/_err` scheme (`_…` when namespaced). The S/N cut now applies to **all** injected bands. | +| **3** | `IsochroneModel` is multi-band / multi-survey: masses are drawn **once** (exactly `nstars`) and interpolated into every survey's bands, so the *same physical star* is consistent across surveys. Roman bands are auto-converted Vega→AB. | +| **4** | `MultiSurveyInjector` orchestrates one shared sky placement + one shared true-mag fill, then a per-survey loop writing `__obs/_err` and `_flag_observed`. | + +See `docs/source/roman_multisurvey_plan.md` for the full design. +""") + +co("""import warnings +warnings.filterwarnings("ignore") +import numpy as np +import pandas as pd +import healpy as hp +import yaml +import matplotlib.pyplot as plt + +from streamobs.surveys import Survey +from streamobs.model import StreamModel, IsochroneModel +from streamobs.observed import StreamInjector, MultiSurveyInjector +from streamobs import columns as C + +import os +# Resolve the repo root whether the notebook runs from repo root or notebooks/. +REPO = ".." if os.path.exists("../config/scenes/roman_rubin_demo.yaml") else "." +rng = np.random.default_rng(42) +""") + +md(r"""## A runnable stub survey + +The real Roman/Rubin maglim maps and CSV tables are **not committed** to this +branch (they live in the git-ignored `data/surveys/`). So that this notebook +runs end-to-end, we use a tiny `StubSurvey` that: + +* keeps the **real** `Survey.get_photo_error` (so the Phase-1 two-curve split is + genuine) and `get_maglim`, +* supplies analytic `log_photo_error_*` curves and a logistic completeness. + +The **isochrones are real** (`Marigo2017` via `ugali`). To run against real +surveys, just replace `StubSurvey(...)` with `Survey.load("lsst", release=...)` +etc. — the injector code is identical. +""") + +co('''NSIDE = 1 # whole-sky single-pixel maps; enough for a synthetic demo + +class StubSurvey(Survey): + """Minimal Survey: real photo-error machinery, analytic completeness/maps.""" + + def __init__(self, name, bands, completeness_band, maglim=27.0, + sample_inflation=1.9): + self.name = name + self.bands = list(bands) + self.completeness_band = completeness_band + self.saturation = {b: 16.0 for b in bands} + self.sys_error = {b: 0.005 for b in bands} + self.delta_saturation = -10.0 + self.coeff_extinc = {b: 0.0 for b in bands} + self.ebv_map = np.zeros(hp.nside2npix(NSIDE)) + self.maglim_maps = {b: np.full(hp.nside2npix(NSIDE), maglim) for b in bands} + self.coverage = np.ones(hp.nside2npix(NSIDE)) # footprint = whole sky + # Phase 1: two error curves, both functions of delta_mag = mag - maglim. + # Catalog = reported error; sample = true scatter (here ~inflation x larger, + # echoing the Roman DC2 finding that true scatter ~2x reported magerr). + self.log_photo_error_catalog = lambda dm: np.log10( + 0.01 + 0.10 * np.exp(np.clip(dm, -30, 5))) + self.log_photo_error_sample = lambda dm: np.log10( + sample_inflation * (0.01 + 0.10 * np.exp(np.clip(dm, -30, 5)))) + + # analytic rolloff: ~1 when bright (mag << maglim), 0.5 at maglim, ->0 fainter + def get_completeness(self, band, mag, maglim): + return 1.0 / (1.0 + np.exp((np.asarray(mag) - np.asarray(maglim)) / 0.25)) + + def get_detection_efficiency(self, band, mag, maglim): + return self.get_completeness(band, mag, maglim) + + def get_extinction(self, band, pixel=None): + return np.zeros(np.size(pixel)) + +print("StubSurvey ready")''') + +md(r"""## Phase 1 — sample vs. catalog photometric error + +`Survey` now carries two curves. `get_photo_error(kind="catalog")` is the +reported error that becomes `magerr` and drives the S/N cut; +`get_photo_error(kind="sample")` is the *true* scatter used to draw the observed +magnitude. When no sample curve is loaded, `sample` transparently falls back to +`catalog`, so legacy single-curve behaviour is bit-for-bit preserved. +""") + +co("""sv = StubSurvey("lsst", ["g", "r"], completeness_band="r", maglim=26.5) +mags = np.linspace(20, 28, 200) +maglim = np.full_like(mags, 26.5) +err_cat = sv.get_photo_error("r", mags, maglim, kind="catalog") +err_smp = sv.get_photo_error("r", mags, maglim, kind="sample") + +# A survey with NO sample curve -> sample falls back to catalog (identical) +sv_legacy = StubSurvey("lsst", ["g", "r"], "r", maglim=26.5) +sv_legacy.log_photo_error_sample = None +err_fallback = sv_legacy.get_photo_error("r", mags, maglim, kind="sample") +assert np.allclose(err_fallback, sv_legacy.get_photo_error("r", mags, maglim, kind="catalog")) + +fig, ax = plt.subplots(figsize=(6, 4)) +ax.plot(mags, err_cat, label='catalog (reported magerr, drives S/N cut)') +ax.plot(mags, err_smp, label='sample (true scatter, drives noise draw)') +ax.axvline(26.5, ls=':', c='k', lw=1, label='maglim') +ax.set_xlabel('magnitude'); ax.set_ylabel('photometric error [mag]') +ax.set_title('Phase 1: two error curves on Survey'); ax.legend(); fig.tight_layout() +print("no sample curve -> sample falls back to catalog:", + np.allclose(err_fallback, err_cat))""") + +md(r"""## Phase 2 — arbitrary bands + `columns.py` + +The injector no longer hard-codes `{r, g}`. Column names come from +`streamobs.columns`, using one **uniform** convention: `_true` / +`_obs` / `_err` / `flag_observed` single-survey, and the same with a +`_` prefix multi-survey. (This intentionally drops the historical +`mag_` / `magerr_` names — not backward compatible.) Below we inject +Roman NIR bands `F106`/`F158` through the *single-survey* `StreamInjector` — +impossible under the old `{r,g}` block. +""") + +co( + """print("single-survey:", C.true_col("r"), C.obs_col("r"), C.err_col("r"), C.flag_col()) +print("multi-survey :", C.true_col("F158", "roman"), C.obs_col("F158", "roman"), + C.err_col("F158", "roman"), C.flag_col("roman")) + +roman_sv = StubSurvey("roman", ["F106", "F158"], completeness_band="F158", maglim=27.0) +inj = StreamInjector(roman_sv) +N = 1500 +df = pd.DataFrame({ + "ra": rng.uniform(10, 20, N), + "dec": rng.uniform(-5, 5, N), + "F106_true": rng.uniform(20, 28, N), + "F158_true": rng.uniform(20, 28, N), +}) +out = inj.inject(df, bands=["F106", "F158"], seed=1, verbose=False) +print("\\ninjected NIR-only bands -> columns:", + [c for c in out.columns if c.endswith(("_obs", "_err")) or c == "flag_observed"]) +print("detected:", int(out.flag_observed.sum()), "/", len(out))""" +) + +md(r"""## Phase 3 — multi-band / multi-survey isochrone (exactly `nstars`) + +`IsochroneModel.sample` now draws **exactly** `nstars` (a fixed mass set), for +both single- and multi-survey configs. First, the single-survey path: +""") + +co("""single_cfg = { + "density": {"type": "Uniform", "xmin": -9.0, "xmax": 9.0}, + "track": {"center": {"type": "Constant", "value": 0.0}, + "spread": {"type": "Constant", "value": 0.2}, "sampler": "Gaussian"}, + "distance_modulus": {"center": {"type": "Line", "slope": 0.1, "intercept": 16.5}, + "spread": {"type": "Constant", "value": 1e-4}, "sampler": "Uniform"}, + "isochrone": {"name": "Marigo2017", "survey": "lsst", "age": 12.0, "z": 0.0006, + "band_1": "g", "band_2": "r"}, +} +sm = StreamModel(single_cfg) +for n in (5000, 1234): + assert len(sm.sample(n)) == n +print("single-survey StreamModel.sample returns EXACTLY nstars (5000, 1234) -> OK")""") + +md(r"""Now the multi-survey scene. One mass draw feeds both surveys, so a star's +LSST and Roman magnitudes describe the *same object*.""") + +co("""scene = yaml.safe_load(open(f"{REPO}/config/scenes/roman_rubin_demo.yaml")) +sm_ms = StreamModel(scene["stream"]) +df_ms = sm_ms.sample(4000) +true_cols = sorted(c for c in df_ms.columns if c.endswith("_true")) +print("multi-survey true columns:", true_cols) +print("rows:", len(df_ms)) + +rho = np.corrcoef(df_ms["lsst_r_true"], df_ms["roman_F158_true"])[0, 1] +print(f"corr(lsst_r, roman_F158) = {rho:.3f} (shared masses => tightly correlated)") + +fig, axes = plt.subplots(1, 2, figsize=(10, 4.2), sharey=True) +axes[0].scatter(df_ms.lsst_g_true - df_ms.lsst_r_true, df_ms.lsst_r_true, s=3, alpha=.3) +axes[0].set_xlabel("g - r"); axes[0].set_ylabel("r"); axes[0].set_title("Rubin/LSST CMD") +axes[0].invert_yaxis() +axes[1].scatter(df_ms.roman_F106_true - df_ms.roman_F158_true, df_ms.roman_F158_true, s=3, alpha=.3, c="C3") +axes[1].set_xlabel("F106 - F158"); axes[1].set_ylabel("F158"); axes[1].set_title("Roman CMD") +axes[1].invert_yaxis() +fig.suptitle("Phase 3: same physical stars, two surveys"); fig.tight_layout()""") + +md(r"""Roman isochrone magnitudes are **always** converted Vega→AB (no config +flag) using the fixed `ROMAN_VEGA_TO_AB` table, sourced from the +`rubin_roman_object_classification` prototype. Non-Roman bands pass through +unchanged. (A `TODO` in the code notes this ideally belongs in `ugali`.)""") + +co("""from streamobs.model import ROMAN_VEGA_TO_AB +print("Roman Vega->AB offsets (AB = Vega + diff):") +for b, v in ROMAN_VEGA_TO_AB.items(): + print(f" {b}: +{v}") + +iso = StreamModel(scene["stream"]).isochrone # multi-survey isochrone +x = np.array([20.0, 21.0]) +print("\\nF158 shift:", (iso._to_ab("F158", x) - x), " (always +1.315)") +print("r shift:", (iso._to_ab("r", x) - x), " (0 -> non-Roman pass-through)")""") + +md(r"""## Phase 4 — `MultiSurveyInjector` + +One orchestrator, one shared sky placement and shared masses, then per-survey +observed columns and flags. Per-survey RNGs come from `rng.spawn(...)`, so the +result is reproducible and independent of survey order. +""") + +co( + """lsst_sv = StubSurvey("lsst", ["g", "r"], completeness_band="r", maglim=26.0) +roman_sv = StubSurvey("roman", ["F106", "F158"], completeness_band="F158", maglim=27.0) +msi = MultiSurveyInjector({"lsst": StreamInjector(lsst_sv), + "roman": StreamInjector(roman_sv)}, primary="lsst") + +# Input carries only stream coordinates; everything else is sampled once. +N = 4000 +stream_in = pd.DataFrame({"phi1": rng.uniform(-9, 9, N), "phi2": np.zeros(N)}) +cat = msi.inject(stream_in.copy(), scene["survey_bands"], + stream_config=scene["stream"], seed=7, verbose=False) + +print("columns produced:") +for grp in ("lsst", "roman"): + print(f" {grp}:", sorted(c for c in cat.columns if c.startswith(grp + "_"))) +print(f"\\nshared sky placement: ra/dec present = {('ra' in cat) and ('dec' in cat)}") +print(f"lsst detected: {int(cat.lsst_flag_observed.sum()):5d} / {len(cat)}") +print(f"roman detected: {int(cat.roman_flag_observed.sum()):5d} / {len(cat)}")""" +) + +co( + """# Reproducible from seed (given the same true-mag draw) +base = sm_ms.sample(3000) +base["ra"] = rng.uniform(10, 20, len(base)); base["dec"] = rng.uniform(-5, 5, len(base)) +a = msi.inject(base.copy(), scene["survey_bands"], seed=11, verbose=False) +b = msi.inject(base.copy(), scene["survey_bands"], seed=11, verbose=False) +c = msi.inject(base.copy(), scene["survey_bands"], seed=22, verbose=False) +print("same seed -> identical obs & flags:", + a.roman_F158_obs.equals(b.roman_F158_obs) and a.lsst_flag_observed.equals(b.lsst_flag_observed)) +print("different seed -> different noise draw:", not a.roman_F158_obs.equals(c.roman_F158_obs))""" +) + +co( + """# Detection efficiency vs magnitude, per survey (Roman is deeper here: maglim 27 vs 26) +fig, ax = plt.subplots(figsize=(6.5, 4)) +for col, flag, lab, cc in [("lsst_r_true", "lsst_flag_observed", "LSST r (maglim 26.0)", "C0"), + ("roman_F158_true", "roman_flag_observed", "Roman F158 (maglim 27.0)", "C3")]: + m = cat[col].to_numpy(float); f = cat[flag].to_numpy(bool) + bins = np.linspace(20, 29, 28); idx = np.digitize(m, bins) + eff = [f[idx == i].mean() if (idx == i).any() else np.nan for i in range(1, len(bins))] + ax.plot(0.5 * (bins[1:] + bins[:-1]), eff, marker="o", ms=3, label=lab, c=cc) +ax.set_xlabel("true magnitude"); ax.set_ylabel("detected fraction") +ax.set_title("Phase 4: per-survey selection from one catalog"); ax.legend(); fig.tight_layout()""" +) + +md(r"""## Notes for real runs + +* Swap `StubSurvey(...)` for `Survey.load("lsst", release="dc2")` and the real + Roman survey once its config/maps land — the injector code is unchanged. +* A band label is used **both** as the ugali isochrone field name and as the key + into a survey's maglim/photo-error maps, so they must agree (ugali's Roman + fields are upper-case: `F106`, `F158`, ...). +* **`nstars` is now exactly N** (was an emergent IMF count). This is adopted but + intentionally still **flagged for review** in the plan doc, because it changes + what `StreamModel.sample(size)` returns for existing single-survey configs. +""") + +nb = new_notebook(cells=cells) +nb.metadata.update( + { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3", + }, + "language_info": {"name": "python"}, + } +) +out_path = "notebooks/multisurvey_phases_demo.ipynb" +with open(out_path, "w") as f: + nbf.write(nb, f) +print("wrote", out_path, "with", len(cells), "cells") diff --git a/streamobs/columns.py b/streamobs/columns.py index 45b522b..d8f8945 100644 --- a/streamobs/columns.py +++ b/streamobs/columns.py @@ -2,35 +2,45 @@ Column-name helpers for injected catalogs. These centralize the naming convention so the injector is not hard-coded to -specific bands (``mag_r_obs``, ``magerr_g``, ...). Two conventions are -supported, selected by the ``survey`` argument: +specific bands. A single, uniform ``_true`` / ``_obs`` / +``_err`` convention is used everywhere; the only difference between the +single- and multi-survey cases is an optional survey prefix: -- **Legacy / single-survey** (``survey=None``): ``mag_`` (true), - ``mag__obs`` (observed), ``magerr_`` (error), ``flag_observed``. - This is what :class:`~streamobs.observed.StreamInjector` emits and what - downstream consumers already read, so it is preserved unchanged. +- **Single-survey** (``survey=None``): ``_true`` (true / noiseless), + ``_obs`` (observed / noisy), ``_err`` (reported error), + ``flag_observed``. - **Multi-survey** (``survey="roman"``, ``"lsst"``, ...): ``__true``, ``__obs``, ``__err``, ``_flag_observed``. - Used by the (future) ``MultiSurveyInjector`` so each band's columns are - namespaced by survey. + Used by :class:`~streamobs.observed.MultiSurveyInjector` so each band's + columns are namespaced by survey. + +.. note:: + This convention intentionally **drops** the historical ``mag_`` / + ``mag__obs`` / ``magerr_`` names — it is not backward compatible + with catalogs written by older ``streamobs`` versions. """ def true_col(band, survey=None): """Column holding the *true* (noiseless) apparent magnitude for ``band``.""" - return f"{survey}_{band}_true" if survey else f"mag_{band}" + return f"{survey}_{band}_true" if survey else f"{band}_true" def obs_col(band, survey=None): """Column holding the *observed* (noisy) magnitude for ``band``.""" - return f"{survey}_{band}_obs" if survey else f"mag_{band}_obs" + return f"{survey}_{band}_obs" if survey else f"{band}_obs" def err_col(band, survey=None): """Column holding the reported magnitude error for ``band``.""" - return f"{survey}_{band}_err" if survey else f"magerr_{band}" + return f"{survey}_{band}_err" if survey else f"{band}_err" def flag_col(survey=None): """Column holding the detection flag (band-independent).""" return f"{survey}_flag_observed" if survey else "flag_observed" + + +def perfect_flag_col(survey=None): + """Column holding the perfect star/galaxy-separation flag (band-independent).""" + return f"{survey}_flag_perfect_galstarsep" if survey else "flag_perfect_galstarsep" diff --git a/streamobs/model.py b/streamobs/model.py index 59511bc..a093be9 100644 --- a/streamobs/model.py +++ b/streamobs/model.py @@ -13,6 +13,26 @@ from streamobs.functions import function_factory from streamobs.samplers import sampler_factory +# Roman ugali isochrones are delivered in Vega magnitudes, but our catalogs are +# AB. These are the per-band AB - Vega offsets (AB = Vega + diff) for the Roman +# WFI filters — the mode of the by-chip zeropoints from the Roman technical +# information (Roman_zeropoints_20240301.ecsv), as used by the +# rubin_roman_object_classification prototype. The conversion is applied +# unconditionally to any Roman band (a no-op for non-Roman bands). +# +# TODO: this Vega->AB conversion really belongs in ugali, so isochrones are +# returned natively in AB. Move it upstream and delete this table once that lands. +ROMAN_VEGA_TO_AB = { + "F062": 0.153, + "F087": 0.481, + "F106": 0.660, + "F129": 1.051, + "F146": 1.164, + "F158": 1.315, + "F184": 1.556, + "F213": 1.837, +} + class ConfigurableModel(object): """Baseclass for models built from configs.""" @@ -117,8 +137,8 @@ def sample(self, size): pandas.DataFrame Columns include: ``phi1``, ``phi2``, ``dist``, ``mu1``, ``mu2``, ``rv``, and the isochrone magnitude columns. For a single-survey - isochrone these are the legacy ``mag_g`` / ``mag_r`` (its two bands); - for a multi-survey isochrone they are ``__true`` per + isochrone these are ``_true`` (its two bands); for a + multi-survey isochrone they are ``__true`` per survey/band. Some may be None if the sub-model is absent. """ @@ -154,7 +174,7 @@ def sample(self, size): if self.isochrone: mag_data = self._sample_iso_mags(size, dist) else: - mag_data = {"mag_g": None, "mag_r": None} # legacy placeholder + mag_data = {} # no isochrone -> no magnitude columns for col, vals in mag_data.items(): df[col] = vals @@ -212,9 +232,10 @@ def complete_catalog( that length. columns_to_add : sequence of str or None, optional The columns to ensure in the output. Valid entries are - {'phi1','phi2','dist','mag_g','mag_r','mu1','mu2','rv'}. - If None, all valid columns supported by the configured model are - considered. + {'phi1','phi2','dist','mu1','mu2','rv'} plus the isochrone magnitude + columns (``_true`` single-survey, ``__true`` + multi-survey). If None, all valid columns supported by the + configured model are considered. size : int or None, optional Required when ``catalog`` is None or an empty table; ignored otherwise. @@ -252,7 +273,7 @@ def complete_catalog( """ # Supported outputs and capability filtering # Columns this method can fill using the configured model - # Magnitude columns are band-/survey-general (legacy mag_g/mag_r for a + # Magnitude columns are band-/survey-general (_true for a # single-survey isochrone; __true for multi-survey). mag_cols = self._iso_mag_columns() all_cols = ("phi1", "phi2", "dist") + tuple(mag_cols) + ("mu1", "mu2", "rv") @@ -480,8 +501,8 @@ def _standardize_columns_name(self, catalog): # Mapping of possible column name variants to standard names col_mapping = { "dist": ["dist", "distance", "distance_modulus"], - "mag_g": ["mag_g", "g_mag", "g", "gmag", "magnitude_g"], - "mag_r": ["mag_r", "r_mag", "r", "rmag", "magnitude_r"], + "g_true": ["g_true", "mag_g", "g_mag", "g", "gmag", "magnitude_g"], + "r_true": ["r_true", "mag_r", "r_mag", "r", "rmag", "magnitude_r"], "phi1": ["phi1", "phi_1", "Phi1", "Phi_1"], "phi2": ["phi2", "phi_2", "Phi2", "Phi_2"], "mu1": ["mu1", "mu_1"], @@ -586,13 +607,16 @@ class IsochroneModel(ConfigurableModel): ``band_2``, ...). :meth:`sample` returns ``(mag_band_1, mag_band_2)`` and reproduces the previous behaviour exactly. - **Multi-survey**: a ``surveys`` mapping - ``{survey_name: {survey, band_1, band_2, vega_to_ab}}`` plus shared keys + ``{survey_name: {survey, band_1, band_2}}`` plus shared keys (``name``, ``age``, ``z``, ...) at the top level. One ``ugali`` isochrone is built per survey from the *same* stellar population, so a single shared draw of initial masses (:meth:`sample_masses`) is interpolated into every survey's bands — giving the same physical star consistent magnitudes across surveys. :meth:`sample_multisurvey` returns ``{(survey, band): apparent_mag}``. + + Roman bands are always converted from Vega to AB (see + :data:`ROMAN_VEGA_TO_AB`); other bands pass through unchanged. """ # Defaults for the shared isochrone mass grid (see ugali Isochrone.sample) @@ -633,8 +657,7 @@ def _create_single_isochrone(self, config): 'Please use the "distance_modulus" section of the configuration ' "file, instead of the isochrone section, to define a distance modulus." ) - factory_config = {k: v for k, v in config.items() if k != "vega_to_ab"} - self.iso = self._build_iso(factory_config) + self.iso = self._build_iso(config) self.survey_name = config.get("survey") self.band_1 = config.get("band_1") self.band_2 = config.get("band_2") @@ -642,23 +665,17 @@ def _create_single_isochrone(self, config): self.surveys = [self.survey_name] self.isos = {self.survey_name: self.iso} self.survey_bands = {self.survey_name: (self.band_1, self.band_2)} - self._vega_to_ab = {self.survey_name: config.get("vega_to_ab")} def _create_multisurvey_isochrones(self, config): """Build one isochrone per survey, sharing the top-level stellar params.""" shared = {k: v for k, v in config.items() if k != "surveys"} self.isos = {} self.survey_bands = {} - self._vega_to_ab = {} self.surveys = [] for name, scfg in config["surveys"].items(): - factory_config = { - **shared, - **{k: v for k, v in scfg.items() if k != "vega_to_ab"}, - } + factory_config = {**shared, **scfg} self.isos[name] = self._build_iso(factory_config) self.survey_bands[name] = (scfg.get("band_1"), scfg.get("band_2")) - self._vega_to_ab[name] = scfg.get("vega_to_ab") self.surveys.append(name) # Primary isochrone drives the shared mass draw and the legacy sample(). self.survey_name = self.surveys[0] @@ -707,24 +724,17 @@ def _absolute_mags(self, iso, masses, mass_min=None, mass_steps=None): np.interp(masses, mass_init, mag_2[order]), ) - def _apply_vega_to_ab(self, survey, band, mag): - """Apply an optional per-band Vega->AB offset (``AB = Vega + offset``). + def _to_ab(self, band, mag): + """Convert Roman bands from Vega to AB (``AB = Vega + offset``). - ``vega_to_ab`` in the config is a ``{band: offset}`` mapping; if absent - or empty, the magnitudes are returned unchanged. This is the isolated - shim that lets multi-survey injection work while ``ugali`` still returns - some bands in Vega; it becomes a no-op once bands are natively AB. + Applied unconditionally: Roman bands use the offset in + :data:`ROMAN_VEGA_TO_AB`, every other band passes through unchanged. + ``ugali`` delivers Roman isochrones in Vega while our catalogs are AB. + + TODO: this really belongs in ugali (return AB natively); remove once it + does. """ - spec = self._vega_to_ab.get(survey) - if not spec: - return mag - if isinstance(spec, dict): - return mag + spec.get(band, 0.0) - warnings.warn( - f"vega_to_ab for survey '{survey}' is set but is not a " - "{band: offset} mapping; no Vega->AB correction applied." - ) - return mag + return mag + ROMAN_VEGA_TO_AB.get(band, 0.0) @staticmethod def _add_distance_modulus(abs_mag, distance_modulus): @@ -755,8 +765,8 @@ def sample_multisurvey(self, nstars, distance_modulus, rng=None, **kwargs): for name in self.surveys: band_1, band_2 = self.survey_bands[name] abs_1, abs_2 = self._absolute_mags(self.isos[name], masses) - abs_1 = self._apply_vega_to_ab(name, band_1, abs_1) - abs_2 = self._apply_vega_to_ab(name, band_2, abs_2) + abs_1 = self._to_ab(band_1, abs_1) + abs_2 = self._to_ab(band_2, abs_2) out[(name, band_1)] = self._add_distance_modulus(abs_1, distance_modulus) out[(name, band_2)] = self._add_distance_modulus(abs_2, distance_modulus) return out @@ -764,10 +774,19 @@ def sample_multisurvey(self, nstars, distance_modulus, rng=None, **kwargs): def sample(self, nstars, distance_modulus, rng=None, **kwargs): """Simulate magnitudes in the two bands of the (primary) isochrone. + Draws *exactly* ``nstars`` stars: a fixed set of initial masses is drawn + once from the isochrone IMF (:meth:`sample_masses`) and interpolated into + the two bands. This differs from the historical behaviour, where + ``nstars`` was converted to a total stellar mass and ``ugali``'s + ``simulate`` returned a random-length IMF realization (count generally + ``!= nstars``). The fixed-count semantics are required so the *same + physical star* can be shared across surveys (see + :meth:`sample_multisurvey`). + Parameters ---------- nstars : int - Number of stars to simulate. + Number of stars to simulate (returns exactly this many). distance_modulus : float or array-like Distance modulus per star (broadcast if scalar). @@ -778,30 +797,11 @@ def sample(self, nstars, distance_modulus, rng=None, **kwargs): this returns the primary survey's two bands; use :meth:`sample_multisurvey` to get every survey's bands. """ - if getattr(self, "multi_survey", False): - mags = self.sample_multisurvey( - nstars, distance_modulus, rng=rng, **kwargs - ) - return ( - mags[(self.survey_name, self.band_1)], - mags[(self.survey_name, self.band_2)], - ) - - # Single-survey: preserve the existing ugali.simulate-based behaviour. - stellar_mass = nstars * self.iso.stellar_mass() - mag_1, mag_2 = self.iso.simulate( - stellar_mass, distance_modulus=self.iso.distance_modulus + mags = self.sample_multisurvey(nstars, distance_modulus, rng=rng, **kwargs) + return ( + mags[(self.survey_name, self.band_1)], + mags[(self.survey_name, self.band_2)], ) - if np.isscalar(distance_modulus): - mag_1, mag_2 = [ - mag + np.ones_like(mag) * distance_modulus for mag in (mag_1, mag_2) - ] - else: - mag_1, mag_2 = [mag + distance_modulus for mag in (mag_1, mag_2)] - - mag_1 = self._apply_vega_to_ab(self.survey_name, self.band_1, mag_1) - mag_2 = self._apply_vega_to_ab(self.survey_name, self.band_2, mag_2) - return mag_1, mag_2 def _dist_to_modulus(self, distance): """ diff --git a/streamobs/observed.py b/streamobs/observed.py index 4c71f8c..735e719 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -10,7 +10,7 @@ import numpy as np import pandas as pd -from .columns import err_col, flag_col, obs_col, true_col +from .columns import err_col, flag_col, obs_col, perfect_flag_col, true_col from .model import StreamModel from .plotting import plot_stream_in_mask from .surveys import Survey @@ -120,8 +120,8 @@ def inject(self, data, bands=["r", "g"], **kwargs): pd.DataFrame DataFrame with the following added columns: - - mag__obs : Observed magnitudes for each band - - magerr_ : Photometric errors for each band + - _obs : Observed magnitudes for each band + - _err : Photometric errors for each band - flag_observed : Boolean flag (True=detected, False=not detected). Includes both detection and classification efficiencies. - flag_perfect_galstarsep : Boolean flag assuming perfect star/galaxy separation (detection efficiency only, no classification losses; only if requested with perfect_galstarsep=True) - ra, dec : Sky coordinates (if not already present) @@ -131,9 +131,6 @@ def inject(self, data, bands=["r", "g"], **kwargs): ValueError If required columns are missing or bands are not supported. """ - verbose = kwargs.get("verbose", True) - perfect_galstarsep = kwargs.pop("perfect_galstarsep", False) - # Load data data = self._load_data(data) @@ -144,6 +141,60 @@ def inject(self, data, bands=["r", "g"], **kwargs): # Complete missing columns (ra/dec, magnitudes) data = self.complete_data(data, rng=rng, seed=seed, bands=bands, **kwargs) + # Run the per-survey observational injection using the legacy column + # names (survey_namespace=None). + data = self._inject_one_survey( + data, bands, rng=rng, seed=seed, survey_namespace=None, **kwargs + ) + + # Save if requested + if kwargs.get("save"): + self._save_injected_data(data, kwargs.get("folder", None)) + + # Return data (do NOT store as instance attribute to avoid conflicts between runs) + return data + + def _inject_one_survey( + self, data, bands, rng=None, seed=None, survey_namespace=None, **kwargs + ): + """Add this survey's observed magnitudes, errors and detection flags. + + This holds the per-band observational logic shared by single-survey + :meth:`inject` and :class:`MultiSurveyInjector`. It assumes ``data`` + already carries ``ra``/``dec`` and the true-magnitude columns for the + requested bands; it does **not** sample positions or true magnitudes. + + Parameters + ---------- + data : pandas.DataFrame + Catalog with ``ra``/``dec`` and ``true_col(band, survey_namespace)`` + for every requested band. + bands : list of str + Bands to process for this survey. + rng : numpy.random.Generator, optional + Random generator for the noise draw and detection sampling. + seed : int, optional + Seed used to build an RNG when ``rng`` is None. + survey_namespace : str or None, optional + Column-naming namespace. ``None`` ⇒ single-survey names + (``_obs`` / ``_err`` / ``flag_observed``); + a survey name ⇒ ``__obs`` / ``__err`` / + ``_flag_observed``. + **kwargs + ``nside``, ``detection_mag_cut``, ``dust_correction``, + ``perfect_galstarsep``, ``verbose`` (see :meth:`inject`). + + Returns + ------- + pandas.DataFrame + ``data`` with this survey's observed columns and detection flag(s). + """ + if rng is None: + rng = np.random.default_rng(seed) + + verbose = kwargs.get("verbose", True) + perfect_galstarsep = kwargs.pop("perfect_galstarsep", False) + # Get HEALPix pixel indices nside = kwargs.pop("nside", 4096) pix = hp.ang2pix(nside, data["ra"], data["dec"], lonlat=True) @@ -163,7 +214,7 @@ def inject(self, data, bands=["r", "g"], **kwargs): extinction_band = self.survey.get_extinction(band, pixel=pix_ebv) # Calculate true apparent magnitudes (including extinction) - apparent_mag_true = data[true_col(band)] + extinction_band + apparent_mag_true = data[true_col(band, survey_namespace)] + extinction_band # Get magnitude limits nside_maglim = hp.get_nside(self.survey.maglim_maps[band]) @@ -215,8 +266,8 @@ def inject(self, data, bands=["r", "g"], **kwargs): # Add new columns new_columns = pd.DataFrame( { - obs_col(band): mag_obs, - err_col(band): mag_err, + obs_col(band, survey_namespace): mag_obs, + err_col(band, survey_namespace): mag_err, } ) @@ -262,7 +313,7 @@ def inject(self, data, bands=["r", "g"], **kwargs): # Start with flux validity check (not BAD_MAG) across all injected bands flag_valid_flux = None for band in bands: - band_valid = data[obs_col(band)] != "BAD_MAG" + band_valid = data[obs_col(band, survey_namespace)] != "BAD_MAG" flag_valid_flux = ( band_valid if flag_valid_flux is None else flag_valid_flux & band_valid ) @@ -293,7 +344,7 @@ def inject(self, data, bands=["r", "g"], **kwargs): continue if verbose: print(f"Applying detection cut on {band}-band with SNR >= {SNR_min}") - SNR = 1.0 / data[err_col(band)] + SNR = 1.0 / data[err_col(band, survey_namespace)] flag_observed &= SNR >= SNR_min if perfect_galstarsep: flag_perfect &= SNR >= SNR_min @@ -302,19 +353,16 @@ def inject(self, data, bands=["r", "g"], **kwargs): # (the SNR cut is baked into the completeness functions but not into the # detection-only efficiency functions used for the perfect flag). if perfect_galstarsep: - SNR_compl = 1.0 / data[err_col(self.survey.completeness_band)] + SNR_compl = ( + 1.0 / data[err_col(self.survey.completeness_band, survey_namespace)] + ) flag_perfect &= SNR_compl >= SNR_min # Store flags in DataFrame - data[flag_col()] = flag_observed + data[flag_col(survey_namespace)] = flag_observed if perfect_galstarsep: - data["flag_perfect_galstarsep"] = flag_perfect - - # Save if requested - if kwargs.get("save"): - self._save_injected_data(data, kwargs.get("folder", None)) + data[perfect_flag_col(survey_namespace)] = flag_perfect - # Return data (do NOT store as instance attribute to avoid conflicts between runs) return data def _load_data(self, data): @@ -1152,3 +1200,190 @@ def plot_stream_in_mask(self, data, mask_type, ebv_threshold=0.2, **kwargs): data["ra"], data["dec"], mask, output_folder=kwargs.get("output_folder") ) return fig, ax + + +class MultiSurveyInjector: + """Inject stream observations for several surveys into one catalog. + + The orchestrator holds one :class:`StreamInjector` per survey and delegates + the per-survey observational work to each (it is *not* a composite + ``Survey``). A single shared sky placement and a single shared draw of true + magnitudes — masses are sampled once via a multi-survey + :class:`~streamobs.model.IsochroneModel` and interpolated into every + survey's bands — guarantee that the **same physical star** gets consistent + magnitudes across surveys. Each survey then contributes its own + ``__obs`` / ``__err`` / ``_flag_observed`` + columns, computed with its own maglim maps and completeness functions. + + Parameters + ---------- + surveys : dict or list + Either ``{name: spec}`` or a list of ``spec``, where ``spec`` is a + survey-name string, a :class:`~streamobs.surveys.Survey`, or a + pre-built :class:`StreamInjector`. The dict key is used as the column + namespace; for a list, the survey's own name is used. + primary : str, optional + Name of the survey whose footprint drives the shared sky placement and + whose ``_save_injected_data`` is used. Defaults to the first survey. + **kwargs + Forwarded to :meth:`StreamInjector` construction when a ``spec`` is a + name/``Survey`` rather than an injector (e.g. ``release``). + + Examples + -------- + >>> msi = MultiSurveyInjector({"lsst": "lsst", "roman": "roman"}) + >>> out = msi.inject( + ... df, survey_bands={"lsst": ["r", "g"], "roman": ["f106", "f158"]}, + ... stream_config=scene["stream"], seed=42, + ... ) + """ + + def __init__(self, surveys, primary=None, **kwargs): + if isinstance(surveys, (list, tuple)): + surveys = {self._spec_name(s): s for s in surveys} + if not isinstance(surveys, dict): + raise ValueError("surveys must be a dict {name: spec} or a list of specs.") + + self.injectors = {} + for name, spec in surveys.items(): + if isinstance(spec, StreamInjector): + self.injectors[name] = spec + else: + self.injectors[name] = StreamInjector(spec, **kwargs) + + self.survey_names = list(self.injectors) + if not self.survey_names: + raise ValueError("At least one survey is required.") + self.primary = primary if primary is not None else self.survey_names[0] + if self.primary not in self.injectors: + raise ValueError( + f"primary='{self.primary}' is not one of {self.survey_names}." + ) + + # Shared sky placement is cached here, mirroring StreamInjector. + self._last_gc_frame = None + + @staticmethod + def _spec_name(spec): + """Best-effort survey name for a spec passed in a list.""" + if isinstance(spec, StreamInjector): + return spec.survey.name + if isinstance(spec, Survey): + return spec.name + return str(spec) + + def inject(self, data, survey_bands, stream_config=None, **kwargs): + """Inject observations for every survey into a single catalog. + + Parameters + ---------- + data : str or pandas.DataFrame + Input catalog (or path). May contain only stream coordinates + (``phi1``/``phi2`` or ``ra``/``dec``); anything missing is sampled + from ``stream_config``. An all-empty frame of length ``N`` is also + accepted (geometry and magnitudes are then sampled for ``N`` rows). + survey_bands : dict + ``{survey_name: [bands]}`` — the bands to inject for each survey. + Keys must match the surveys this orchestrator was built with. + stream_config : dict, optional + The ``stream`` section consumed by + :class:`~streamobs.model.StreamModel`. Its ``isochrone`` must be in + the multi-survey form so the same shared masses produce every + survey's ``__true`` columns. Required when any + coordinate or true-magnitude column is missing. + **kwargs + ``seed``, ``nside``, ``detection_mag_cut``, ``dust_correction``, + ``perfect_galstarsep``, ``gc_frame``, ``mask_type``, ``save``, + ``folder``, ``verbose`` — see :meth:`StreamInjector.inject`. + + Returns + ------- + pandas.DataFrame + Catalog with shared ``ra``/``dec`` and, per survey, + ``__true/_obs/_err`` and ``_flag_observed``. + """ + unknown = set(survey_bands) - set(self.injectors) + if unknown: + raise ValueError( + f"survey_bands references unknown surveys {sorted(unknown)}; " + f"available: {self.survey_names}." + ) + + ref = self.injectors[self.primary] + data = ref._load_data(data) + + seed = kwargs.pop("seed", None) + rng = np.random.default_rng(seed) + + # (1)+(2) Shared sky placement and shared true-magnitude fill (masses + # sampled once across all surveys). + data = self._complete_shared( + data, + survey_bands, + stream_config=stream_config, + rng=rng, + seed=seed, + **kwargs, + ) + + # (3) Per-survey observational injection. Independent child RNGs make the + # result independent of survey ordering and reproducible from `seed`. + children = rng.spawn(len(self.survey_names)) + for child_rng, name in zip(children, self.survey_names): + if name not in survey_bands: + continue + data = self.injectors[name]._inject_one_survey( + data, + list(survey_bands[name]), + rng=child_rng, + survey_namespace=name, + **kwargs, + ) + + if kwargs.get("save"): + ref._save_injected_data(data, kwargs.get("folder", None)) + + return data + + def _complete_shared( + self, data, survey_bands, stream_config=None, rng=None, seed=None, **kwargs + ): + """Fill shared geometry, ``ra``/``dec`` and per-survey true magnitudes. + + Positions and masses are drawn *once* so all surveys describe the same + physical stars. Existing columns are preserved. + """ + verbose = kwargs.get("verbose", True) + ref = self.injectors[self.primary] + + true_cols = [] + for name, bands in survey_bands.items(): + true_cols += [true_col(b, name) for b in bands] + + have_radec = "ra" in data.columns and "dec" in data.columns + have_phi = "phi1" in data.columns and "phi2" in data.columns + missing_true = [c for c in true_cols if c not in data.columns] + + # Sample stream geometry and/or the shared true magnitudes from the model. + need_phi = not have_radec and not have_phi + if need_phi or missing_true: + if stream_config is None: + raise ValueError( + "stream_config is required to sample stream geometry/magnitudes." + ) + stream_model = StreamModel(stream_config) + cols_to_add = [] + if need_phi: + cols_to_add += ["phi1", "phi2"] + # `dist` is needed before magnitudes; the model fills it if absent. + cols_to_add += ["dist"] + missing_true + data = stream_model.complete_catalog( + data, columns_to_add=cols_to_add, inplace=True, verbose=verbose + ) + + # Convert (phi1, phi2) -> (ra, dec) using the primary survey footprint. + if not have_radec: + data = ref.complete_data(data, bands=[], rng=rng, seed=seed, **kwargs) + self._last_gc_frame = ref._last_gc_frame + + return data diff --git a/streamobs/plotting.py b/streamobs/plotting.py index f39fe97..28ddb96 100644 --- a/streamobs/plotting.py +++ b/streamobs/plotting.py @@ -9,6 +9,8 @@ import pandas as pd import pylab as plt +from .columns import flag_col, obs_col, true_col + try: import healpy as hp import skyproj @@ -95,8 +97,8 @@ def plot_inject(data, survey, bands=None, range=None, **kwargs): Data containing the injected stream. Must have columns: - 'ra', 'dec': Sky coordinates in degrees - 'flag_observed': Boolean flag for detected stars - - 'mag_': True magnitudes for each band - - 'mag__obs': Observed magnitudes for each band + - '_true': True magnitudes for each band + - '_obs': Observed magnitudes for each band survey : Survey Survey object containing magnitude limit maps and other properties. bands : list of str, optional @@ -134,18 +136,18 @@ def plot_inject(data, survey, bands=None, range=None, **kwargs): required_cols = [ "ra", "dec", - "flag_observed", - f"mag_{band1}", - f"mag_{band2}", - f"mag_{band1}_obs", - f"mag_{band2}_obs", + flag_col(), + true_col(band1), + true_col(band2), + obs_col(band1), + obs_col(band2), ] missing_cols = [col for col in required_cols if col not in data.columns] if missing_cols: raise ValueError(f"Missing required columns: {missing_cols}") # Get detection flags - sel = data["flag_observed"].astype(bool) + sel = data[flag_col()].astype(bool) # Create figure fig, ax = plt.subplots(1, 3, figsize=(14, 6)) @@ -205,8 +207,8 @@ def plot_inject(data, survey, bands=None, range=None, **kwargs): # --- Panel 2: HR diagram with true magnitudes --- ax[1].set_title("HR diagram using True magnitudes") - color_true = data[f"mag_{band1}"] - data[f"mag_{band2}"] - mag_true = data[f"mag_{band1}"] + color_true = data[true_col(band1)] - data[true_col(band2)] + mag_true = data[true_col(band1)] ax[1].scatter( color_true, @@ -234,8 +236,8 @@ def plot_inject(data, survey, bands=None, range=None, **kwargs): ax[2].set_title("HR diagram using sampled observed magnitudes") # Convert measured magnitudes to numeric, handling "BAD_MAG" strings - mag1_obs = pd.to_numeric(data[f"mag_{band1}_obs"], errors="coerce") - mag2_obs = pd.to_numeric(data[f"mag_{band2}_obs"], errors="coerce") + mag1_obs = pd.to_numeric(data[obs_col(band1)], errors="coerce") + mag2_obs = pd.to_numeric(data[obs_col(band2)], errors="coerce") # Mask out bad measurements mask_good = (~mag1_obs.isna()) & (~mag2_obs.isna()) diff --git a/streamobs/samplers.py b/streamobs/samplers.py index 4bf42e9..a4b8bdc 100644 --- a/streamobs/samplers.py +++ b/streamobs/samplers.py @@ -6,13 +6,15 @@ import numpy as np import scipy.stats -from streamobs.functions import (CubicSplineInterpolation, - FileCubicSplineInterpolation, - FileInterpolation, - FileLinearDensityCubicSplineInterpolation, - Interpolation, - LinearDensityCubicSplineInterpolation, - Sinusoid) +from streamobs.functions import ( + CubicSplineInterpolation, + FileCubicSplineInterpolation, + FileInterpolation, + FileLinearDensityCubicSplineInterpolation, + Interpolation, + LinearDensityCubicSplineInterpolation, + Sinusoid, +) def sampler_factory(type_, **kwargs): diff --git a/streamobs/surveys.py b/streamobs/surveys.py index 903dc9c..105c633 100644 --- a/streamobs/surveys.py +++ b/streamobs/surveys.py @@ -279,7 +279,12 @@ def get_extinction(self, band: str, pixel: int = None) -> float: return extinction[pixel] def get_photo_error( - self, band: str, magnitude: float, maglim: float, kind: str = "catalog", **kwargs + self, + band: str, + magnitude: float, + maglim: float, + kind: str = "catalog", + **kwargs, ) -> float: """ Get photometric error estimate. diff --git a/streamobs/utils.py b/streamobs/utils.py index 7eca8bb..c226c0f 100644 --- a/streamobs/utils.py +++ b/streamobs/utils.py @@ -2,6 +2,7 @@ """ Utils for streamobs """ + import yaml diff --git a/tests/test_functions.py b/tests/test_functions.py index 2884fc0..179c110 100644 --- a/tests/test_functions.py +++ b/tests/test_functions.py @@ -1,78 +1,155 @@ - -from streamobs.functions import (LinearDensityCubicSplineInterpolation, - FileLinearDensityCubicSplineInterpolation, - CubicSplineInterpolation, - FileCubicSplineInterpolation) import numpy as np +from streamobs.functions import ( + CubicSplineInterpolation, + FileCubicSplineInterpolation, + FileLinearDensityCubicSplineInterpolation, + LinearDensityCubicSplineInterpolation, +) + SPREAD_NODES = np.array([-13.0, -7.875, -2.75, 2.375, 7.5]) -SPREAD_NODE_VALUES = np.array([0.67851425, 0.12068391, 0.19419976, 0.15820543, - 0.12868499]) - -SPREAD_INTERP_ARRAY = np.array([0.28385327, 0.18494655, 0.12147638, 0.09911923, - 0.10862358, 0.13679006, 0.17041929, 0.19631621, - 0.20546274, 0.20080746, 0.18742835, 0.17040343, - 0.15479583, 0.1437526, 0.13663492, 0.1323599, - 0.12984461, np.nan, np.nan, np.nan]) -INTENSITY_NODES = np.array([-13., -11.04761905, -10.07142857, - -9.0952381, -6.16666667, -5.92261905, - -5.19047619, -4.45833333, -4.21428571, -3.9702381, - -0.30952381, 0.66666667, 1.64285714, 3.5952381, - 4.57142857, 5.54761905, 7.5]) - -INTENSITY_NODE_VALUES = np.array([ - 3.57488822e-08, 8.15443503e-02, 7.43156465e-02, 8.38736587e-02, - 1.29506112e-01, 1.48465666e-01, 1.51251953e-08, 9.32309494e-02, - 1.91713194e-02, 4.61099534e-03, 4.17791354e-02, 4.89747482e-02, - 1.55361917e-02, 2.27116146e-02, 2.45111417e-02, 6.95831709e-02, - 1.03856772e-07]) - -LINEAR_DENSITY_INTERP_ARRAY = np.array([ - 0.05301498, 0.03867171, 0.01956495, 0.018129, 0.03598436, - 0.02941, 0.00440678, 0.01117077, 0.01486688, 0.01937192, - 0.02381247, 0.00740761, 0.00514529, 0.00808078, 0.01046202, - 0.02456511, 0.01387564, np.nan, np.nan, np.nan]) +SPREAD_NODE_VALUES = np.array( + [0.67851425, 0.12068391, 0.19419976, 0.15820543, 0.12868499] +) + +SPREAD_INTERP_ARRAY = np.array( + [ + 0.28385327, + 0.18494655, + 0.12147638, + 0.09911923, + 0.10862358, + 0.13679006, + 0.17041929, + 0.19631621, + 0.20546274, + 0.20080746, + 0.18742835, + 0.17040343, + 0.15479583, + 0.1437526, + 0.13663492, + 0.1323599, + 0.12984461, + np.nan, + np.nan, + np.nan, + ] +) +INTENSITY_NODES = np.array( + [ + -13.0, + -11.04761905, + -10.07142857, + -9.0952381, + -6.16666667, + -5.92261905, + -5.19047619, + -4.45833333, + -4.21428571, + -3.9702381, + -0.30952381, + 0.66666667, + 1.64285714, + 3.5952381, + 4.57142857, + 5.54761905, + 7.5, + ] +) + +INTENSITY_NODE_VALUES = np.array( + [ + 3.57488822e-08, + 8.15443503e-02, + 7.43156465e-02, + 8.38736587e-02, + 1.29506112e-01, + 1.48465666e-01, + 1.51251953e-08, + 9.32309494e-02, + 1.91713194e-02, + 4.61099534e-03, + 4.17791354e-02, + 4.89747482e-02, + 1.55361917e-02, + 2.27116146e-02, + 2.45111417e-02, + 6.95831709e-02, + 1.03856772e-07, + ] +) + +LINEAR_DENSITY_INTERP_ARRAY = np.array( + [ + 0.05301498, + 0.03867171, + 0.01956495, + 0.018129, + 0.03598436, + 0.02941, + 0.00440678, + 0.01117077, + 0.01486688, + 0.01937192, + 0.02381247, + 0.00740761, + 0.00514529, + 0.00808078, + 0.01046202, + 0.02456511, + 0.01387564, + np.nan, + np.nan, + np.nan, + ] +) def test_CubicSplineInterpolation(): # using atlas width from patrick_2022.csv - interp=CubicSplineInterpolation(SPREAD_NODES,SPREAD_NODE_VALUES) + interp = CubicSplineInterpolation(SPREAD_NODES, SPREAD_NODE_VALUES) - result=interp(np.linspace(-10,10,20)) + result = interp(np.linspace(-10, 10, 20)) np.testing.assert_allclose(result, SPREAD_INTERP_ARRAY) def test_FileCubicSplineInterpolation(): # using atlas width from patrick_2022.csv - filepath="./data/patrick_2022_splines.csv" - stream_name="atlas" - spline_type="spread" + filepath = "./data/patrick_2022_splines.csv" + stream_name = "atlas" + spline_type = "spread" - interp=FileCubicSplineInterpolation(filepath, spline_type=spline_type, stream_name=stream_name) - result=interp(np.linspace(-10,10,20)) + interp = FileCubicSplineInterpolation( + filepath, spline_type=spline_type, stream_name=stream_name + ) + result = interp(np.linspace(-10, 10, 20)) np.testing.assert_allclose(result, SPREAD_INTERP_ARRAY) + def test_LinearDensityCubicSplineInterpolation(): # using atlas width from patrick_2022.csv - interp=LinearDensityCubicSplineInterpolation(spread_nodes=SPREAD_NODES, - spread_node_values=SPREAD_NODE_VALUES, - intensity_nodes = INTENSITY_NODES, - intensity_node_values = INTENSITY_NODE_VALUES, - ) - result=interp(np.linspace(-10,10,20)) + interp = LinearDensityCubicSplineInterpolation( + spread_nodes=SPREAD_NODES, + spread_node_values=SPREAD_NODE_VALUES, + intensity_nodes=INTENSITY_NODES, + intensity_node_values=INTENSITY_NODE_VALUES, + ) + result = interp(np.linspace(-10, 10, 20)) np.testing.assert_allclose(result, LINEAR_DENSITY_INTERP_ARRAY, atol=1e-7) def test_FileLinearDensityCubicSplineInterpolation(): # using atlas width from patrick_2022.csv - filename="./data/patrick_2022_splines.csv" - stream_name="atlas" - interp=FileLinearDensityCubicSplineInterpolation(filename=filename, - stream_name=stream_name) + filename = "./data/patrick_2022_splines.csv" + stream_name = "atlas" + interp = FileLinearDensityCubicSplineInterpolation( + filename=filename, stream_name=stream_name + ) - result=interp(np.linspace(-10,10,20)) - np.testing.assert_allclose(result, LINEAR_DENSITY_INTERP_ARRAY, atol=1e-7) \ No newline at end of file + result = interp(np.linspace(-10, 10, 20)) + np.testing.assert_allclose(result, LINEAR_DENSITY_INTERP_ARRAY, atol=1e-7) From 7c965ae3604481be767e916c196b052694bf677e Mon Sep 17 00:00:00 2001 From: psferguson Date: Tue, 16 Jun 2026 11:19:35 -0700 Subject: [PATCH 06/29] Unify injector into one StreamInjector; always-namespaced columns Merge MultiSurveyInjector into StreamInjector: one class now accepts a single survey or several (name/Survey, {namespace: spec} dict, or list). Output columns are always survey-namespaced (__true/_obs/_err, _flag_observed), even for a single survey. The model emits __true uniformly (single-survey isochrone is just the one-survey case). - observed.py: StreamInjector takes one-or-many surveys; shared _inject_one_survey/detect_flag now take an explicit survey; public complete_data() fills missing geometry/ra-dec/true-mags from the config; MultiSurveyInjector removed. - model.py: complete_catalog never overwrites present values (fills only missing rows, per column); add `dist` (scalar/vector) to set distances directly without phi1 / a distance_modulus model. - columns.py docs, scene yaml, demo builder + regenerated notebook updated. - tests: namespaced columns; new TestCompleteCatalogPermutations. - plan doc: single class, always-namespace, exact-nstars agreed; flagged for removal (migrate to docs) before merge. Co-Authored-By: Claude Opus 4.8 (1M context) --- config/scenes/roman_rubin_demo.yaml | 9 +- docs/source/roman_multisurvey_plan.md | 148 +++--- notebooks/multisurvey_phases_demo.ipynb | 191 ++++--- scripts/build_multisurvey_demo_nb.py | 50 +- streamobs/columns.py | 20 +- streamobs/model.py | 130 +++-- streamobs/observed.py | 665 ++++++++++++------------ tests/test_model.py | 239 ++++++++- tests/test_observed.py | 125 +++-- 9 files changed, 924 insertions(+), 653 deletions(-) diff --git a/config/scenes/roman_rubin_demo.yaml b/config/scenes/roman_rubin_demo.yaml index b8c9fc3..1b0bbae 100644 --- a/config/scenes/roman_rubin_demo.yaml +++ b/config/scenes/roman_rubin_demo.yaml @@ -1,12 +1,13 @@ # Multi-survey demo scene: a single toy stream observed by BOTH Rubin/LSST and -# Roman. Consumed by `streamobs.observed.MultiSurveyInjector` (Phase 4). +# Roman. Consumed by `streamobs.observed.StreamInjector` (Phase 4) — the same +# injector class handles one survey or several. # # Usage (see notebooks/multisurvey_phases_demo.ipynb): # # import yaml, pandas as pd -# from streamobs.observed import MultiSurveyInjector +# from streamobs.observed import StreamInjector # scene = yaml.safe_load(open("config/scenes/roman_rubin_demo.yaml")) -# msi = MultiSurveyInjector(scene["surveys"]) +# msi = StreamInjector(scene["surveys"]) # df = pd.DataFrame(index=range(int(scene["stream"]["nstars"]))) # out = msi.inject(df, scene["survey_bands"], # stream_config=scene["stream"], seed=42) @@ -15,7 +16,7 @@ # columns; each band's errors / detection come from that survey's own maps. # Surveys to inject. The mapping KEY is the column namespace (lsst_r_obs, ...). -# Each value is a StreamInjector spec: a survey-name string here (loaded via +# Each value is a survey spec: a survey-name string here (loaded via # Survey.load); could also be a {name, release} once the loader supports it. surveys: lsst: lsst diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md index 19f5de3..5201c21 100644 --- a/docs/source/roman_multisurvey_plan.md +++ b/docs/source/roman_multisurvey_plan.md @@ -7,6 +7,14 @@ importantly — the **behaviour changes that need discussion** before we rely on them. Sections marked *(future)* are designed but not yet implemented. ``` +```{important} +**Remove this file before merging the `roman_multisurvey` branch.** It is a +working design/roadmap doc, not user documentation. Before merge, migrate the +durable content — the column convention, the sample/catalog error split, the +multi-survey `StreamInjector` usage, and the Vega→AB handling — into the proper +docs pages (and the API docstrings), then delete `roman_multisurvey_plan.md`. +``` + ## Motivation `streamobs` was built for **single-survey** stream injection (LSST). We want to @@ -35,20 +43,22 @@ Two science realities drive specific features: ## Locked design decisions -1. **Multi-survey via a `MultiSurveyInjector` orchestrator** that holds - `{survey_name: Survey}` and delegates per-survey work to the existing, - unchanged `Survey` per-band API. Not a composite `Survey`; not manual - re-runs. -2. **Column convention (uniform `_true`/`_obs`/`_err`).** A single naming scheme - is used everywhere: `{band}_true` / `{band}_obs` / `{band}_err` / - `flag_observed` single-survey, and `{survey}_{band}_true` / +1. **One `StreamInjector` for one *or* many surveys.** A single injector holds + `{survey_name: Survey}` (size 1 for the single-survey case) and delegates + per-survey work to the existing, unchanged `Survey` per-band API via a shared + `_inject_one_survey` helper. Not a composite `Survey`; not manual re-runs; + and **no separate multi-survey class** — `StreamInjector` accepts a survey + name/`Survey`, a `{name: spec}` dict, or a list of specs. +2. **Column convention (always survey-namespaced `{survey}_{band}_true/_obs/_err`).** + A single naming scheme is used everywhere — `{survey}_{band}_true` / `{survey}_{band}_obs` / `{survey}_{band}_err` / `{survey}_flag_observed` - multi-survey (e.g. `roman_f158_obs`, `lsst_r_err`). The single- and - multi-survey forms differ only by the optional survey prefix. - **This intentionally drops the historical `mag_{band}` / `mag_{band}_obs` / - `magerr_{band}` names — it is *not* backward compatible** with catalogs or - downstream readers expecting those columns (decision made deliberately to - keep one convention; see decision 5). + (e.g. `roman_f158_obs`, `lsst_r_err`) — and it is **always namespaced by + survey, even for a single survey** (a one-survey injection of LSST emits + `lsst_r_obs`, not `r_obs`). There is no longer an un-namespaced single-survey + form. **This intentionally drops the historical `mag_{band}` / + `mag_{band}_obs` / `magerr_{band}` names — it is *not* backward compatible** + with catalogs or downstream readers expecting those columns (decision made + deliberately to keep one convention; see decision 5). 3. **Sample-vs-catalog error split, backward-compatible by default.** `Survey` holds two error curves, both functions of `delta_mag = mag − maglim`: - `log_photo_error_catalog` — the survey's **reported** error curve (the @@ -68,12 +78,13 @@ Two science realities drive specific features: 4. **Sample stellar masses once, interpolate per survey.** This is a correctness requirement (see below) and the engine of the whole feature. 5. **Public API preserved; column schema deliberately changed.** The - `StreamInjector(survey).inject(df, bands=[...])` API is unchanged. The - **column names are not** — we adopt the uniform `{band}_true/_obs/_err` - scheme (decision 2) *instead of* preserving the historical - `mag_g_obs`/`mag_r_obs`/`magerr_g` names. Downstream consumers that read those - columns must be updated. This is an accepted break in exchange for one - convention across single- and multi-survey output. + `StreamInjector(survey).inject(df, bands=[...])` single-survey call still + works (the same `StreamInjector` also takes a dict/list for several surveys). + The **column names are not** preserved — we adopt the always-namespaced + `{survey}_{band}_true/_obs/_err` scheme (decision 2) *instead of* the + historical `mag_g_obs`/`mag_r_obs`/`magerr_g` names. Downstream consumers that + read those columns must be updated. This is an accepted break in exchange for + one convention across single- and multi-survey output. ## Behaviour changes for discussion @@ -94,16 +105,15 @@ and makes "observed" mean "detected in everything you asked for". Callers can restore any prior behaviour by passing `detection_mag_cut=[...]` explicitly (e.g. `["g"]` for the old LSST default). **Adopted, but flagged for review.** -### `nstars` becomes "exactly N stars" (was an emergent IMF count) *(adopted, but flagged for review)* +### `nstars` becomes "exactly N stars" (was an emergent IMF count) *(adopted — agreed)* ```{important} -**Adopted (Phase 4).** {meth}`~streamobs.model.IsochroneModel.sample` now draws -*exactly* `nstars` (the shared-mass path described below), for **both** +**Adopted (Phase 4) and agreed.** {meth}`~streamobs.model.IsochroneModel.sample` +now draws *exactly* `nstars` (the shared-mass path described below), for **both** single-survey and multi-survey isochrones. The single-survey -`ugali.simulate()` emergent-count path has been removed. This flag is **left in -place for review** because it changes what `StreamModel.sample(size)` returns -for existing single-survey configs — see the discussion below before relying on -the new normalization. +`ugali.simulate()` emergent-count path has been removed. This was reviewed and +**accepted as the intended semantics** (you control N, and it is shared across +surveys); it is no longer open for discussion. ``` Previously {meth}`~streamobs.model.IsochroneModel.sample` converted `nstars` @@ -121,10 +131,10 @@ sampled_masses = rng.choice(init_mass[sel], size=nstars, p=imf_pdf) # exactly # then, per survey: mag_band = np.interp(sampled_masses, init_mass, mag_band) + dist_mod ``` -This returns *exactly* `nstars` stars. It is almost certainly the right -semantics for injection (you control N, and it is shared across surveys), but it -changes what `StreamModel.sample(size)` returns and could shift normalization in -any analysis that relied on the old emergent count. **Open for discussion.** +This returns *exactly* `nstars` stars. It is the right semantics for injection +(you control N, and it is shared across surveys). It changes what +`StreamModel.sample(size)` returns relative to the old emergent count, but this +was reviewed and **agreed** — no further discussion needed. ### Roman Vega→AB conversion is automatic and unconditional @@ -180,9 +190,10 @@ survey's `survey_files`. ### Phase 2 — De-hardcode the injector to arbitrary bands ✅ *(implemented)* - ✅ New `streamobs/columns.py` with `true_col` / `obs_col` / `err_col` helpers - `(band, survey=None)` and `flag_col(survey=None)` (`survey=None` ⇒ legacy - names `mag_` / `mag__obs` / `magerr_` / `flag_observed`; - a survey name ⇒ the `__…` multi-survey convention for Phase 4). + `(band, survey=None)` and `flag_col(survey=None)`. Injected catalogs are + **always** survey-namespaced (`__…` / `_flag_observed`); + `survey=None` is retained only as a low-level fallback that the injector itself + never uses. - ✅ `observed.py`: removed the `bands in {"r","g"}` hard block; the true-mag read, the observed/err columns, the valid-flux check (now ANDs over every injected band), the S/N cut, the per-survey detection flag, and the stored @@ -192,10 +203,9 @@ survey's `survey_files`. - ⚠️ The S/N-cut default changed from the hard-coded `["g"]` to **all injected bands** — see *Behaviour changes for discussion* above. -**Validated:** single-band (`bands=["r"]`) and arbitrary band sets now inject -without the old hard block; legacy column names and the `inject(df, bands=[...])` -API are unchanged; the test-branch suite stays green (94 passing; the lone -`des_yr6` photo-error failure is pre-existing and unrelated). +**Validated:** single-band (`bands=["r"]`) and arbitrary band sets inject without +the old hard block; the `inject(df, bands=[...])` API is unchanged (output now +namespaced); `tests/test_observed.py` + `tests/test_model.py` green. ### Phase 3 — Multi-band / multi-survey `IsochroneModel` ✅ *(implemented)* @@ -213,43 +223,48 @@ API are unchanged; the test-branch suite stays green (94 passing; the lone the `ROMAN_VEGA_TO_AB` table (no config flag; non-Roman bands pass through). Applied in the shared `sample_multisurvey` path. See the Vega→AB section above. - ✅ `StreamModel.sample`/`complete_catalog` derive their magnitude columns from - the isochrone via `_iso_mag_columns()` / `_sample_iso_mags()`: `_true` - for a single-survey isochrone, `__true` for a multi-survey one. - Naming routes through `columns.true_col`. + the isochrone via `_iso_mag_columns()` / `_sample_iso_mags()`, which **always** + emit `__true` (a single-survey isochrone simply has one survey; + `IsochroneModel` tracks `surveys`/`survey_bands` in both config forms). Naming + routes through `columns.true_col`. **Note on the chosen API:** the plan originally named the dict-returning method `sample` and a tuple `sample_legacy`; to avoid `sample()` changing return *type* -by config (a foot-gun for existing callers), the implementation keeps `sample()` -as the `(mag_1, mag_2)` tuple and adds `sample_multisurvey()` for the dict. -`StreamModel` dispatches on `isochrone.multi_survey`. +by config (a foot-gun for existing callers), the implementation keeps +`IsochroneModel.sample()` as the `(mag_1, mag_2)` tuple and adds +`sample_multisurvey()` for the dict. `StreamModel` always goes through +`sample_multisurvey()` (a single-survey isochrone is just the one-survey case), +so the emitted columns are uniformly `__true`. -**Validated:** single-survey model tests unchanged (test branch green, 94 -passing); a two-isochrone multi-survey config produces consistent shared-mass -magnitudes, Roman bands are converted Vega→AB by the fixed `ROMAN_VEGA_TO_AB` -offsets, and `StreamModel.sample` emits the `__true` columns. +**Validated:** model tests green; a two-isochrone multi-survey config produces +consistent shared-mass magnitudes, Roman bands are converted Vega→AB by the +fixed `ROMAN_VEGA_TO_AB` offsets, and `StreamModel.sample` emits the +`__true` columns. -### Phase 4 — `MultiSurveyInjector` ✅ *(implemented)* +### Phase 4 — one `StreamInjector` for one *or* many surveys ✅ *(implemented)* -- ✅ The per-band body of `StreamInjector.inject` is extracted into a shared - `StreamInjector._inject_one_survey(data, bands, survey_namespace=None, ...)` +- ✅ The per-band body of injection lives in a shared + `StreamInjector._inject_one_survey(data, bands, survey, survey_namespace, ...)` helper. It assumes positions and true magnitudes are already present and only does the observed/err draw, detection flags, and S/N cut, routing every column - name through `columns.py` (`survey_namespace=None` ⇒ legacy names). `inject` - now just completes the data and delegates to it, so single-survey behaviour is - unchanged. -- ✅ `MultiSurveyInjector(surveys).inject(data, survey_bands, stream_config=...)`: - (1) one shared sky placement; (2) one shared true-magnitude fill via a - multi-survey isochrone (masses sampled once → every survey's - `__true`); (3) a per-survey loop calling each survey's - `_inject_one_survey` with `survey_namespace=`, writing - `__obs/_err` and `_flag_observed` from that survey's own - `completeness_band` and maglim maps. Per-survey RNG via `rng.spawn(...)` for - order-independent reproducibility. `columns.perfect_flag_col` namespaces the - optional `perfect_galstarsep` flag. + name through `columns.py`. `survey`/`survey_namespace` are passed explicitly so + the same method serves every survey. +- ✅ `StreamInjector` accepts **one survey or several** (a name/`Survey`, a + `{namespace: spec}` dict, or a list); `__init__` normalizes to + `self.surveys = {namespace: Survey}` with a `survey` property pointing at the + `primary`. `inject(data, survey_bands=None, bands=None, stream_config=...)`: + (1) one shared sky placement; (2) one shared true-magnitude fill via the + isochrone (masses sampled once → every survey's `__true`); + (3) a per-survey loop calling `_inject_one_survey` with `survey_namespace=`, + writing `__obs/_err` and `_flag_observed` from that + survey's own `completeness_band` and maglim maps. Per-survey RNG via + `rng.spawn(...)` for order-independent reproducibility. `columns.perfect_flag_col` + namespaces the optional `perfect_galstarsep` flag. The separate + `MultiSurveyInjector` class has been **removed**. - ✅ A *scene* config (`config/scenes/roman_rubin_demo.yaml`) lists the surveys, per-survey bands, the multi-survey isochrone, and shared stream geometry. - ✅ `notebooks/multisurvey_phases_demo.ipynb` walks through Phases 1–4 end to - end. + end (executes against `StubSurvey` + real `ugali` isochrones). ### Phase 5 *(future)* — Lightweight background + galaxy misclassification @@ -288,9 +303,8 @@ recreated here, so it can land cleanly when the `roman_hlwas` work merges. | File | Phase | Role | |---|---|---| | `streamobs/surveys.py` | 1 | sample/catalog error fields, `get_photo_error(kind=)`, loader | -| `streamobs/columns.py` | 2 | NEW — column-name helpers | -| `streamobs/observed.py` | 1,2,4 | error wiring; de-hardcode bands; `_inject_one_survey`; `MultiSurveyInjector` | -| `streamobs/model.py` | 3 | multi-band `IsochroneModel`; band-generalized `StreamModel` | -| `streamobs/multisurvey.py` | 4 | NEW — orchestrator (or a class in `observed.py`) | +| `streamobs/columns.py` | 2 | NEW — column-name helpers (always namespaced) | +| `streamobs/observed.py` | 1,2,4 | error wiring; de-hardcode bands; unified one-or-many-survey `StreamInjector` (`_inject_one_survey` + `_complete_shared`) | +| `streamobs/model.py` | 3 | multi-band `IsochroneModel`; always-namespaced `StreamModel` | | `config/scenes/roman_rubin_demo.yaml` | 4 | NEW — multi-survey scene | | `streamobs/background.py` | 5 *(future)* | NEW — lightweight background | diff --git a/notebooks/multisurvey_phases_demo.ipynb b/notebooks/multisurvey_phases_demo.ipynb index a8f0dbb..39ee820 100644 --- a/notebooks/multisurvey_phases_demo.ipynb +++ b/notebooks/multisurvey_phases_demo.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "956da58f", + "id": "154f0f43", "metadata": {}, "source": [ "# Multi-survey injection — Phases 1-4 demo\n", @@ -14,9 +14,9 @@ "| Phase | What changed |\n", "|---|---|\n", "| **1** | `Survey` holds two error curves — a *catalog* (reported `magerr`, drives the S/N cut) and an optional *sample* (true scatter, drives the noise draw). `get_photo_error(..., kind=)` selects between them. |\n", - "| **2** | The injector is de-hardcoded off `{r, g}`; column names route through `streamobs.columns`, using a **uniform** `_true/_obs/_err` scheme (`_…` when namespaced). The S/N cut now applies to **all** injected bands. |\n", + "| **2** | The injector is de-hardcoded off `{r, g}`; column names route through `streamobs.columns`, using a uniform, **always survey-namespaced** `__true/_obs/_err` scheme. The S/N cut now applies to **all** injected bands. |\n", "| **3** | `IsochroneModel` is multi-band / multi-survey: masses are drawn **once** (exactly `nstars`) and interpolated into every survey's bands, so the *same physical star* is consistent across surveys. Roman bands are auto-converted Vega→AB. |\n", - "| **4** | `MultiSurveyInjector` orchestrates one shared sky placement + one shared true-mag fill, then a per-survey loop writing `__obs/_err` and `_flag_observed`. |\n", + "| **4** | A single `StreamInjector` accepts one survey **or several**: it does one shared sky placement + one shared true-mag fill, then a per-survey loop writing `__obs/_err` and `_flag_observed`. |\n", "\n", "See `docs/source/roman_multisurvey_plan.md` for the full design.\n" ] @@ -24,13 +24,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "1d385c8b", + "id": "faa963cc", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:33:47.506938Z", - "iopub.status.busy": "2026-06-15T23:33:47.506845Z", - "iopub.status.idle": "2026-06-15T23:33:57.035573Z", - "shell.execute_reply": "2026-06-15T23:33:57.034912Z" + "iopub.execute_input": "2026-06-16T18:01:24.411403Z", + "iopub.status.busy": "2026-06-16T18:01:24.411297Z", + "iopub.status.idle": "2026-06-16T18:01:25.632931Z", + "shell.execute_reply": "2026-06-16T18:01:25.632424Z" } }, "outputs": [], @@ -45,7 +45,7 @@ "\n", "from streamobs.surveys import Survey\n", "from streamobs.model import StreamModel, IsochroneModel\n", - "from streamobs.observed import StreamInjector, MultiSurveyInjector\n", + "from streamobs.observed import StreamInjector\n", "from streamobs import columns as C\n", "\n", "import os\n", @@ -56,7 +56,7 @@ }, { "cell_type": "markdown", - "id": "5dd03468", + "id": "bc624c63", "metadata": {}, "source": [ "## A runnable stub survey\n", @@ -77,13 +77,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "8ed0d733", + "id": "9fe2c7bf", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:33:57.037569Z", - "iopub.status.busy": "2026-06-15T23:33:57.037358Z", - "iopub.status.idle": "2026-06-15T23:33:57.041674Z", - "shell.execute_reply": "2026-06-15T23:33:57.041252Z" + "iopub.execute_input": "2026-06-16T18:01:25.634939Z", + "iopub.status.busy": "2026-06-16T18:01:25.634739Z", + "iopub.status.idle": "2026-06-16T18:01:25.638611Z", + "shell.execute_reply": "2026-06-16T18:01:25.638254Z" } }, "outputs": [ @@ -136,7 +136,7 @@ }, { "cell_type": "markdown", - "id": "aa861d61", + "id": "d4f9c999", "metadata": {}, "source": [ "## Phase 1 — sample vs. catalog photometric error\n", @@ -151,13 +151,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "63de7e59", + "id": "51d6fb5d", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:33:57.042872Z", - "iopub.status.busy": "2026-06-15T23:33:57.042761Z", - "iopub.status.idle": "2026-06-15T23:33:57.234295Z", - "shell.execute_reply": "2026-06-15T23:33:57.233794Z" + "iopub.execute_input": "2026-06-16T18:01:25.639625Z", + "iopub.status.busy": "2026-06-16T18:01:25.639518Z", + "iopub.status.idle": "2026-06-16T18:01:25.741575Z", + "shell.execute_reply": "2026-06-16T18:01:25.741220Z" } }, "outputs": [ @@ -204,30 +204,30 @@ }, { "cell_type": "markdown", - "id": "86c9e1fd", + "id": "041939f0", "metadata": {}, "source": [ "## Phase 2 — arbitrary bands + `columns.py`\n", "\n", "The injector no longer hard-codes `{r, g}`. Column names come from\n", - "`streamobs.columns`, using one **uniform** convention: `_true` /\n", - "`_obs` / `_err` / `flag_observed` single-survey, and the same with a\n", - "`_` prefix multi-survey. (This intentionally drops the historical\n", - "`mag_` / `magerr_` names — not backward compatible.) Below we inject\n", - "Roman NIR bands `F106`/`F158` through the *single-survey* `StreamInjector` —\n", - "impossible under the old `{r,g}` block.\n" + "`streamobs.columns`, using one uniform, **always survey-namespaced** convention:\n", + "`__true` / `__obs` / `__err` /\n", + "`_flag_observed`. (This intentionally drops the historical `mag_` /\n", + "`magerr_` names — not backward compatible.) Below we inject Roman NIR bands\n", + "`F106`/`F158` through a **single-survey** `StreamInjector` — impossible under the\n", + "old `{r,g}` block — and the output is namespaced by the survey's name (`roman`).\n" ] }, { "cell_type": "code", "execution_count": 4, - "id": "c54f0211", + "id": "3b531fc3", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:33:57.235495Z", - "iopub.status.busy": "2026-06-15T23:33:57.235382Z", - "iopub.status.idle": "2026-06-15T23:33:57.248981Z", - "shell.execute_reply": "2026-06-15T23:33:57.248544Z" + "iopub.execute_input": "2026-06-16T18:01:25.742803Z", + "iopub.status.busy": "2026-06-16T18:01:25.742698Z", + "iopub.status.idle": "2026-06-16T18:01:25.755667Z", + "shell.execute_reply": "2026-06-16T18:01:25.755283Z" } }, "outputs": [ @@ -235,43 +235,35 @@ "name": "stdout", "output_type": "stream", "text": [ - "single-survey: r_true r_obs r_err flag_observed\n", - "multi-survey : roman_F158_true roman_F158_obs roman_F158_err roman_flag_observed\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "namespaced columns: roman_F158_true roman_F158_obs roman_F158_err roman_flag_observed\n", "\n", - "injected NIR-only bands -> columns: ['F106_obs', 'F106_err', 'F158_obs', 'F158_err', 'flag_observed']\n", - "detected: 1281 / 1500\n" + "injected NIR-only bands -> columns: ['roman_F106_obs', 'roman_F106_err', 'roman_F158_obs', 'roman_F158_err', 'roman_flag_observed']\n", + "detected: 1274 / 1500\n" ] } ], "source": [ - "print(\"single-survey:\", C.true_col(\"r\"), C.obs_col(\"r\"), C.err_col(\"r\"), C.flag_col())\n", - "print(\"multi-survey :\", C.true_col(\"F158\", \"roman\"), C.obs_col(\"F158\", \"roman\"),\n", + "print(\"namespaced columns:\", C.true_col(\"F158\", \"roman\"), C.obs_col(\"F158\", \"roman\"),\n", " C.err_col(\"F158\", \"roman\"), C.flag_col(\"roman\"))\n", "\n", "roman_sv = StubSurvey(\"roman\", [\"F106\", \"F158\"], completeness_band=\"F158\", maglim=27.0)\n", - "inj = StreamInjector(roman_sv)\n", + "inj = StreamInjector(roman_sv) # one survey -> namespaced by its name, \"roman\"\n", "N = 1500\n", "df = pd.DataFrame({\n", " \"ra\": rng.uniform(10, 20, N),\n", " \"dec\": rng.uniform(-5, 5, N),\n", - " \"F106_true\": rng.uniform(20, 28, N),\n", - " \"F158_true\": rng.uniform(20, 28, N),\n", + " \"roman_F106_true\": rng.uniform(20, 28, N),\n", + " \"roman_F158_true\": rng.uniform(20, 28, N),\n", "})\n", "out = inj.inject(df, bands=[\"F106\", \"F158\"], seed=1, verbose=False)\n", "print(\"\\ninjected NIR-only bands -> columns:\",\n", - " [c for c in out.columns if c.endswith((\"_obs\", \"_err\")) or c == \"flag_observed\"])\n", - "print(\"detected:\", int(out.flag_observed.sum()), \"/\", len(out))" + " [c for c in out.columns if c.endswith((\"_obs\", \"_err\")) or c.endswith(\"flag_observed\")])\n", + "print(\"detected:\", int(out.roman_flag_observed.sum()), \"/\", len(out))" ] }, { "cell_type": "markdown", - "id": "4eae6753", + "id": "ef8fcedd", "metadata": {}, "source": [ "## Phase 3 — multi-band / multi-survey isochrone (exactly `nstars`)\n", @@ -283,13 +275,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "cdcb361c", + "id": "2798a8c1", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:33:57.250040Z", - "iopub.status.busy": "2026-06-15T23:33:57.249928Z", - "iopub.status.idle": "2026-06-15T23:33:59.883954Z", - "shell.execute_reply": "2026-06-15T23:33:59.883368Z" + "iopub.execute_input": "2026-06-16T18:01:25.756657Z", + "iopub.status.busy": "2026-06-16T18:01:25.756551Z", + "iopub.status.idle": "2026-06-16T18:01:25.823450Z", + "shell.execute_reply": "2026-06-16T18:01:25.822899Z" } }, "outputs": [ @@ -319,7 +311,7 @@ }, { "cell_type": "markdown", - "id": "e414d472", + "id": "4bc79636", "metadata": {}, "source": [ "Now the multi-survey scene. One mass draw feeds both surveys, so a star's\n", @@ -329,13 +321,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "dbc7de53", + "id": "95a245ed", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:33:59.885548Z", - "iopub.status.busy": "2026-06-15T23:33:59.885425Z", - "iopub.status.idle": "2026-06-15T23:34:00.223968Z", - "shell.execute_reply": "2026-06-15T23:34:00.223395Z" + "iopub.execute_input": "2026-06-16T18:01:25.824533Z", + "iopub.status.busy": "2026-06-16T18:01:25.824423Z", + "iopub.status.idle": "2026-06-16T18:01:28.378539Z", + "shell.execute_reply": "2026-06-16T18:01:28.377918Z" } }, "outputs": [ @@ -345,12 +337,12 @@ "text": [ "multi-survey true columns: ['lsst_g_true', 'lsst_r_true', 'roman_F106_true', 'roman_F158_true']\n", "rows: 4000\n", - "corr(lsst_r, roman_F158) = 0.996 (shared masses => tightly correlated)\n" + "corr(lsst_r, roman_F158) = 0.995 (shared masses => tightly correlated)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -382,7 +374,7 @@ }, { "cell_type": "markdown", - "id": "2f39058a", + "id": "637766d8", "metadata": {}, "source": [ "Roman isochrone magnitudes are **always** converted Vega→AB (no config\n", @@ -394,13 +386,13 @@ { "cell_type": "code", "execution_count": 7, - "id": "5468d5aa", + "id": "57c4f2c5", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:34:00.225519Z", - "iopub.status.busy": "2026-06-15T23:34:00.225397Z", - "iopub.status.idle": "2026-06-15T23:34:00.266916Z", - "shell.execute_reply": "2026-06-15T23:34:00.266455Z" + "iopub.execute_input": "2026-06-16T18:01:28.379807Z", + "iopub.status.busy": "2026-06-16T18:01:28.379696Z", + "iopub.status.idle": "2026-06-16T18:01:28.421767Z", + "shell.execute_reply": "2026-06-16T18:01:28.421196Z" } }, "outputs": [ @@ -437,26 +429,27 @@ }, { "cell_type": "markdown", - "id": "82017106", + "id": "10f3ebee", "metadata": {}, "source": [ - "## Phase 4 — `MultiSurveyInjector`\n", + "## Phase 4 — one `StreamInjector`, many surveys\n", "\n", - "One orchestrator, one shared sky placement and shared masses, then per-survey\n", - "observed columns and flags. Per-survey RNGs come from `rng.spawn(...)`, so the\n", - "result is reproducible and independent of survey order.\n" + "The same `StreamInjector` class accepts a `{namespace: survey}` mapping. It does\n", + "one shared sky placement and one shared mass draw, then a per-survey loop writing\n", + "each survey's observed columns and flags. Per-survey RNGs come from\n", + "`rng.spawn(...)`, so the result is reproducible and independent of survey order.\n" ] }, { "cell_type": "code", "execution_count": 8, - "id": "9b63b52a", + "id": "3bf8c97b", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:34:00.268030Z", - "iopub.status.busy": "2026-06-15T23:34:00.267909Z", - "iopub.status.idle": "2026-06-15T23:34:00.376660Z", - "shell.execute_reply": "2026-06-15T23:34:00.376201Z" + "iopub.execute_input": "2026-06-16T18:01:28.422876Z", + "iopub.status.busy": "2026-06-16T18:01:28.422759Z", + "iopub.status.idle": "2026-06-16T18:01:28.500974Z", + "shell.execute_reply": "2026-06-16T18:01:28.500442Z" } }, "outputs": [ @@ -469,16 +462,15 @@ " roman: ['roman_F106_err', 'roman_F106_obs', 'roman_F106_true', 'roman_F158_err', 'roman_F158_obs', 'roman_F158_true', 'roman_flag_observed']\n", "\n", "shared sky placement: ra/dec present = True\n", - "lsst detected: 1066 / 4000\n", - "roman detected: 3110 / 4000\n" + "lsst detected: 1105 / 4000\n", + "roman detected: 3113 / 4000\n" ] } ], "source": [ "lsst_sv = StubSurvey(\"lsst\", [\"g\", \"r\"], completeness_band=\"r\", maglim=26.0)\n", "roman_sv = StubSurvey(\"roman\", [\"F106\", \"F158\"], completeness_band=\"F158\", maglim=27.0)\n", - "msi = MultiSurveyInjector({\"lsst\": StreamInjector(lsst_sv),\n", - " \"roman\": StreamInjector(roman_sv)}, primary=\"lsst\")\n", + "msi = StreamInjector({\"lsst\": lsst_sv, \"roman\": roman_sv}, primary=\"lsst\")\n", "\n", "# Input carries only stream coordinates; everything else is sampled once.\n", "N = 4000\n", @@ -497,13 +489,13 @@ { "cell_type": "code", "execution_count": 9, - "id": "5aabf327", + "id": "4a4c2ff4", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:34:00.377871Z", - "iopub.status.busy": "2026-06-15T23:34:00.377760Z", - "iopub.status.idle": "2026-06-15T23:34:00.445055Z", - "shell.execute_reply": "2026-06-15T23:34:00.444545Z" + "iopub.execute_input": "2026-06-16T18:01:28.502120Z", + "iopub.status.busy": "2026-06-16T18:01:28.502001Z", + "iopub.status.idle": "2026-06-16T18:01:28.568555Z", + "shell.execute_reply": "2026-06-16T18:01:28.568019Z" } }, "outputs": [ @@ -531,19 +523,19 @@ { "cell_type": "code", "execution_count": 10, - "id": "171f7526", + "id": "e154bc4b", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T23:34:00.446054Z", - "iopub.status.busy": "2026-06-15T23:34:00.445937Z", - "iopub.status.idle": "2026-06-15T23:34:00.516601Z", - "shell.execute_reply": "2026-06-15T23:34:00.516250Z" + "iopub.execute_input": "2026-06-16T18:01:28.569657Z", + "iopub.status.busy": "2026-06-16T18:01:28.569543Z", + "iopub.status.idle": "2026-06-16T18:01:28.640101Z", + "shell.execute_reply": "2026-06-16T18:01:28.639713Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAGGCAYAAADrfDCjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbvFJREFUeJzt3Qd8U1X7B/Cn6W5pyy6UUfYeIktAQJSh4Na/KCpDUBAXoIIoioCKCwRfX+D1VVGcKEtxsIfI3siQvSmUFujeuf/P75SbN0lbaNrs/L6fT5rk5ubm5N6b5Ok55znHT9M0TYiIiIjIZxhcXQAiIiIici4GgEREREQ+hgEgERERkY9hAEhERETkYxgAEhEREfkYBoBEREREPoYBIBEREZGPYQBIRERE5GMYABIRERH5GAaA5BBffvml+Pn5mS4BAQFSvXp1GTRokJw9e7bAetu2bfPYI7FixQrT+0xISHB1cciF3nzzTXUeOMqGDRvUa1y5cqXAY7fccou6uMLOnTula9euEhUVpd7/tGnTXFIOEvnuu+9Kvf9deS6R8wQ48bXIB82ePVsaNWokGRkZ8ueff8rkyZNl7dq18vfff0t4eLh4utTUVHnyySclJiZGzp075+rikJdDADhhwgQZOHCglC1b1uKxGTNmuKxcTzzxhKSlpckPP/wg5cqVk1q1armsLL4OAeDevXtlxIgRri4KuTkGgORQzZo1kzZt2qjb3bp1k7y8PJk0aZIsWrRIHn30UY/f+6+88or6wevTp4+89dZb4gkQjIeGhrrktdPT0yUsLMwlr+3tmjRp4rLXRsCBf4TuuOOO6557ISEhDq0lJaLiYRMwOdVNN92krk+ePGmxPCUlRZ5++mmpWLGiVKhQQe6///4CNWpz586Vnj17StWqVVUA07hxYxWAoebB3LFjx+Thhx9WtXLBwcESHR0tt912m+zatavA9jp06KBqIsuUKSO9evVSTVnFtW7dOvn000/ls88+E39/fyktNLkgYMZ2sZ/wHqtVqyavv/66CpzNZWdnq4ATtat4j5UqVVLN6xcvXrRYDzUxd955pyxYsEBatWqlfnxRg1SUn376Sdq3b6+a8hCo1alTR9XuWDfZnzhxwuJ5a9asUctxbf1+UPPbsWNHtT1s695775XY2FgxGo0FXh+vfeONN5rua5qmarZuuOEGtT8QbD/44IPqGOvwDwW6GJw+fbrA9vB6OJ8yMzOLfM/OOF+K+9zNmzfLXXfdpcqMY1W3bl1TTQ6afl9++WV1u3bt2qZuB/o+L6zZ7tKlSzJ8+HB1HgUFBanj+dprr0lWVpbFetjOs88+K19//bX6XOFYtWzZUn799ddrvi/9fMjNzZWZM2eaymT+2LJly9RxwDmK7eK1cezff/990/lbuXJl6d+/v5w5c8Zi+/o5tHHjRnUO4RzAOY2WBfjtt9/U+YLtNm/eXJYsWVKs43Hq1Cl57LHH1Ovi9fGep0yZYnFO4hxH+T/88EOZOnWq2uc4djiOmzZtKrBNdGO5++67pXz58urY4fP2448/Fqs82CcTJ05U5cBzcfzxDzNqfHX//ve/pUuXLqrMOI/wfrEPc3JyLPYX9gm+X8274Ojw2cdnDGWMjIxU++7zzz9Xn7PrKe65hO4JgwcPVq+B/YV/jvEZQzlwDpMb0YgcYPbs2fhG0bZu3WqxfPr06Wr5p59+arFenTp1tOeee05bunSp9tlnn2nlypXTunXrZvHcSZMmaR999JH222+/aWvWrNFmzZql1a5du8B6DRs21OrVq6d9/fXX2tq1a7X58+drL774orZ69WrTOm+//bbm5+enPfHEE9qvv/6qLViwQOvQoYMWHh6u7du377rvLz09Xatfv7728ssvq/vjx49X7+PixYsW6+E1sRyPX0/Xrl21ChUqaDExMdrHH3+s9sXzzz+vnv/MM8+Y1svLy9Nuv/12VdYJEyZoy5cvV/usWrVqWpMmTVTZdLGxsVrVqlXV/v3iiy9UebZs2VLo62/YsEHtk4cfflj7/ffftVWrVqnj8/jjj5vW0Y/X8ePHC32f5vsY76d8+fJajRo1tH/961/qMRyPn3/+Wa2Lcps7cOCAWo73rnvyySe1wMBAdfyWLFmifffdd1qjRo206Oho7fz582qdCxcuaMHBwdprr71msb3ExEQtNDTUdIyKYs/zRT8PzBX3uXh/eK8tWrTQvvzyS7X/ccxwPOD06dPqM4LtYxsbN25Ul6SkJNP+xkWXkZGhtoXX+fDDD7Vly5Zpr7/+uhYQEKD17t3boozYZq1atbR27dppP/74ozr+t9xyi1r36NGjRe67+Ph4VQY8/8EHHzSVyfxcwXn51FNPaX/88Yc2b948LTc3V93HY88++6x63/gsV6pUSZ0r5p8h/TOBY/T555+rz8Sdd96pnotzv3nz5tr333+vynvTTTep8+Ds2bPXPN4oM8qE18Pr4vVRDmzz6aefNq2Hc1zfL/i8LVq0SF3wmvh+unLlimldHKugoCCtc+fO2ty5c9U2Bw4cqJ6P/XAtOTk56jsM+/qll15S7+WXX37RXn31VfXedCNHjtRmzpypto3Xw3dhxYoVtUGDBpnWwfnUqVMnrUqVKqZjoR8PQJmwH/HZwwXfqfiMYF+aK+m5hO+mm2++WQsJCdHeffddtR62je/K4n4PkvMwACSH0L/8N23apL7gUlJS1I8fvnQjIiJMP976esOHD7d4/vvvv6+Wx8XFFbp9o9GotosfbKy3e/dutTwhIUHdnzZtWpFlO3XqlPriwo+pOZQRX5wPPfTQdd8fAgQEVXqwVVQAiEDV39+/wBdsYfCFi20gQDKHIMhgMGgnT55U9/GjgPUQqJhDsI3lM2bMsAgA8foHDx687uvjix3PN/9hs2ZrAIhlK1eutFgXxw0BXL9+/SyWjx49Wv2I4hiCHlhMmTLFYj0EQvjRwvq6AQMGaJUrV9aysrJMy9577z2136zLas7e54t1AGjLc+vWrasu+LEtygcffFDo/i/sRxvBDdZFQGcO+wXL8eOsw30ck+TkZNMyfEax/yZPnlxkecyfb/5Pivm50r9//0IDfevP/ObNm9VyBD7m7wnLtm3bZhHY45zGOWAe7O3atavAPxCFeeWVV9R6eD1zCP4QqOufFT0ARMCHoFWHf6Cw3Dw4wz8lrVq1Uue2OQSr+AcMgVFR5syZo7b33//+VysubA+vhediX1y6dMn0WJ8+fdTnvrjbmDhxogqy8Z1a2nMJ/5zjPgJVcziHGAC6HzYBk0OhKTMwMFAiIiJUU2SVKlXkjz/+UM1s5tB0Yq5FixYFmorRjNCvXz+1DTS5YrvIPIQDBw6oazQ7oNnsgw8+UM02aGazbmpcunSparJCkxOu9QuaXrA982bMwmzZskVl2f3nP/+5bl86bA/bfuONN4q1v7CfrPcF3jPeA5pSAc1ySABAU6F5+dFMin1jXX7sywYNGpjuoznZ/Hn6/mnbtq26fuihh1TTlXm2dkmhyfbWW2+1WIbmWjS/oVk6KSnJVCY0P95zzz2q+Ut/n2g2wrrm5cV7RPOk+ft84YUXJD4+XjVhA94TmiTR/HSthARHny/Ffe6hQ4fk6NGjqukMj9nDqlWrVFMhmszNIYEEVq5cabEcTY44/3T4jKK50bq7hq0eeOABi/urV6+2KIeuXbt2qgnUulzo8tG6dWuLY4Zy4XxHs70Oz4XrlRf7Bf0l8XrmUB7EsnjcHM4h8y4e1t9NR44ckX/++cfUp9n8OPfu3Vvi4uLk4MGDRZYH34c45uZdLQqDcxPfDfh86N9/OK/w2cH5Uxx4b927d1ddPPRt4LspMTFRfX5Key4hwU//DjH3yCOPFKt85FwMAMmh5syZI1u3blVfXujTt2fPHunUqVOB9fQffR365eidxvVs286dO6s+Uuj7hh9ObBdBhPl6CBjwZYQ+Vugfgz4u6Hv0/PPPq36GcOHCBVPAgy9A8wv6al1vKBd8UaOPIpJb0N8FF72PWXJysul1SsI6MAYEPIAvab38eE30w7Eu//nz5wuUHz+g5tC/zfw5+g8P+hchOUcPWDBsD/pfff/99yV+P9avrcNrYp8ha1QPlPBDiX6MOrxP/CBjn1i/T/TBMn+f6G+F8wP9pPTgEX240K/tWhx9vhT3uXrfTexze8H5gnPHOuECwROCcP18KuozqH8O9c+Wvc4B/XULOzcQ0FmXCwGfNZz71suxDK7V31N//aJe27x8xf1u0o/xSy+9VOAYo88cXOscwbHHaxsMhmv2WcT5jX/Kpk+frvoJ4/tPP9+Lc4zwjyv6UMN///tfWb9+vdoG+vFdbxvFPZdwjfvWx6aw7zVyPWYBk0Phv3I9C7g08B8oAkgEfnqtHxQ2HhoSDNCxGfCfMWqz0PkYiROzZs1SiSYwb948ta6t9u3bpy56bZM51Cahdso6gaC49B8TcwjqzH+I9ESZojq8m9figPWXNmouzYNUfX8AauBwQcduBFkYtgc1kKhFQ+d3vXbKuuN3UT9wRWV76jUw6Mw/dOhQdY0fQf0HSi8Xno8fO/1H15z1MgRt//d//yc7duyQTz75RNV69ujRQ67HkedLcZ+LoBOskyBKA+cI/mFCEG1+HFDTgyDf/Lg7kvU5oJ/HCPitA158xh1dLrw+XtuannRm6+vr648dO1b9Y1iYhg0bXvPY//XXX6rmuaggEP+YIdkN//Can0e2fM/gny0EpfjnyLyWGdu217mE9XAfCSPmQaD+HUbuhQEgeQT9S8f6Rx/BzLUgCBg3bpzMnz9fBQaA2h78l4omN+vmqeLQm7DMIePxq6++Ul+myJIrKQRmv/zyi0UzMMb1wg8DaugATen4MkfTDzL6bHWtHyMd9jMCbTQ1o3YONbgIAPXmVNTkmm8HZbYVavuQ+Y0fv8WLF8uoUaMsmtrwPt99911V62HdpFSY++67T2rWrCkvvviiaor66KOPbB5uxN7nS3Gfi9fFPw9ffPGF2g+FBbyF1T5dC2p6EczinMS+Ma+V1x93Bb1LwDfffGPqdgCojUJXDr1GylHwvvGPDY6vecY59gvOFzSF2wKfg/r168vu3bvlnXfesbk8GDoHtez4DimqGbiw7z8EY6jJK26trT4gv/lnDOuh64W9ziV8Z6AmHbXb+Gzr9Jp+ci8MAMkjYAgI9CcbNmyYjB8/Xv0n++2336ovXXMITNDsh5ogfCmjWQi1h1iOIWMAQQyGXMAPDfoV3n777WrbqH1DMwn6ulxrqJTCRsjX+3Khedu8BgGBCL4c0c+mOP0A8R80vjjR5IOg4Pfff1df8liG4AYwZAneO/oXoe8batKwP1B7hOAUNXjmX9LFhfJhGygvamZQu4rmJvO+lvjBxg8emrvwnz7228KFC1UQZyv0C0Kwg2vUKFr3CcO+fOqpp1SgiCE2EADj2KD2Bq+HYTDMf2Tww/bMM8/ImDFj1HrW2yuMo88XW56L5jz060S/2ZEjR6rjjfMAATiON+A9A47LgAED1LHB8bCu9QU042ObWA/N4Xgu9huCFJw76AvmCigvjuu//vUv9Y8NAiCUD8Md1ahRQ713R8L2Ebigbx+ODWrUMHQKhhvC+WTeX7a48I8o3gcCfpx3+CcQtWAIaBFoFtZaoMP5jxpwfLehryACUNQGosYNLSj4vKMmG+cm1h09erRq5kYf18uXLxfYHo4zagrxOPpOYh+jFQbvF/1cUaOP/Y/mWgxxU9Q/GyU5l3B+43OLf8LQHQavjyF89EDxWs3c5AKuzkIh3xoGprjrFZZVimFKMHxGWFiYyiYeMmSItmPHDouhFjAkCIY6QFYehiwoU6aMGr4AQyaYZ/IBhnTA8AuRkZFq+AhkzmEoixUrVtj8fu01DEzTpk1V5nCbNm1UmZBBiKxI6+xC3EfWbsuWLdWQC3ifeM9Dhw7VDh8+bFoP7wlZgcWBLO077rhDDZGBbFxk1WKIh3Xr1lmsd+jQIa1nz55qv+E4IMNVz/6zzgLG+7kWZALjeRi6oigYCqV9+/bqeCLzE5myyCw1zwzVnThxQm1v2LBhxXrP9j5fChsGprjP1TOfcQyioqLUenivGP7D3NixY9VQQcjQNd/n1pmbesYs9gXOI2Qj43Xx/MzMzOtm8QLWR4Z1abKAC/sOQAYqMkgbNGighr7BcCaPPfaYyvA2V9Q5VNR5XdT7sIaMepx7yH7F62OYGWRYm2fr6lnAWF7Y61h/pjESAbK68bnBNpHlfeutt6oM2utB5vcbb7yhhkvBZw/lwnPxnadbvHix6fOOzyiGN8LQOtafO2QE49wqW7asymo2Px/xWcJ7xbmFUQyQnYthYawzy0tzLuH1MTQNXh/f1T169FCjQeA1MAwYuQ8//HFF4ElEBWsW0ZcOsypQyaBWCX0BsQ+bNm3K3UjkBtCNBVnSSDxBaw65BzYBE5HHQx/F48ePqyY9NIEz+CNyDfRnRL9dNBOjyRfJZBhmCV04GPy5FwaAROTx0OcRmYYYKgOZu0TkGuiPiqQPDNeFzGUMuYN+kZ4yV7ovYRMwERERkY9hSg4RERGRj2EASERERORjGAASERER+RifSwLBAJuY8gcdVW2dJYCIiIjIXWFkP8wodb35pX0yAETwh9HmiYiIiLzR6dOnC8y1Lb4eAOpTJmHnREZGuro4RERERHaBKfhQyVXY9JDi6wGg3uyL4I8BIBEREXmb4nRxYxIIERERkY9hAEhERETkYxgAEhEREfkYBoBEREREPoYBIBEREZGPYQBIRERE5GMYABIRERH5GJcGgH/++afcddddasoSjFmzaNGi6z5n7dq10rp1awkJCZE6derIrFmznFJWIiIiIm/h0gAwLS1NWrZsKZ988kmx1j9+/Lj07t1bOnfuLDt37pRXX31Vnn/+eZk/f764m7OHTsiWBcvUNbfH/cdzhZ8Ne30X5Jw/L2mbNqtrd9qWI7ZHRA6kuQkUZeHChddcZ/To0VqjRo0slg0dOlS76aabiv06SUlJ6rVw7ShL3/+PtrdhY21/w0bqGve5Pe4/niv8bJT2u+DyTz9p+xs3Ud8tuMZ9d9iWI7ZHRLazJcbxwx9xA2gCXrhwodx7771FrtOlSxdp1aqVTJ8+3bQMz3nooYckPT1dAgMDCzwnKytLXaznyUtKSnLIVHD4L//K3b3FIP/brbh1tkINMQYULN/1GHJzpFriaTGf1IXb8479585l4/Yct/9Sa9SRkLAQCfI3SKC/nxgM15+yST03O1uyDvxTYHlw40biFxRkU9nsua0it2cwSL1VKyWwShWbt0dEJYMYJyoqqlgxjkfNBXz+/HmJjo62WIb7ubm5kpCQIFWrVi3wnMmTJ8uECROcVsazew9JhFnwB/h6r5542m6vwe157/5z57Jxe/bZfxGnj6nb+JbItsM2Cwvk3GFbYjTKyQEDpOx990lEz14SXKe2/bZNRKXmUQFgYRMc6xWYRU18PHbsWBk1alSBGkBHqdasgVwRP4saQKP4ydkhIyWsUkWbt5d+MUGqffYRt+eF+8+dy8btOW7//dxjoFw0hMrl9GzJyM4r1rYC/Q1S1S9TBq7/rsD2wse9IRViLP8xvp7cy5fl/Lhx+AL930KDQapMmiQB5crZtK0it4c+gSdPycVp09UluH59iejZUyJ69VS3izNZPRE5jkcFgFWqVFG1gObi4+MlICBAKlSoUOhzgoOD1cVZqjWoJfsGj5CYL6aJv6ZJnp+fnHtihPR86ckSb3OZpnF7Xrr/3Lls3J5j9t+rLz9lejwtK1fOJ2fK+aRMiUvKlAvJuM4w3cd1Ytr/6gmTbsiW53fPM23v45YPSmZ2bbm/XHXpWK+CVI4IKXbZ/DSjxL0xXtXUIfirOnGClH3g/hK/V+vtVR4zRvzDwyR52TJJ27hJsg4fVpeEf/9bgmrXVoFgZM+eEty4MYNBIhfwqD6AY8aMkcWLF8v+/ftNy55++mnZtWuXbNy40e7t46XtC3hu32GJaVpfBYXcHvcfzxV+NkryXZCVmyfxyVmy92ySDP92h1TIuCJVUxMkrkxFSQgta7Fug+gy0qleRbm5XkVpX6eClAm+9v/4yNbNPnlKgmJr2qWvXlHby0tKkpTVqyVl6TJJW79e9RnUBdaoIZG9eqrawZDmzRkMEpWCLTGOSwPA1NRUOXLkiLqN5I6pU6dKt27dpHz58lKzZk3VfHv27FmZM2eOaRiYZs2aydChQ+XJJ59UQd+wYcPk+++/lwceeMCtAkAiInubu/WUvLpgr+RpmiB3ZFCn2hLg7ycbjiTK3nNJFi2wAQY/uaFGWRUQ4oLbQQGuH/s/LzVVUteslZSlSyV13TrRMjNNjwXEVJXIHvnNxKE33CC58fGSfeKkBNWKZTIJkTcFgGvWrFEBn7UBAwbIl19+KQMHDpQTJ06o9cwHgh45cqTs27dPDSCNWkEEgcXFAJCIPBmaiE8kpEutimFSNSrUtPxyWrZsPJYofx1JkPVHEuRkYrrF88KC/KV97fL5NYT1K0rD6AjV/Hw8IU1qVwy32JazGNPTJfXPdZKybKmkrFkrWvr/ymyIiBBjSkr+HT8/qfzKK1L+8cfEz+D6IJbIXXlMAOgKDACJyBecvpSuAkEEhBuOJsols76EUCbYX1Kz8pNQUJs4+f7m0rdtTReVVsSYmamah5OXLpWUFSstgkETf38JqFBB/CtWkICKFSWgQsX860oVxb8CllWSgKuPGSIjCzQnqyZq1iiSF0tmAGifnUNE5A2MRk3+OZ9iCgg3H0uUzFyjxTr+fn7y1yvdXFITaC31r7/k9JCSJ9+AX2Cg+KsgMT8gzEtJlowdO/MzlfWklwcftFuZidyB144DSEREtsNg001iItXlyS51ZO2heBnwxVaLddCvEE3L7hAABterp4I0lVGsMxik1twfRPwMkpeYILkJuCRevb4oefrtxEQxJieLlpMjuXFx6lKAMT9jOfzmm9m3kHwWA0AiIh/TIDpCNfsaNcsaQPQrdAfIIEYNnfUwNaHNmxfr+casLMlL1IPDREnbskUuf/ml1UpGlbHMmUrIVzEAJCLyMajlQ5+/sQv+NgWBk+5t6ha1fzo0z6KGriTD1BiCg8UQEyOBMTHqfkiTxnIZo0mY1ygi0KzpuEkBiNwd06mIiHwQEj7+HN1NzUcMHeraPtuJoyHoC2/frtS1dHqNompWNpOxbXspS0jkuRgAEhH5qOrlwlRzMBy+cHXIFS+FGsV6q1ZKza++knKDBqpl5ydNkpwL8a4uGpFLMAAkIvJh9SuXUdeH41PF2+k1itGjRklIs2YqWSRu3DjTnPJEvoQBIBGRD6t/tQbwiA8EgOZDxMS8O1n8goIkbd06ufLTT64uEpHTMQAkIvJh9Uw1gN7dBFzYUDOVRoxQt+PffU+yz5xxdZGInIoBIBGRD9ObgFEDiAGjfUn5Af0ltE1rNSVd3NhXRbPKEibyZgwAiYh8WM3yYRLkb5DMHKOcvZIhvsTP319i3nlH/MLCJH3rVrn89deuLhKR0zAAJCLyYQH+BqlTKdwnm4EhqGZNiR79srodP/UjyTp2zNVFInIKBoBERD7O1A/wgu8kgpgr27evhHfqJFpWlpx7ZaxoubmuLhKRwzEAJCLycfUrXx0L0Icygc35+flJ1bffEkNEhGTu2SOJn33m6iIRORwDQCIiH1c/2nfGArzWGIFVXh+nbl/89wzJPHDA1UUicigGgEREPs6UCXwhxacHRY686y6J6NFdJCdHzo15RYzZ2a4uEpHDMAAkIvJxsRXCJcDgJ2nZeRKXlCm+Ck3BVd58U/zLl5esQ4ck4ZN/u7pIRA7DAJCIyMcFBRikVkU9E9h3m4EhoEIFqfLmeHUbfQHTd+50dZGIHIIBIBER/W9O4Au+NxSMtciePSXy7rtEjEaJe2WsGDN8a3xE8g0MAImIyGJGEBKp8tprEhAdLdknT6rxAYm8DQNAIiKSetG+PRSMNf+oKKn61lvqNmYISdu0ydVFIrIrBoBERGTRBOzLmcDmynS+WQ0SDedefVXyUhkck/dgAEhERFK7YrgY/ESSM3PlYkoW98hVmCYusHp1yT0XJxfefZf7hbwGA0AiIpKQQH81HAywGdjsRzI8XGImv4MxYiRp3nxJWbOGZwt5BQaARERkNScwM4HNhbVtK+UHDFC3415/XXIvX+YZQx6PASAREVn2A2QiSAGVRo6QoLp1Je9iglyYlJ8cQuTJGAASEZHCOYGv8WMZHCwx704W8feX5N9/l+Q//uBZQx6NASARESn1K+cPBcOxAAsX2ry5VBz6lLp9/s0JknvxIs8c8lgMAImISKlbqQxyHeRSWrYkpjITuDAVhw2T4CaNJS8pSc6+PFpSN22SnPPneQaRx2EASERESmiQv1QvF6pusx9g4fyCgiQGw8H4+0v6pk1yeuAgOXLrbXJl3jyeReRRGAASEVGBZmAGgEXzj4xU8wSbYM7gN8azJpA8CgNAIiIqOCcwh4IpUvaJkyLWs6UYjZJ98hTPJPIYDACJiKjgWIAcCqZIQbViRQxWP58GgwTF1uSZRB6DASAREZnUj2YT8PUEVqkiVSdOsAgCo19/XS0n8hQMAImIqEANIOYDvpKezT1ThLIPPih1V64QQ/ny6n5gdGXuK/IoDACJiMikTHCAxESFqNscD/DagqpWlbJ33alupyxdyrOIPAoDQCIislCPzcDFFtGrl7pOWbVajNmsMSXPwQCQiIgKnxP4Qir3zHWE3nCDBFSqJMaUFEnfuJH7izwGA0AiIio8AIxP4Z65Dj+DQSJ69lS3k5cu4/4ij8EAkIiILNSPvjoWIIeCKZaIXvkBYMrKlaLl5PBsIo/AAJCIiCzUq5Q/FExcUqakZDKguZ6w1q3Fv0IFMSYlSdqmzTybyCMwACQiIgtRYYFSOSJY3WYt4PX5+ftLRI/u6nbKMmYDk2dgAEhEREU2A3NGkOKJ1LOBl68QLTeXZxS5PQaARERUQP3K+c3ArAEsnrC2bcW/bFnJu3JF0rdu5RlFbs/lAeCMGTOkdu3aEhISIq1bt5Z169Zdc/1vv/1WWrZsKWFhYVK1alUZNGiQJCYmOq28REQ+NSfwBWYCF4dfQICpGTiZg0KTB3BpADh37lwZMWKEvPbaa7Jz507p3Lmz3HHHHXLq1KlC1//rr7+kf//+MnjwYNm3b5/89NNPsnXrVhkyZIjTy05E5BtDwXAswOKK6HX7/5qB8/IcdmyIPD4AnDp1qgrmEMA1btxYpk2bJjVq1JCZM2cWuv6mTZukVq1a8vzzz6taw5tvvlmGDh0q27Ztc3rZiYi8Wf2rs4GcuZwh6dns01Yc4e3biSEqSvISEyV9+3YHHyEiDw0As7OzZfv27dLz6gCaOtzfsGFDoc/p2LGjnDlzRn7//XfRNE0uXLgg8+bNkz59+jip1EREvqF8eJBUCA9St9kPsHj8AgMl4rbb1O0UDgpNbs5lAWBCQoLk5eVJdHS0xXLcP3/+fJEBIPoA9u3bV4KCgqRKlSpStmxZ+de//lXk62RlZUlycrLFhYiIbOkHyGbg4orUB4Vetkw0o5GnGbktlyeB+Pn5WdxHzZ71Mt3+/ftV8+8bb7yhag+XLFkix48fl2HDhhW5/cmTJ0tUVJTpgiZmIiK6Pg4FY7uwDh3EEBEhuRcvSsauXTzNyG25LACsWLGi+Pv7F6jti4+PL1AraB7MderUSV5++WVp0aKF9OrVS2URf/HFFxIXF1foc8aOHStJSUmmy+nTpx3yfoiIvHcoGGYCF5chKEgibu2mbqcwG5jcmMsCQDThYtiX5cuXWyzHfTT1FiY9PV0MBssiI4jUaw4LExwcLJGRkRYXIiK6PmYCl0zE1UGhk5eyGZjcl0ubgEeNGiWfffaZqsE7cOCAjBw5Ug0BozfpovYOw77o7rrrLlmwYIHKEj527JisX79eNQm3a9dOYmJiXPhOiIi8T72rs4GcupQumTkc1qS4wjt1EkNYmOSePy+Ze/Y48AgRlVyAuBCSOTCI88SJE1UTbrNmzVSGb2xsrHocy8zHBBw4cKCkpKTIJ598Ii+++KJKALn11lvlvffec+G7ICLyTpXKBEtUaKAkZeTI0Yup0jQmytVF8giG4GAp062bJP/2m6oFDL3hBlcXiagAP62otlMvhSxgJIOgPyCbg4mIru3/Zm2QrScuy/SHb5B7bqjG3VXc35ply+Ts8y9IYEyM1F25osjkRiJXxTguzwImIiL3Ve9qIgiHgrFNmc6dxS80VHLOnZPMvfsccmyISoMBIBERFSMRhJnANv24hoZKma5d1e2UZUt5hpHbYQBIRERF4liApR8UWmUD+1ZvK/IADACJiOi6YwGeTEyXrFxmAtuiTJcu4hccLDmnTknWP//wLCO3wgCQiIiKFB0ZLBHBAZJn1OREQjr3lC0/sOHhKgiEZA4KTW6GASARERUJ2av6eIDsB1jyQaFTlixlMzC5FQaARERUvESQC6ncUzYqc0tX8QsKkuwTJyTr8GHuP3IbDACJiKiYcwIzALSVf5kyEn7zzaZaQCJ3wQCQiIiuiU3AdsoG5nAw5EYYABIRUbGagI8npElOnpF7y0aYFk4CAyX7yFHJOnKE+4/cAgNAIiK6ppioUAkL8pecPE0NB0O28Y+MlPCOHUxTxBG5AwaARER07R8Kg5/Uu1oLeIQzgpRIZM+r2cBLGQCSe2AASERE16UHgMwELpmI224VCQiQrIMHJev4cZ5x5HIMAImIqNiZwIeZCVwi/mXLSnj79up2yrLlPOPI5RgAEhFR8ccCZABYYhFXs4FTOCsIuQEGgEREdF31r84GcvRiqpoWjmwX0b07OlRK5v79kn36NHchuRQDQCIiuq7q5cIkOMAg2blGOX2JmcAlEVC+vIS1a6dupzAbmFyMASAREV2Xv8FP6lZiM3BpRd6enw2czGxgcjEGgEREZFMz8GEOBVO6ZmA/P8ncs0dyzp7lmUcuE2DrE/Ly8uTLL7+UlStXSnx8vBiNlqPCr1q1yp7lIyIiN0sEOXKBcwKXVEDFihLWpo2kb90qycuWS4VBA+14hIgcGAC+8MILKgDs06ePNGvWTPz8/GzdBBEReaB6HArGLiJ69VIBILKBGQCSxwSAP/zwg/z444/Su3dvx5SIiIjcugn4SHyqGI2amiGEbBfRo4dceOstydi1S3LOn5fAKlW4G8n9+wAGBQVJvXr1HFMaIiJyW7HlwyTQ308ycvLk7JUMVxfHYwVGV5bQG29UtzkoNHlMAPjiiy/K9OnTRdM4DhQRkS8J8DdInYr/qwWkkou8Oih08rKl3I3kGU3Af/31l6xevVr++OMPadq0qQQGBlo8vmDBAnuWj4iI3Ei96DJy8EKKygTu1qiyq4vj2c3Ak9+VjO07JCc+XgIrc1+SmweAZcuWlfvuu88xpSEiIs+YEo6ZwKUSGBMjIS1bSObuPZKyYoWU79fPPgeIyFEB4OzZs219ChEReYn6zAS2m8ievfIDwKXLGACS5wwEffHiRdUcvH79enWbiIh8KxOYfcFLJ+JqP0AMCZObmGiHo0PkwAAwLS1NnnjiCalatap06dJFOnfuLDExMTJ48GBJT+f8kERE3qxWhXA1LVxqVq6cT850dXE8WlD16hLStKmI0SgpK1a6ujjkY2wOAEeNGiVr166VxYsXy5UrV9Tl559/VsuQIUxERN4rKMAgtSqEqdvsB2ifQaEBg0ITuXUAOH/+fPn888/ljjvukMjISHXBoND//e9/Zd68eY4pJRERuQ32A7T/cDBpmzdL7uXLdtwykZ0DQDTzRkdHF1heuXJlNgETEflUP8AUVxfF4wXFxkpw48YieXmSupLNwOTGAWCHDh1k/Pjxkpn5v74fGRkZMmHCBPUYERF5t3ocCsYxg0IvXWbfDRPZcxgYzAJy++23S/Xq1aVly5bi5+cnu3btkpCQEFnKPgxERD7VBIxMYPwOUMlF9OwlF6dNl7QNGyRl5SoJadqE8wOT+wWAzZo1k8OHD8s333wj//zzj/rwP/zww/Loo49KaGioY0pJRERuo06lcDH4iSRl5MjF1CypHBHi6iJ5tOA6tSWgcmXJjY+XM888I2IwSNWJE6Tsgw+6umjkxWwOAAGB3pNPPmn/0hARkdsLCfSXmuXD5ERiuhy5kMoAsJRyzp+XXPPxdI1GiXtjvITffDNrAsm1AeAvv/yisn4x7y9uX8vdd99tr7IREZGbqlc5QgWAaAbuWK+iq4vj0bJPnBTRNMuFRqNknzzFAJBcGwDee++9cv78eZXpi9tFQT+QvLw8e5aPiIjcNBN4xYELcpiZwKUWVCtWNfsi6DMxGCQotmbpN05Umixgo9Gogj/9dlEXBn9ERL6hPjOB7SawShXV58/Ez0/dx3IitxkGZs6cOZKVlVVgeXZ2tnqMiIh8JxMYcwJT6SHho9LIkep2SIsWTAAh9wsABw0aJElJSQWWp6SkqMeIiMj71a0crq4T07IlMbVgpQDZLqJHD3WdtX+/GM3G2iVyiwCwqDGfzpw5I1FRUfYqFxERubGwoACpXi5/6C/WAtpHUO1aElCpkmg5OZKxa7edtkpUymFgWrVqpQI/XG677TYJCPjfU9H37/jx42qAaCIi8p1+gGcuZ6hM4PZ1Kri6OB4Pv69h7dtL8q+/SvqWzRJ+U3tXF4m8WLEDQD37F7N+9OrVS8qUyZ8LEoKCgqRWrVrywAMPOKaURETkdupHR8jqgxdZA2hHYe3aqgAwbfMWqWTPDROVNADE/L+AQA8zfwQHBxf3qURE5M1zAnMoGLsJb59f65exZ48YMzLEwBm2yF36ADZp0kTVAlrbvHmzbNu2zeYCzJgxQ2rXrq3mEm7durWsW7fumusjA/m1116T2NhYFYTWrVtXvvjiC5tfl4iISodDwdhfYM2aEoDhX9APcOdOB7wCUQkDwGeeeUZOnz5dYPnZs2fVY7aYO3eujBgxQgV0O3fulM6dO6sZR06dOlXkcx566CFZuXKlfP7553Lw4EH5/vvvpVGjRra+DSIislMNYHxKliSl53B/2qkfYHj7duo2moGJ3CYA3L9/v9x4442FJongMVtMnTpVBg8eLEOGDJHGjRvLtGnTpEaNGjJz5sxC11+yZImsXbtWfv/9d+nevbtqjm7Xrp107NjR1rdBRESlFBESKFWjQtTtIxdTuD/tJKxdfgCYvnkz9ym5TwCIZtcLFy4UWB4XF2eRGXw9GDh6+/bt0rNnT4vluL9hw4ZCn4N5iNu0aSPvv/++VKtWTRo0aCAvvfSSZGRk2Po2iIjInv0AL3BAaHtBJjBk7N0rxrQ0u22XqFQBYI8ePWTs2LEWg0FfuXJFXn31VfVYcSUkJKjhY6Kjoy2W4z7mHS7MsWPH5K+//pK9e/fKwoULVY3hvHnzrtn0jD6DycnJFhciIrLvjCAYCobsI6h6dQmMiRHJzZX0HewHSG4SAE6ZMkX1AUQSRrdu3dQFSRwI2vCYrawHlS5qoGnAfMN47Ntvv1VNv71791bNyF9++WWRtYCTJ09WA1TrFzQxExGRfdSPzq8BPHSBTcAOaQbewmZgcpMAEE2ve/bsUc2wyAhG5u706dPl77//tim4qlixovj7+xeo7YuPjy9QK6irWrWqen3zGUfQdxBBI2YiKYxeW6lfCktgISKikmlwNQDkbCCOaQZO28JEEHKM4nfaMxMeHi5PPfVUqV4Yg0cjeFy+fLncd999puW4f8899xT6nE6dOslPP/0kqamppoGoDx06JAaDQapXr15kn0WOWUhE5Bj1KuU3AcclZUpKZo5KDKHS0zOBM/fuk7zUNPEvkz/3MpFLA0BAxi+Ga0Eyh7m777672NsYNWqUPP744yqxo0OHDvLpp5+qbQ4bNsxUe4fhZebMmaPu9+vXTyZNmiSDBg2SCRMmqH6EL7/8sjzxxBMSysEyiYicLiosUCpHBKuhYFAL2KpmOR4FO0AfwMAaNSTn9GnJ2L5NynTtyv1Krg0AkYiBGjs0+aI/HppfQe+3h8SO4urbt68kJibKxIkTVRZxs2bN1BAv6F8IWGY+JiBq/VBD+Nxzz6mgsUKFCmpcwLfeesvWt0FERHbsB4gAEIkgDADtOy1c0unTqhmYASC5PAB84YUXVNLHihUrpE6dOrJlyxYVxL344ovy4Ycf2lyA4cOHq0thkNxhDYM+IwgkIiL3yQRefySR/QAdMC1c0vwFks4BockdAsCNGzfKqlWrpFKlSqrvHS4333yzyrZ9/vnn1YweRETki2MBMhPYEZnAmfv3S15KivhH5Pe3JHJJFjCaePUEDGTynjt3Tt1Gsy2mZiMiIh+dE5hjAdpVYJUqEhhbE2OgSfq2bfbdOPk8mwNA9NPDMDDQvn17NRzM+vXrVT8+NAkTEZFvqR+dXzN15nKGpGfnuro4XiW8Xf5wMGwGJpcHgOPGjVMDMgOSL06ePCmdO3dWyRsff/yx3QtIRETurXx4kFQID1K3j8Zz6jLHjAfIAaHJxX0Ae/XqZbqNGj8MB3Pp0iUpV65ckTN4EBGR9/cDTDx+SQ7Hp0jz6v8brJ9KnwkMWQf+kbykJPE3mwiByGk1gLm5uRIQEKDm4jVXvnx5Bn9ERD5MnxKO/QDtK7ByZQmqXRvzpLIfILkuAETwh2QPW8b6IyIi3xgKBg5fSHV1UbxO2NVZQdI2sxmYXNwHEDN0oNmXiIjIPBP4SDyHgnHEeIDARBByaR9AJHocOXJEYmJiVG0g5gU2t2PHDnuWj4iIPEC9q03AJxPT5URCmtSqyLlr7SWs7dV+gAcPSu7lyxJQjtPtkQsCwHvvvdcOL0tERN5k1YF4dY3JQbtNWSPv3t9c+rat6epieYWAihUlqF5dyT5yVNK3bpXInj1dXSTylQAQtX5PPfWUhISEyKBBg6R69epqBhAiIqK4pAx5deHfph2BKeJfXbBXujSoJFWjQrmD7DQeoAoAN29hAEh2UawobtSoUZKcnKxuYx7ghIQE+7w6ERF5vOMJaWJE1Z+ZPE2TEwnpriqS104Ll75li6uLQr5UA4j+fvPnz5fevXuLpmly5swZyczMLHTdmjVZ5U9E5EtqVwwXg59YBIH+fn5Sq2KYK4vllZnAWYcPS+6lSxJQvryri0S+UAOIzN8RI0aogZ8x2HPbtm1VTaD5pVatWuqaiIh8C5p5J9/fXMznAnjn/mZs/rUjJH4EN2igbrMWkJxWA4j+f4888oia9q1FixayYsUKqVChgl0KQEREng8JH+XCguSpr7dLdEQwE0Ac1AycdeiQCgAjb7/dES9BPqTYWcARERHSrFkzmT17tnTq1EmCg4MdWzIiIvIorWrmD08Sn5olWbl5Ehzg7+oieV0z8OVvvpG0zewHSKVncyrvgAEDGPwREVEBFcsESWigv8oCPns5g3vIzsIxHqCfn2QfPSq5Fy9y/1KpcCwXIiKyC/QRr1k+P/Hj1CVmANubf9myEtyokbqN8QCJSoMBIBER2U2NqwHgaQaADhHeLn9WEDYDU2kxACQiIrvRawBPswnYIcJM8wJvdswLkM9gAEhERHZTs3z+zB+nEtkE7Ahhbdrk9wM8cUJyLuRPv0fksCxgzARSXFOnTi1RQYiIyPPVrMA+gI7kHxkpIY0bS+b+/Wo4mKi77nTo65GPB4A7d+60uL99+3bJy8uThg0bqvuHDh0Sf39/ad26tWNKSUREntUEfCldzRyFxBCyfzNwfgC4mQEgOTYAXL16tUUNH8YE/Oqrr6Rcufwxny5fviyDBg2Szp07l7wkRETk8aqXyw8AU7Jy5Up6jpQLD3J1kbxyPMBLs2czEYSc2wdwypQpMnnyZFPwB7j91ltvqceIiMh3hQT6S3Rk/kQBHArGgf0ADQbJOXVKcuLiHPQq5O1sDgCTk5PlwoULBZbHx8dLSkqKvcpFREQeimMBOpZ/mTIS0rSpus15gclpAeB9992nmnvnzZsnZ86cURfcHjx4sNx///0lLggREXnXWICsAXSc8Pbt1DXHAySnBYCzZs2SPn36yGOPPSaxsbHq8uijj8odd9whM2bMKHFBiIjIO9S42g+Qg0E7YTzALZwXmByYBGIuLCxMBXoffPCBHD16VGV51atXT8LDw0tYBCIi8iZsAna80FY3ivj7S86ZM5Jz9qwEVqvmhFclb1LigaDj4uLUpUGDBir4QyBIRETEsQAdz79MuIQ2a6ZusxmYnBIAJiYmym233aYCv969e6sgEIYMGSIvvvhiiQpBRETeVwN47kqG5OQZXV0cr8VmYHJqADhy5EgJDAyUU6dOqeZgXd++fWXJkiWlKgwREXm+SmWCJTjAIEYtPwgkxwhrdzURZMtmtsKR4wPAZcuWyXvvvSfVq1e3WF6/fn05efKk7SUgIiKvYjD4MRPYCcJubCUSGCi55+JUX0AihwaAaWlpFjV/uoSEBAkOzh/8k4iIfBsTQRzPEBYmoc2bq9vMBiaHB4BdunSROXPmmO5jnkej0aiygrt162ZzAYiIyJvnBGYTsKOnhYO0zZsd+jrkfWweBgaB3i233CLbtm2T7OxsGT16tOzbt08uXbok69evd0wpiYjIIweD5liAjhXerp0kzpwl6Zu3qH6AqJQhckgNYJMmTWTPnj3Srl076dGjh2oSxgwgO3fulLp169q6OSIi8kJsAnaO0FatxA/9AC9ckBz2wydH1gAi+7dGjRoyYcKEQh+rWbOmrZskIiIvwwDQOQwhIRLasqWkb9smaVu2SFCtWk56ZfK5GsDatWvLxYsXCx0fEI8RERHVKB+qdkJSRo4kpedwhzhhOBg0AxM5LAAsqo9BamqqhISE2Lo5IiLyQmFBAVKxTP7IEKcvp7u6OD4xIDTHAySHNAGPGjVKXSP4e/311y2GgsnLy5PNmzfLDTfcYNOLExGR96pZPlQSUrPk1KV0aVYtytXF8VqhN7QUv6AgybuYINnHT0hwHbbGkR0DQCR56DWAf//9twQFBZkew+2WLVvKSy+9VNzNERGRD/QD3HHqigoAyXEMwcESesMNaizA9C2bGQCSfQPA1atXq+tBgwbJ9OnTJTIysrhPJSIiH6QPBcMA0DnjASIAxHiA5R5+2AmvSD7XB3DatGmSm5tbYDnGAUxOTrZXuYiIyMNxLEDnCb/aDzB9y1bOC0yOCQAffvhh+eGHHwos//HHH9VjREREwKFgnCekRQvxCwmRvMREyT56lCcg2T8ARLJHYVO+YXYQPGarGTNmqOFjkEHcunVrWbduXbGeh1lHAgICmHhCROTmAeDZyxmSm2d0dXG8miEoSEJb5Sdiclo4ckgAmJWVVWgTcE5OjmRk2Dbn49y5c2XEiBHy2muvqSSTzp07yx133KEGlL6WpKQk6d+/v9x22222Fp+IiJwkOjJEgvwNkmvUJC4pk/vdic3ARHYPANu2bSuffvppgeWzZs1SNXi2mDp1qgwePFiGDBkijRs3Vv0LMcvIzJkzr/m8oUOHSr9+/aRDhw62Fp+IiJzE3+An1cvlDwjNOYEdL6ydHgBuEc3IGley81Rwb7/9tnTv3l12795tqoFbuXKlbN26VZYtW1bs7WRnZ8v27dvllVdesVjes2dP2bBhQ5HPmz17thw9elS++eYbeeutt4pVY4mLjokqRETOTQQ5lpCmMoE7csc7VGizpuIXGip5ly9L1uEjEtKwAfc42a8GsFOnTrJx40apXr26SvxYvHix1KtXT/bs2aOacIsrISFBDSAdHR1tsRz3z58/X+hzDh8+rALGb7/9VvX/K47JkydLVFSU6YIaRiIicm4/QM4G4ngYDDrsxhtNtYBEdq0BBMz48d1334k9WE8rV9RUcwgW0ew7YcIEadCg+P/VjB071jSLiV4DyCCQiMjZmcC29RGnkk8Ll7Z+vRoQuvzjj3E3kn0DQDTBoin22LFjqt9e5cqVZcmSJSqwatq0abG2UbFiRfH39y9Q2xcfH1+gVhBSUlJk27ZtKlnk2WefVcuMRqMKGFEbiObnW2+9tcDzgoOD1YWIiJyPg0E7V3i7tnJRHw/QaBQ/g80NfeQjbD4z1q5dK82bN1dDvsyfP19SU1PVcjQBjx8/vtjbwfRxSBpZvny5xXLc79ixYE8RzDyCKeh27dplugwbNkwaNmyobre/mv1ERERu2ATM6eCcIqRpUzGEhUleUpJkHTzonBcl3wgA0QcPyRcI1MznA8bYgOgbaAs0zX722WfyxRdfyIEDB2TkyJFqCBgEdnrzLYZ7UQU1GKRZs2YWF9Q8YvxA3A4PD7f1rRARkYPVKJ+fBXwpLVtSMnO4vx3MLzBQQtvkj8jBfoBk1wAQtXD33XdfgeWVKlWSxMREm7bVt29f1YQ8ceJE1a/wzz//lN9//11iY2PV43FxcdcdE5CIiNxXREiglA/Pryw4zX6ATh0PMG0zE0HIjgFg2bJlVWBmDX3zqlWrZuvmZPjw4XLixAk1VAuGhenSpYvpsS+//FLWrFlT5HPffPNN1fxLRETui/0AnSusXTt1nb51q2h5eU5+dfLaABCZuGPGjFHJG8jWRSIGpmV76aWXTM21REREOvYDdK6Qxo3FUKaMGFNS5PJP8ySniKHVyLcZSjIQdM2aNVVtHxJAmjRpomrtkLgxbtw4x5SSiIg8Vo2rs4FgMGhyPL+AAAm82iJ34c035citt8mVefO466l0w8AEBgaqgZgnTZokO3bsUDWArVq1kvr169u6KSIi8qmxABkAOgNq/LIOHfrfAqNR4t4YL+E33yyBVao4pQzkhTWASNhIT0+XOnXqyIMPPigPPfSQCv4yMjLUY0RERObYBOxc2SdOYlYFy4VGo2SfZFIllSIAxEwc+th/5hAU4jEiIqLCkkDOXM6QPKNVYEJ2F1QrFmOnWS40GCQotib3NpU8ACxqqrbdu3dL+fLlbd0cERF5uapRIRJg8JPsPKNcSM50dXG8Hpp5q040q5AxGNR9Nv9SifoAlitXTgV+uGAuXvMgEPP0olZQH8CZiIjI9EPjb5Bq5ULlZGK66gcYUzY/KYQcp+yDD0rqX+slZckSKffYo+o+UYkCQAzYjNq/J554QjX1RkVFmR7DjCC1atWSDh06FHdzRETkY/0AEQBiSrib6lRwdXF8QlibNioAzGHfPypNADhgwAB1Xbt2benUqZMEBNicQExERD7eD5BzAjtPSNMm6jpj/z4nvip5bR/Arl27ysmTJ9WYf4888ojEx8er5UuWLJF9+3iSERFRQRwKxvlCGjVS/f/yLiZIztXfaqISB4Br166V5s2by+bNm2XBggWmjOA9e/bI+PHjbd0cERH5AAaAzmcIDZXgunXU7UxW0FBpA8BXXnlF3nrrLVm+fLnq+6fr1q2bbNy40dbNERGRTwWAGa4uik8JadJUXWfu2+/qopCnB4B///233HfffQWWV6pUSRITE+1VLiIi8sI+gAmpWZKenevq4vhcP8DM/QwAqZQBYNmyZSUuLq7A8p07d6r5gYmIiKxFhQaqC5xmLaDThDTVawDZR59KGQD269dPxowZI+fPn1djAWIu4PXr18tLL70k/fv3t3VzRETkI9gP0EWJIH5+knvhguQmJLigBOQ1AeDbb78tNWvWVLV9SABp0qSJdOnSRTp27Kgyg4mIiArDAND5DOHhElS7trrNZmAyZ/NgfoGBgfLtt9/KxIkTVbMvagBbtWol9evXt3VTRETkQzgWoOuagbOPHVPNwGW6dHFRKcjdlHg057p166oLERFRcdQonz8FHKaDI+cJadJEkhcvZg0g2R4Ajho1Sopr6tSpxV6XiIh8B5uAXTwjCBNByNYAEE295rZv3y55eXnSsGFDdf/QoUPi7+8vrVu3Ls7miIjIhwNATAdnNGpiMPi5ukg+UwMIuefiJPfyZQkoV87VRSJPCQBXr15tUcMXEREhX331lZS7ehJdvnxZBg0aJJ07d3ZcSYmIyKPFlA0VxHxZuUa5mJol0ZEhri6ST/AvU0aCYmMl++RJNSB0mZs7ubpI5IlZwFOmTJHJkyebgj/AbcwOgseIiIgKE+hvUEEgsB+gc3E8QCp1AJicnCwXLlwosDw+Pl5SUlJs3RwREfloMzA5D2cEoVIHgJgGDs298+bNkzNnzqgLbg8ePFjuv/9+WzdHREQ+hIkgrsEaQCr1MDCzZs1Ss3489thjkpOTk7+RgAAVAH7wwQe2bo6IiHxwLEA2AbsmESTnzBnJS0oS/6goJ5eAPL4GMCwsTGbMmCGJiYkqO3jHjh1y6dIltSw8PNwxpSQiIq/AJmDX8I+MlMAaNdRtzghCJQoAdQj2WrRoIS1btmTgR0RExcImYNdhMzDZJQAkIiIqaQB4ITlLMnPyuANd0AzMGkACBoBEROQ0ZcMCJSI4v/v5mcvMBHYmzghC5hgAEhGR0/j5+TERxNWJICdPSR6HbfN5DACJiMg1/QATWQPoTJgCLjAmRt3O3H/Aqa9N7ocBIBEROVXNCvpQMBnc807GRBDSMQAkIiKnqlGO08G5CmcEIR0DQCIicslg0JwOzvlYA0g6BoBEROSysQA1TePed0EiSPaJE5KXmsZ978MYABIRkVNVKxcqfn4iGTl5kpCazb3vRAEVKkhAlSoimiZZ/zARxJcxACQiIqcKDvCXqpEh6vZpjgXodGwGJmAASERETsd+gK4T0qSxuuaMIL6NASARETkdxwJ0fQ1gxr59LiwFuRoDQCIicmkiCDlX6NUAMPvYcTGmc//7KgaARETkwsGgGYA4W0ClSuoiRqNk/nPQ6a9P7oEBIBEROR37ALoWE0GIASAREbmsCTguOVOycvN4BFw0HiATQXwXA0AiInK6CuFBEhbkj+Ho5OxlzgnsbCHN8vsBZjIRxGcxACQiIqfz8/NjIogbNAFnHT0qxsxMVxaFfDUAnDFjhtSuXVtCQkKkdevWsm7duiLXXbBggfTo0UMqVaokkZGR0qFDB1m6dKlTy0tERPbBfoCuE1C5svhXqCCSlydZB5kI4otcGgDOnTtXRowYIa+99prs3LlTOnfuLHfccYecOnWq0PX//PNPFQD+/vvvsn37dunWrZvcdddd6rlERORZOBSMa2tgQ5rm9wPkeIC+yaUB4NSpU2Xw4MEyZMgQady4sUybNk1q1KghM2fOLHR9PD569Ghp27at1K9fX9555x11vXjxYqeXnYiISqdGuVB1zaFgXIOJIL7NZQFgdna2qsXr2bOnxXLc37BhQ7G2YTQaJSUlRcqXL1/kOllZWZKcnGxxISIidxoLkEkgrh0KZr9LXp98NABMSEiQvLw8iY6OtliO++fPny/WNqZMmSJpaWny0EMPFbnO5MmTJSoqynRBDSMREblPE/DpS+miIR2YXDIjSNbhw2LMzube9zEGd+iHYA5fAtbLCvP999/Lm2++qfoRVq5cucj1xo4dK0lJSabL6dOn7VJuIiIqnerl8gPA1KxcuZyew93pZAFVq4p/2bIiubmSdfAQ97+PcVkAWLFiRfH39y9Q2xcfH1+gVtAagj70Hfzxxx+le/fu11w3ODhYZQybX4iIyPVCAv0lOjLYVAtIrkgE4XiAvsplAWBQUJAa9mX58uUWy3G/Y8eO16z5GzhwoHz33XfSp08fJ5SUiIgchZnArsVEEN8V4MoXHzVqlDz++OPSpk0bNabfp59+qoaAGTZsmKn59uzZszJnzhxT8Ne/f3+ZPn263HTTTabaw9DQUNW/j4iIPG8swK0nLjMT2EVYA+i7XBoA9u3bVxITE2XixIkSFxcnzZo1U2P8xcbGqsexzHxMwP/85z+Sm5srzzzzjLroBgwYIF9++aVL3gMREdknEYRcNyVc1qFDomVni19QEA+Dj3BpAAjDhw9Xl8JYB3Vr1qxxUqmIiMgZ2ATsWoHVqokhKkqMSUmSdeSIqUmYvJ/Ls4CJiMh3MQB0g0SQJo3Vbc4I4lsYABIRkcsDwHNXMiQnz8gj4QJMBPFNDACJiMhlKkUES3CAQYxafhBIrhsQmjOC+BYGgERE5NImSDYDu0cmcNY//4iWwwG5fQUDQCIicikGgK4VWKOGGMqUUVnAWceOubg05CwMAImIyOVjAcIpDgXjEn4Gw//6Ae7d55pCkNMxACQiIrcIADkWoBsMCL1/vwtLQc7EAJCIiFyKTcCuZ6oB3McaQF/BAJCIiNwjAEzkbCAurwFEIkhursvKQT40E4i7ysvLkxxmQxF5jMDAQPH393d1MagEapQPVdfJmbmSlJ4jUWGB3I9OFlQrVgxhYWJMT5fs48cluH59HgMvxwDQiqZpcv78ebly5YprjggRlVjZsmWlSpUqamgR8hxhQQFSsUywJKRmyenL6RIVFuXqIvlkIkhwk8aSsW27mhGEAaD3YwBoRQ/+KleuLGFhYfwhIfKQf9zS09MlPj5e3a9ataqri0Q2qlk+VAWAyARuVo0BoKsGhEYAqBJB7r3XJWUg52EAaNXsqwd/FSpUcOJhIKLSCg3Nb0ZEEIjPMJuDPa8f4I5TVzgUjFskgjAT2BcwCcSM3ucPNX9E5Hn0zy7773oeZgK7USLIgQOi5eW5ujjkYAwAC8H+Q0SeiZ9dz8WxAF0vqHZt8QsNFQ2JICdPuro45GAMAMmtPP744/LOO++IO6hVq5ZMmzbNIrhYtGiReIu///5bqlevLmlpaa4uChFrAN2An7+/hDRqpG5zPEDvxwDQSwwcOFDuvUan3Z07d8qdd96p+kaFhISo4KZv376SkJBgWmf+/PnSvn17iYqKkoiICGnatKm8+OKL6rFbbrlFBUBFXbC90tqzZ4/89ttv8txzz4k7iouLkzvuuMOu29y9e7c88sgjUqNGDdWHrXHjxjJ9+vRCkxw+/PBDadCggQQHB6v1rxcoX758WQXUOJ644LZ5dnvz5s2lXbt28tFHH9n1PRGVRM0K+c33Zy9nSG6ekTvR1c3A7Afo9ZgE4gPQKb579+5y1113ydKlS9VQGcePH5dffvlFZU7CihUr5OGHH1ZBxd13362Cuv3798vKlSvV4wsWLJDs7Gx1+/Tp0ypwwHMQJEJxO9yjbxbGayvMJ598Iv/3f/+ngk93hOFF7G379u1SqVIl+eabb1RQt2HDBnnqqafU/nz22WdN673wwguybNkyFQQicEtKSrII3gvTr18/OXPmjCxZskTdx3YRBC5evNi0zqBBg2TYsGEyduxYJk2QS0VHhEiQv0Gy84wSl5RpahIm5+KMID5E8zFJSUka3jaurWVkZGj79+9X1/Zw7kq6tv7IRXXtaAMGDNDuueeeQh9buHChFhAQoOXk5BT5/BdeeEG75ZZbivVax48fV/tw586d1113/PjxWsuWLbXPP/9cq127tubn56cZjcYC6+Xl5Wlly5bVfv31V4vlsbGx2qRJk7THH39cCw8P12rWrKktWrRIi4+P1+6++261rFmzZtrWrVtNz0lISNAefvhhrVq1alpoaKh6/LvvvrPYbnJystavXz8tLCxMq1KlijZ16lSta9euaj+Yv/ZHH31kuo/3jH1pvg/mzp2r3XzzzVpISIjWpk0b7eDBg9qWLVu01q1bq7L16tVLldUWw4cP17p162a6j3MSx++ff/4p9jbwHJRv06ZNpmUbN25Uy8y3k5WVpQUHB2srV67UvIG9P8PkXN0+XK3FjvlVW3/4Ine9i2T8c1Db37CR9s+NrTVjXh6PgxfFONbYBHz9AFnSs3Ntvny98YR0eneV9PvvZnWN+7ZuIz/msE/NVW5urixcuLDIbWKdffv2yd69e8Xejhw5Ij/++KNqYt61a1eRzb9onmzTpk2Bx9BE2alTJ9WM3adPH1WL1b9/f3nsscdkx44dUq9ePXVff2+ZmZnSunVr+fXXX9X70Wu+Nm/ebNrmqFGjZP369aoWdPny5bJu3Tq1LVuNHz9exo0bp54bEBCgmnNHjx6tmnGxzaNHj8obb7xh0zZRu1e+fHnTfdTY1alTR72f2rVrq+b2IUOGyKVLl4rcxsaNG1WzL5r0dTfddJNahlpGXVBQkLRs2VKVlcjVmAnsesF164hfcLAY09Ik59QpVxeHHIhNwNeRkZMnTd5YWqqdbNREXv95n7rYYv/EXmqE/NLCD/+rr76qmgTR3Ifm21tvvVUFTdHR0Wod9LtDEIDmxdjYWPWcnj17yqOPPqr6nJUGmo6//vpr1dRZlBMnTqgmSPRRtNa7d28ZOnSouo1gaubMmdK2bVvVXAxjxoyRDh06yIULF1QgW61aNXnppZdMz8d7QzPoTz/9pAKilJQU+eqrr+S7776T2267Ta0ze/ZsiYmJsfm94XV69eplaqZFAIhmcwSsMHjwYPnyyy+LvT0EbgiW0RdSd+zYMTl58qQq/5w5c9R4lSNHjpQHH3xQVq1aVeSA5oXtSyzDY+awv7D/iVyNAaDr+QUESHCjhpK5e4+aESTIDv27yT2xBtBHvP322+qHf9asWdKkSRN13ahRI5UJCuHh4SroQG0darTKlCmjEkAQLOr9BEsKAeW1gj/IyMhQgWZhw3i0aNHCdFsPWBGoWi/TZ4FAgIT3i+dhQG+8F/SfO3X1v1kEVOiLiPemQ81Yw4YNbX5vxSmbXq7rQQ3sPffco4LcHj16mJYbjUbJyspSwV/nzp1VQs7nn38uq1evloMHDxa5vcL2JWpJrZcj+aS0x5jIHhgAus+MIKBmBCGvxRrA6wgN9Fc1cbY4n5Qp3aeuVTV/OoOfyIpRXaVKVIhNr21PCIZQa4bL5MmTpVWrViqpALVhurp166oLmhhfe+01lXU6d+5clSxQUggur6dixYoqCEFtIZolzZknjejBS2HLECjBlClTVLMxhnBBMIbXHzFihCmJRW8qtg6EStLkXpyy6eW6FiTcoFb2ySefVAG4OUxrhuZlHAsdsoUBQW1hgStqQlEjau3ixYumQFWHpmQccyJXq14uP/Hj9CX+Q+JKnBHEN7AG8DrwA45mWFsudSqVkcn3Nxf/qwEBrnEfy23ZjiMHtUWQhR/9a40Bh75mmFnBGePE3XDDDaZAqLTQlI2aNPQRRP829J87fPiw6XG8bwRpW7ZsMS1LTk62WMeZUPPXrVs3GTBggKq5tIbmZPThRH9C3aFDh0y1q4VBkzj6Epq/R/SBxLKOHTtarIt+kvhngMjVWAPoZkPB7N9vt77o5H5YA+ggfdvWlC4NKsmJhHSpVTFMqkblz1PqSPhxt06yQDIBEix++OEHNcwLapHwgUZiwe+//676vsGbb76pauDQ3w5BBRIyPv74Y9VUat4c6ShoIr7xxhvlr7/+MgWDJYWkECScINmhXLlyMnXqVNX8rdeaYZgZBFsvv/yy2j/oF4dkDoPB4PSZJPTgD/0tkZii989Df0i92RxD+GDfPPHEE6pWEzWKzzzzjDoueq0gAj306UT/Q/Tpw3u9/fbbVY3if/7zH7UOkmEwFqR5jSH6/p09e1a9BpGr1Sif/z15OT1HUjJzJCKk8CGjyLGC69YVv8BAMSYnS86ZMxJUowZ3uRdiDaADIejrULeCU4I/WLNmjarJMb+gPxn6/KEmD336EFwhwQOJBp999pnKjoWuXbuqvnEIItA3EAMeIxhB37mS9I0rCQQo3377bam38/rrr6uACckZ6C+H5lDrQbIRFKKWDAERgh/UsiFowiDZzoTEDjTL4n2jqVe/IMlFh8AUATuaybt06aIyoVFWBPU6BO/oD2g+By62iSZwBJe4oL8iknHMff/99+qxomoSiZwJAV/58PwuIKcvZXDnu4hfUJAEX/3e54wg3ssPY8GID0FTHzr8o7YsMjLS4jEMH4IBkjHUhrMDAcrf/wg2EdggOHMmNHOj5gz9B5G56wuQWFK/fn0VBOpZy56On2HPd8+/18vu01dk1mOt5fZm9h98nYonbvybcmXuXKnw5JNS+cVR3G1eEONYYw0guQ0E3ch0vd4MF/aAMQUR+KBfHcbww3A3gL6DvgJDyyDRx1uCP/KufoBMBHEtzgji/dgHkNwKmqKdBRnQaDZFQgwGjkbyCJpZfQX6D5pnFhO5g5pX+wGeYiawm8wJvK/Q4aPI8zEAJJ+E/pGYh5eI3Aszgd1DcIP6GNNK8pKSJPfcOQmsVs3VRSI7YxMwERG5jRpsAnYLBiSC1K+nbmNGEPI+DACJiMjtagDPXM6QPPPR9MnpOCOId2MASEREbgPDZgUY/CQ7zygXkjNdXRyfxhlBvBsDQCIichv+Bj+pXo6JIO6YCELehQEgERG5ZT9AZgK7VjBGCfD3l7xLlyS3kLnFybMxACQiIrfCsQDdgyEkRILr5SeCcEYQ78MAkKiEMIYgpplLSUlx+T788ssvpWzZsqb7mNu5tHMqu5sHH3xQTeFH3o9DwbhjM/B+VxeF7IwBoJcYOHCgGqgTl4CAAKlZs6Y8/fTTcvnyZfFUmMdXf0/ml9zcXPX4ggUL1Hy/GLwZy3ft2lWsbTz88MMW6xw6dEjNAILtYOoczIyxevXq65YPs2g888wzEhERIe7mpZdekpUrV9p9u5MnT1bzFOM9V65cWc2xjEDYXGHHDJcPPvjgmtueP3++mrc6ODhYXS9cuNDiccxr/fbbb6upjsi7sQnYfXBGEO/FANCL3H777RIXFycnTpyQzz77TBYvXizDhw8XT/bkk0+q92R+QYCrz9+LYO3dd9+1aRv/+c9/LB7v06ePCipXrVqlBodGzdmdd94p58+fL3KbZ86ckV9++UUGDRok7qhMmTJSoUIFu2937dq1KujdtGmTLF++XO23nj17qmOhsz5eX3zxhQoAH3jggSK3u3HjRunbt688/vjjsnv3bnX90EMPyebNm03rtGjRQmrVqiXffvut3d8XuRc2AbuPkKZN1HXGfo4F6G0YADpQzvnzkrZps7p2BtScoEmyevXq6kcZP6jLli0zPW40GmXixInqcayLQGfJkiWmxxE44of6xx9/lM6dO0toaKiq7UEN2datW6VNmzYqsECgefHiRdPz8FiPHj1UDRomocZ0bphf1xy2i6D0vvvuk7CwMKlfv74KoK4H6+I9mV90CBJQK9S9e3ebtoEy6jDv8JEjR+SVV15RAQbKhYAyPT1d9l1j8FPso5YtW6p9ad0M++uvv0rDhg3V66LZEsHRV199pYKXcuXKyXPPPSd5eXmm533zzTdq36JWDeXr16+fxMfHW7we9hXKhmPSrVs3tT3s0ytXrhRaPusmYNQQo7bunXfekejoaFXOCRMmqADu5ZdflvLly6v3gmDtWnC+YFtNmzZV73/27Nly6tQpi1lVrI/Xzz//rMpcp06dIrc7bdo0dQ6NHTtWGjVqpK5vu+02tdzc3XffreZwJt+oAUxIzZb07Pwaf3KNkEaNRAwGybuYIDlW30vk2RgAXgdS343p6TZfLn33nRy59TY5NXCgusZ9W7dRmrT7Y8eOqR/rwMBA07Lp06fLlClT1By4e/bsUc2n+EE9fPiwxXPHjx8v48aNU0EcatseeeQRGT16tHo+5ss9evSoCrx06AM3YMAA9RhqhhCo9O7du0DfOAQcqNXBa+PxRx99VC5duiSOhhojBKcIWtA0al4u1JI1btxY5syZowI1BESoIUSQhPmBi/Lnn3+qoM0aAsePP/5YfvjhB7X/16xZI/fff7/8/vvv6vL111/Lp59+KvPmzTM9Jzs7WyZNmqRqvhYtWiTHjx9XQZZ5YI5AEgEcmrmHDh2qmp9thRrOc+fOqbKjLx2CRNR0IihFTduwYcPU5fTp08XeZlJSkrpGAFmYCxcuyG+//SaDBw++5nZQA4h/Wszh/NywYYPFsnbt2smWLVskKyur2GUkzxMVGqgucPpShquL49MMoaESXDf/nzcmgngZzcckJSUhqlLX1jIyMrT9+/era11eWpq2v2Ejl1zw2sU1YMAAzd/fXwsPD9dCQkLUe8Rl6tSppnViYmK0t99+2+J5bdu21YYPH65uHz9+XD3ns88+Mz3+/fffq2UrV640LZs8ebLWsGHDIsuSm5urRUREaIsXLzYtwzbGjRtnup+amqr5+flpf/zxR5Hb6dq1qxYYGKjek34ZNWpUgfX0cu/cubPAY59++qm2fPly7e+//1bvpVatWlr37t0t1jlz5ozWunVrVR7sQ+ynwrZlrmXLltrEiRMtls2ePVuV48iRI6ZlQ4cO1cLCwrSUlBTTsl69eqnlRdmyZYvajv6cMWPGaM2aNbNY57XXXlPrXL582fTaUVFRpsfHjx+vymh+fsTGxmp5eXmmZTiGnTt3tjhu2MfYT8VhNBq1u+66S7v55puLXOe9997TypUrZ/GZKgyO87fffmuxDPeDgoIslu3evVu97xMnThS6ncI+w+SZ7vx4nRY75ldt2b7zri6Kzzs7eoz6TYr/5BOf3xeeHONYy+9MRV4BzWwzZ85UtVBobkXTLZobAR3nUfuDPnPmcB81T+bQFKpDTRg0b97cYpl5EyVuo0YQNUyo8UHzJsqApsGithseHq6aPK2bOq2hltC8tss807U40P9P16xZM1U7iZo71G7eeOONqpYV/SSR0IAaTDSxYt+hZgxN21WrVi10uxkZGRISElJgOZp969ata7Gv0PSLpnPzZebve+fOnao2DrV7qBFFUz1g/yEZAkkWaIq3rgmzFWpADQaDRTmwT3T+/v6qRvR6x0T37LPPqtrcv/76q8h10KSMY1jYvrKGJm1zODbWy3B8AOcXeX8/wL/PJnEsQDfpB5j088/MBPYyDACvwy80VBru+F//puLIuXBBjvW5E53u/rfQYJA6v/0qgVcDquK+ti0QVNW7OmYTmiEREKLZFc2LtvzImjcb649ZL9ODFEBzJfoEor9WbGys6l/YoUMH1bRZ1HYL205h0F9Pf0/2gKAP5UCzN24jaEWfPWRLIwMYZsyYoRIc0M8OfQMLgyblwjKsC3uP13rfaHZG0ycu6AtYqVIlFfih+VPff4Udo5J0D7C1bNeCfyzQLxHNyeb9IM0hoEbwOnfu3OtuD30FrZNuEIjq/4Do9C4D2E/kG/0AT19isO9OM4KQ93B5H0D82NauXVvVEKDPFX40rpeFiPWwPjqVz5o1y6Hlww+iISzMpktw7dpSdeIEFfQpBoO6j+W2bMf6R99W6MuH/n6o+UNwExMTU6C2Bn2s0AeuNHDMnn/+edWvD7VMCACRXOGOkNiRk5NjqtnTa5LMa8b0+9cKhFq1aiX795d+XKx//vlH7SskniDxBgkQ1jVwWIbaSHPbtm0TV0DgiZo/DMGD4Bmf3aJ8/vnn6rOKZJHrwT8MCLrNIYGpY8eOFsv27t2rAk4E4OTdOBagmyWCYAiuCxck102/28nDAkDUDIwYMUI18aEZDD+Ad9xxR4GmQx06xyPIwHpY/9VXX1WBB8YPczdlH3xQ6q1aKTW/+kpd476zYQw8BGTI/ARke7733ntqv6NmBrVbaHZ84YUXSvU6qKFDcsOBAwdUMgGa/PSmOkdCbRDKrwdieE+4r9ckIVkFWc8IlpBIgSSM//u//1PBm94UjsADSRBIYkFTOJrNsZ9wrmF4mKKghg6JC+bZvCWB8RqDgoLkX//6l0rcQa2aeY0tIOkDgeKYMWNU+ZCBjIxjKO0/CbbCEDCoqfzuu+9UEz72NS5oEjeHLgc//fSTDBkypNDt9O/fX2X66nAOIuDD+Yn3iusVK1ao7wfrfzask0XIOzEAdB+G8HAJuvrP3pUFC502sgV5cQCITERkB+JHArVQaEKsUaOG6sdWGNT24QcT62F9PO+JJ55QtVzuKLBKFQlv305du8qoUaPkv//9r8rsRLD84osvqgv69CFLVR9epDTQzwvNoQisMDQLXgd96hwNZcdr6oEaBnjGfb1WGIEVBkNGsIZhWVAuBA8ILNDfDVCThP2Qmpoqt956q+ofiFpSDF1yrZor/COC5lNsqzTQlIlgDsES+vuhJtD6fEYtG7KGUeuGfpT4fOj9IlHb6kx4bWT+4p8L1KLqF+tmXmRBo7YQGeSFwT95GCNQh5o+PAfDyuA9Yp9gm+3btzetk5mZqQaHNu/XSd4fAJ5MSJOzl+3TDByXlCEbjiaoa27PNoarA95fnDpVjnS7Vc5PnCRpm7dI5oEDkn3mrOQlJ4tWjO4j5s4eOiFbFixT16Vlz215wvbswQ+ZIK54YfRvQod5/PBhbDjzmgDU4qCp11qXLl3UDzyGI9HhBwFDi6Apz7o/U2FQM4F+ZfgR0/t8mf/AoOZHb5Imul73BQSKS5cudfqOwowYCHRtGbLF0/373/9W+9t8bEtr/Ax7j+82n5RXF+5Vt1HP/WSXOnJro5L/Y7nqn3j577pjgl88VJw/2ZnbKy6/hHiJ6P+A+KnBJYqmYceGhYsWXka0MmXyr8MjzG5jeYS6jtuyQ2qvXyoG0cQofnLklnsk5o7bSnRsz/2xUuqt+dku23LG9s4OHiE9X35KHOFaMY7bJIGg3xOaz6w7eeN+UTMwYHlh62PsNmyvsIxNjBdmPmYYp5Eie3nqqadUzSfGFXT0dHAINpEJjCzd9evXq2nV0BfPl+AfPDSVk/dDDd24RfnBHyDs+PTPY+piDwgCub3ia3HxiLxXSPB3IaSsBGp5Ep6TIcHGXNQoiaSlil9aqsh1BhOoa9EUqUmDNYtEcCmBBnbcljO2F/PFNDl7T0+p1qCW+HQWcHGyUq+3fmHLzecuRSYskb1hkOySDMhcEshafuutt1S/R3SDQDO+eR86Xwm4yTccT0gTYyGVTTFlQyQsyPafLcwmcu5KJrdXwv2XF1hN1VwheDEtw/zed70oWeXyM/IDcnMkNDtDQrPT86+z0iUsO0NCzG6rx7IypFxSvNRNOFngdRLCy0lOoG3dWgJzsqRi2mW7bMtZ2/PXNDm377DvBoDoe4V+WMUZ+uF6Q0Xgh7ioeU/xI4l+cOY1gOhnSORJPvroI3Uh8gW1K4aLwU8sgkB/Pz+Z/3RHqRoVWqIaxU7vruL2SrH/JhzZI8/umqeCFwR/n9zwf/LZS31KtD30g7tyd+8CAWWd77+zOSiy57acub2YpqXre+/RSSDooI8hIqyHfsB966EfrjdUBDruF9X/D53k0Q5ufiEiIveFoGLy/c1V0Ae4fuf+ZiUKNrg9++y/bqOGyBO9xsnoTsPUdbdRg0u8PQRS6AeHQAhwfe6JESUKsOy5LU/YnlckgQCy/JA1is7sCO4wRyoyVjFWGwYURu3d2bNn1TytgAQNzFyAYTGQCYhhODB3KSaHf+CBB4r1mkwCIfJeTALxLqh5OpGQLrUqhpU42OD23Hf/oXYMTaGoDSttQGTPbXnC9uyRBOLSAFDv3P7++++rISEQ3KGZC9m++gwTGL9tzZo1pvWRHTxy5EgVJGJgY4yNhiCwuIoTAGLqLmeMY0dE9oXxCPGdwUx+IvJFyZ4UALrTzkFWMgbaxRh2RfUpJCL3lZiYqPoFN2jQwDTWIxGRr0j2hGFg3BF+MMqWLWuaigvjFDp7pgUish3+j8VYoPjs4jPM4I+I6NoYABaSaQzW87ESkftD8Kd/homIqGgMAK2gxg8DSqMZOCcn5xq7jojcCUYCYM0fEVHxMAAsAn5I+GNCRERE3shl4wASERERkWswACQiIiLyMQwAiYiIiHyMz/UB1Ic9xFg5RERERN5Cj22KM8SzzwWAKSkp6rpGjRquLgoRERGRQ2IdDAh9LT43E4jRaJRz585JREREiQZ5RnSN4PH06dPXHWWbPA+Pr/fisfVePLbei8fWNgjpEPxhqlyD4dq9/HyuBhA7pHr16qXeDoI/BoDei8fXe/HYei8eW+/FY1t816v50zEJhIiIiMjHMAAkIiIi8jEMAG0UHBws48ePV9fkfXh8vRePrffisfVePLaO43NJIERERES+jjWARERERD6GASARERGRj2EASERERORjGAAWYvLkydK2bVs1WHTlypXl3nvvlYMHD1qsg66Tb775phpsMTQ0VG655RbZt2+fs44bOfD45uTkyJgxY6R58+YSHh6ujnH//v3VAOLk+Z9dc0OHDlUDwk+bNs2p5STHHdsDBw7I3XffrcZCw7o33XSTnDp1irvcC45vamqqPPvss2osX/zuNm7cWGbOnOmyMns6BoCFWLt2rTzzzDOyadMmWb58ueTm5krPnj0lLS3NtM77778vU6dOlU8++US2bt0qVapUkR49epimmiPPPb7p6emyY8cOef3119X1ggUL5NChQ+pHhTz/s6tbtGiRbN68WQX45B3H9ujRo3LzzTdLo0aNZM2aNbJ79271OQ4JCXFp2ck+x3fkyJGyZMkS+eabb1Sgj/vPPfec/Pzzz9zFJYEsYLq2+Ph4ZEpra9euVfeNRqNWpUoV7d133zWtk5mZqUVFRWmzZs3i7vTw41uYLVu2qHVOnjzp1LKRY47tmTNntGrVqml79+7VYmNjtY8++oi72guObd++fbXHHnvMpeUixx3fpk2bahMnTrRY78Ybb9TGjRvH3V4CrAEshqSkJHVdvnx5dX38+HE5f/68+u/EfKyirl27yoYNG0oUiJP7HN+i1kFTYdmyZZ1YMnLEscV84I8//ri8/PLL0rRpU+5kLzm2OK6//fabNGjQQHr16qWaEdu3b69qesk7Pruo3f3ll1/k7NmzqhvW6tWrVesMjjfZjgHgdeAkGzVqlDrxmjVrppYh+IPo6GiLdXFff4w89/hay8zMlFdeeUX69evH+Z+94Ni+9957EhAQIM8//7xLy0f2Pbbx8fGqj9i7774rt99+uyxbtkzuu+8+uf/++1XzInn+Z/fjjz+WJk2aqD6AQUFB6jjPmDFDrUe2CyjBc3wKOpzu2bNH/vrrrwKPoUbI+qS1Xkaee3z1hJCHH35Y1S7gi4Y8+9hu375dpk+frvp28rPqXccWn1G45557VN8wuOGGG1SrzKxZs1QLDXn29zICQPQRRC1gbGys/PnnnzJ8+HCpWrWqdO/e3WXl9VglaTf2Fc8++6xWvXp17dixYxbLjx49qvom7Nixw2L53XffrfXv39/JpSR7H19ddna2du+992otWrTQEhISuKO94Niir5+fn5/m7+9vuuCzbDAYVF9A8txjm5WVpQUEBGiTJk2yWD569GitY8eOTi4l2fv4pqena4GBgdqvv/5qsXzw4MFar169uMNLgE3AhQfF6j8QZH+uWrVKateubfE47iPrF5lKuuzsbNXM0LFjR8dH7eTQ46vX/D300ENy+PBhWbFihVSoUIF73QuOLfr+oWZh165dpguygNEfcOnSpS4rN5X+2KJJEMOIWA8dgj5iqC0izz6++E7GxWCwDFv8/f1Ntb9kGzYBFwKp6N99951KLceYRHq/PowrhbGH0HQ0YsQIeeedd6R+/frqgtthYWGqnxh59vHF8AMPPvigaib89ddfJS8vz7QOOiTjh4Y889gikLcO5gMDA9U/dA0bNnRRqckexxYQyPft21e6dOki3bp1U0OGLF68WA0JQ559fCMjI1UzPo4x7iOoR6XLnDlz1JBsVAIlqTb0dtgthV1mz55tWgdDwYwfP14NBxMcHKx16dJF+/vvv11abrLP8T1+/HiR66xevZq72cM/u9Y4DIx3HdvPP/9cq1evnhYSEqK1bNlSW7RokcvKTPY9vnFxcdrAgQO1mJgYdXwbNmyoTZkyRf0ek+388KckgSMREREReSb2ASQiIiLyMQwAiYiIiHwMA0AiIiIiH8MAkIiIiMjHMAAkIiIi8jEMAImIiIh8DANAIiIiIh/DAJCIiIjIxzAAJCLyICdOnFDTUWIeY0fAthctWuSQbROR+2AASERu5ZZbblFzbVPhatSoIXFxcdKsWTN1H/PcImi7cuUKdxkRFVtA8VclInIPmMEyLy9PAgJ87yvM399fqlSp4upiEJGHYw0gEbmNgQMHytq1a2X69OmqVgsXNHnqtVxLly6VNm3aSHBwsKxbt06tf++991psA7WHqEU0Dxbff/99qVOnjoSGhkrLli1l3rx51yxHrVq15K233pL+/ftLmTJlJDY2Vn7++We5ePGi3HPPPWpZ8+bNZdu2babnJCYmyiOPPCLVq1eXsLAw9fj3339vsd2UlBR59NFHJTw8XKpWrSofffRRgRpPvPY777wjTzzxhEREREjNmjXl008/LbQJGLe7deumlpcrV04txz7RtzNt2jSL17/hhhvkzTffNN0/fPiwdOnSRUJCQqRJkyayfPnyAvvi7Nmz0rdvX7X9ChUqqPeP1yUiz8YAkIjcBgK/Dh06yJNPPqmaOXFBk6du9OjRMnnyZDlw4IC0aNGiWNscN26czJ49W2bOnCn79u2TkSNHymOPPaYCzWtBcNapUyfZuXOn9OnTRx5//HEVEOK5O3bskHr16qn7CDAhMzNTWrduLb/++qvs3btXnnrqKfWczZs3m7Y5atQoWb9+vfzyyy8q2EIQi21ZmzJligp08drDhw+Xp59+Wv75558C62HfzJ8/X90+ePCg2l/Yh8VhNBrl/vvvVzWKmzZtklmzZsmYMWMs1klPT1cBJgLeP//8U/766y91+/bbb5fs7OxivQ4RuSmNiMiNdO3aVXvhhRcslq1evRpRlrZo0SKL5QMGDNDuuecei2V4LrYBqampWkhIiLZhwwaLdQYPHqw98sgjRZYhNjZWe+yxx0z34+Li1Ou//vrrpmUbN25Uy/BYUXr37q29+OKL6nZycrIWGBio/fTTT6bHr1y5ooWFhVm8X+vXNhqNWuXKlbWZM2eq+8ePH1evu3PnTot9c/ny5QLv4aOPPrJY1rJlS238+PHq9tKlSzV/f3/t9OnTpsf/+OMPta2FCxeq+59//rnWsGFDVQZdVlaWFhoaqp5PRJ7L9zrQEJHHQq2YLfbv369q5nr06GGxHLVXrVq1uuZzzWsYo6Oj1TWada2XxcfHqz556JP47rvvyty5c1WzaVZWlrqguReOHTsmOTk50q5dO9M2oqKipGHDhtd8bTTrYvt4HXtCLSqal9FkrUPtq7nt27fLkSNHVFO0OezTo0eP2rU8RORcDACJyGPowZTOYDCYmmB1CLLMmznht99+k2rVqlmsh36E1xIYGGgRhBW1TH8NNNui2Rj97hAooqzo26c3lerl1J+nsy6/9evoz9Ffp7iut28Ke13rsuE10az97bffFli3UqVKNpWHiNwLA0AicitBQUGqNq04EISgv505JEfoARQSGxDonTp1Srp27SqOhP58SJBAH0E9eEKSRePGjdX9unXrqnJt2bLF1K8xOTlZrVOasmF/gfU+w75Bn0AdXuv48eOm+9g32C/nzp2TmJgYtWzjxo0W27jxxhtVjWblypUlMjKyxGUkIvfDJBAicivIXkXiBDJNExISrlnzdeutt6pM3Dlz5qhAavz48RYBIZouX3rpJZX48dVXX6lmSyRW/Pvf/1b37QlJIUjs2LBhg2peHTp0qJw/f96iLAMGDJCXX35ZVq9erRJSkOmLmjrrmjdbIEMZz0fyCbKUU1NTTfvm66+/VoEp9gleGwkfuu7du6vmZySy7N69W6332muvWWwbGcsVK1ZUgS0eRwCJ5JkXXnhBzpw5U+IyE5HrMQAkIreCgA2BCmqoUIuFWqqi9OrVS15//XWVHdy2bVs1zAoCGnOTJk2SN954Q2UPozYOz1m8eLHUrl3bruVGOVBjhu1jaBf027Meombq1Kmqn92dd96pAjBkGaNMGIalpNC0PWHCBHnllVdUv8Rnn31WLR87dqwa4gWv1bt3b1UW1ELqEHguXLhQ9VNEv8QhQ4bI22+/bbFtDGeD7F/0FUTGMMqKoDUjI4M1gkQezg+ZIK4uBBGRL0pLS1MBHPoPDh482NXFISIfwj6AREROguZnjOeHGrekpCSZOHGiWo4mViIiZ2IASETkRB9++KEatBnJG8iwRd869LMjInImNgETERER+RgmgRARERH5GAaARERERD6GASARERGRj2EASERERORjGAASERER+RgGgEREREQ+hgEgERERkY9hAEhERETkYxgAEhEREYlv+X/C+gQGsmYWKgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -567,7 +559,7 @@ }, { "cell_type": "markdown", - "id": "9e34ac16", + "id": "308a08d9", "metadata": {}, "source": [ "## Notes for real runs\n", @@ -577,9 +569,10 @@ "* A band label is used **both** as the ugali isochrone field name and as the key\n", " into a survey's maglim/photo-error maps, so they must agree (ugali's Roman\n", " fields are upper-case: `F106`, `F158`, ...).\n", - "* **`nstars` is now exactly N** (was an emergent IMF count). This is adopted but\n", - " intentionally still **flagged for review** in the plan doc, because it changes\n", - " what `StreamModel.sample(size)` returns for existing single-survey configs.\n" + "* **`nstars` is now exactly N** (was an emergent IMF count). This is the agreed\n", + " semantics for both single- and multi-survey configs.\n", + "* **Output columns are always survey-namespaced** (`__…`), even for\n", + " a single survey — there is no longer an un-namespaced single-survey form.\n" ] } ], diff --git a/scripts/build_multisurvey_demo_nb.py b/scripts/build_multisurvey_demo_nb.py index ca7f0fc..3727252 100644 --- a/scripts/build_multisurvey_demo_nb.py +++ b/scripts/build_multisurvey_demo_nb.py @@ -22,9 +22,9 @@ | Phase | What changed | |---|---| | **1** | `Survey` holds two error curves — a *catalog* (reported `magerr`, drives the S/N cut) and an optional *sample* (true scatter, drives the noise draw). `get_photo_error(..., kind=)` selects between them. | -| **2** | The injector is de-hardcoded off `{r, g}`; column names route through `streamobs.columns`, using a **uniform** `_true/_obs/_err` scheme (`_…` when namespaced). The S/N cut now applies to **all** injected bands. | +| **2** | The injector is de-hardcoded off `{r, g}`; column names route through `streamobs.columns`, using a uniform, **always survey-namespaced** `__true/_obs/_err` scheme. The S/N cut now applies to **all** injected bands. | | **3** | `IsochroneModel` is multi-band / multi-survey: masses are drawn **once** (exactly `nstars`) and interpolated into every survey's bands, so the *same physical star* is consistent across surveys. Roman bands are auto-converted Vega→AB. | -| **4** | `MultiSurveyInjector` orchestrates one shared sky placement + one shared true-mag fill, then a per-survey loop writing `__obs/_err` and `_flag_observed`. | +| **4** | A single `StreamInjector` accepts one survey **or several**: it does one shared sky placement + one shared true-mag fill, then a per-survey loop writing `__obs/_err` and `_flag_observed`. | See `docs/source/roman_multisurvey_plan.md` for the full design. """) @@ -39,7 +39,7 @@ from streamobs.surveys import Survey from streamobs.model import StreamModel, IsochroneModel -from streamobs.observed import StreamInjector, MultiSurveyInjector +from streamobs.observed import StreamInjector from streamobs import columns as C import os @@ -133,32 +133,31 @@ def get_extinction(self, band, pixel=None): md(r"""## Phase 2 — arbitrary bands + `columns.py` The injector no longer hard-codes `{r, g}`. Column names come from -`streamobs.columns`, using one **uniform** convention: `_true` / -`_obs` / `_err` / `flag_observed` single-survey, and the same with a -`_` prefix multi-survey. (This intentionally drops the historical -`mag_` / `magerr_` names — not backward compatible.) Below we inject -Roman NIR bands `F106`/`F158` through the *single-survey* `StreamInjector` — -impossible under the old `{r,g}` block. +`streamobs.columns`, using one uniform, **always survey-namespaced** convention: +`__true` / `__obs` / `__err` / +`_flag_observed`. (This intentionally drops the historical `mag_` / +`magerr_` names — not backward compatible.) Below we inject Roman NIR bands +`F106`/`F158` through a **single-survey** `StreamInjector` — impossible under the +old `{r,g}` block — and the output is namespaced by the survey's name (`roman`). """) co( - """print("single-survey:", C.true_col("r"), C.obs_col("r"), C.err_col("r"), C.flag_col()) -print("multi-survey :", C.true_col("F158", "roman"), C.obs_col("F158", "roman"), + """print("namespaced columns:", C.true_col("F158", "roman"), C.obs_col("F158", "roman"), C.err_col("F158", "roman"), C.flag_col("roman")) roman_sv = StubSurvey("roman", ["F106", "F158"], completeness_band="F158", maglim=27.0) -inj = StreamInjector(roman_sv) +inj = StreamInjector(roman_sv) # one survey -> namespaced by its name, "roman" N = 1500 df = pd.DataFrame({ "ra": rng.uniform(10, 20, N), "dec": rng.uniform(-5, 5, N), - "F106_true": rng.uniform(20, 28, N), - "F158_true": rng.uniform(20, 28, N), + "roman_F106_true": rng.uniform(20, 28, N), + "roman_F158_true": rng.uniform(20, 28, N), }) out = inj.inject(df, bands=["F106", "F158"], seed=1, verbose=False) print("\\ninjected NIR-only bands -> columns:", - [c for c in out.columns if c.endswith(("_obs", "_err")) or c == "flag_observed"]) -print("detected:", int(out.flag_observed.sum()), "/", len(out))""" + [c for c in out.columns if c.endswith(("_obs", "_err")) or c.endswith("flag_observed")]) +print("detected:", int(out.roman_flag_observed.sum()), "/", len(out))""" ) md(r"""## Phase 3 — multi-band / multi-survey isochrone (exactly `nstars`) @@ -218,18 +217,18 @@ def get_extinction(self, band, pixel=None): print("\\nF158 shift:", (iso._to_ab("F158", x) - x), " (always +1.315)") print("r shift:", (iso._to_ab("r", x) - x), " (0 -> non-Roman pass-through)")""") -md(r"""## Phase 4 — `MultiSurveyInjector` +md(r"""## Phase 4 — one `StreamInjector`, many surveys -One orchestrator, one shared sky placement and shared masses, then per-survey -observed columns and flags. Per-survey RNGs come from `rng.spawn(...)`, so the -result is reproducible and independent of survey order. +The same `StreamInjector` class accepts a `{namespace: survey}` mapping. It does +one shared sky placement and one shared mass draw, then a per-survey loop writing +each survey's observed columns and flags. Per-survey RNGs come from +`rng.spawn(...)`, so the result is reproducible and independent of survey order. """) co( """lsst_sv = StubSurvey("lsst", ["g", "r"], completeness_band="r", maglim=26.0) roman_sv = StubSurvey("roman", ["F106", "F158"], completeness_band="F158", maglim=27.0) -msi = MultiSurveyInjector({"lsst": StreamInjector(lsst_sv), - "roman": StreamInjector(roman_sv)}, primary="lsst") +msi = StreamInjector({"lsst": lsst_sv, "roman": roman_sv}, primary="lsst") # Input carries only stream coordinates; everything else is sampled once. N = 4000 @@ -277,9 +276,10 @@ def get_extinction(self, band, pixel=None): * A band label is used **both** as the ugali isochrone field name and as the key into a survey's maglim/photo-error maps, so they must agree (ugali's Roman fields are upper-case: `F106`, `F158`, ...). -* **`nstars` is now exactly N** (was an emergent IMF count). This is adopted but - intentionally still **flagged for review** in the plan doc, because it changes - what `StreamModel.sample(size)` returns for existing single-survey configs. +* **`nstars` is now exactly N** (was an emergent IMF count). This is the agreed + semantics for both single- and multi-survey configs. +* **Output columns are always survey-namespaced** (`__…`), even for + a single survey — there is no longer an un-namespaced single-survey form. """) nb = new_notebook(cells=cells) diff --git a/streamobs/columns.py b/streamobs/columns.py index d8f8945..86845dd 100644 --- a/streamobs/columns.py +++ b/streamobs/columns.py @@ -2,17 +2,15 @@ Column-name helpers for injected catalogs. These centralize the naming convention so the injector is not hard-coded to -specific bands. A single, uniform ``_true`` / ``_obs`` / -``_err`` convention is used everywhere; the only difference between the -single- and multi-survey cases is an optional survey prefix: - -- **Single-survey** (``survey=None``): ``_true`` (true / noiseless), - ``_obs`` (observed / noisy), ``_err`` (reported error), - ``flag_observed``. -- **Multi-survey** (``survey="roman"``, ``"lsst"``, ...): ``__true``, - ``__obs``, ``__err``, ``_flag_observed``. - Used by :class:`~streamobs.observed.MultiSurveyInjector` so each band's - columns are namespaced by survey. +specific bands. Injected catalogs are **always** survey-namespaced — +``__true`` (true / noiseless), ``__obs`` (observed / +noisy), ``__err`` (reported error), and ``_flag_observed`` +— produced by :class:`~streamobs.observed.StreamInjector` whether it serves one +survey or several (e.g. ``lsst_r_obs``, ``roman_F158_obs``). + +The ``survey`` argument therefore identifies the namespace. ``survey=None`` is +retained only as a low-level fallback that yields the bare ``_…`` / +``flag_observed`` names; the injector itself never uses it. .. note:: This convention intentionally **drops** the historical ``mag_`` / diff --git a/streamobs/model.py b/streamobs/model.py index a093be9..eb01720 100644 --- a/streamobs/model.py +++ b/streamobs/model.py @@ -136,10 +136,8 @@ def sample(self, size): ------- pandas.DataFrame Columns include: ``phi1``, ``phi2``, ``dist``, ``mu1``, ``mu2``, - ``rv``, and the isochrone magnitude columns. For a single-survey - isochrone these are ``_true`` (its two bands); for a - multi-survey isochrone they are ``__true`` per - survey/band. Some may be None if the sub-model is absent. + ``rv``, and the isochrone magnitude columns ``__true`` + (per survey/band). Some may be None if the sub-model is absent. """ # Sample phi1 and phi2 @@ -183,28 +181,24 @@ def sample(self, size): def _iso_mag_columns(self): """Names of the magnitude columns produced by the isochrone model. - Single-survey ⇒ legacy ``[mag_, mag_]``; multi-survey ⇒ - ``[__true, ...]`` for every survey/band; no isochrone ⇒ []. + Always ``[__true, ...]`` for every survey/band the + isochrone carries (a single-survey isochrone simply has one survey); no + isochrone ⇒ ``[]``. ``IsochroneModel`` tracks ``surveys`` / + ``survey_bands`` in both configuration forms, so the naming is uniform. """ iso = self.isochrone if iso is None: return [] - if getattr(iso, "multi_survey", False): - cols = [] - for name in iso.surveys: - band_1, band_2 = iso.survey_bands[name] - cols += [true_col(band_1, name), true_col(band_2, name)] - return cols - return [true_col(iso.band_1), true_col(iso.band_2)] + cols = [] + for name in iso.surveys: + band_1, band_2 = iso.survey_bands[name] + cols += [true_col(band_1, name), true_col(band_2, name)] + return cols def _sample_iso_mags(self, n, dist): - """Sample isochrone magnitudes as a ``{column_name: values}`` dict.""" - iso = self.isochrone - if getattr(iso, "multi_survey", False): - mags = iso.sample_multisurvey(n, dist) - return {true_col(band, name): vals for (name, band), vals in mags.items()} - mag_1, mag_2 = iso.sample(n, dist) - return {true_col(iso.band_1): mag_1, true_col(iso.band_2): mag_2} + """Sample isochrone magnitudes as a ``{__true: values}`` dict.""" + mags = self.isochrone.sample_multisurvey(n, dist) + return {true_col(band, name): vals for (name, band), vals in mags.items()} def complete_catalog( self, @@ -214,6 +208,7 @@ def complete_catalog( inplace=False, save_path=None, verbose=True, + dist=None, ): """Complete only the requested columns in a catalog. @@ -223,6 +218,11 @@ def complete_catalog( using the configured sub-models (density, track, distance modulus, isochrone, velocity) and only if those capabilities are available. + Pre-existing values are never overwritten: for every column only the + missing (absent or NaN) rows are filled. In particular, supplying some + of an isochrone's bands and requesting the others fills only the missing + bands and leaves the provided ones untouched. + Parameters ---------- catalog : pandas.DataFrame or str or dict or None @@ -233,9 +233,8 @@ def complete_catalog( columns_to_add : sequence of str or None, optional The columns to ensure in the output. Valid entries are {'phi1','phi2','dist','mu1','mu2','rv'} plus the isochrone magnitude - columns (``_true`` single-survey, ``__true`` - multi-survey). If None, all valid columns supported by the - configured model are considered. + columns (``__true``). If None, all valid columns + supported by the configured model are considered. size : int or None, optional Required when ``catalog`` is None or an empty table; ignored otherwise. @@ -246,6 +245,12 @@ def complete_catalog( If provided, write the completed catalog to this CSV path. verbose : bool, default True If True, print progress/status messages. + dist : float or array-like or None, optional + Distance modulus to use directly instead of sampling one from the + ``distance_modulus`` sub-model. A scalar is broadcast to every row + that needs a ``dist`` value; an array must have one entry per row. + When given, ``phi1`` and a ``distance_modulus`` model are **not** + required to fill magnitudes. Only missing ``dist`` rows are set. Returns ------- @@ -273,8 +278,7 @@ def complete_catalog( """ # Supported outputs and capability filtering # Columns this method can fill using the configured model - # Magnitude columns are band-/survey-general (_true for a - # single-survey isochrone; __true for multi-survey). + # Magnitude columns are survey-namespaced (__true). mag_cols = self._iso_mag_columns() all_cols = ("phi1", "phi2", "dist") + tuple(mag_cols) + ("mu1", "mu2", "rv") target_cols = ( @@ -295,7 +299,7 @@ def complete_catalog( target_cols = [c for c in target_cols if c not in ("mu1", "mu2", "rv")] if removed: self._info(verbose, "Velocity model not defined; skipping velocities.") - if self.distance_modulus is None: + if self.distance_modulus is None and dist is None: removed = [c for c in target_cols if c == "dist"] target_cols = [c for c in target_cols if c != "dist"] if removed: @@ -336,39 +340,69 @@ def complete_catalog( ): idx = self._missing_idx(df, "dist") if len(idx) > 0: - if "phi1" not in df.columns or df["phi1"].isna().any(): - raise ValueError( - "phi1 required to sample dist; include 'phi1' in columns_to_add or provide it in catalog" + if dist is not None: + # Use the distance supplied directly (scalar broadcast or + # per-row vector); no phi1 / distance_modulus model needed. + dist_arr = np.asarray(dist, dtype=float) + if dist_arr.ndim == 0: + df.loc[idx, "dist"] = float(dist_arr) + else: + if dist_arr.shape[0] != N: + raise ValueError( + f"dist vector has length {dist_arr.shape[0]} but " + f"the catalog has {N} rows." + ) + pos = df.index.get_indexer(idx) + df.loc[idx, "dist"] = dist_arr[pos] + self._info(verbose, f"Set {len(idx)} dist values from `dist`.") + else: + if self.distance_modulus is None: + raise ValueError( + "No distance_modulus model is configured; pass `dist` " + "(a float or per-row vector) to set distances." + ) + if "phi1" not in df.columns or df["phi1"].isna().any(): + raise ValueError( + "phi1 required to sample dist; include 'phi1' in columns_to_add or provide it in catalog" + ) + + df.loc[idx, "dist"] = self.distance_modulus.sample( + df.loc[idx, "phi1"].to_numpy() ) - - df.loc[idx, "dist"] = self.distance_modulus.sample( - df.loc[idx, "phi1"].to_numpy() - ) - self._info(verbose, f"Filled {len(idx)} dist values.") + self._info(verbose, f"Filled {len(idx)} dist values.") # magnitudes (need dist and isochrone) - if any(c in target_cols for c in mag_cols): - if all(c in df.columns for c in mag_cols): + requested_mags = [c for c in mag_cols if c in target_cols] + if requested_mags: + # Only touch rows that are missing a requested band; existing values + # are preserved (never overwritten). + missing = {c: self._missing_idx(df, c) for c in requested_mags} + to_fill = {c: idx for c, idx in missing.items() if len(idx) > 0} + if not to_fill: self._info( verbose, - f"{mag_cols} already exist; no sampling performed.", + f"{requested_mags} already present; no sampling performed.", ) else: - # Verify distance modulus availability + # Verify distance availability if "dist" not in df.columns: raise ValueError( - "dist is required to sample apparent magnitudes; include 'dist' in `columns_to_add` or provide it in catalog" + "dist is required to sample apparent magnitudes; include 'dist' in `columns_to_add`, provide it in the catalog, or pass `dist=`." ) dist_vals = df["dist"].to_numpy() - # Sample all bands together to keep colors consistent across rows - if any(c in df.columns for c in mag_cols): - self._info( - verbose, - "Overwriting existing magnitude columns to keep colors consistent.", - ) - for col, vals in self._sample_iso_mags(N, dist_vals).items(): - df[col] = vals - self._info(verbose, f"Filled magnitudes for {N} rows.") + # One shared mass draw -> all bands; the newly filled cells are + # mutually colour-consistent. Assign only the missing rows so any + # bands/values already present are left untouched. + mags = self._sample_iso_mags(N, dist_vals) + for col, idx in to_fill.items(): + pos = df.index.get_indexer(idx) + if col not in df.columns: + df[col] = np.nan + df.loc[idx, col] = np.asarray(mags[col])[pos] + self._info( + verbose, + f"Filled magnitudes for {sorted(to_fill)} (missing rows only).", + ) # velocities (need phi1 and velocity model) if any(c in target_cols for c in ("mu1", "mu2", "rv")): diff --git a/streamobs/observed.py b/streamobs/observed.py index 735e719..06c0b4b 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -18,15 +18,32 @@ class StreamInjector: """ - Inject observational effects into stream data for a given survey. + Inject observational effects into stream data for one or more surveys. - This class handles the core injection logic while keeping survey data separate. - All survey data is loaded once and cached, making multiple injections efficient. + A single injector handles both the single- and multi-survey cases: pass one + survey or several. The same shared sky placement and a single shared draw of + true magnitudes (masses sampled once via the isochrone and interpolated into + every survey's bands) guarantee the **same physical star** gets consistent + magnitudes across surveys. Each survey contributes its own + ``__obs`` / ``__err`` / ``_flag_observed`` + columns, computed with that survey's own maglim maps and completeness + functions. Output columns are **always** survey-namespaced, even for a single + survey. + + All survey data is loaded once and cached, making multiple injections + efficient. Attributes ---------- + surveys : dict + ``{namespace: Survey}`` for every survey this injector serves. The + namespace is the column prefix (``lsst_r_obs``, ``roman_F158_obs``, ...). + primary : str + Namespace of the survey whose footprint drives the shared sky placement + and whose ``_save_injected_data`` is used. survey : Survey - Survey instance containing all survey-specific data and functions. + The primary :class:`~streamobs.surveys.Survey` (convenience accessor used + by the mask / coordinate helpers; equal to ``surveys[primary]``). mask_cache : dict (class attribute) Cache of previously created HEALPix masks to avoid recomputation. _last_gc_frame : GreatCircleICRSFrame or None @@ -35,74 +52,148 @@ class StreamInjector: Examples -------- - Initialize with a survey: + Single survey (columns namespaced by the survey's name): >>> injector = StreamInjector('lsst', release='dc2') + >>> out = injector.inject(df, bands=['r', 'g']) # -> lsst_r_obs, ... - Or with a pre-loaded Survey object: + Several surveys at once: - >>> survey = Survey.load('lsst', release='dc2') - >>> injector = StreamInjector(survey) + >>> injector = StreamInjector({'lsst': 'lsst', 'roman': 'roman'}) + >>> out = injector.inject( + ... df, survey_bands={'lsst': ['r', 'g'], 'roman': ['F106', 'F158']}, + ... stream_config=scene['stream'], seed=42, + ... ) """ mask_cache = {} - def __init__(self, survey, **kwargs): + def __init__(self, survey, primary=None, **kwargs): """ - Initialize with survey configuration. + Initialize with one or more survey configurations. Parameters ---------- - survey : str or Survey - Either a survey name string (e.g., 'lsst') or a pre-loaded Survey instance. + survey : str, Survey, dict, or list + One survey or several. Accepted forms: + + - a survey-name string (e.g. ``'lsst'``) or a pre-loaded + :class:`~streamobs.surveys.Survey` — a single survey, namespaced + by its own name; + - a ``{namespace: spec}`` dict, where ``spec`` is a name string or a + ``Survey`` and the key is the column namespace; + - a list/tuple of specs, each namespaced by its survey's name. + primary : str, optional + Namespace of the survey that drives the shared sky placement. + Defaults to the first survey. **kwargs - Additional keyword arguments passed to Survey.load() if survey is a string. - Common options include: - - release : str, optional - Survey release version (e.g., 'dc2', 'yr1', 'yr10'). + Forwarded to :meth:`Survey.load` for any ``spec`` given as a name + string (e.g. ``release``). Raises ------ ValueError - If survey is neither a string nor a Survey instance. + If ``surveys`` is empty or of an unsupported type, or if ``primary`` + is not one of the provided surveys. """ - - if isinstance(survey, str): - self.survey = Survey.load(survey=survey, **kwargs) - elif isinstance(survey, Survey): - self.survey = survey - else: - raise ValueError("survey must be a string or Survey instance.") + self.surveys = self._normalize_surveys(survey, **kwargs) + self.survey_names = list(self.surveys) + if not self.survey_names: + raise ValueError("At least one survey is required.") + self.primary = primary if primary is not None else self.survey_names[0] + if self.primary not in self.surveys: + raise ValueError( + f"primary='{self.primary}' is not one of {self.survey_names}." + ) # Instance attribute to store the last used gc_frame self._last_gc_frame = None - def inject(self, data, bands=["r", "g"], **kwargs): + @property + def survey(self): + """The primary :class:`~streamobs.surveys.Survey`. + + Mask, coordinate and footprint helpers operate on this survey. """ - Add observed quantities from the survey to the given data. + return self.surveys[self.primary] - This method applies observational effects including photometric errors, - magnitude measurements, and detection flags based on survey properties. + @classmethod + def _normalize_surveys(cls, surveys, **kwargs): + """Coerce the ``surveys`` argument into a ``{namespace: Survey}`` dict.""" + if isinstance(surveys, (str, Survey)): + survey = cls._load_survey(surveys, **kwargs) + return {survey.name: survey} + if isinstance(surveys, (list, tuple)): + out = {} + for spec in surveys: + survey = cls._load_survey(spec, **kwargs) + out[survey.name] = survey + return out + if isinstance(surveys, dict): + return { + name: cls._load_survey(spec, **kwargs) for name, spec in surveys.items() + } + raise ValueError( + "surveys must be a survey name, a Survey, a {name: spec} dict, " + "or a list of specs." + ) + + @staticmethod + def _load_survey(spec, **kwargs): + """Resolve a single survey spec (name string or Survey) to a Survey.""" + if isinstance(spec, Survey): + return spec + if isinstance(spec, str): + return Survey.load(survey=spec, **kwargs) + raise ValueError("Each survey spec must be a string or Survey instance.") + + def inject(self, data, survey_bands=None, bands=None, stream_config=None, **kwargs): + """ + Add observed quantities from every survey into a single catalog. + + Applies observational effects (photometric errors, measured magnitudes, + detection flags) for each survey this injector serves. A single shared + sky placement and a single shared true-magnitude fill (masses sampled + once and interpolated into every survey's bands) ensure the same physical + star is consistent across surveys. Output columns are always + survey-namespaced (``__obs`` etc.). Parameters ---------- data : str or pd.DataFrame - Input data as DataFrame or path to the file (CSV or Excel). - Must contain either (ra, dec) or (phi1, phi2) coordinates, and - magnitude columns for the specified bands. + Input data as DataFrame or path to the file (CSV or Excel). May + contain only stream coordinates (``phi1``/``phi2`` or ``ra``/``dec``); + anything missing is sampled from ``stream_config``. An all-empty frame + of length ``N`` is accepted (geometry and magnitudes are then sampled + for ``N`` rows). + survey_bands : dict, optional + ``{survey_name: [bands]}`` — bands to inject for each survey. Keys + must match the surveys this injector was built with. For a single + survey you may instead pass ``bands`` (below). bands : list of str, optional - List of photometric bands to process. Default is ['r', 'g']. + Convenience shorthand for the single-survey case: the bands to inject + for the (only) survey. Ignored when ``survey_bands`` is given. If + neither is provided and there is exactly one survey, defaults to + ``['r', 'g']``. + stream_config : dict, optional + The ``stream`` section consumed by + :class:`~streamobs.model.StreamModel`. Required when any coordinate + or true-magnitude column is missing. Its isochrone produces the + shared ``__true`` columns. **kwargs Additional keyword arguments: seed : int, optional Random seed for reproducibility. + dist : float or array-like, optional + Distance modulus used directly (scalar broadcast or per-row + vector) instead of sampling from the config's ``distance_modulus`` + model — lets magnitudes be filled without ``phi1``. nside : int, optional HEALPix nside parameter. Default is 4096. detection_mag_cut : list of str, optional Bands to apply the SNR detection cut to. Default is all injected - bands (every band in ``bands`` must have SNR >= 5). + bands (every injected band must have SNR >= 5). save : bool, optional Whether to save the output data. Default is False. folder : str or Path, optional @@ -118,19 +209,25 @@ def inject(self, data, bands=["r", "g"], **kwargs): Returns ------- pd.DataFrame - DataFrame with the following added columns: + DataFrame with shared ``ra``/``dec`` and, per survey: - - _obs : Observed magnitudes for each band - - _err : Photometric errors for each band - - flag_observed : Boolean flag (True=detected, False=not detected). Includes both detection and classification efficiencies. - - flag_perfect_galstarsep : Boolean flag assuming perfect star/galaxy separation (detection efficiency only, no classification losses; only if requested with perfect_galstarsep=True) - - ra, dec : Sky coordinates (if not already present) + - __true : True (noiseless) apparent magnitudes + - __obs : Observed (noisy) magnitudes + - __err : Reported photometric errors + - _flag_observed : Boolean detection flag (detection and + classification efficiencies) + - _flag_perfect_galstarsep : Boolean flag assuming perfect + star/galaxy separation (only if perfect_galstarsep=True) Raises ------ ValueError - If required columns are missing or bands are not supported. + If required columns are missing, or if ``survey_bands`` references an + unknown survey, or if neither ``survey_bands`` nor ``bands`` can be + resolved. """ + survey_bands = self._resolve_survey_bands(survey_bands, bands) + # Load data data = self._load_data(data) @@ -138,15 +235,32 @@ def inject(self, data, bands=["r", "g"], **kwargs): seed = kwargs.pop("seed", None) rng = np.random.default_rng(seed) - # Complete missing columns (ra/dec, magnitudes) - data = self.complete_data(data, rng=rng, seed=seed, bands=bands, **kwargs) - - # Run the per-survey observational injection using the legacy column - # names (survey_namespace=None). - data = self._inject_one_survey( - data, bands, rng=rng, seed=seed, survey_namespace=None, **kwargs + # Shared sky placement + shared true-magnitude fill (masses sampled once + # across all surveys). + data = self._complete_shared( + data, + survey_bands, + stream_config=stream_config, + rng=rng, + seed=seed, + **kwargs, ) + # Per-survey observational injection. Independent child RNGs make the + # result independent of survey ordering and reproducible from `seed`. + children = rng.spawn(len(self.survey_names)) + for child_rng, name in zip(children, self.survey_names): + if name not in survey_bands: + continue + data = self._inject_one_survey( + data, + list(survey_bands[name]), + survey=self.surveys[name], + survey_namespace=name, + rng=child_rng, + **kwargs, + ) + # Save if requested if kwargs.get("save"): self._save_injected_data(data, kwargs.get("folder", None)) @@ -154,15 +268,40 @@ def inject(self, data, bands=["r", "g"], **kwargs): # Return data (do NOT store as instance attribute to avoid conflicts between runs) return data + def _resolve_survey_bands(self, survey_bands, bands): + """Normalize the ``survey_bands`` / ``bands`` arguments to a dict. + + ``survey_bands`` wins if given (validated against the known surveys). + Otherwise ``bands`` is accepted only when there is a single survey; if + neither is given and there is one survey, defaults to ``['r', 'g']``. + """ + if survey_bands is not None: + unknown = set(survey_bands) - set(self.surveys) + if unknown: + raise ValueError( + f"survey_bands references unknown surveys {sorted(unknown)}; " + f"available: {self.survey_names}." + ) + return {name: list(b) for name, b in survey_bands.items()} + + if len(self.survey_names) != 1: + raise ValueError( + "Pass survey_bands={name: [bands]} when the injector serves " + f"multiple surveys ({self.survey_names})." + ) + if bands is None: + bands = ["r", "g"] + return {self.primary: list(bands)} + def _inject_one_survey( - self, data, bands, rng=None, seed=None, survey_namespace=None, **kwargs + self, data, bands, survey, survey_namespace, rng=None, seed=None, **kwargs ): - """Add this survey's observed magnitudes, errors and detection flags. + """Add one survey's observed magnitudes, errors and detection flags. - This holds the per-band observational logic shared by single-survey - :meth:`inject` and :class:`MultiSurveyInjector`. It assumes ``data`` - already carries ``ra``/``dec`` and the true-magnitude columns for the - requested bands; it does **not** sample positions or true magnitudes. + This holds the per-band observational logic. It assumes ``data`` already + carries ``ra``/``dec`` and the true-magnitude columns + (``true_col(band, survey_namespace)``) for the requested bands; it does + **not** sample positions or true magnitudes. Parameters ---------- @@ -171,15 +310,15 @@ def _inject_one_survey( for every requested band. bands : list of str Bands to process for this survey. + survey : Survey + The survey supplying maglim maps, completeness and error curves. + survey_namespace : str + Column-naming namespace ⇒ ``__obs`` / + ``__err`` / ``_flag_observed``. rng : numpy.random.Generator, optional Random generator for the noise draw and detection sampling. seed : int, optional Seed used to build an RNG when ``rng`` is None. - survey_namespace : str or None, optional - Column-naming namespace. ``None`` ⇒ single-survey names - (``_obs`` / ``_err`` / ``flag_observed``); - a survey name ⇒ ``__obs`` / ``__err`` / - ``_flag_observed``. **kwargs ``nside``, ``detection_mag_cut``, ``dust_correction``, ``perfect_galstarsep``, ``verbose`` (see :meth:`inject`). @@ -206,18 +345,18 @@ def _inject_one_survey( # Process each band for band in bands: # Get extinction for this band - nside_ebv = hp.get_nside(self.survey.ebv_map) + nside_ebv = hp.get_nside(survey.ebv_map) if nside_ebv != nside: pix_ebv = hp.ang2pix(nside_ebv, data["ra"], data["dec"], lonlat=True) else: pix_ebv = pix - extinction_band = self.survey.get_extinction(band, pixel=pix_ebv) + extinction_band = survey.get_extinction(band, pixel=pix_ebv) # Calculate true apparent magnitudes (including extinction) apparent_mag_true = data[true_col(band, survey_namespace)] + extinction_band # Get magnitude limits - nside_maglim = hp.get_nside(self.survey.maglim_maps[band]) + nside_maglim = hp.get_nside(survey.maglim_maps[band]) if nside_maglim != nside: pix_maglim = hp.ang2pix( nside_maglim, data["ra"], data["dec"], lonlat=True @@ -230,11 +369,11 @@ def _inject_one_survey( # as magerr and used for the S/N cut. When no sample curve is loaded, # the sample error falls back to the catalog error, so the two are # identical (outputs unchanged from the single-curve behaviour). - maglim_vals = self.survey.get_maglim(band, pixel=pix_maglim) - mag_err_sample = self.survey.get_photo_error( + maglim_vals = survey.get_maglim(band, pixel=pix_maglim) + mag_err_sample = survey.get_photo_error( band, apparent_mag_true, maglim_vals, kind="sample" ) - mag_err = self.survey.get_photo_error( + mag_err = survey.get_photo_error( band, apparent_mag_true, maglim_vals, kind="catalog" ) @@ -277,9 +416,10 @@ def _inject_one_survey( data = pd.concat([data, new_columns], axis=1) # Compute detection flag for completeness-band (reference band) - if band == self.survey.completeness_band: + if band == survey.completeness_band: flag_completeness_band = self.detect_flag( pix_maglim, + survey=survey, mag=apparent_mag_true, band=band, rng=rng, @@ -290,6 +430,7 @@ def _inject_one_survey( if perfect_galstarsep: flag_detection_only_band = self.detect_flag( pix_maglim, + survey=survey, mag=apparent_mag_true, band=band, rng=rng, @@ -300,13 +441,13 @@ def _inject_one_survey( # Apply detection threshold if flag_completeness_band is None: - if self.survey.completeness_band in bands: + if survey.completeness_band in bands: raise ValueError( - f"flag_completeness_{self.survey.completeness_band} must be computed for detection in {self.survey.completeness_band} band." + f"flag_completeness_{survey.completeness_band} must be computed for detection in {survey.completeness_band} band." ) else: raise ValueError( - f"Detection flag requires '{self.survey.completeness_band}' band to be in bands." + f"Detection flag requires '{survey.completeness_band}' band to be in bands." ) # Build combined detection flags @@ -353,9 +494,7 @@ def _inject_one_survey( # (the SNR cut is baked into the completeness functions but not into the # detection-only efficiency functions used for the perfect flag). if perfect_galstarsep: - SNR_compl = ( - 1.0 / data[err_col(self.survey.completeness_band, survey_namespace)] - ) + SNR_compl = 1.0 / data[err_col(survey.completeness_band, survey_namespace)] flag_perfect &= SNR_compl >= SNR_min # Store flags in DataFrame @@ -397,150 +536,118 @@ def _load_data(self, data): else: raise ValueError(f"Unsupported file format") - def complete_data(self, data, bands=["r", "g"], **kwargs): - """ - Validate and complete the columns needed for injection. + def complete_data( + self, + data, + survey_bands=None, + bands=None, + stream_config=None, + dist=None, + **kwargs, + ): + """Complete the columns the injector needs, filling the rest from the config. - This function ensures sky coordinates are present and, if requested, - fills missing photometric magnitude columns using a stream model. - Specifically: + Public helper: give it a (possibly partial) catalog and it returns one + with everything the injector requires present — sky coordinates + (``ra``/``dec``, converting from ``phi1``/``phi2`` if needed) and the + per-survey true-magnitude columns ``__true``. Anything + already present is preserved; only missing columns are sampled, using + ``stream_config`` (a :class:`~streamobs.model.StreamModel` config). The + stellar masses are drawn **once** and interpolated into every survey's + bands, so the same physical star is consistent across surveys. - - If (ra, dec) are missing but (phi1, phi2) exist, it converts to - sky coordinates via ``phi_to_radec``. - - It checks for ``mag_`` for each requested band; any missing - bands are generated via ``StreamModel.complete_catalog`` when a - ``stream_config`` is provided. - - Existing columns are preserved and are not overwritten. + This is the same completion :meth:`inject` runs internally, exposed so + you can build/inspect a completed catalog without injecting noise. Parameters ---------- - data : pandas.DataFrame - Input catalog. Must contain either (ra, dec) or (phi1, phi2). - The DataFrame is copied; the input object is not modified in place. - bands : list[str], optional - Photometric bands to ensure (as ``mag_``). Default is - ``['r', 'g']``. + data : str or pandas.DataFrame + Input catalog (or path). May contain only stream coordinates + (``phi1``/``phi2`` or ``ra``/``dec``), an all-empty frame of length + ``N``, or any subset of the target columns. + survey_bands : dict, optional + ``{survey_name: [bands]}`` — the true-magnitude columns to ensure per + survey. For a single survey you may instead pass ``bands``; if neither + is given and there is exactly one survey, defaults to ``['r', 'g']``. + bands : list of str, optional + Single-survey shorthand for ``survey_bands={primary: bands}``. + stream_config : dict, optional + :class:`~streamobs.model.StreamModel` config used to sample any + missing geometry / true magnitudes. Required only when something is + missing. + dist : float or array-like or None, optional + Distance modulus to use directly (scalar broadcast or per-row + vector) instead of sampling from the config's ``distance_modulus`` + model. Lets magnitudes be filled without ``phi1`` / a distance model. **kwargs - Additional options: - - rng : numpy.random.Generator, optional - Random number generator instance. - seed : int, optional - Random seed used to initialize an RNG if ``rng`` is not given. - gc_frame : gala.coordinates.GreatCircleICRSFrame or 'last', optional - Great circle frame to use. If 'last', uses the frame from the - previous call. If None, generates a new random frame. - stream_config : dict, optional - Configuration passed to ``StreamModel``. Required only when at - least one requested magnitude band is missing. See - ``StreamModel`` for the expected schema (e.g., track, distance - modulus, isochrone). - - Keyword arguments forwarded to ``phi_to_radec`` (only used when - converting from (phi1, phi2)): - - mask_type : list[str] or str, optional - Mask(s) used when searching a frame (e.g., 'footprint', - 'maglim_r', 'ebv'). - percentile_threshold : float, optional - Fraction of points that must lie inside the mask when selecting - a frame. Default defined in ``phi_to_radec``. - max_iter : int, optional - Maximum trials when searching a frame. Default defined in - ``phi_to_radec``. + ``rng`` / ``seed`` for reproducibility, plus ``gc_frame``, + ``mask_type``, ``percentile_threshold``, ``max_iter`` forwarded to + :meth:`phi_to_radec` when converting ``phi1``/``phi2`` → ``ra``/``dec``. Returns ------- pandas.DataFrame - A copy of the input with the required columns present: - ``ra``, ``dec``, and one ``mag_`` column per requested band. + A copy of the input with ``ra``/``dec`` and the requested + ``__true`` columns present. Raises ------ ValueError - If neither (ra, dec) nor (phi1, phi2) are present; or if one or - more magnitude bands are missing and ``stream_config`` is not - provided; or if after completion a required column is still absent. - - Notes - ----- - - Only missing magnitude columns are synthesized; existing values are - left untouched. - - Magnitudes are produced by ``StreamModel.complete_catalog`` and rely - on the model's configuration (e.g., isochrone and distance modulus). - - When a new gc_frame is created or used, it is stored in ``self._last_gc_frame`` - for potential reuse via ``gc_frame='last'``. + If neither (ra, dec) nor (phi1, phi2) are present, or if columns are + missing and ``stream_config`` is not provided. Examples -------- - Convert from (phi1, phi2) and generate both bands: - >>> df = pd.DataFrame({'phi1': [-5, 0, 5], 'phi2': [0, 0, 0]}) - >>> cfg = {...} # stream model config >>> out = injector.complete_data(df, bands=['r', 'g'], stream_config=cfg) - - Use already existing ra/dec and fill a missing 'g' band from a model: - - >>> df = pd.DataFrame({'phi1': [-5, 0, 5], 'phi2': [0, 0, 0], 'ra': [10.1, 12.5, 24.7], 'dec': [5.2, 6.2, 7.2],}) - >>> out = injector.complete_data(df, bands=['r', 'g'], stream_config=cfg, seed=42) - - Reuse the same gc_frame for multiple streams: - - >>> data1 = injector.complete_data(df1, seed=42) # Creates new frame - >>> data2 = injector.complete_data(df2, gc_frame='last') # Reuses frame from data1 + >>> out = injector.complete_data( + ... df, survey_bands={'lsst': ['r', 'g'], 'roman': ['F106', 'F158']}, + ... stream_config=cfg, seed=42, + ... ) """ - - required_columns = ["ra", "dec"] + [true_col(band) for band in bands] + survey_bands = self._resolve_survey_bands(survey_bands, bands) + data = self._load_data(data).copy() rng = kwargs.pop("rng", None) seed = kwargs.pop("seed", None) + if rng is None: + rng = np.random.default_rng(seed) - # Make explicit copy to avoid SettingWithCopyWarning - data = data.copy() + return self._complete_shared( + data, + survey_bands, + stream_config=stream_config, + rng=rng, + seed=seed, + dist=dist, + **kwargs, + ) - if not ("ra" in data.columns and "dec" in data.columns): - if "phi1" not in data.columns or "phi2" not in data.columns: - raise ValueError( - "Input data must contain either (ra, dec) or (phi1, phi2) columns." - ) + def _ensure_radec(self, data, rng=None, seed=None, **kwargs): + """Ensure ``ra``/``dec`` are present, converting from (phi1, phi2) if needed. - # Handle 'last' keyword for gc_frame - gc_frame_param = kwargs.get("gc_frame", None) - if gc_frame_param == "last": - kwargs["gc_frame"] = self._last_gc_frame + Existing ``ra``/``dec`` are left untouched. When converting, the great + circle frame is found (or reused via ``gc_frame='last'``) through + :meth:`phi_to_radec`, using the primary survey's footprint. + """ + if "ra" in data.columns and "dec" in data.columns: + return data - # Convert coordinates (Phi1, Phi2) into (ra,dec) - stream_coord = self.phi_to_radec( - data["phi1"], - data["phi2"], - seed=seed, - rng=rng, - **kwargs, - ) - data.loc[:, "ra"] = stream_coord.icrs.ra.deg - data.loc[:, "dec"] = stream_coord.icrs.dec.deg - - # Sample missing magnitudes if needed - mag_bands_missing = [ - true_col(band) for band in bands if true_col(band) not in data.columns - ] - if mag_bands_missing: - stream_config = kwargs.get("stream_config", None) - if stream_config is None: - raise ValueError( - "`stream_config` must be provided to sample missing magnitudes." - ) - stream_model = StreamModel(stream_config) - data = stream_model.complete_catalog( - data, - inplace=True, - columns_to_add=mag_bands_missing, + if "phi1" not in data.columns or "phi2" not in data.columns: + raise ValueError( + "Input data must contain either (ra, dec) or (phi1, phi2) columns." ) - for col in required_columns: - if col not in data.columns: - raise ValueError(f"Input data must contain '{col}' column.") + # Handle 'last' keyword for gc_frame + if kwargs.get("gc_frame", None) == "last": + kwargs["gc_frame"] = self._last_gc_frame + # Convert coordinates (phi1, phi2) into (ra, dec) + stream_coord = self.phi_to_radec( + data["phi1"], data["phi2"], seed=seed, rng=rng, **kwargs + ) + data.loc[:, "ra"] = stream_coord.icrs.ra.deg + data.loc[:, "dec"] = stream_coord.icrs.dec.deg return data def phi_to_radec( @@ -971,7 +1078,7 @@ def sample_measured_magnitudes(self, mag_true, mag_err, **kwargs): return mag_obs - def detect_flag(self, pix, mag=None, band="r", **kwargs): + def detect_flag(self, pix, mag=None, band="r", survey=None, **kwargs): """ Apply the survey selection to determine detection flags for stars. @@ -986,6 +1093,9 @@ def detect_flag(self, pix, mag=None, band="r", **kwargs): Magnitude(s). Default is None. band : str, optional Band to consider for detection. Default is 'r'. + survey : Survey, optional + Survey whose completeness/detection-efficiency curves to use. + Defaults to the primary survey. **kwargs Additional keyword arguments: @@ -1012,14 +1122,17 @@ def detect_flag(self, pix, mag=None, band="r", **kwargs): seed = kwargs.pop("seed", None) rng = np.random.default_rng(seed) + if survey is None: + survey = self.survey + # Select the appropriate magnitude and map depending on the band - maglim = self.survey.get_maglim(band, pixel=pix) + maglim = survey.get_maglim(band, pixel=pix) perfect_galstarsep = kwargs.get("perfect_galstarsep", False) if perfect_galstarsep: - compl = self.survey.get_detection_efficiency(band, mag, maglim) + compl = survey.get_detection_efficiency(band, mag, maglim) else: - compl = self.survey.get_completeness(band, mag, maglim) + compl = survey.get_completeness(band, mag, maglim) # Set the threshold using completeness threshold = rng.uniform(size=len(mag)) <= compl @@ -1201,160 +1314,26 @@ def plot_stream_in_mask(self, data, mask_type, ebv_threshold=0.2, **kwargs): ) return fig, ax - -class MultiSurveyInjector: - """Inject stream observations for several surveys into one catalog. - - The orchestrator holds one :class:`StreamInjector` per survey and delegates - the per-survey observational work to each (it is *not* a composite - ``Survey``). A single shared sky placement and a single shared draw of true - magnitudes — masses are sampled once via a multi-survey - :class:`~streamobs.model.IsochroneModel` and interpolated into every - survey's bands — guarantee that the **same physical star** gets consistent - magnitudes across surveys. Each survey then contributes its own - ``__obs`` / ``__err`` / ``_flag_observed`` - columns, computed with its own maglim maps and completeness functions. - - Parameters - ---------- - surveys : dict or list - Either ``{name: spec}`` or a list of ``spec``, where ``spec`` is a - survey-name string, a :class:`~streamobs.surveys.Survey`, or a - pre-built :class:`StreamInjector`. The dict key is used as the column - namespace; for a list, the survey's own name is used. - primary : str, optional - Name of the survey whose footprint drives the shared sky placement and - whose ``_save_injected_data`` is used. Defaults to the first survey. - **kwargs - Forwarded to :meth:`StreamInjector` construction when a ``spec`` is a - name/``Survey`` rather than an injector (e.g. ``release``). - - Examples - -------- - >>> msi = MultiSurveyInjector({"lsst": "lsst", "roman": "roman"}) - >>> out = msi.inject( - ... df, survey_bands={"lsst": ["r", "g"], "roman": ["f106", "f158"]}, - ... stream_config=scene["stream"], seed=42, - ... ) - """ - - def __init__(self, surveys, primary=None, **kwargs): - if isinstance(surveys, (list, tuple)): - surveys = {self._spec_name(s): s for s in surveys} - if not isinstance(surveys, dict): - raise ValueError("surveys must be a dict {name: spec} or a list of specs.") - - self.injectors = {} - for name, spec in surveys.items(): - if isinstance(spec, StreamInjector): - self.injectors[name] = spec - else: - self.injectors[name] = StreamInjector(spec, **kwargs) - - self.survey_names = list(self.injectors) - if not self.survey_names: - raise ValueError("At least one survey is required.") - self.primary = primary if primary is not None else self.survey_names[0] - if self.primary not in self.injectors: - raise ValueError( - f"primary='{self.primary}' is not one of {self.survey_names}." - ) - - # Shared sky placement is cached here, mirroring StreamInjector. - self._last_gc_frame = None - - @staticmethod - def _spec_name(spec): - """Best-effort survey name for a spec passed in a list.""" - if isinstance(spec, StreamInjector): - return spec.survey.name - if isinstance(spec, Survey): - return spec.name - return str(spec) - - def inject(self, data, survey_bands, stream_config=None, **kwargs): - """Inject observations for every survey into a single catalog. - - Parameters - ---------- - data : str or pandas.DataFrame - Input catalog (or path). May contain only stream coordinates - (``phi1``/``phi2`` or ``ra``/``dec``); anything missing is sampled - from ``stream_config``. An all-empty frame of length ``N`` is also - accepted (geometry and magnitudes are then sampled for ``N`` rows). - survey_bands : dict - ``{survey_name: [bands]}`` — the bands to inject for each survey. - Keys must match the surveys this orchestrator was built with. - stream_config : dict, optional - The ``stream`` section consumed by - :class:`~streamobs.model.StreamModel`. Its ``isochrone`` must be in - the multi-survey form so the same shared masses produce every - survey's ``__true`` columns. Required when any - coordinate or true-magnitude column is missing. - **kwargs - ``seed``, ``nside``, ``detection_mag_cut``, ``dust_correction``, - ``perfect_galstarsep``, ``gc_frame``, ``mask_type``, ``save``, - ``folder``, ``verbose`` — see :meth:`StreamInjector.inject`. - - Returns - ------- - pandas.DataFrame - Catalog with shared ``ra``/``dec`` and, per survey, - ``__true/_obs/_err`` and ``_flag_observed``. - """ - unknown = set(survey_bands) - set(self.injectors) - if unknown: - raise ValueError( - f"survey_bands references unknown surveys {sorted(unknown)}; " - f"available: {self.survey_names}." - ) - - ref = self.injectors[self.primary] - data = ref._load_data(data) - - seed = kwargs.pop("seed", None) - rng = np.random.default_rng(seed) - - # (1)+(2) Shared sky placement and shared true-magnitude fill (masses - # sampled once across all surveys). - data = self._complete_shared( - data, - survey_bands, - stream_config=stream_config, - rng=rng, - seed=seed, - **kwargs, - ) - - # (3) Per-survey observational injection. Independent child RNGs make the - # result independent of survey ordering and reproducible from `seed`. - children = rng.spawn(len(self.survey_names)) - for child_rng, name in zip(children, self.survey_names): - if name not in survey_bands: - continue - data = self.injectors[name]._inject_one_survey( - data, - list(survey_bands[name]), - rng=child_rng, - survey_namespace=name, - **kwargs, - ) - - if kwargs.get("save"): - ref._save_injected_data(data, kwargs.get("folder", None)) - - return data - def _complete_shared( - self, data, survey_bands, stream_config=None, rng=None, seed=None, **kwargs + self, + data, + survey_bands, + stream_config=None, + rng=None, + seed=None, + dist=None, + **kwargs, ): """Fill shared geometry, ``ra``/``dec`` and per-survey true magnitudes. Positions and masses are drawn *once* so all surveys describe the same - physical stars. Existing columns are preserved. + physical stars (the isochrone produces every survey's + ``__true`` column from one shared mass draw). Existing + columns are preserved (only missing values are filled). ``ra``/``dec`` + are placed using the primary survey's footprint. ``dist`` (a float or + per-row vector) overrides the model's distance sampling when given. """ verbose = kwargs.get("verbose", True) - ref = self.injectors[self.primary] true_cols = [] for name, bands in survey_bands.items(): @@ -1375,15 +1354,19 @@ def _complete_shared( cols_to_add = [] if need_phi: cols_to_add += ["phi1", "phi2"] - # `dist` is needed before magnitudes; the model fills it if absent. + # `dist` is needed before magnitudes; the model fills it (from the + # distance_modulus model or the supplied `dist`) if absent. cols_to_add += ["dist"] + missing_true data = stream_model.complete_catalog( - data, columns_to_add=cols_to_add, inplace=True, verbose=verbose + data, + columns_to_add=cols_to_add, + inplace=True, + verbose=verbose, + dist=dist, ) # Convert (phi1, phi2) -> (ra, dec) using the primary survey footprint. if not have_radec: - data = ref.complete_data(data, bands=[], rng=rng, seed=seed, **kwargs) - self._last_gc_frame = ref._last_gc_frame + data = self._ensure_radec(data, rng=rng, seed=seed, **kwargs) return data diff --git a/tests/test_model.py b/tests/test_model.py index ee02115..bded770 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -17,7 +17,6 @@ TrackModel, ) - # --------------------------------------------------------------------------- # Helpers # --------------------------------------------------------------------------- @@ -29,6 +28,7 @@ # DensityModel # --------------------------------------------------------------------------- + @pytest.mark.model class TestDensityModel: """Unit tests for DensityModel (phi1 sampler).""" @@ -46,8 +46,9 @@ def test_uniform_sample(self): cfg = {"type": "uniform", "xmin": -10.0, "xmax": 10.0} model = DensityModel(cfg) samples = self._verify_sampling(model) - assert np.all(samples>cfg["xmin"]) and np.all(samples cfg["xmin"]) and np.all( + samples < cfg["xmax"] + ), "Uniform samples must be within [xmin, xmax]" def test_gaussian_sample_shape(self): cfg = {"type": "gaussian", "mu": 0.0, "sigma": 1.0} @@ -55,8 +56,6 @@ def test_gaussian_sample_shape(self): samples = self._verify_sampling(model) - - # --------------------------------------------------------------------------- # TrackModel # --------------------------------------------------------------------------- @@ -72,68 +71,254 @@ def _verify_sampling(self, model, phi1): assert np.all(np.isfinite(samples)), "Samples must be finite numbers" assert np.all(~np.isnan(samples)), "Samples must not contain NaNs" return samples - + def test_constant_track(self): cfg = { "center": {"type": "constant", "value": 0.0}, "spread": {"type": "constant", "value": 0.2}, - "sampler": "gaussian" + "sampler": "gaussian", } model = TrackModel(cfg) phi1 = np.linspace(-10, 10, N) samples = self._verify_sampling(model, phi1) - assert np.all(np.abs(samples) < 10*cfg["spread"]['value']), "Samples should be within a few sigma of the center" + assert np.all( + np.abs(samples) < 10 * cfg["spread"]["value"] + ), "Samples should be within a few sigma of the center" def test_sinusoidal_track(self): cfg = { - "center": {"type": "sinusoid", "amplitude": 0.5, "period": 2.}, + "center": {"type": "sinusoid", "amplitude": 0.5, "period": 2.0}, "spread": {"type": "constant", "value": 0.2}, - "sampler": "gaussian" + "sampler": "gaussian", } model = TrackModel(cfg) phi1 = np.linspace(-10, 10, N) samples = self._verify_sampling(model, phi1) - expected_center = cfg["center"]["amplitude"] * np.sin(phi1*2*np.pi/cfg["center"]["period"]) - assert np.all(np.abs(samples - expected_center) < 10*cfg["spread"]['value']), "Samples should be within a few sigma of the sinusoidal center" + expected_center = cfg["center"]["amplitude"] * np.sin( + phi1 * 2 * np.pi / cfg["center"]["period"] + ) + assert np.all( + np.abs(samples - expected_center) < 10 * cfg["spread"]["value"] + ), "Samples should be within a few sigma of the sinusoidal center" # --------------------------------------------------------------------------- # StreamModel — full # --------------------------------------------------------------------------- + @pytest.mark.model class TestStreamModelFull: """Tests for StreamModel when having a complete config""" def _verify_catalogue_content(self, catalog, expected_columns): """Helper to verify that a completed catalog contains the expected columns with valid data.""" - assert expected_columns.issubset(catalog.columns), f"Catalog should contain columns {expected_columns}" + assert expected_columns.issubset( + catalog.columns + ), f"Catalog should contain columns {expected_columns}" for col in expected_columns: - assert np.issubdtype(catalog[col].dtype, np.floating), f"Column {col} should contain floats" - assert np.all(np.isfinite(catalog[col])), f"Column {col} should contain finite numbers" - assert np.all(~np.isnan(catalog[col])), f"Column {col} should not contain NaNs" + assert np.issubdtype( + catalog[col].dtype, np.floating + ), f"Column {col} should contain floats" + assert np.all( + np.isfinite(catalog[col]) + ), f"Column {col} should contain finite numbers" + assert np.all( + ~np.isnan(catalog[col]) + ), f"Column {col} should not contain NaNs" def test_full_model(self, stream_config_with_distance): """Test that StreamModel can be instantiated and sampled with a full config.""" model = StreamModel(stream_config_with_distance) samples = model.sample(N) - assert isinstance(samples, pd.DataFrame), "Samples should be returned as a DataFrame" - expected_columns = {"phi1", "phi2", "dist", "mag_g", "mag_r"} # Not adding mu1, mu2, rv since not implemented yet + assert isinstance( + samples, pd.DataFrame + ), "Samples should be returned as a DataFrame" + expected_columns = { + "phi1", + "phi2", + "dist", + "lsst_g_true", + "lsst_r_true", + } # Not adding mu1, mu2, rv since not implemented yet self._verify_catalogue_content(samples, expected_columns) - def test_complete_catalog(self, sample_catalog_phi,stream_config_with_distance): + def test_complete_catalog(self, sample_catalog_phi, stream_config_with_distance): """Test that complete_catalog produces a catalog with the expected columns and valid data.""" model = StreamModel(stream_config_with_distance) - completed_catalog = model.complete_catalog(catalog = sample_catalog_phi) - expected_columns = {"phi1", "phi2", "dist", "mag_g", "mag_r"} # Not adding mu1, mu2, rv since not implemented yet + completed_catalog = model.complete_catalog(catalog=sample_catalog_phi) + expected_columns = { + "phi1", + "phi2", + "dist", + "lsst_g_true", + "lsst_r_true", + } # Not adding mu1, mu2, rv since not implemented yet self._verify_catalogue_content(completed_catalog, expected_columns) - assert len(completed_catalog) == len(sample_catalog_phi), f"Completed catalog should have the same number of rows as the input catalog" + assert len(completed_catalog) == len( + sample_catalog_phi + ), f"Completed catalog should have the same number of rows as the input catalog" # Verify that I can add a targeted column (e.g. dist) to the input catalog and complete the rest - partial_catalog = completed_catalog.drop(columns=['mag_r', 'dist', 'mag_g']).reset_index(drop=True) - completed_catalog = model.complete_catalog(catalog=partial_catalog,columns_to_add=["dist"],) - expected_columns = {"phi1", "phi2", "dist"} # Not adding mu1, mu2, rv since not implemented yet + partial_catalog = completed_catalog.drop( + columns=["lsst_r_true", "dist", "lsst_g_true"] + ).reset_index(drop=True) + completed_catalog = model.complete_catalog( + catalog=partial_catalog, + columns_to_add=["dist"], + ) + expected_columns = { + "phi1", + "phi2", + "dist", + } # Not adding mu1, mu2, rv since not implemented yet self._verify_catalogue_content(completed_catalog, expected_columns) - assert len(completed_catalog) == len(partial_catalog), f"Completed catalog should have the same number of rows as the input catalog" - assert "mag_r" not in completed_catalog.columns, "Column 'mag_r' should not be added when not requested" + assert len(completed_catalog) == len( + partial_catalog + ), f"Completed catalog should have the same number of rows as the input catalog" + assert ( + "lsst_r_true" not in completed_catalog.columns + ), "Column 'lsst_r_true' should not be added when not requested" + + +# --------------------------------------------------------------------------- +# StreamModel.complete_catalog — permutations of input columns / dist source +# --------------------------------------------------------------------------- + + +@pytest.mark.model +class TestCompleteCatalogPermutations: + """Exercise complete_catalog across the ways a catalog can be partially filled. + + Covers: which columns are supplied (empty frame, phi-only, ra/dec+dist), + where the distance comes from (distance_modulus model vs. a directly supplied + scalar/vector ``dist``), and the preserve-existing-values contract (whole + columns and individual NaN rows are never overwritten). + """ + + MAGS = {"lsst_g_true", "lsst_r_true"} + + def test_empty_frame_fills_all_model_columns(self, stream_config_with_distance): + """size=N with no catalog -> geometry, dist, and both bands are filled.""" + model = StreamModel(stream_config_with_distance) + out = model.complete_catalog(catalog=None, size=12, verbose=False) + assert len(out) == 12 + assert ({"phi1", "phi2", "dist"} | self.MAGS).issubset(out.columns) + assert out[list(self.MAGS)].notna().all().all() + + def test_phi_only_fills_dist_then_mags( + self, sample_catalog_phi, stream_config_with_distance + ): + """phi1/phi2 present -> dist sampled from the model, then magnitudes.""" + model = StreamModel(stream_config_with_distance) + out = model.complete_catalog(catalog=sample_catalog_phi.copy(), verbose=False) + assert ({"dist"} | self.MAGS).issubset(out.columns) + assert out[list(self.MAGS)].notna().all().all() + + def test_radec_plus_dist_fills_mags_without_phi(self, stream_config_with_distance): + """With dist already present, magnitudes fill even when phi1 is absent.""" + model = StreamModel(stream_config_with_distance) + df = pd.DataFrame( + {"ra": [10.0, 11.0, 12.0], "dec": [-1.0, 0.0, 1.0], "dist": [16.0] * 3} + ) + out = model.complete_catalog( + catalog=df, columns_to_add=list(self.MAGS), verbose=False + ) + assert self.MAGS.issubset(out.columns) + assert out[list(self.MAGS)].notna().all().all() + assert "phi1" not in out.columns + + def test_existing_band_preserved_when_filling_other( + self, stream_config_with_distance + ): + """Providing one band and requesting both leaves the provided one intact.""" + model = StreamModel(stream_config_with_distance) + g = np.array([20.0, 21.0, 22.0]) + df = pd.DataFrame({"dist": [16.0] * 3, "lsst_g_true": g.copy()}) + out = model.complete_catalog( + catalog=df, columns_to_add=list(self.MAGS), verbose=False + ) + assert np.allclose(out["lsst_g_true"].to_numpy(), g), "present band overwritten" + assert out["lsst_r_true"].notna().all(), "missing band not filled" + + def test_present_columns_skip_sampling(self, stream_config_with_distance): + """Both bands present -> values are returned untouched.""" + model = StreamModel(stream_config_with_distance) + g = np.array([20.0, 21.0]) + r = np.array([19.0, 19.5]) + df = pd.DataFrame( + {"dist": [16.0, 16.0], "lsst_g_true": g.copy(), "lsst_r_true": r.copy()} + ) + out = model.complete_catalog( + catalog=df, columns_to_add=list(self.MAGS), verbose=False + ) + assert np.allclose(out["lsst_g_true"].to_numpy(), g) + assert np.allclose(out["lsst_r_true"].to_numpy(), r) + + def test_partial_rows_only_missing_filled(self, stream_config_with_distance): + """A band with some NaN rows keeps its finite rows; only NaNs are filled.""" + model = StreamModel(stream_config_with_distance) + g = np.array([20.0, np.nan, 22.0]) + df = pd.DataFrame({"dist": [16.0] * 3, "lsst_g_true": g.copy()}) + out = model.complete_catalog( + catalog=df, columns_to_add=["lsst_g_true"], verbose=False + ) + filled = out["lsst_g_true"].to_numpy() + assert filled[0] == 20.0 and filled[2] == 22.0, "finite rows overwritten" + assert np.isfinite(filled[1]), "NaN row not filled" + + def test_dist_scalar_broadcast_without_distance_model(self, minimal_stream_config): + """A scalar `dist` lets mags fill with no distance_modulus model / no phi1.""" + model = StreamModel(minimal_stream_config) # no distance_modulus section + df = pd.DataFrame({"ra": [10.0, 11.0], "dec": [0.0, 1.0]}) + out = model.complete_catalog( + catalog=df, + columns_to_add=["dist"] + list(self.MAGS), + dist=16.5, + verbose=False, + ) + assert np.allclose(out["dist"].to_numpy(), 16.5) + assert out[list(self.MAGS)].notna().all().all() + + def test_dist_vector_assigned_per_row(self, minimal_stream_config): + """A per-row `dist` vector is assigned row-wise.""" + model = StreamModel(minimal_stream_config) + df = pd.DataFrame({"ra": [10.0, 11.0, 12.0], "dec": [0.0, 1.0, 2.0]}) + dvec = np.array([15.0, 16.0, 17.0]) + out = model.complete_catalog( + catalog=df, + columns_to_add=["dist"] + list(self.MAGS), + dist=dvec, + verbose=False, + ) + assert np.allclose(out["dist"].to_numpy(), dvec) + assert out[list(self.MAGS)].notna().all().all() + + def test_dist_vector_wrong_length_raises(self, minimal_stream_config): + model = StreamModel(minimal_stream_config) + df = pd.DataFrame({"ra": [10.0, 11.0, 12.0], "dec": [0.0, 1.0, 2.0]}) + with pytest.raises(ValueError): + model.complete_catalog( + catalog=df, + columns_to_add=["dist"], + dist=np.array([1.0, 2.0]), + verbose=False, + ) + + def test_dist_overrides_distance_model(self, stream_config_with_distance): + """When given, `dist` is used instead of the configured distance model.""" + model = StreamModel(stream_config_with_distance) # model would give 16.8 + df = pd.DataFrame({"phi1": [0.0, 1.0], "phi2": [0.0, 0.0]}) + out = model.complete_catalog( + catalog=df, columns_to_add=["dist"], dist=20.0, verbose=False + ) + assert np.allclose(out["dist"].to_numpy(), 20.0) + def test_mags_without_dist_or_phi_raises(self, minimal_stream_config): + """No distance_modulus model, no dist, no phi1 -> cannot fill magnitudes.""" + model = StreamModel(minimal_stream_config) + df = pd.DataFrame({"ra": [10.0, 11.0], "dec": [0.0, 1.0]}) + with pytest.raises(ValueError): + model.complete_catalog( + catalog=df, columns_to_add=list(self.MAGS), verbose=False + ) diff --git a/tests/test_observed.py b/tests/test_observed.py index 5b06e08..a0c800d 100644 --- a/tests/test_observed.py +++ b/tests/test_observed.py @@ -15,25 +15,35 @@ from streamobs.observed import StreamInjector from streamobs.surveys import Survey - # --------------------------------------------------------------------------- # Injector properties # --------------------------------------------------------------------------- + @pytest.mark.observed class TestStreamInjectorProperties: """Tests for StreamInjector properties and basic behavior.""" def test_injector_initialization(self, mock_injector): """Test that the injector initializes with the expected properties.""" - assert isinstance(mock_injector, StreamInjector), "Injector must be an instance of StreamInjector" - assert hasattr(mock_injector, "survey"), "Injector must have a 'survey' property" - assert isinstance(mock_injector.survey, Survey), "Survey property must be a Survey instance" - assert hasattr(mock_injector, "mask_cache"), "Injector must have a 'mask_cache' property" + assert isinstance( + mock_injector, StreamInjector + ), "Injector must be an instance of StreamInjector" + assert hasattr( + mock_injector, "survey" + ), "Injector must have a 'survey' property" + assert isinstance( + mock_injector.survey, Survey + ), "Survey property must be a Survey instance" + assert hasattr( + mock_injector, "mask_cache" + ), "Injector must have a 'mask_cache' property" # Initialize injector directly with survey name and release injector_direct = StreamInjector(survey="lsst", release="yr4") - assert isinstance(injector_direct, StreamInjector), "Directly initialized injector must be an instance of StreamInjector" + assert isinstance( + injector_direct, StreamInjector + ), "Directly initialized injector must be an instance of StreamInjector" assert injector_direct.survey.name == "lsst", "Survey name must be 'lsst'" assert injector_direct.survey.release == "yr4", "Survey release must be 'yr4'" @@ -42,50 +52,102 @@ def test_injector_initialization(self, mock_injector): # Injector behavior # --------------------------------------------------------------------------- + @pytest.mark.observed class TestStreamInjectorBehavior: """Tests for StreamInjector behavior and output structure.""" - def _verify_injected_catalog_content(self, injected_catalog, expected_columns=["ra", "dec","mag_g", "mag_r", "mag_g_obs", "mag_r_obs","flag_observed", "flag_perfect_galstarsep"]): + + def _verify_injected_catalog_content( + self, + injected_catalog, + expected_columns=[ + "ra", + "dec", + "lsst_g_true", + "lsst_r_true", + "lsst_g_obs", + "lsst_r_obs", + "lsst_flag_observed", + "lsst_flag_perfect_galstarsep", + ], + ): """Helper method to verify the content of the injected catalog.""" # Verify expected columns are present - assert set(expected_columns).issubset(injected_catalog.columns), "Injected catalog must contain all expected columns" - + assert set(expected_columns).issubset( + injected_catalog.columns + ), "Injected catalog must contain all expected columns" def test_full_injection_pipeline(self, mock_injector, stream_catalog, verbose): """Test the full injection pipeline with a controlled input catalog.""" # Perform injection - injected_catalog = mock_injector.inject(stream_catalog, perfect_galstarsep=True, verbose=verbose) + injected_catalog = mock_injector.inject( + stream_catalog, perfect_galstarsep=True, verbose=verbose + ) # Minimal expected columns in the injected catalog (position, magnitude, and flags) - self._verify_injected_catalog_content(injected_catalog,) + self._verify_injected_catalog_content( + injected_catalog, + ) - def test_injection_partialinput(self, mock_injector,stream_catalog, stream_config_with_distance, verbose): + def test_injection_partialinput( + self, mock_injector, stream_catalog, stream_config_with_distance, verbose + ): """Test injection with a catalog that has some missing columns.""" - data_without_mag = stream_catalog.drop(columns=["mag_g", "mag_r"]) - injected_catalog = mock_injector.inject(data_without_mag, perfect_galstarsep=True, stream_config=stream_config_with_distance, verbose=verbose) + data_without_mag = stream_catalog.drop(columns=["lsst_g_true", "lsst_r_true"]) + injected_catalog = mock_injector.inject( + data_without_mag, + perfect_galstarsep=True, + stream_config=stream_config_with_distance, + verbose=verbose, + ) self._verify_injected_catalog_content(injected_catalog) - def test_random_injection(self, mock_injector, stream_catalog,seed, verbose): + def test_random_injection(self, mock_injector, stream_catalog, seed, verbose): """Test random sky injection""" mask_type = ["footprint", "ebv", "maglim_g"] # Inject a first time - stream_coord_1 = mock_injector.phi_to_radec(stream_catalog['phi1'], stream_catalog['phi2'], seed=seed,gc_frame=None,mask_type=mask_type, verbose=verbose) + stream_coord_1 = mock_injector.phi_to_radec( + stream_catalog["phi1"], + stream_catalog["phi2"], + seed=seed, + gc_frame=None, + mask_type=mask_type, + verbose=verbose, + ) gc_1 = mock_injector._last_gc_frame # Inject a second time with the same random seed - stream_coord_2 = mock_injector.phi_to_radec(stream_catalog['phi1'], stream_catalog['phi2'], seed=seed,gc_frame=None,mask_type=mask_type, verbose=verbose) + stream_coord_2 = mock_injector.phi_to_radec( + stream_catalog["phi1"], + stream_catalog["phi2"], + seed=seed, + gc_frame=None, + mask_type=mask_type, + verbose=verbose, + ) gc_2 = mock_injector._last_gc_frame # Inject a 3rd time using the existing gc_frame (should not use a random # seed) - stream_coord_3 = mock_injector.phi_to_radec(stream_catalog['phi1'], stream_catalog['phi2'], seed=None,gc_frame=gc_1,mask_type=mask_type, verbose=verbose) + stream_coord_3 = mock_injector.phi_to_radec( + stream_catalog["phi1"], + stream_catalog["phi2"], + seed=None, + gc_frame=gc_1, + mask_type=mask_type, + verbose=verbose, + ) gc_3 = mock_injector._last_gc_frame def compare_coords(coord1, coord2): """Helper function to compare two coordinate DataFrames.""" - assert np.allclose(coord1.icrs.ra.deg, coord2.icrs.ra.deg), "RA values should be the same" - assert np.allclose(coord1.icrs.dec.deg, coord2.icrs.dec.deg), "Dec values should be the same" - + assert np.allclose( + coord1.icrs.ra.deg, coord2.icrs.ra.deg + ), "RA values should be the same" + assert np.allclose( + coord1.icrs.dec.deg, coord2.icrs.dec.deg + ), "Dec values should be the same" + def get_gc_frame_dict(gc_frame): origin = gc_frame.origin pole = gc_frame.pole @@ -96,14 +158,20 @@ def get_gc_frame_dict(gc_frame): "dec": float(origin.dec.deg), "unit": "deg", }, - "pole": {"ra": float(pole.ra.deg), "dec": float(pole.dec.deg), "unit": "deg"}, + "pole": { + "ra": float(pole.ra.deg), + "dec": float(pole.dec.deg), + "unit": "deg", + }, "priority": str(priority), } return gc_frame_params def compare_gc_frames(gc1, gc2): """Helper function to compare two gc_frame objects.""" - assert get_gc_frame_dict(gc1) == get_gc_frame_dict(gc2), "gc_frame parameters should be the same" + assert get_gc_frame_dict(gc1) == get_gc_frame_dict( + gc2 + ), "gc_frame parameters should be the same" # Verify that the first two injections produce the same coordinates (same random seed) compare_coords(stream_coord_1, stream_coord_2) @@ -117,11 +185,6 @@ def compare_gc_frames(gc1, gc2): mock_injector.clear_mask_cache() masks = mock_injector.list_cached_masks() assert len(masks) == 0, "Mask cache should be empty after clearing" - assert len(masks_before) > len(masks), "Mask cache should have had entries before clearing" - - - - - - - \ No newline at end of file + assert len(masks_before) > len( + masks + ), "Mask cache should have had entries before clearing" From efd06a61367f494f3e634d84cfda909d06893c0d Mon Sep 17 00:00:00 2001 From: psferguson Date: Tue, 16 Jun 2026 11:28:27 -0700 Subject: [PATCH 07/29] S/N cut: apply reference-band cut once (option b) The reference band (survey.completeness_band) has its SNR>=5 cut baked into the survey selection functions, so the per-band loop was double-applying it (idempotent today, but conceptually double-counted and fragile), and a special-cased "force" block was needed for the perfect-galstarsep flag because the detection-efficiency curve does not bake the cut in. Now the reference-band cut is applied exactly once (to both flags) and the detection_mag_cut loop defaults to all injected bands except the reference band, which is skipped. Behaviour-preserving (same bands cut, ref counted once); removes the double-count and the flag asymmetry. Document the path from (b) to (a) -- folding the cut into the detection-efficiency curve itself -- in roman_multisurvey_plan.md, including which data products must be regenerated (per-survey detection_eff tables) and how. Co-Authored-By: Claude Opus 4.8 (1M context) --- docs/source/roman_multisurvey_plan.md | 80 +++++++++++++++++++++++++++ streamobs/observed.py | 43 ++++++++++---- 2 files changed, 112 insertions(+), 11 deletions(-) diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md index 5201c21..ed3d9b1 100644 --- a/docs/source/roman_multisurvey_plan.md +++ b/docs/source/roman_multisurvey_plan.md @@ -105,6 +105,86 @@ and makes "observed" mean "detected in everything you asked for". Callers can restore any prior behaviour by passing `detection_mag_cut=[...]` explicitly (e.g. `["g"]` for the old LSST default). **Adopted, but flagged for review.** +### S/N cut ownership: who applies the reference-band cut *(adopted — option (b))* + +The reference band (`survey.completeness_band`, e.g. LSST `r`) is special: the +survey's **selection functions are estimated with the SNR ≥ 5 cut already +applied** in that band. So the reference-band cut is conceptually *owned by the +selection functions*, not by the injector's per-band loop. + +**The problem (pre-(b)).** The old code applied the per-band SNR loop to *every* +injected band, including the reference band — so the reference band's cut was +applied **twice** (once inside `get_completeness`, once in the loop). That is +idempotent today (`A & A == A`), so `flag_observed` was numerically correct, but +it is conceptually double-counted and fragile: it silently breaks if `SNR_min` +ever differs from the threshold the curve was estimated at. Worse, the two +selection curves disagreed about ownership — `get_completeness` bakes the cut +in, but `get_detection_efficiency` (used for the perfect-galstarsep flag) does +**not** — which forced a special-cased "force SNR cut on the completeness band" +block just for `flag_perfect`. + +**Option (b) — implemented now (injector-only, no data regeneration).** Treat the +reference-band cut as owned by the selection functions and apply it **exactly +once**, to both flags: + +- The reference band's SNR cut is applied once in `_inject_one_survey`, to + `flag_observed` (idempotent with the baked-in completeness cut) and to + `flag_perfect` (which supplies it, since the efficiency curve lacks it). +- `detection_mag_cut` defaults to *every injected band except the reference + band*; the reference band is skipped inside the loop. +- The old special-cased "force" block is removed. + +This is **behaviour-preserving** (the same set of bands gets an SNR cut, the +reference band counted once instead of twice) but removes the double-count and +the asymmetry between the two flags. `survey.completeness_band` is the single +attribute identifying the reference band for both completeness and detection +efficiency (default `"r"`). + +**Option (a) — the eventual "correct home" (deferred; requires new data).** Fold +the SNR cut into the **detection-efficiency curve itself**, so that +`get_completeness` *and* `get_detection_efficiency` both own it consistently. +Then the injector needs no reference-band special-casing at all — it simply +**skips** `survey.completeness_band` in the SNR loop (the curves handle it), and +the once-applied reference-band block from (b) can be deleted. + +*Why (a) is better:* the "a star's reference-band detectability already includes +SNR ≥ 5" fact lives in **one place** — the survey product — rather than being +re-asserted in the injector. Any consumer of `get_detection_efficiency` (not +just this injector) then gets a self-consistent curve, and there is no implicit +contract that "the caller must remember to also apply the SNR cut". + +*How to get from (b) to (a):* + +1. **Regenerate the detection-efficiency product with the SNR cut applied.** In + the build script that emits the efficiency tables + (`scripts/roman/create_streamobs_files_hlwas.py` for Roman DC2; the analogous + LSST/DES builders for the others), the *denominator* of the detection + efficiency is all true stars and the *numerator* is true stars detected — add + the requirement that the numerator detection also passes SNR ≥ 5 in the + reference band (the completeness/`classification_detection_eff` curve is + already built this way; mirror that selection for the detection-only curve). + Concretely: the column the loader reads for `type="detection_efficiency"` + (`detection_eff`, via `selection="detected"` in `set_completeness`) must be + recomputed with the SNR cut, so it matches how `classifiction_eff` / + `classification_detection_eff` are produced. +2. **Re-emit the per-survey efficiency CSVs** (e.g. Roman + `roman_stellar_efficiency_cutf158.csv` in `data/surveys/roman_hlwas/`, and the + LSST/DES equivalents in `data/others/`) and re-run the notebook/build so the + committed products carry the cut. Keep the `classifiction_eff` header spelling + the loader greps for. +3. **Flip the injector to (a):** drop the once-applied reference-band block and + change the `detection_mag_cut` default to skip the reference band *without* + re-adding its cut (the curve now carries it). `flag_observed` and + `flag_perfect` then both inherit the reference-band cut purely from the + selection functions. +4. **Validate** that detection counts are unchanged within noise versus (b) on a + fixed seed (they should be, since (b) already applies the same cut once) — this + confirms the regenerated curve encodes exactly the SNR ≥ 5 selection rather + than a different threshold. + +Until those products are regenerated, (b) is the correct, behaviour-preserving +state. + ### `nstars` becomes "exactly N stars" (was an emergent IMF count) *(adopted — agreed)* ```{important} diff --git a/streamobs/observed.py b/streamobs/observed.py index 06c0b4b..36d2e0e 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -192,8 +192,11 @@ def inject(self, data, survey_bands=None, bands=None, stream_config=None, **kwar nside : int, optional HEALPix nside parameter. Default is 4096. detection_mag_cut : list of str, optional - Bands to apply the SNR detection cut to. Default is all injected - bands (every injected band must have SNR >= 5). + Non-reference bands to apply the explicit SNR>=5 cut to. The + reference band (``survey.completeness_band``) is always cut via + the selection functions, so the default here is every injected + band *except* the reference band. Net effect: every injected band + must have SNR >= 5, with the reference band counted once. save : bool, optional Whether to save the output data. Default is False. folder : str or Path, optional @@ -472,11 +475,36 @@ def _inject_one_survey( else flag_valid_flux ) - # Apply SNR cuts. Default: require SNR >= SNR_min in every injected band. - detection_mag_cut = kwargs.get("detection_mag_cut", list(bands)) + # Apply SNR cuts. + # + # The SNR>=SNR_min cut on the *reference* band (``survey.completeness_band``) + # is owned by the survey's selection functions — they are estimated with + # that cut already applied. We therefore apply it to the reference band + # exactly **once** here, to both flags. (``get_completeness`` bakes it in, + # so for ``flag_observed`` this is idempotent; ``get_detection_efficiency`` + # does not, so for ``flag_perfect`` this line is what supplies it.) See + # the "S/N cut ownership" note in docs/source/roman_multisurvey_plan.md + # for the path to folding it into the efficiency curve itself (option a). + # + # Every *other* injected band gets the cut applied explicitly below. SNR_min = 5.0 + ref_band = survey.completeness_band + if ref_band in bands: + SNR_ref = 1.0 / data[err_col(ref_band, survey_namespace)] + flag_observed &= SNR_ref >= SNR_min + if perfect_galstarsep: + flag_perfect &= SNR_ref >= SNR_min + + # Non-reference bands. Default: every injected band except the reference + # band (whose cut is handled above via the selection functions). + detection_mag_cut = kwargs.get( + "detection_mag_cut", [b for b in bands if b != ref_band] + ) for band in detection_mag_cut: + if band == ref_band: + # The reference band's SNR cut is already applied above. + continue if band not in bands: if verbose: print( @@ -490,13 +518,6 @@ def _inject_one_survey( if perfect_galstarsep: flag_perfect &= SNR >= SNR_min - # Force SNR cut on the completeness band for perfect gal/star separation - # (the SNR cut is baked into the completeness functions but not into the - # detection-only efficiency functions used for the perfect flag). - if perfect_galstarsep: - SNR_compl = 1.0 / data[err_col(survey.completeness_band, survey_namespace)] - flag_perfect &= SNR_compl >= SNR_min - # Store flags in DataFrame data[flag_col(survey_namespace)] = flag_observed if perfect_galstarsep: From b7d52c7b576712d56b2741646c96586d59820e5f Mon Sep 17 00:00:00 2001 From: psferguson Date: Tue, 16 Jun 2026 11:58:32 -0700 Subject: [PATCH 08/29] docs update and fix some sphinx warnings --- docs/source/_static/.gitkeep | 0 docs/source/column_convention.md | 64 +++++++++++ docs/source/conf.py | 7 ++ docs/source/index.rst | 2 + docs/source/multisurvey.md | 162 ++++++++++++++++++++++++++++ docs/source/quickstart.md | 41 ++++--- docs/source/streamobs.functions.rst | 1 - docs/source/streamobs.model.rst | 1 - docs/source/streamobs.observed.rst | 1 - docs/source/streamobs.plotting.rst | 1 - docs/source/streamobs.rst | 1 - docs/source/streamobs.samplers.rst | 1 - docs/source/streamobs.surveys.rst | 1 - docs/source/streamobs.utils.rst | 1 - streamobs/observed.py | 7 +- streamobs/plotting.py | 8 +- streamobs/surveys.py | 22 ++-- 17 files changed, 278 insertions(+), 43 deletions(-) create mode 100644 docs/source/_static/.gitkeep create mode 100644 docs/source/column_convention.md create mode 100644 docs/source/multisurvey.md diff --git a/docs/source/_static/.gitkeep b/docs/source/_static/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/docs/source/column_convention.md b/docs/source/column_convention.md new file mode 100644 index 0000000..d8a376d --- /dev/null +++ b/docs/source/column_convention.md @@ -0,0 +1,64 @@ +# Output column convention + +Injected catalogs use a single, uniform naming scheme for every column the +injector produces, and it is **always survey-namespaced** — even for a single +survey. + +## The scheme + +For a survey with namespace `` (the survey's name, or the key you gave it +when constructing a multi-survey `StreamInjector`) and a photometric band +``: + +| Column | Meaning | +|---|---| +| `__true` | True (noiseless) apparent magnitude | +| `__obs` | Observed (noisy) magnitude; `"BAD_MAG"` where the noisy flux went negative | +| `__err` | Reported photometric error (the *catalog* error; see below) | +| `_flag_observed` | Detection flag — `True` if detected **and** classified as a star | +| `_flag_perfect_galstarsep` | Optional flag assuming perfect star/galaxy separation (detection only); emitted only when `perfect_galstarsep=True` | + +Plus the shared, un-namespaced sky coordinates `ra`, `dec`. + +Examples: `lsst_r_obs`, `lsst_g_err`, `roman_F158_true`, `lsst_flag_observed`. + +These names are produced by the helpers in `streamobs.columns` +(`true_col`, `obs_col`, `err_col`, `flag_col`, `perfect_flag_col`), which take a +`band` and a `survey` namespace. + +```{important} +This convention intentionally **drops** the historical `mag_` / +`mag__obs` / `magerr_` names and the un-namespaced single-survey form +(`r_obs`, `flag_observed`, …). It is **not backward compatible** with catalogs or +downstream readers expecting those columns — everything is now namespaced by +survey, even when only one survey is injected. +``` + +## Two error curves: catalog vs. sample + +Each survey carries **two** photometric-error curves, both functions of +`delta_mag = mag − maglim`: + +- **Catalog error** — the survey's *reported* error (e.g. SExtractor `magerr`). + This is what is written to `__err`, and it drives the S/N + detection cut. +- **Sample error** — an optional curve giving the *true scatter* of + observed − true magnitudes. This is what is used to **draw** the observed + magnitude (`__obs`). + +The split exists because, for the Roman DC2 catalogs, the true photometric +scatter is ≈ 2× the reported error — so the noise you draw and the error you +report are genuinely different. When a survey has no sample curve loaded, the +sample draw transparently falls back to the catalog curve, so the two are +identical and outputs match the single-curve behaviour. + +Select between them via +{meth}`streamobs.surveys.Survey.get_photo_error` with `kind="catalog"` (default, +reproduces the reported error) or `kind="sample"` (true scatter). + +## See also + +- [Injecting one or many surveys](multisurvey.md) — how these columns are + produced and the multi-survey "same physical star" guarantee. +- `streamobs.columns` — the column-name helper functions. +- {meth}`streamobs.surveys.Survey.get_photo_error` — the two error curves. diff --git a/docs/source/conf.py b/docs/source/conf.py index a643357..6259e9b 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -31,6 +31,13 @@ templates_path = ['_templates'] exclude_patterns = [] +# -- numpydoc ---------------------------------------------------------------- +# autodoc's `:members:` already documents every class member, so tell numpydoc +# not to also list them. This avoids both the "stub file not found" autosummary +# warnings (numpydoc's default member toctree) and "duplicate object +# description" warnings (numpydoc + autodoc documenting the same members). +numpydoc_show_class_members = False + # -- Options for HTML output ------------------------------------------------- diff --git a/docs/source/index.rst b/docs/source/index.rst index 8d87f08..b4ae8ba 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -83,6 +83,7 @@ Documentation Contents about installation quickstart + multisurvey citation .. toctree:: @@ -105,6 +106,7 @@ Documentation Contents :maxdepth: 2 :caption: Reference + column_convention data modules diff --git a/docs/source/multisurvey.md b/docs/source/multisurvey.md new file mode 100644 index 0000000..f1ae705 --- /dev/null +++ b/docs/source/multisurvey.md @@ -0,0 +1,162 @@ +# Injecting one or many surveys + +`streamobs.observed.StreamInjector` injects observational effects (photometric +errors, observed magnitudes, detection flags) into a stream catalog. **The same +class handles a single survey or several at once** — there is no separate +multi-survey class. When several surveys are injected together, every survey +describes the *same physical stars*, so you can build catalogs that carry both +Rubin/LSST and Roman photometry for one stream. + +## Constructing an injector + +Pass one survey, or several: + +```python +from streamobs.observed import StreamInjector + +# One survey (loaded by name; `release` etc. forwarded to Survey.load) +inj = StreamInjector("lsst", release="dc2") + +# Several surveys: {namespace: spec}, where spec is a survey name or a Survey. +# The dict key is the column namespace. +inj = StreamInjector({"lsst": "lsst", "roman": "roman"}, primary="lsst") + +# Or a list — each survey is namespaced by its own name. +inj = StreamInjector(["lsst", "roman"]) +``` + +- `primary` selects the survey whose footprint drives the shared sky placement + (defaults to the first survey). +- `inj.surveys` is the `{namespace: Survey}` mapping; `inj.survey` is the primary + `Survey`. + +## Injecting + +```python +# Single survey: `bands` is the shorthand (defaults to ['r', 'g']). +out = inj.inject(df, bands=["r", "g"], stream_config=cfg, seed=42) + +# Several surveys: give the bands per survey. +out = inj.inject( + df, + survey_bands={"lsst": ["r", "g"], "roman": ["F106", "F158"]}, + stream_config=cfg, + seed=42, +) +``` + +`df` may already contain `ra`/`dec` or `phi1`/`phi2`, may be a fully empty frame +of length *N*, or any subset — anything missing is sampled from `stream_config` +(see *Completing a catalog* below). The output carries shared +`ra`/`dec` plus, **per survey**, the namespaced columns described in +[Output column convention](column_convention.md): + +``` +ra, dec, +lsst_r_true, lsst_r_obs, lsst_r_err, lsst_g_true, ..., lsst_flag_observed, +roman_F106_true, roman_F106_obs, ..., roman_flag_observed +``` + +Useful `inject` keyword arguments: + +| kwarg | meaning | +|---|---| +| `seed` | reproducibility (per-survey RNGs are spawned from it, so results are independent of survey order) | +| `dist` | distance modulus used directly (scalar or per-row vector) instead of sampling one — see below | +| `detection_mag_cut` | non-reference bands to apply the explicit SNR ≥ 5 cut to (see *S/N cut ownership* below) | +| `perfect_galstarsep` | also emit a `_flag_perfect_galstarsep` flag (detection only, no classification losses) | +| `dust_correction` | apply extinction correction to observed magnitudes (default `True`) | +| `mask_type`, `gc_frame` | forwarded to the `phi1`/`phi2` → `ra`/`dec` placement | + +## The same physical star across surveys + +For a multi-survey injection the isochrone draws **one set of initial masses** +(exactly `nstars`) and interpolates *those same masses* into every survey's +bands. So a star's LSST and Roman magnitudes describe the same object — the +true magnitudes are physically consistent and tightly correlated across surveys +rather than drawn independently. + +This requires a **multi-survey isochrone** in the stream config: a top-level +`surveys:` mapping sharing one stellar population, e.g. + +```yaml +stream: + # ... density / track / distance_modulus ... + isochrone: + name: Marigo2017 # shared population + age: 12.0 + z: 0.0006 + surveys: + lsst: {survey: lsst, band_1: g, band_2: r} + roman: {survey: roman, band_1: F106, band_2: F158} +``` + +A single-survey isochrone (the flat `survey`/`band_1`/`band_2` form) is just the +one-survey case of the same machinery and produces `__true` +identically. + +```{note} +**Roman bands are converted Vega→AB automatically.** `ugali` returns Roman +isochrone magnitudes in Vega while the catalogs are AB, so `IsochroneModel` +applies a fixed per-band offset (`streamobs.model.ROMAN_VEGA_TO_AB`) to every +Roman band unconditionally. Non-Roman bands pass through unchanged; there is no +config flag. +``` + +```{note} +**`nstars` means exactly N stars.** `StreamModel.sample(size)` / the isochrone +draw return *exactly* that many stars (a fixed mass set), not a random-length IMF +realization. This is required so the same masses can be shared across surveys. +``` + +## Completing a catalog + +`StreamInjector.complete_data(...)` is the public "fill in the rest from the +config" helper — the same completion `inject` runs internally, exposed so you can +build or inspect a completed catalog **without** injecting noise. It fills +`ra`/`dec` (converting from `phi1`/`phi2` if needed) and the per-survey +`__true` columns, **preserving anything already present**: + +```python +# Partial input -> filled from the config; existing columns are kept. +full = inj.complete_data(df, bands=["r", "g"], stream_config=cfg, seed=1) +``` + +### Supplying a distance directly + +Apparent magnitudes need a distance modulus. Normally it comes from the config's +`distance_modulus` model (which needs `phi1`), but you can pass `dist` directly — +a scalar (broadcast to all rows) or a per-row vector — to fill magnitudes without +a distance model or `phi1`: + +```python +out = inj.inject(df, bands=["r", "g"], stream_config=cfg, dist=16.8) # scalar +out = inj.inject(df, bands=["r", "g"], stream_config=cfg, dist=dist_arr) # per-row +``` + +When given, `dist` overrides the configured distance model. Only rows that are +missing a `dist` value are set. + +### Existing values are never overwritten + +Completion fills only the **missing** rows of each column. If you supply one band +and request another, the supplied band is left untouched and only the missing one +is filled (newly-filled cells still come from one shared mass draw, so they are +mutually colour-consistent). + +## S/N cut ownership + +The reference band (`survey.completeness_band`, e.g. LSST `r`) is special: the +survey's **selection functions are estimated with the SNR ≥ 5 cut already +applied** in that band. The injector therefore applies the reference-band cut +exactly **once**, and the explicit `detection_mag_cut` loop applies SNR ≥ 5 to +every *other* injected band (its default is all injected bands except the +reference band). Net effect: a star must have SNR ≥ 5 in every injected band to +be flagged observed, with the reference band counted once. + +## See also + +- [Output column convention](column_convention.md) — the `__…` + scheme and the sample-vs-catalog error split. +- {class}`streamobs.observed.StreamInjector` — full API. +- {class}`streamobs.model.StreamModel` — the stream/isochrone config. diff --git a/docs/source/quickstart.md b/docs/source/quickstart.md index 5e7dc79..9564a99 100644 --- a/docs/source/quickstart.md +++ b/docs/source/quickstart.md @@ -47,7 +47,9 @@ config = parse_config('config/toy1_config.yaml') stream = StreamModel(config['stream']) stream_df = stream.sample(config['stream']['nstars']) -# The dataframe contains: phi1, phi2, distance, magnitudes, etc. +# The dataframe contains: phi1, phi2, dist, and the isochrone magnitude +# columns, which are survey-namespaced as __true +# (e.g. lsst_g_true, lsst_r_true). print(stream_df.head()) ``` @@ -68,28 +70,31 @@ lsst_survey = surveys.Survey.load(survey='lsst', release='yr1') # Create the stream injector injector = observed.StreamInjector(lsst_survey) -# Create or load your mock stream data -# Here we create a simple test dataset -# This could contain (ra, dec) coordinates if you want to skip coordinate transformation +# Create or load your mock stream data. +# Here we create a simple test dataset. Could instead contain (ra, dec) to skip +# the coordinate transformation. True (noiseless) magnitudes are passed in as +# survey-namespaced __true columns (the survey's name is its +# namespace; here "lsst"). Alternatively, omit the magnitudes and pass a +# `stream_config=` so the injector samples them from an isochrone. rng = np.random.default_rng(42) mock_data = pd.DataFrame({ - 'phi1': rng.uniform(-5, 5, 1000), # Stream longitude - 'phi2': rng.uniform(-1, 1, 1000), # Stream latitude - 'mag_g': rng.uniform(18, 28, 1000), # g-band magnitude - 'mag_r': rng.uniform(18, 28, 1000), # r-band magnitude + 'phi1': rng.uniform(-5, 5, 1000), # Stream longitude + 'phi2': rng.uniform(-1, 1, 1000), # Stream latitude + 'lsst_g_true': rng.uniform(18, 28, 1000), # true g-band apparent magnitude + 'lsst_r_true': rng.uniform(18, 28, 1000), # true r-band apparent magnitude }) # Apply survey effects: footprint, extinction, photometric errors observed_data = injector.inject( - mock_data, + mock_data, + bands=['r', 'g'], # bands to inject (single-survey shorthand) seed=42, - bands = ['r', 'g'] # Choose the bands to use - mask_type=['footprint', 'ebv'], # Restrict injection to a mask created from the footprind and low dust area - verbose=True + mask_type=['footprint', 'ebv'], # place the stream within the footprint + low-dust area + verbose=True, ) print(f"Input stars: {len(mock_data)}") -print(f"Detected stars: {len(observed_data[observed_data['flag_observed']==1])}") +print(f"Detected stars: {int(observed_data['lsst_flag_observed'].sum())}") ``` ### What the Injector Does @@ -102,11 +107,13 @@ The `StreamInjector` applies several observational effects: 4. **Detection completeness**: Applies magnitude-dependent detection probability -The output dataframe includes: +The output dataframe includes (all magnitude/flag columns are **survey-namespaced** +as `_...`; for the LSST survey loaded above the namespace is `lsst`): - `ra`, `dec`: Sky coordinates -- `mag_g_obs`, `mag_r_obs`: Observed magnitudes with errors -- `magerr_g`, `magerr_r`: Photometric uncertainties -- `flag_observed`: Detection and clasification flag (1=detected & classified as a star, 0=not detected of not classified as a star) +- `lsst_g_true`, `lsst_r_true`: True (noiseless) apparent magnitudes +- `lsst_g_obs`, `lsst_r_obs`: Observed (noisy) magnitudes +- `lsst_g_err`, `lsst_r_err`: Reported photometric uncertainties +- `lsst_flag_observed`: Detection and classification flag (`True`=detected & classified as a star, `False`=not detected or not classified as a star) ## Next Steps diff --git a/docs/source/streamobs.functions.rst b/docs/source/streamobs.functions.rst index 17dc5ce..a0b8bb8 100644 --- a/docs/source/streamobs.functions.rst +++ b/docs/source/streamobs.functions.rst @@ -4,4 +4,3 @@ streamobs.functions module .. automodule:: streamobs.functions :members: :show-inheritance: - :undoc-members: diff --git a/docs/source/streamobs.model.rst b/docs/source/streamobs.model.rst index 24d0150..d716a21 100644 --- a/docs/source/streamobs.model.rst +++ b/docs/source/streamobs.model.rst @@ -4,4 +4,3 @@ streamobs.model module .. automodule:: streamobs.model :members: :show-inheritance: - :undoc-members: diff --git a/docs/source/streamobs.observed.rst b/docs/source/streamobs.observed.rst index 68b104c..96fae5b 100644 --- a/docs/source/streamobs.observed.rst +++ b/docs/source/streamobs.observed.rst @@ -4,4 +4,3 @@ streamobs.observed module .. automodule:: streamobs.observed :members: :show-inheritance: - :undoc-members: diff --git a/docs/source/streamobs.plotting.rst b/docs/source/streamobs.plotting.rst index 7f2527c..9c2ff57 100644 --- a/docs/source/streamobs.plotting.rst +++ b/docs/source/streamobs.plotting.rst @@ -4,4 +4,3 @@ streamobs.plotting module .. automodule:: streamobs.plotting :members: :show-inheritance: - :undoc-members: diff --git a/docs/source/streamobs.rst b/docs/source/streamobs.rst index 279061d..612cd5f 100644 --- a/docs/source/streamobs.rst +++ b/docs/source/streamobs.rst @@ -4,7 +4,6 @@ streamobs package .. automodule:: streamobs :members: :show-inheritance: - :undoc-members: Submodules ---------- diff --git a/docs/source/streamobs.samplers.rst b/docs/source/streamobs.samplers.rst index 334b40b..b17ae4c 100644 --- a/docs/source/streamobs.samplers.rst +++ b/docs/source/streamobs.samplers.rst @@ -4,4 +4,3 @@ streamobs.samplers module .. automodule:: streamobs.samplers :members: :show-inheritance: - :undoc-members: diff --git a/docs/source/streamobs.surveys.rst b/docs/source/streamobs.surveys.rst index ace942f..a79f771 100644 --- a/docs/source/streamobs.surveys.rst +++ b/docs/source/streamobs.surveys.rst @@ -4,4 +4,3 @@ streamobs.surveys module .. automodule:: streamobs.surveys :members: :show-inheritance: - :undoc-members: diff --git a/docs/source/streamobs.utils.rst b/docs/source/streamobs.utils.rst index d92c9b9..611ce49 100644 --- a/docs/source/streamobs.utils.rst +++ b/docs/source/streamobs.utils.rst @@ -4,4 +4,3 @@ streamobs.utils module .. automodule:: streamobs.utils :members: :show-inheritance: - :undoc-members: diff --git a/streamobs/observed.py b/streamobs/observed.py index 36d2e0e..5dec240 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -40,10 +40,9 @@ class StreamInjector: namespace is the column prefix (``lsst_r_obs``, ``roman_F158_obs``, ...). primary : str Namespace of the survey whose footprint drives the shared sky placement - and whose ``_save_injected_data`` is used. - survey : Survey - The primary :class:`~streamobs.surveys.Survey` (convenience accessor used - by the mask / coordinate helpers; equal to ``surveys[primary]``). + and whose ``_save_injected_data`` is used. The primary + :class:`~streamobs.surveys.Survey` itself is available via the ``survey`` + property (``surveys[primary]``), used by the mask/coordinate helpers. mask_cache : dict (class attribute) Cache of previously created HEALPix masks to avoid recomputation. _last_gc_frame : GreatCircleICRSFrame or None diff --git a/streamobs/plotting.py b/streamobs/plotting.py index 28ddb96..b17e59d 100644 --- a/streamobs/plotting.py +++ b/streamobs/plotting.py @@ -26,8 +26,8 @@ def draw_stream(phi1, phi2): ---------- phi1, phi2 : coordinates of stars (deg) - Returns: - -------- + Returns + ------- num, xedges, yedges, im : output of imshow """ @@ -42,8 +42,8 @@ def draw_stream(phi1, phi2): ax = plt.gca() ax.set_title("Mock Stream") - ax.set_xlabel("$\phi_1$ [deg]") - ax.set_ylabel("$\phi_2$ [deg]") + ax.set_xlabel(r"$\phi_1$ [deg]") + ax.set_ylabel(r"$\phi_2$ [deg]") image = ax.imshow( hist.T, diff --git a/streamobs/surveys.py b/streamobs/surveys.py index 105c633..bb97a47 100644 --- a/streamobs/surveys.py +++ b/streamobs/surveys.py @@ -69,8 +69,6 @@ class Survey: magnitudes. Optional second curve (config key ``log_photo_error_sample``). If not provided, the noise draw falls back to the catalog model, which reproduces the previous single-curve behaviour exactly. - log_photo_error : callable - Read/write alias for ``log_photo_error_catalog`` (backward compatibility). Examples -------- @@ -469,15 +467,16 @@ def get_efficiency( True apparent magnitude(s). maglim : float or np.ndarray Magnitude limit(s) at the position(s). - + type : str, optional + Type of efficiency function to use. Options are ``"completeness"``, + ``"detection_efficiency"``, or ``"classification_efficiency"``. + Default is ``"completeness"``. **kwargs - Additional keyword arguments: - type : str, optional - Type of efficiency function to use. Options are "completeness", "detection_efficiency", or "classification_efficiency". - Default is "completeness". + Additional keyword arguments. Currently: + delta_saturation : float, optional - Magnitude difference for saturation threshold in the initial completeness function. - Default is -10.4. + Magnitude difference for saturation threshold in the initial + completeness function. Default is -10.4. Returns ------- @@ -592,6 +591,8 @@ def create_survey( Custom configuration dictionary to use instead of loading from file. If provided, bypasses the standard config file loading. **kwargs + Additional keyword arguments. Recognized: + uniform_survey : bool, optional If True, also creates and caches a uniform version of the survey with constant magnitude limits. The uniform survey can be accessed @@ -599,7 +600,8 @@ def create_survey( Default is False. verbose : bool, optional Whether to print progress messages. Default is True. - Additional keyword arguments override config values + + Any other keyword arguments override config values. Returns ------- From 0935b2d4e4d8150f58d1fef3eeea68a45dd2e65d Mon Sep 17 00:00:00 2001 From: psferguson Date: Tue, 16 Jun 2026 12:13:36 -0700 Subject: [PATCH 09/29] remove some unnesseary files --- docs/source/multisurvey.md | 16 ++ docs/source/roman_multisurvey_plan.md | 9 + notebooks/multisurvey_phases_demo.ipynb | 156 ++----------- notebooks/roman_dc2_combine_plan.md | 128 ---------- scripts/build_multisurvey_demo_nb.py | 299 ------------------------ 5 files changed, 44 insertions(+), 564 deletions(-) delete mode 100644 notebooks/roman_dc2_combine_plan.md delete mode 100644 scripts/build_multisurvey_demo_nb.py diff --git a/docs/source/multisurvey.md b/docs/source/multisurvey.md index f1ae705..d3d753c 100644 --- a/docs/source/multisurvey.md +++ b/docs/source/multisurvey.md @@ -95,6 +95,22 @@ A single-survey isochrone (the flat `survey`/`band_1`/`band_2` form) is just the one-survey case of the same machinery and produces `__true` identically. +A complete, runnable example — the surveys, per-survey bands, the multi-survey +isochrone, and the shared stream geometry — is provided as a *scene* config in +[`config/scenes/roman_rubin_demo.yaml`](https://github.com/LSSTDESC/streamobs/blob/main/config/scenes/roman_rubin_demo.yaml): + +```python +import yaml +from streamobs.observed import StreamInjector + +scene = yaml.safe_load(open("config/scenes/roman_rubin_demo.yaml")) +inj = StreamInjector(scene["surveys"]) # {"lsst": "lsst", "roman": "roman"} +cat = inj.inject( + df, survey_bands=scene["survey_bands"], # {"lsst": [...], "roman": [...]} + stream_config=scene["stream"], seed=42, +) +``` + ```{note} **Roman bands are converted Vega→AB automatically.** `ugali` returns Roman isochrone magnitudes in Vega while the catalogs are AB, so `IsochroneModel` diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md index ed3d9b1..2d6f4dd 100644 --- a/docs/source/roman_multisurvey_plan.md +++ b/docs/source/roman_multisurvey_plan.md @@ -13,6 +13,15 @@ working design/roadmap doc, not user documentation. Before merge, migrate the durable content — the column convention, the sample/catalog error split, the multi-survey `StreamInjector` usage, and the Vega→AB handling — into the proper docs pages (and the API docstrings), then delete `roman_multisurvey_plan.md`. + +**Also remove before merge — useful for now, but not part of the merged package:** + +- `notebooks/multisurvey_phases_demo.ipynb` — the Phases 1–4 walkthrough. It is + kept tracked (with outputs stripped) during the branch's life, but should be + removed before merge and migrated into the rendered docs as an Examples page + (see the separate notebooks→docs migration). Its generator, + `scripts/build_multisurvey_demo_nb.py`, is a local-only helper and is **not** + tracked. ``` ## Motivation diff --git a/notebooks/multisurvey_phases_demo.ipynb b/notebooks/multisurvey_phases_demo.ipynb index 39ee820..790819f 100644 --- a/notebooks/multisurvey_phases_demo.ipynb +++ b/notebooks/multisurvey_phases_demo.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "faa963cc", "metadata": { "execution": { @@ -76,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "9fe2c7bf", "metadata": { "execution": { @@ -86,15 +86,7 @@ "shell.execute_reply": "2026-06-16T18:01:25.638254Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "StubSurvey ready\n" - ] - } - ], + "outputs": [], "source": [ "NSIDE = 1 # whole-sky single-pixel maps; enough for a synthetic demo\n", "\n", @@ -150,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "51d6fb5d", "metadata": { "execution": { @@ -160,25 +152,7 @@ "shell.execute_reply": "2026-06-16T18:01:25.741220Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "no sample curve -> sample falls back to catalog: True\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sv = StubSurvey(\"lsst\", [\"g\", \"r\"], completeness_band=\"r\", maglim=26.5)\n", "mags = np.linspace(20, 28, 200)\n", @@ -220,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "3b531fc3", "metadata": { "execution": { @@ -230,18 +204,7 @@ "shell.execute_reply": "2026-06-16T18:01:25.755283Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "namespaced columns: roman_F158_true roman_F158_obs roman_F158_err roman_flag_observed\n", - "\n", - "injected NIR-only bands -> columns: ['roman_F106_obs', 'roman_F106_err', 'roman_F158_obs', 'roman_F158_err', 'roman_flag_observed']\n", - "detected: 1274 / 1500\n" - ] - } - ], + "outputs": [], "source": [ "print(\"namespaced columns:\", C.true_col(\"F158\", \"roman\"), C.obs_col(\"F158\", \"roman\"),\n", " C.err_col(\"F158\", \"roman\"), C.flag_col(\"roman\"))\n", @@ -274,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "2798a8c1", "metadata": { "execution": { @@ -284,15 +247,7 @@ "shell.execute_reply": "2026-06-16T18:01:25.822899Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single-survey StreamModel.sample returns EXACTLY nstars (5000, 1234) -> OK\n" - ] - } - ], + "outputs": [], "source": [ "single_cfg = {\n", " \"density\": {\"type\": \"Uniform\", \"xmin\": -9.0, \"xmax\": 9.0},\n", @@ -320,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "95a245ed", "metadata": { "execution": { @@ -330,27 +285,7 @@ "shell.execute_reply": "2026-06-16T18:01:28.377918Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "multi-survey true columns: ['lsst_g_true', 'lsst_r_true', 'roman_F106_true', 'roman_F158_true']\n", - "rows: 4000\n", - "corr(lsst_r, roman_F158) = 0.995 (shared masses => tightly correlated)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "scene = yaml.safe_load(open(f\"{REPO}/config/scenes/roman_rubin_demo.yaml\"))\n", "sm_ms = StreamModel(scene[\"stream\"])\n", @@ -385,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "57c4f2c5", "metadata": { "execution": { @@ -395,26 +330,7 @@ "shell.execute_reply": "2026-06-16T18:01:28.421196Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Roman Vega->AB offsets (AB = Vega + diff):\n", - " F062: +0.153\n", - " F087: +0.481\n", - " F106: +0.66\n", - " F129: +1.051\n", - " F146: +1.164\n", - " F158: +1.315\n", - " F184: +1.556\n", - " F213: +1.837\n", - "\n", - "F158 shift: [1.315 1.315] (always +1.315)\n", - "r shift: [0. 0.] (0 -> non-Roman pass-through)\n" - ] - } - ], + "outputs": [], "source": [ "from streamobs.model import ROMAN_VEGA_TO_AB\n", "print(\"Roman Vega->AB offsets (AB = Vega + diff):\")\n", @@ -442,7 +358,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "3bf8c97b", "metadata": { "execution": { @@ -452,21 +368,7 @@ "shell.execute_reply": "2026-06-16T18:01:28.500442Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "columns produced:\n", - " lsst: ['lsst_flag_observed', 'lsst_g_err', 'lsst_g_obs', 'lsst_g_true', 'lsst_r_err', 'lsst_r_obs', 'lsst_r_true']\n", - " roman: ['roman_F106_err', 'roman_F106_obs', 'roman_F106_true', 'roman_F158_err', 'roman_F158_obs', 'roman_F158_true', 'roman_flag_observed']\n", - "\n", - "shared sky placement: ra/dec present = True\n", - "lsst detected: 1105 / 4000\n", - "roman detected: 3113 / 4000\n" - ] - } - ], + "outputs": [], "source": [ "lsst_sv = StubSurvey(\"lsst\", [\"g\", \"r\"], completeness_band=\"r\", maglim=26.0)\n", "roman_sv = StubSurvey(\"roman\", [\"F106\", \"F158\"], completeness_band=\"F158\", maglim=27.0)\n", @@ -488,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "4a4c2ff4", "metadata": { "execution": { @@ -498,16 +400,7 @@ "shell.execute_reply": "2026-06-16T18:01:28.568019Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "same seed -> identical obs & flags: True\n", - "different seed -> different noise draw: True\n" - ] - } - ], + "outputs": [], "source": [ "# Reproducible from seed (given the same true-mag draw)\n", "base = sm_ms.sample(3000)\n", @@ -522,7 +415,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "e154bc4b", "metadata": { "execution": { @@ -532,18 +425,7 @@ "shell.execute_reply": "2026-06-16T18:01:28.639713Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Detection efficiency vs magnitude, per survey (Roman is deeper here: maglim 27 vs 26)\n", "fig, ax = plt.subplots(figsize=(6.5, 4))\n", diff --git a/notebooks/roman_dc2_combine_plan.md b/notebooks/roman_dc2_combine_plan.md deleted file mode 100644 index 153a7ae..0000000 --- a/notebooks/roman_dc2_combine_plan.md +++ /dev/null @@ -1,128 +0,0 @@ -# Roman DC2 mock: plan to build a single truth catalog with observations - -**Status:** PLAN ONLY — not executed yet. -**Source:** Troxel et al. 2023, *A Joint Roman + Rubin Synthetic Wide-Field Imaging Survey* -([arXiv:2209.06829](https://arxiv.org/abs/2209.06829)). -**Data:** `/astro/store/shire/stream_team/stream_finding/data/roman_mock` -(symlinked as `data/surveys/roman_dc2/`). ~20 deg², **1039 coadd tiles**, tiles named by -center `{ra}_{dec}` in degrees (e.g. `50.93_-38.8`). -**Python:** `/astro/store/shiren/conda-envs/stream_team/envs/streamobs/bin/python` -(astropy 7.2, numpy, pandas, healpy; no fitsio). - ---- - -## 1. What the files actually are (verified by inspection) - -| File(s) | Count | Granularity | Key columns | Notes | -|---|---|---|---|---| -| `det/dc2_det_{tile}.fits.gz` | 2078 | per coadd, **one row per detection** | `number`, `alphawin_j2000`,`deltawin_j2000` (RA/Dec **deg**), `flux_auto`,`fluxerr_auto`, `mag_auto`, `mag_auto_{Y106,J129,H158,F184}` (+magerr,flux,fluxerr), `flags`, `class_star`, shape moments | SExtractor on the coadd. ~21k rows/tile. | -| `truth/dc2_index_{tile}.fits.gz` | 1479 (1039 real + 440 empty) | per coadd, **one row per object** | `ind` (truth ID), `ra`,`dec` (**deg**), `mag_{Y106,J129,H158,F184}`, `dered_{...}`, `gal_star` (**1=star, 0=gal**), `sca`,`dither`,`x`,`y`,`stamp`,`start_row` | **THE truth product to use.** 440 files are 53-byte empty placeholders (tiles with no objects). | -| `truth/coadd/dc2_index_{tile}.fits.gz` | 1481 | — | — | **Byte-identical** to `truth/dc2_index_{tile}` (confirmed via `filecmp`). Ignore one of them. | -| `truth/dc2_index_star.fits.gz` | 1 | **per (object × SCA exposure)** | `ind,sca,dither,x,y,ra,dec,mag,stamp,xmin,xmax,ymin,ymax,dudx,dudy,dvdx,dvdy,start_row` | 414 MB, ~6.36M rows. RA/Dec in **RADIANS**. Single-epoch index; **not needed** for coadd matching. | -| `truth/dc2_index.fits.gz` | 1 | **per (object × SCA exposure)** | same 18 cols as star index | **78 GB.** All objects (gal+star). Header `NAXIS2=0` (streaming FITS — astropy reads 0 rows; see §5). **Not needed for this task.** | -| `truth/dc2_coaddlist.fits.gz` | 1 | per coadd tile | `tilename,coadd_i,coadd_j,coadd_ra,coadd_dec,d_ra,d_dec,input_list` | 1838 rows; `input_list` = contributing exposures. Optional metadata. | - -### The key realization -**We do NOT need the 78 GB `dc2_index.fits` (nor the star index) for this.** -The per-coadd `truth/dc2_index_{tile}.fits.gz` files already carry, per object: -truth RA/Dec (deg), truth mags in all 4 Roman bands, dereddening, and the star/galaxy -flag. They are tile-for-tile aligned with the `det/dc2_det_{tile}.fits.gz` files. So the -whole job reduces to **per-tile positional matching** — tractable and parallel. - -The big index is only needed if you later want single-epoch (per-SCA) info: which exposures -saw an object, its pixel position/postage stamp, etc. - ---- - -## 2. The combine = per-tile positional match (truth ← det) - -Following the paper's matching recipe: - -For each of the **1039 real coadd tiles** (intersection of det-tile names and non-empty truth-tile names): - -1. **Load truth tile** → table of objects (ind, ra, dec, mag_*, dered_*, gal_star, ...). -2. **Load det tile** → detections (alphawin_j2000, deltawin_j2000, mag_auto_*, flux_auto, fluxerr_auto, flags, class_star). -3. **Cut det**: `S/N = flux_auto / fluxerr_auto > 5` (paper's threshold; removes only ~0.05%). - Optionally also `flags == 0` (stricter; the paper removes ~32% via flags — leave this as a toggle, default OFF). -4. **Match** truth → det by sky position with **1.0 arcsec** radius - (`astropy.coordinates.SkyCoord.match_to_catalog_sky`, or a KD-tree on a local tangent plane). - - Paper's rule: among matches within 1″, when ambiguous take the closest **in magnitude** - among the up-to-3 nearest. v1 can just take the **nearest neighbor within 1″**; add the - mag-tiebreak as a refinement. -5. **Left-join on truth**: every truth row is kept. Attach the matched det columns - (prefixed `det_`) when a match exists; else NaN. Add `detected` (bool) and `match_sep_arcsec`. -6. **Tag** each row with `tile` (the `{ra}_{dec}` string). -7. **Concatenate** all tiles → one catalog. Write to **parquet** (fast, typed) — and/or FITS. - -Output is then a single **truth-complete** catalog: one row per true object across the -footprint, with observed (detected) quantities where they exist. From it you can trivially -derive detection efficiency / completeness vs. magnitude, color, `gal_star`, etc., which is -exactly what stream-injection / selection-function work needs. - -### Output schema (proposed) -``` -ind, tile, ra, dec, gal_star, -mag_Y106, mag_J129, mag_H158, mag_F184, # truth -dered_Y106, dered_J129, dered_H158, dered_F184, # truth -detected (bool), match_sep_arcsec, -det_number, det_ra, det_dec, -det_mag_auto, det_mag_auto_Y106..F184, -det_flux_auto, det_fluxerr_auto, det_sn, -det_flags, det_class_star -``` -(`mag_* == 0.0` in truth means "no flux in that band" → treat as NaN on load.) - ---- - -## 3. Column subset for the big index (`dc2_index.fits`, 78 GB) — if you still want it - -You offered to pre-subset it. **For the coadd truth+det catalog you can skip it entirely** -(use the per-tile truth files). If you do subset it (e.g. for per-SCA / single-epoch studies), -the 18 columns are: - -| keep? | column | type | meaning | -|---|---|---|---| -| ✅ | `ind` | int64 | object ID — links to input truth catalog (join key across files) | -| ✅ | `ra`,`dec` | float64 | sky position (**radians** in this file) | -| ✅ | `mag` | float64 | true magnitude (in that exposure's band) | -| ✅ | `sca` | int64 | Roman detector (1–18) | -| ✅ | `dither` | int64 | exposure / pointing ID | -| ➖ | `x`,`y` | float64 | pixel position on the SCA | -| ➖ | `stamp`,`start_row` | int64 | postage-stamp pointers into the image-stamp file | -| ❌ | `xmin,xmax,ymin,ymax` | int64 | stamp bounding box | -| ❌ | `dudx,dudy,dvdx,dvdy` | float64 | local WCS Jacobian | - -Minimal useful subset: **`ind, sca, dither, ra, dec, mag`** (6 of 18 → ~⅓ the size). -Add `x,y,stamp,start_row` if you need to find/cut postage stamps. Note: a single object -appears in **many rows** here (once per SCA exposure it lands on), so you must group by `ind`. - ---- - -## 4. Decisions to confirm before coding - -1. **Stars only, or all objects?** streamobs is stellar streams → likely `gal_star==1`. - But keeping galaxies lets us model the contaminating background. → *propose: keep all, - carry `gal_star`, filter downstream.* -2. **flags cut?** S/N>5 only (your call), or also `flags==0` (drops ~32%, removes - blends/edges). → *propose: S/N>5 default, `flags==0` as an option.* -3. **Match radius / tie-break:** 1.0″ nearest-neighbor (v1) vs. paper's mag-tiebreak FoF. → *propose: 1.0″ NN first, refine if needed.* -4. **Output format/location:** parquet under `data/surveys/roman_dc2/` (+ optional FITS). -5. **Galaxy de-blending:** the paper notes 20–30% of Rubin objects split into multiple - Roman objects; with a 1″ radius a det can match several truths — we keep the truth-centric - left join (each truth → its nearest det), so this is handled implicitly. Flag if needed. - ---- - -## 5. Implementation notes / gotchas - -- **Read gzipped FITS**: `with gzip.open(path,'rb') as f: Table(astropy.io.fits.open(io.BytesIO(f.read()))[1].data)`. - (astropy's direct `.fits.gz` open chokes on the big NAXIS2=0 files; the per-tile files open fine.) -- **`NAXIS2=0` streaming files** (star/master index only): astropy returns 0 rows. To read: - skip the primary + extension headers (2880-byte blocks to `END`), then - `np.frombuffer(rest, dtype=<144-byte big-endian dtype>)`; n_rows = data_bytes // 144. -- **Units**: per-tile truth + det are **degrees**; star/master index are **radians**. -- **Missing mags**: truth `mag_* == 0.0` and det un-matched → use NaN. -- **Parallelism**: 1039 independent tiles. Natural fan-out — one worker per tile, then concat. - (Good candidate for a Workflow run, or simple multiprocessing / joblib.) -- **Sanity check tile** `50.93_-38.8`: 34378 truth objects (175 stars, 34203 gals); - 21382 detections, 21372 with S/N>5; truth & det RA/Dec ranges overlap as expected. diff --git a/scripts/build_multisurvey_demo_nb.py b/scripts/build_multisurvey_demo_nb.py deleted file mode 100644 index 3727252..0000000 --- a/scripts/build_multisurvey_demo_nb.py +++ /dev/null @@ -1,299 +0,0 @@ -#!/usr/bin/env python -"""Build notebooks/multisurvey_phases_demo.ipynb (Phases 1-4 showcase). - -Local helper to (re)generate the demo notebook from a single source of truth. -Run it from the repo root inside the `streamobs` conda env, then execute with -`jupyter nbconvert --to notebook --execute --inplace`. -""" - -import nbformat as nbf -from nbformat.v4 import new_code_cell, new_markdown_cell, new_notebook - -cells = [] -md = lambda s: cells.append(new_markdown_cell(s)) -co = lambda s: cells.append(new_code_cell(s)) - -md(r"""# Multi-survey injection — Phases 1-4 demo - -This notebook walks through the `roman_multisurvey` refactor that lets `streamobs` -inject a single stream carrying **both Roman and Rubin/LSST** photometry, where -each band draws its errors and detection probability from its *own* survey. - -| Phase | What changed | -|---|---| -| **1** | `Survey` holds two error curves — a *catalog* (reported `magerr`, drives the S/N cut) and an optional *sample* (true scatter, drives the noise draw). `get_photo_error(..., kind=)` selects between them. | -| **2** | The injector is de-hardcoded off `{r, g}`; column names route through `streamobs.columns`, using a uniform, **always survey-namespaced** `__true/_obs/_err` scheme. The S/N cut now applies to **all** injected bands. | -| **3** | `IsochroneModel` is multi-band / multi-survey: masses are drawn **once** (exactly `nstars`) and interpolated into every survey's bands, so the *same physical star* is consistent across surveys. Roman bands are auto-converted Vega→AB. | -| **4** | A single `StreamInjector` accepts one survey **or several**: it does one shared sky placement + one shared true-mag fill, then a per-survey loop writing `__obs/_err` and `_flag_observed`. | - -See `docs/source/roman_multisurvey_plan.md` for the full design. -""") - -co("""import warnings -warnings.filterwarnings("ignore") -import numpy as np -import pandas as pd -import healpy as hp -import yaml -import matplotlib.pyplot as plt - -from streamobs.surveys import Survey -from streamobs.model import StreamModel, IsochroneModel -from streamobs.observed import StreamInjector -from streamobs import columns as C - -import os -# Resolve the repo root whether the notebook runs from repo root or notebooks/. -REPO = ".." if os.path.exists("../config/scenes/roman_rubin_demo.yaml") else "." -rng = np.random.default_rng(42) -""") - -md(r"""## A runnable stub survey - -The real Roman/Rubin maglim maps and CSV tables are **not committed** to this -branch (they live in the git-ignored `data/surveys/`). So that this notebook -runs end-to-end, we use a tiny `StubSurvey` that: - -* keeps the **real** `Survey.get_photo_error` (so the Phase-1 two-curve split is - genuine) and `get_maglim`, -* supplies analytic `log_photo_error_*` curves and a logistic completeness. - -The **isochrones are real** (`Marigo2017` via `ugali`). To run against real -surveys, just replace `StubSurvey(...)` with `Survey.load("lsst", release=...)` -etc. — the injector code is identical. -""") - -co('''NSIDE = 1 # whole-sky single-pixel maps; enough for a synthetic demo - -class StubSurvey(Survey): - """Minimal Survey: real photo-error machinery, analytic completeness/maps.""" - - def __init__(self, name, bands, completeness_band, maglim=27.0, - sample_inflation=1.9): - self.name = name - self.bands = list(bands) - self.completeness_band = completeness_band - self.saturation = {b: 16.0 for b in bands} - self.sys_error = {b: 0.005 for b in bands} - self.delta_saturation = -10.0 - self.coeff_extinc = {b: 0.0 for b in bands} - self.ebv_map = np.zeros(hp.nside2npix(NSIDE)) - self.maglim_maps = {b: np.full(hp.nside2npix(NSIDE), maglim) for b in bands} - self.coverage = np.ones(hp.nside2npix(NSIDE)) # footprint = whole sky - # Phase 1: two error curves, both functions of delta_mag = mag - maglim. - # Catalog = reported error; sample = true scatter (here ~inflation x larger, - # echoing the Roman DC2 finding that true scatter ~2x reported magerr). - self.log_photo_error_catalog = lambda dm: np.log10( - 0.01 + 0.10 * np.exp(np.clip(dm, -30, 5))) - self.log_photo_error_sample = lambda dm: np.log10( - sample_inflation * (0.01 + 0.10 * np.exp(np.clip(dm, -30, 5)))) - - # analytic rolloff: ~1 when bright (mag << maglim), 0.5 at maglim, ->0 fainter - def get_completeness(self, band, mag, maglim): - return 1.0 / (1.0 + np.exp((np.asarray(mag) - np.asarray(maglim)) / 0.25)) - - def get_detection_efficiency(self, band, mag, maglim): - return self.get_completeness(band, mag, maglim) - - def get_extinction(self, band, pixel=None): - return np.zeros(np.size(pixel)) - -print("StubSurvey ready")''') - -md(r"""## Phase 1 — sample vs. catalog photometric error - -`Survey` now carries two curves. `get_photo_error(kind="catalog")` is the -reported error that becomes `magerr` and drives the S/N cut; -`get_photo_error(kind="sample")` is the *true* scatter used to draw the observed -magnitude. When no sample curve is loaded, `sample` transparently falls back to -`catalog`, so legacy single-curve behaviour is bit-for-bit preserved. -""") - -co("""sv = StubSurvey("lsst", ["g", "r"], completeness_band="r", maglim=26.5) -mags = np.linspace(20, 28, 200) -maglim = np.full_like(mags, 26.5) -err_cat = sv.get_photo_error("r", mags, maglim, kind="catalog") -err_smp = sv.get_photo_error("r", mags, maglim, kind="sample") - -# A survey with NO sample curve -> sample falls back to catalog (identical) -sv_legacy = StubSurvey("lsst", ["g", "r"], "r", maglim=26.5) -sv_legacy.log_photo_error_sample = None -err_fallback = sv_legacy.get_photo_error("r", mags, maglim, kind="sample") -assert np.allclose(err_fallback, sv_legacy.get_photo_error("r", mags, maglim, kind="catalog")) - -fig, ax = plt.subplots(figsize=(6, 4)) -ax.plot(mags, err_cat, label='catalog (reported magerr, drives S/N cut)') -ax.plot(mags, err_smp, label='sample (true scatter, drives noise draw)') -ax.axvline(26.5, ls=':', c='k', lw=1, label='maglim') -ax.set_xlabel('magnitude'); ax.set_ylabel('photometric error [mag]') -ax.set_title('Phase 1: two error curves on Survey'); ax.legend(); fig.tight_layout() -print("no sample curve -> sample falls back to catalog:", - np.allclose(err_fallback, err_cat))""") - -md(r"""## Phase 2 — arbitrary bands + `columns.py` - -The injector no longer hard-codes `{r, g}`. Column names come from -`streamobs.columns`, using one uniform, **always survey-namespaced** convention: -`__true` / `__obs` / `__err` / -`_flag_observed`. (This intentionally drops the historical `mag_` / -`magerr_` names — not backward compatible.) Below we inject Roman NIR bands -`F106`/`F158` through a **single-survey** `StreamInjector` — impossible under the -old `{r,g}` block — and the output is namespaced by the survey's name (`roman`). -""") - -co( - """print("namespaced columns:", C.true_col("F158", "roman"), C.obs_col("F158", "roman"), - C.err_col("F158", "roman"), C.flag_col("roman")) - -roman_sv = StubSurvey("roman", ["F106", "F158"], completeness_band="F158", maglim=27.0) -inj = StreamInjector(roman_sv) # one survey -> namespaced by its name, "roman" -N = 1500 -df = pd.DataFrame({ - "ra": rng.uniform(10, 20, N), - "dec": rng.uniform(-5, 5, N), - "roman_F106_true": rng.uniform(20, 28, N), - "roman_F158_true": rng.uniform(20, 28, N), -}) -out = inj.inject(df, bands=["F106", "F158"], seed=1, verbose=False) -print("\\ninjected NIR-only bands -> columns:", - [c for c in out.columns if c.endswith(("_obs", "_err")) or c.endswith("flag_observed")]) -print("detected:", int(out.roman_flag_observed.sum()), "/", len(out))""" -) - -md(r"""## Phase 3 — multi-band / multi-survey isochrone (exactly `nstars`) - -`IsochroneModel.sample` now draws **exactly** `nstars` (a fixed mass set), for -both single- and multi-survey configs. First, the single-survey path: -""") - -co("""single_cfg = { - "density": {"type": "Uniform", "xmin": -9.0, "xmax": 9.0}, - "track": {"center": {"type": "Constant", "value": 0.0}, - "spread": {"type": "Constant", "value": 0.2}, "sampler": "Gaussian"}, - "distance_modulus": {"center": {"type": "Line", "slope": 0.1, "intercept": 16.5}, - "spread": {"type": "Constant", "value": 1e-4}, "sampler": "Uniform"}, - "isochrone": {"name": "Marigo2017", "survey": "lsst", "age": 12.0, "z": 0.0006, - "band_1": "g", "band_2": "r"}, -} -sm = StreamModel(single_cfg) -for n in (5000, 1234): - assert len(sm.sample(n)) == n -print("single-survey StreamModel.sample returns EXACTLY nstars (5000, 1234) -> OK")""") - -md(r"""Now the multi-survey scene. One mass draw feeds both surveys, so a star's -LSST and Roman magnitudes describe the *same object*.""") - -co("""scene = yaml.safe_load(open(f"{REPO}/config/scenes/roman_rubin_demo.yaml")) -sm_ms = StreamModel(scene["stream"]) -df_ms = sm_ms.sample(4000) -true_cols = sorted(c for c in df_ms.columns if c.endswith("_true")) -print("multi-survey true columns:", true_cols) -print("rows:", len(df_ms)) - -rho = np.corrcoef(df_ms["lsst_r_true"], df_ms["roman_F158_true"])[0, 1] -print(f"corr(lsst_r, roman_F158) = {rho:.3f} (shared masses => tightly correlated)") - -fig, axes = plt.subplots(1, 2, figsize=(10, 4.2), sharey=True) -axes[0].scatter(df_ms.lsst_g_true - df_ms.lsst_r_true, df_ms.lsst_r_true, s=3, alpha=.3) -axes[0].set_xlabel("g - r"); axes[0].set_ylabel("r"); axes[0].set_title("Rubin/LSST CMD") -axes[0].invert_yaxis() -axes[1].scatter(df_ms.roman_F106_true - df_ms.roman_F158_true, df_ms.roman_F158_true, s=3, alpha=.3, c="C3") -axes[1].set_xlabel("F106 - F158"); axes[1].set_ylabel("F158"); axes[1].set_title("Roman CMD") -axes[1].invert_yaxis() -fig.suptitle("Phase 3: same physical stars, two surveys"); fig.tight_layout()""") - -md(r"""Roman isochrone magnitudes are **always** converted Vega→AB (no config -flag) using the fixed `ROMAN_VEGA_TO_AB` table, sourced from the -`rubin_roman_object_classification` prototype. Non-Roman bands pass through -unchanged. (A `TODO` in the code notes this ideally belongs in `ugali`.)""") - -co("""from streamobs.model import ROMAN_VEGA_TO_AB -print("Roman Vega->AB offsets (AB = Vega + diff):") -for b, v in ROMAN_VEGA_TO_AB.items(): - print(f" {b}: +{v}") - -iso = StreamModel(scene["stream"]).isochrone # multi-survey isochrone -x = np.array([20.0, 21.0]) -print("\\nF158 shift:", (iso._to_ab("F158", x) - x), " (always +1.315)") -print("r shift:", (iso._to_ab("r", x) - x), " (0 -> non-Roman pass-through)")""") - -md(r"""## Phase 4 — one `StreamInjector`, many surveys - -The same `StreamInjector` class accepts a `{namespace: survey}` mapping. It does -one shared sky placement and one shared mass draw, then a per-survey loop writing -each survey's observed columns and flags. Per-survey RNGs come from -`rng.spawn(...)`, so the result is reproducible and independent of survey order. -""") - -co( - """lsst_sv = StubSurvey("lsst", ["g", "r"], completeness_band="r", maglim=26.0) -roman_sv = StubSurvey("roman", ["F106", "F158"], completeness_band="F158", maglim=27.0) -msi = StreamInjector({"lsst": lsst_sv, "roman": roman_sv}, primary="lsst") - -# Input carries only stream coordinates; everything else is sampled once. -N = 4000 -stream_in = pd.DataFrame({"phi1": rng.uniform(-9, 9, N), "phi2": np.zeros(N)}) -cat = msi.inject(stream_in.copy(), scene["survey_bands"], - stream_config=scene["stream"], seed=7, verbose=False) - -print("columns produced:") -for grp in ("lsst", "roman"): - print(f" {grp}:", sorted(c for c in cat.columns if c.startswith(grp + "_"))) -print(f"\\nshared sky placement: ra/dec present = {('ra' in cat) and ('dec' in cat)}") -print(f"lsst detected: {int(cat.lsst_flag_observed.sum()):5d} / {len(cat)}") -print(f"roman detected: {int(cat.roman_flag_observed.sum()):5d} / {len(cat)}")""" -) - -co( - """# Reproducible from seed (given the same true-mag draw) -base = sm_ms.sample(3000) -base["ra"] = rng.uniform(10, 20, len(base)); base["dec"] = rng.uniform(-5, 5, len(base)) -a = msi.inject(base.copy(), scene["survey_bands"], seed=11, verbose=False) -b = msi.inject(base.copy(), scene["survey_bands"], seed=11, verbose=False) -c = msi.inject(base.copy(), scene["survey_bands"], seed=22, verbose=False) -print("same seed -> identical obs & flags:", - a.roman_F158_obs.equals(b.roman_F158_obs) and a.lsst_flag_observed.equals(b.lsst_flag_observed)) -print("different seed -> different noise draw:", not a.roman_F158_obs.equals(c.roman_F158_obs))""" -) - -co( - """# Detection efficiency vs magnitude, per survey (Roman is deeper here: maglim 27 vs 26) -fig, ax = plt.subplots(figsize=(6.5, 4)) -for col, flag, lab, cc in [("lsst_r_true", "lsst_flag_observed", "LSST r (maglim 26.0)", "C0"), - ("roman_F158_true", "roman_flag_observed", "Roman F158 (maglim 27.0)", "C3")]: - m = cat[col].to_numpy(float); f = cat[flag].to_numpy(bool) - bins = np.linspace(20, 29, 28); idx = np.digitize(m, bins) - eff = [f[idx == i].mean() if (idx == i).any() else np.nan for i in range(1, len(bins))] - ax.plot(0.5 * (bins[1:] + bins[:-1]), eff, marker="o", ms=3, label=lab, c=cc) -ax.set_xlabel("true magnitude"); ax.set_ylabel("detected fraction") -ax.set_title("Phase 4: per-survey selection from one catalog"); ax.legend(); fig.tight_layout()""" -) - -md(r"""## Notes for real runs - -* Swap `StubSurvey(...)` for `Survey.load("lsst", release="dc2")` and the real - Roman survey once its config/maps land — the injector code is unchanged. -* A band label is used **both** as the ugali isochrone field name and as the key - into a survey's maglim/photo-error maps, so they must agree (ugali's Roman - fields are upper-case: `F106`, `F158`, ...). -* **`nstars` is now exactly N** (was an emergent IMF count). This is the agreed - semantics for both single- and multi-survey configs. -* **Output columns are always survey-namespaced** (`__…`), even for - a single survey — there is no longer an un-namespaced single-survey form. -""") - -nb = new_notebook(cells=cells) -nb.metadata.update( - { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3", - }, - "language_info": {"name": "python"}, - } -) -out_path = "notebooks/multisurvey_phases_demo.ipynb" -with open(out_path, "w") as f: - nbf.write(nb, f) -print("wrote", out_path, "with", len(cells), "cells") From 79d14c7d940b33be341d1673c7090db9064fcd6a Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Wed, 17 Jun 2026 16:24:23 +0200 Subject: [PATCH 10/29] testing multi survey injector --- tests/test_observed.py | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/tests/test_observed.py b/tests/test_observed.py index a0c800d..73d0fc1 100644 --- a/tests/test_observed.py +++ b/tests/test_observed.py @@ -47,6 +47,47 @@ def test_injector_initialization(self, mock_injector): assert injector_direct.survey.name == "lsst", "Survey name must be 'lsst'" assert injector_direct.survey.release == "yr4", "Survey release must be 'yr4'" + def test_injector_multisurveys(self): + """Test that the injector can handle multiple surveys.""" + # Create a second survey and injector + survey1_dict = {"survey": "lsst", "release": "yr4"} + survey2_dict = {"survey": "lsst", "release": "yr5"} + survey1 = Survey.load(**survey1_dict) + survey2 = Survey.load(**survey2_dict) + + def test_injector_initialization_with_multiple_surveys(injector): + """Test that the injector initializes with multiple surveys.""" + assert isinstance( + injector, StreamInjector + ), "Injector must be an instance of StreamInjector" + assert hasattr( + injector, "primary" + ), "Injector must have a 'primary' property" + assert isinstance( + injector.surveys, dict + ), "Survey property must be a dict of Survey instances" + assert all( + isinstance(value, Survey) for key, value in injector.surveys.items() + ), "All elements in survey dict must be Survey instances" + assert ( + len(injector.surveys) == 2 + ), f"Injector must have 2 surveys, got {len(injector.surveys)} with keys: {list(injector.surveys.keys())}" + assert isinstance( + injector.primary, Survey + ), "Primary survey must be a Survey instance" + + # Intialize injectors for both surveys using list of survey objects + injector1 = StreamInjector(survey=[survey1, survey2]) + test_injector_initialization_with_multiple_surveys(injector1) + + # Initialize injectors for both surveys using list of survey dicts + injector3 = StreamInjector(survey=[survey1_dict, survey2_dict]) + test_injector_initialization_with_multiple_surveys(injector3) + + # Initialize injectors for both surveys using dicts # but I do not think + # this is more useful than the previous approach. + injector3 = StreamInjector({"lsst_yr4": survey1_dict, "lsst_yr5": survey2_dict}) + test_injector_initialization_with_multiple_surveys(injector3) # --------------------------------------------------------------------------- # Injector behavior From 67999d84b09e084db56d76a1108029a2f15866fe Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Wed, 17 Jun 2026 16:25:13 +0200 Subject: [PATCH 11/29] black + isort format --- bin/download_data.py | 151 ++++++++++------- bin/example_generate_pal5.py | 8 +- bin/generate_spline_stream.py | 34 ++-- bin/generate_stream.py | 43 ++--- docs/source/conf.py | 15 +- streamobs/samplers.py | 16 +- tests/conftest.py | 81 ++++++--- tests/test_functions.py | 10 +- tests/test_model.py | 6 +- tests/test_observed.py | 1 + tests/test_surveys.py | 303 +++++++++++++++++++++++----------- 11 files changed, 415 insertions(+), 253 deletions(-) diff --git a/bin/download_data.py b/bin/download_data.py index 904468c..06655e4 100755 --- a/bin/download_data.py +++ b/bin/download_data.py @@ -6,15 +6,14 @@ (e.g., Zenodo, institutional server) and extracts it to the data/ directory. """ +import argparse import os import sys -import argparse -import urllib.request +import tempfile import urllib.error -from pathlib import Path +import urllib.request import zipfile -import tempfile - +from pathlib import Path # ============================================================================= # CONFIGURATION - Update this URL when data location changes @@ -30,7 +29,7 @@ DATA_ARCHIVE_URL = BASE_DATA_URL + DATA_ARCHIVE_NAME # Expected size (approximate, for user information) -ARCHIVE_SIZE_MB = 30 #Mb +ARCHIVE_SIZE_MB = 30 # Mb # ============================================================================= # ============================================================================= @@ -41,16 +40,18 @@ def download_file(url, output_path, description="file"): print(f"Downloading {description}...") print(f" From: {url}") print(f" To: {output_path}") - + def progress_hook(count, block_size, total_size): """Show download progress.""" if total_size > 0: percent = int(count * block_size * 100 / total_size) mb_downloaded = count * block_size / (1024 * 1024) mb_total = total_size / (1024 * 1024) - sys.stdout.write(f"\r Progress: {percent}% ({mb_downloaded:.1f}/{mb_total:.1f} MB)") + sys.stdout.write( + f"\r Progress: {percent}% ({mb_downloaded:.1f}/{mb_total:.1f} MB)" + ) sys.stdout.flush() - + try: urllib.request.urlretrieve(url, output_path, reporthook=progress_hook) print("\n ✓ Download complete!") @@ -65,20 +66,20 @@ def extract_zip(zip_path, extract_to, description="archive"): print(f"\nExtracting {description}...") print(f" From: {zip_path}") print(f" To: {extract_to}") - + try: - with zipfile.ZipFile(zip_path, 'r') as zip_ref: + with zipfile.ZipFile(zip_path, "r") as zip_ref: # Get list of files file_list = zip_ref.namelist() print(f" Found {len(file_list)} files in archive") - + # Extract all files zip_ref.extractall(extract_to) print(" ✓ Extraction complete!") - + # Clean up unwanted files after extraction cleanup_unwanted_files(extract_to) - + return True except Exception as e: print(f" ✗ Extraction failed: {e}") @@ -89,16 +90,16 @@ def cleanup_unwanted_files(base_path): """Remove unwanted files like .DS_Store, .backup, etc. after extraction.""" base_path = Path(base_path) removed_count = 0 - + # Patterns to remove unwanted_patterns = [ - '**/.DS_Store', # macOS system files - '**/__MACOSX', # macOS resource forks - '**/*.backup', # Backup files - '**/*.bak', # Backup files - '**/*~', # Temporary files + "**/.DS_Store", # macOS system files + "**/__MACOSX", # macOS resource forks + "**/*.backup", # Backup files + "**/*.bak", # Backup files + "**/*~", # Temporary files ] - + for pattern in unwanted_patterns: for item in base_path.glob(pattern): try: @@ -107,47 +108,48 @@ def cleanup_unwanted_files(base_path): removed_count += 1 elif item.is_dir(): import shutil + shutil.rmtree(item) removed_count += 1 except Exception: pass # Ignore errors during cleanup - + if removed_count > 0: print(f" Cleaned up {removed_count} unwanted file(s)") - def list_data_contents(data_dir): """List what's in the data directory after download.""" print("\n📂 Data directory contents:") print("=" * 80) - + if not data_dir.exists(): print(" (empty - data directory doesn't exist yet)") return - + # List subdirectories - subdirs = [d for d in data_dir.iterdir() if d.is_dir() and not d.name.startswith('.')] + subdirs = [ + d for d in data_dir.iterdir() if d.is_dir() and not d.name.startswith(".") + ] if not subdirs: print(" (empty - no subdirectories found)") return - + for subdir in sorted(subdirs): print(f"\n {subdir.name}/") # Count files in subdirectory try: - files = list(subdir.rglob('*')) - files = [f for f in files if f.is_file() and not f.name.startswith('.')] + files = list(subdir.rglob("*")) + files = [f for f in files if f.is_file() and not f.name.startswith(".")] total_size = sum(f.stat().st_size for f in files) print(f" Files: {len(files)} ({total_size / (1024*1024):.1f} MB)") except Exception: print(f" (unable to read directory)") - def main(): parser = argparse.ArgumentParser( - description='Download and extract large data files for streamobs', + description="Download and extract large data files for streamobs", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: @@ -162,60 +164,81 @@ def main(): # Use custom data URL python download_data.py --url https://my-server.edu/data.zip - """ + """, + ) + + parser.add_argument( + "--list", + action="store_true", + help="List current data directory contents without downloading", + ) + parser.add_argument( + "--url", + type=str, + default=DATA_ARCHIVE_URL, + help=f"URL for data archive (default: configured Zenodo URL)", + ) + parser.add_argument( + "--data-dir", + type=str, + default=None, + help="Data directory (default: streamobs/data/)", ) - - parser.add_argument('--list', action='store_true', - help='List current data directory contents without downloading') - parser.add_argument('--url', type=str, default=DATA_ARCHIVE_URL, - help=f'URL for data archive (default: configured Zenodo URL)') - parser.add_argument('--data-dir', type=str, default=None, - help='Data directory (default: streamobs/data/)') - parser.add_argument('--force', action='store_true', - help='Force re-download even if data exists') - parser.add_argument('--keep-archive', action='store_true', - help='Keep the downloaded zip file after extraction') - + parser.add_argument( + "--force", action="store_true", help="Force re-download even if data exists" + ) + parser.add_argument( + "--keep-archive", + action="store_true", + help="Keep the downloaded zip file after extraction", + ) + args = parser.parse_args() - + # Determine data directory if args.data_dir: data_dir = Path(args.data_dir) else: # Assume script is in streamobs/bin/ script_dir = Path(__file__).parent - data_dir = script_dir.parent / 'data' - + data_dir = script_dir.parent / "data" + # List contents and exit if requested if args.list: list_data_contents(data_dir) return 0 - + # Check if URL is configured - if 'XXXXX' in args.url: + if "XXXXX" in args.url: print("=" * 80) print("ERROR: Data URL is not yet configured!") print("=" * 80) print("\nThe DATA_ARCHIVE_URL in this script is still set to a placeholder.") print("Please update it with the actual data hosting location.\n") print("Steps:") - print(" 1. Upload your data/ directory as a zip file to Zenodo or another host") + print( + " 1. Upload your data/ directory as a zip file to Zenodo or another host" + ) print(" 2. Edit this script and update BASE_DATA_URL and DATA_ARCHIVE_NAME") print(" 3. Or use --url to specify a custom URL\n") return 1 - + # Check if data already exists if data_dir.exists() and not args.force: - subdirs = [d for d in data_dir.iterdir() if d.is_dir() and not d.name.startswith('.')] + subdirs = [ + d for d in data_dir.iterdir() if d.is_dir() and not d.name.startswith(".") + ] if subdirs: print("=" * 80) print("Data directory already exists with content!") print("=" * 80) list_data_contents(data_dir) print("\n" + "=" * 80) - print("Use --force to re-download and overwrite, or --list to view contents") + print( + "Use --force to re-download and overwrite, or --list to view contents" + ) return 0 - + # Download and extract print("=" * 80) print("Stream Simulation Data Download") @@ -224,36 +247,36 @@ def main(): print(f"Destination: {data_dir}") print(f"Archive size: ~{ARCHIVE_SIZE_MB} MB") print("\n" + "=" * 80) - + # Create data directory data_dir.mkdir(parents=True, exist_ok=True) - + # Create temporary file for download - with tempfile.NamedTemporaryFile(suffix='.zip', delete=False) as tmp_file: + with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_file: tmp_path = Path(tmp_file.name) - + try: # Download if not download_file(args.url, tmp_path, "data archive"): print("\n✗ Download failed!") return 1 - + # Extract if not extract_zip(tmp_path, data_dir.parent, "data archive"): print("\n✗ Extraction failed!") return 1 - + # Show what was extracted list_data_contents(data_dir) - + print("\n" + "=" * 80) print("✓ Data download and extraction complete!") print("=" * 80) print("\nYou can now run stream simulations with this data.") print("The data has been extracted to:", data_dir) - + return 0 - + finally: # Clean up temporary file unless requested to keep it if tmp_path.exists(): @@ -265,5 +288,5 @@ def main(): tmp_path.unlink() -if __name__ == '__main__': +if __name__ == "__main__": sys.exit(main()) diff --git a/bin/example_generate_pal5.py b/bin/example_generate_pal5.py index b72c5c3..5c9d278 100644 --- a/bin/example_generate_pal5.py +++ b/bin/example_generate_pal5.py @@ -14,10 +14,10 @@ def inverse_transfom_sample(vals, pdf, size): cdf /= cdf[-1] fn = scipy.interpolate.interp1d(cdf, list(range(0, len(cdf)))) x_new = np.random.uniform(size=np.rint(size).astype(int)) - x_new[ - x_new < 1e-3 - ] = 1e-3 # running into error that values close to 0 are flagged as being - # below interp range + x_new[x_new < 1e-3] = ( + 1e-3 # running into error that values close to 0 are flagged as being + ) + # below interp range index = np.rint(fn(x_new)).astype(int) return vals[index] diff --git a/bin/generate_spline_stream.py b/bin/generate_spline_stream.py index bf1152d..883467a 100755 --- a/bin/generate_spline_stream.py +++ b/bin/generate_spline_stream.py @@ -5,13 +5,14 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd -from streamobs.model import SplineStreamModel, BackgroundModel + +from streamobs.model import BackgroundModel, SplineStreamModel from streamobs.plotting import plot_stream from streamobs.utils import parse_config def generate_stream(config): - """ Generate the simulated stream. + """Generate the simulated stream. Parameters ---------- @@ -23,32 +24,33 @@ def generate_stream(config): """ print("Generating stream...") - stream = SplineStreamModel(config['stream']) - stream_df = stream.sample(config['stream']['nstars']) + stream = SplineStreamModel(config["stream"]) + stream_df = stream.sample(config["stream"]["nstars"]) print(f" generated {len(stream_df)} stream stars.") print("Generating background...") - bkg = BackgroundModel(config['background']) - bkg_df = bkg.sample(config['background']['nstars']) + bkg = BackgroundModel(config["background"]) + bkg_df = bkg.sample(config["background"]["nstars"]) print(f" generated {len(bkg_df)} background stars.") print("Combining stream and background.") out = pd.concat([stream_df, bkg_df]) - out['flag'] = np.hstack([np.ones(len(stream_df), dtype=int), - np.zeros(len(bkg_df), dtype=int)]) + out["flag"] = np.hstack( + [np.ones(len(stream_df), dtype=int), np.zeros(len(bkg_df), dtype=int)] + ) return out if __name__ == "__main__": import argparse + parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument('config', - help='configuration file') - parser.add_argument('-o', '--outfile', default='stream_out.csv', - help='output file') - parser.add_argument('-p', '--plot', action='store_true', - help='plot stream and background') + parser.add_argument("config", help="configuration file") + parser.add_argument("-o", "--outfile", default="stream_out.csv", help="output file") + parser.add_argument( + "-p", "--plot", action="store_true", help="plot stream and background" + ) args = parser.parse_args() print(f"Reading config: {args.config}") @@ -62,7 +64,7 @@ def generate_stream(config): if args.plot: print("Plotting stars...") - fig, ax = plot_stream(stars['phi1'], stars['phi2']) - pngfile = args.outfile.replace('.csv', '.png') + fig, ax = plot_stream(stars["phi1"], stars["phi2"]) + pngfile = args.outfile.replace(".csv", ".png") print(f"Writing {pngfile}") plt.savefig(pngfile, facecolor="white") diff --git a/bin/generate_stream.py b/bin/generate_stream.py index 46b6616..017bfeb 100755 --- a/bin/generate_stream.py +++ b/bin/generate_stream.py @@ -2,8 +2,8 @@ """ More modular stream generation example. """ -import os import copy +import os from importlib import reload import matplotlib.pyplot as plt @@ -11,15 +11,19 @@ import pandas as pd import scipy.interpolate +import streamobs.model + +reload(streamobs.model) +import streamobs.plotting +from streamobs.model import BackgroundModel, StreamModel -import streamobs.model; reload(streamobs.model) -from streamobs.model import StreamModel, BackgroundModel -import streamobs.plotting; reload(streamobs.plotting) +reload(streamobs.plotting) from streamobs.plotting import plot_stream from streamobs.utils import parse_config + def generate_stream(config): - """ Generate the simulated stream. + """Generate the simulated stream. Parameters ---------- @@ -31,32 +35,33 @@ def generate_stream(config): """ print("Generating stream...") - stream = StreamModel(config['stream']) - stream_df = stream.sample(config['stream']['nstars'] ) + stream = StreamModel(config["stream"]) + stream_df = stream.sample(config["stream"]["nstars"]) print(f" generated {len(stream_df)} stream stars.") print("Generating background...") - bkg = BackgroundModel(config['background']) - bkg_df = bkg.sample(config['background']['nstars']) + bkg = BackgroundModel(config["background"]) + bkg_df = bkg.sample(config["background"]["nstars"]) print(f" generated {len(bkg_df)} background stars.") print("Combining stream and background.") out = pd.concat([stream_df, bkg_df]) - out['flag'] = np.hstack([np.ones(len(stream_df),dtype=int), - np.zeros(len(bkg_df),dtype=int)]) + out["flag"] = np.hstack( + [np.ones(len(stream_df), dtype=int), np.zeros(len(bkg_df), dtype=int)] + ) return out if __name__ == "__main__": import argparse + parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument('config', - help='configuration file') - parser.add_argument('-o','--outfile', default='stream_out.csv', - help='output file') - parser.add_argument('-p','--plot', action='store_true', - help='plot stream and background') + parser.add_argument("config", help="configuration file") + parser.add_argument("-o", "--outfile", default="stream_out.csv", help="output file") + parser.add_argument( + "-p", "--plot", action="store_true", help="plot stream and background" + ) args = parser.parse_args() print(f"Reading config: {args.config}") @@ -70,7 +75,7 @@ def generate_stream(config): if args.plot: print(f"Plotting stars...") - fig,ax = plot_stream(stars['phi1'], stars['phi2']) - pngfile = args.outfile.replace('.csv','.png') + fig, ax = plot_stream(stars["phi1"], stars["phi2"]) + pngfile = args.outfile.replace(".csv", ".png") print(f"Writing {pngfile}") plt.savefig(pngfile, facecolor="white") diff --git a/docs/source/conf.py b/docs/source/conf.py index 6259e9b..dfa7e7b 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -3,17 +3,17 @@ # For the full list of built-in configuration values, see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html -import sys import os +import sys -sys.path.insert(0, os.path.abspath('../..')) +sys.path.insert(0, os.path.abspath("../..")) # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information -project = 'streamobs' -copyright = '2025, DESC' -author = 'DESC' +project = "streamobs" +copyright = "2025, DESC" +author = "DESC" # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration @@ -28,7 +28,7 @@ "myst_parser", ] -templates_path = ['_templates'] +templates_path = ["_templates"] exclude_patterns = [] # -- numpydoc ---------------------------------------------------------------- @@ -39,9 +39,8 @@ numpydoc_show_class_members = False - # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output html_theme = "sphinx_book_theme" -html_static_path = ['_static'] +html_static_path = ["_static"] diff --git a/streamobs/samplers.py b/streamobs/samplers.py index a4b8bdc..4bf42e9 100644 --- a/streamobs/samplers.py +++ b/streamobs/samplers.py @@ -6,15 +6,13 @@ import numpy as np import scipy.stats -from streamobs.functions import ( - CubicSplineInterpolation, - FileCubicSplineInterpolation, - FileInterpolation, - FileLinearDensityCubicSplineInterpolation, - Interpolation, - LinearDensityCubicSplineInterpolation, - Sinusoid, -) +from streamobs.functions import (CubicSplineInterpolation, + FileCubicSplineInterpolation, + FileInterpolation, + FileLinearDensityCubicSplineInterpolation, + Interpolation, + LinearDensityCubicSplineInterpolation, + Sinusoid) def sampler_factory(type_, **kwargs): diff --git a/tests/conftest.py b/tests/conftest.py index 66f5638..fe4913b 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -14,59 +14,76 @@ # Utilities # --------------------------------------------------------------------------- + @pytest.fixture(scope="session") def seed(): """Fixed random seed for reproducibility.""" return 42 + @pytest.fixture(scope="session") def rng(seed): """Random number generator initialized with a fixed seed.""" return np.random.default_rng(seed) + @pytest.fixture(scope="session") def verbose(): """Control verbosity of test output.""" return True + # --------------------------------------------------------------------------- # Minimal stream model config (no isochrone, no velocity — pure geometry) # --------------------------------------------------------------------------- + @pytest.fixture(scope="session") def minimal_stream_config(): """Minimal StreamModel config: density + track only (no isochrone / velocity).""" return { - 'density': {'type': 'Uniform', 'xmin': -9.0, 'xmax': 9.0}, - + "density": {"type": "Uniform", "xmin": -9.0, "xmax": 9.0}, # Track model - 'track': {'center': {'type': 'Constant', 'value': 0.0}, # center line of the stream in degrees - 'spread': {'type': 'Constant', 'value': 0.2}, # spread of the stream in degrees - 'sampler': 'Gaussian'}, # how to sample across the stream - + "track": { + "center": { + "type": "Constant", + "value": 0.0, + }, # center line of the stream in degrees + "spread": { + "type": "Constant", + "value": 0.2, + }, # spread of the stream in degrees + "sampler": "Gaussian", + }, # how to sample across the stream # Isochrone model - 'isochrone': {'name': 'Marigo2017', # isochrone set name - 'survey': 'lsst', # survey for filter set - 'age': 12.0, # Age in Gyr of the population - 'z': 0.0006, # Metallicity of the population - 'band_1': 'g', # first band for color-magnitude - 'band_2': 'r', # second band for color-magnitude - 'band_1_detection': True}, + "isochrone": { + "name": "Marigo2017", # isochrone set name + "survey": "lsst", # survey for filter set + "age": 12.0, # Age in Gyr of the population + "z": 0.0006, # Metallicity of the population + "band_1": "g", # first band for color-magnitude + "band_2": "r", # second band for color-magnitude + "band_1_detection": True, + }, } + @pytest.fixture(scope="session") def stream_config_with_distance(minimal_stream_config): """StreamModel config that also produces a distance modulus column.""" cfg = dict(minimal_stream_config) - cfg["distance_modulus"] ={'center': {'type': 'Constant', 'value': 16.8}, - 'spread': {'type': 'Constant', 'value': 0.0}, - } + cfg["distance_modulus"] = { + "center": {"type": "Constant", "value": 16.8}, + "spread": {"type": "Constant", "value": 0.0}, + } return cfg + # --------------------------------------------------------------------------- # Tiny sample DataFrame used for injection tests # --------------------------------------------------------------------------- + @pytest.fixture def sample_catalog_radec(rng): """ @@ -74,10 +91,12 @@ def sample_catalog_radec(rng): without needing coordinate conversion or a stream model. """ n = 50 - return pd.DataFrame({ - "ra": rng.uniform(30.0, 60.0, n), - "dec": rng.uniform(-20.0, 0.0, n), - }) + return pd.DataFrame( + { + "ra": rng.uniform(30.0, 60.0, n), + "dec": rng.uniform(-20.0, 0.0, n), + } + ) @pytest.fixture @@ -86,58 +105,70 @@ def sample_catalog_phi(rng): n = 50 phi1 = rng.uniform(-8.0, 8.0, n) phi2 = rng.normal(0.0, 0.1, n) - return pd.DataFrame({ - "phi1": phi1, - "phi2": phi2, - }) + return pd.DataFrame( + { + "phi1": phi1, + "phi2": phi2, + } + ) # --------------------------------------------------------------------------- # Magnitudes samples # --------------------------------------------------------------------------- + @pytest.fixture(scope="session") def saturation_magnitudes(): """Array of magnitudes spanning the saturation threshold.""" return np.linspace(10.0, 17.0, 10) + @pytest.fixture(scope="session") def bright_magnitudes(rng): """Array of magnitudes well above the saturation threshold.""" return rng.uniform(18.0, 21.0, 100) + @pytest.fixture(scope="session") def faint_magnitudes(rng): """Array of magnitudes well below the saturation threshold.""" return rng.uniform(27.0, 30.0, 100) + # --------------------------------------------------------------------------- # Default survey config for injection tests # --------------------------------------------------------------------------- + @pytest.fixture(scope="session") def base_maglim(): """Base magnitude limit for the mock survey.""" return 26 + @pytest.fixture(scope="session") def mock_survey(verbose): from streamobs import surveys + return surveys.Survey.load( survey="lsst", release="yr4", verbose=verbose, ) + @pytest.fixture(scope="session") def mock_injector(mock_survey, verbose): from streamobs.observed import StreamInjector + return StreamInjector(survey=mock_survey, verbose=verbose) @pytest.fixture(scope="session") def stream_catalog(stream_config_with_distance): from streamobs.model import StreamModel + model = StreamModel(stream_config_with_distance) samples = model.sample(1000) - return samples \ No newline at end of file + return samples diff --git a/tests/test_functions.py b/tests/test_functions.py index 179c110..0133baf 100644 --- a/tests/test_functions.py +++ b/tests/test_functions.py @@ -1,11 +1,9 @@ import numpy as np -from streamobs.functions import ( - CubicSplineInterpolation, - FileCubicSplineInterpolation, - FileLinearDensityCubicSplineInterpolation, - LinearDensityCubicSplineInterpolation, -) +from streamobs.functions import (CubicSplineInterpolation, + FileCubicSplineInterpolation, + FileLinearDensityCubicSplineInterpolation, + LinearDensityCubicSplineInterpolation) SPREAD_NODES = np.array([-13.0, -7.875, -2.75, 2.375, 7.5]) diff --git a/tests/test_model.py b/tests/test_model.py index bded770..8045a37 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -11,11 +11,7 @@ import pandas as pd import pytest -from streamobs.model import ( - DensityModel, - StreamModel, - TrackModel, -) +from streamobs.model import DensityModel, StreamModel, TrackModel # --------------------------------------------------------------------------- # Helpers diff --git a/tests/test_observed.py b/tests/test_observed.py index 73d0fc1..3ca6973 100644 --- a/tests/test_observed.py +++ b/tests/test_observed.py @@ -89,6 +89,7 @@ def test_injector_initialization_with_multiple_surveys(injector): injector3 = StreamInjector({"lsst_yr4": survey1_dict, "lsst_yr5": survey2_dict}) test_injector_initialization_with_multiple_surveys(injector3) + # --------------------------------------------------------------------------- # Injector behavior # --------------------------------------------------------------------------- diff --git a/tests/test_surveys.py b/tests/test_surveys.py index d45ecec..682fcbf 100644 --- a/tests/test_surveys.py +++ b/tests/test_surveys.py @@ -21,42 +21,77 @@ from platform import release -import pytest -from streamobs import surveys import numpy as np +import pytest +from streamobs import surveys # --------------------------------------------------------------------------- # Registry — add new surveys here # --------------------------------------------------------------------------- SURVEY_REGISTRY = [ - {"survey": "lsst", "release": "yr1", "expected_bands": ["g", "r"], "expected_maglim": ['g', 'r']}, - {"survey": "lsst", "release": "yr2", "expected_bands": ["g", "r"], "expected_maglim": ['g', 'r']}, - {"survey": "lsst", "release": "yr3", "expected_bands": ["g", "r"], "expected_maglim": ['g', 'r']}, - {"survey": "lsst", "release": "yr4", "expected_bands": ["g", "r"], "expected_maglim": ['g', 'r']}, - {"survey": "lsst", "release": "yr5", "expected_bands": ["g", "r"], "expected_maglim": ['g', 'r']}, - {"survey": "des", "release": "yr6", "expected_bands": ["g", "r"], "expected_maglim": ['g', 'r']}, + { + "survey": "lsst", + "release": "yr1", + "expected_bands": ["g", "r"], + "expected_maglim": ["g", "r"], + }, + { + "survey": "lsst", + "release": "yr2", + "expected_bands": ["g", "r"], + "expected_maglim": ["g", "r"], + }, + { + "survey": "lsst", + "release": "yr3", + "expected_bands": ["g", "r"], + "expected_maglim": ["g", "r"], + }, + { + "survey": "lsst", + "release": "yr4", + "expected_bands": ["g", "r"], + "expected_maglim": ["g", "r"], + }, + { + "survey": "lsst", + "release": "yr5", + "expected_bands": ["g", "r"], + "expected_maglim": ["g", "r"], + }, + { + "survey": "des", + "release": "yr6", + "expected_bands": ["g", "r"], + "expected_maglim": ["g", "r"], + }, ] + # IDs shown in pytest output, e.g. "lsst_yr4" def _survey_id(entry): return f"{entry['survey']}_{entry['release'] or 'base'}" + # --------------------------------------------------------------------------- # Fixtures # --------------------------------------------------------------------------- + @pytest.mark.surveys -@pytest.fixture(scope="module", params=SURVEY_REGISTRY, ids=[_survey_id(e) for e in SURVEY_REGISTRY]) +@pytest.fixture( + scope="module", params=SURVEY_REGISTRY, ids=[_survey_id(e) for e in SURVEY_REGISTRY] +) def loaded_survey(request, verbose): """Load each registered survey once per module and cache it.""" - entry = request.param + entry = request.param survey = surveys.Survey.load( survey=entry["survey"], release=entry["release"], verbose=verbose, - uniform_survey = True, # Also build the uniform survey for testing purposes + uniform_survey=True, # Also build the uniform survey for testing purposes ) # Attach the registry entry so tests can access expected values survey._test_entry = entry @@ -82,9 +117,11 @@ def test_name_matches_registry(self, loaded_survey): def test_release_matches_registry(self, loaded_survey): assert loaded_survey.release == loaded_survey._test_entry["release"] + @pytest.mark.surveys class TestSurveyFactory: """Test that SurveyFactory creates and caches surveys as expected.""" + def test_cache(self, verbose): """Test that SurveyFactory returns the same instance for repeated loads.""" @@ -95,35 +132,66 @@ def test_cache(self, verbose): cache_key2 = f"{survey_2_prop['survey']}_{survey_2_prop['release']}" cache_key3 = f"{survey_3_prop['survey']}_{survey_3_prop['release']}" - survey1 = surveys.SurveyFactory.create_survey(survey_1_prop["survey"], survey_1_prop["release"], uniform_survey=True, verbose=verbose) - survey2 = surveys.SurveyFactory.create_survey(survey_2_prop["survey"], survey_2_prop["release"], uniform_survey=True, verbose=verbose) - survey3 = surveys.SurveyFactory.create_survey(survey_3_prop["survey"], survey_3_prop["release"], uniform_survey=True, verbose=verbose) - + survey1 = surveys.SurveyFactory.create_survey( + survey_1_prop["survey"], + survey_1_prop["release"], + uniform_survey=True, + verbose=verbose, + ) + survey2 = surveys.SurveyFactory.create_survey( + survey_2_prop["survey"], + survey_2_prop["release"], + uniform_survey=True, + verbose=verbose, + ) + survey3 = surveys.SurveyFactory.create_survey( + survey_3_prop["survey"], + survey_3_prop["release"], + uniform_survey=True, + verbose=verbose, + ) cache = surveys.SurveyFactory.list_cached_surveys() - assert cache_key1 in cache, f"Survey '{cache_key1}' should be in cache after loading" - assert cache_key2 in cache, f"Survey '{cache_key2}' should be in cache after loading" - - - surveys.SurveyFactory.clear_cache(survey_1_prop['survey'], survey_1_prop['release'], verbose=verbose) + assert ( + cache_key1 in cache + ), f"Survey '{cache_key1}' should be in cache after loading" + assert ( + cache_key2 in cache + ), f"Survey '{cache_key2}' should be in cache after loading" + + surveys.SurveyFactory.clear_cache( + survey_1_prop["survey"], survey_1_prop["release"], verbose=verbose + ) cache_after_clear = surveys.SurveyFactory.list_cached_surveys() - assert cache_key1 not in cache_after_clear, f"Survey '{cache_key1}' should have been cleared from cache" - assert cache_key2 in cache_after_clear, f"Survey '{cache_key2}' should still be in cache after clearing '{cache_key1}'" - assert cache_key3 in cache_after_clear, f"Survey '{cache_key3}' should still be in cache after clearing '{cache_key1}'" - - surveys.SurveyFactory.clear_cache(survey_2_prop['survey'], verbose=verbose) + assert ( + cache_key1 not in cache_after_clear + ), f"Survey '{cache_key1}' should have been cleared from cache" + assert ( + cache_key2 in cache_after_clear + ), f"Survey '{cache_key2}' should still be in cache after clearing '{cache_key1}'" + assert ( + cache_key3 in cache_after_clear + ), f"Survey '{cache_key3}' should still be in cache after clearing '{cache_key1}'" + + surveys.SurveyFactory.clear_cache(survey_2_prop["survey"], verbose=verbose) cache_after_clear2 = surveys.SurveyFactory.list_cached_surveys() - assert cache_key2 not in cache_after_clear2, f"Survey '{cache_key2}' should have been cleared from cache" - if survey_3_prop['survey'] == survey_2_prop['survey']: - assert cache_key3 not in cache_after_clear2, f"Survey '{cache_key3}' should have been cleared from cache since it has the same survey name as '{cache_key2}'" + assert ( + cache_key2 not in cache_after_clear2 + ), f"Survey '{cache_key2}' should have been cleared from cache" + if survey_3_prop["survey"] == survey_2_prop["survey"]: + assert ( + cache_key3 not in cache_after_clear2 + ), f"Survey '{cache_key3}' should have been cleared from cache since it has the same survey name as '{cache_key2}'" else: - assert cache_key3 in cache_after_clear2, f"Survey '{cache_key3}' should still be in cache after clearing '{cache_key2}' since it has a different survey name" + assert ( + cache_key3 in cache_after_clear2 + ), f"Survey '{cache_key3}' should still be in cache after clearing '{cache_key2}' since it has a different survey name" surveys.SurveyFactory.clear_cache(verbose=verbose) cache_after_clear_tot = surveys.SurveyFactory.list_cached_surveys() - assert len(cache_after_clear_tot) == 0, "All surveys should have been cleared from cache" - - + assert ( + len(cache_after_clear_tot) == 0 + ), "All surveys should have been cleared from cache" # --------------------------------------------------------------------------- @@ -138,21 +206,25 @@ class TestSurveyProperties: def test_expected_bands_present(self, loaded_survey): expected = set(loaded_survey._test_entry["expected_bands"]) - assert expected.issubset(set(loaded_survey.bands)), ( - f"Missing bands: {expected - set(loaded_survey.bands)}" - ) + assert expected.issubset( + set(loaded_survey.bands) + ), f"Missing bands: {expected - set(loaded_survey.bands)}" def test_maglim_maps_loaded_for_each_band(self, loaded_survey): expected_maglim = set(loaded_survey._test_entry["expected_maglim"]) for band in loaded_survey.bands: if band in expected_maglim: - assert band in loaded_survey.maglim_maps, f"No maglim map for band '{band}'" - assert loaded_survey.maglim_maps[band] is not None, ( - f"maglim_maps['{band}'] is None" - ) + assert ( + band in loaded_survey.maglim_maps + ), f"No maglim map for band '{band}'" + assert ( + loaded_survey.maglim_maps[band] is not None + ), f"maglim_maps['{band}'] is None" def test_ebv_map_loaded(self, loaded_survey): - assert loaded_survey.coeff_extinc is not None, "Extinction coefficients are None" + assert ( + loaded_survey.coeff_extinc is not None + ), "Extinction coefficients are None" assert loaded_survey.ebv_map is not None, "EBV map is None" def test_coverage_map_loaded(self, loaded_survey): @@ -160,23 +232,29 @@ def test_coverage_map_loaded(self, loaded_survey): def test_errors_loaded(self, loaded_survey): assert loaded_survey.sys_error is not None, "Systematic error dict is None" - assert loaded_survey.log_photo_error is not None, "Log photo error function is None" + assert ( + loaded_survey.log_photo_error is not None + ), "Log photo error function is None" def test_delta_saturation_loaded(self, loaded_survey): assert loaded_survey.delta_saturation is not None, "delta_saturation is None" assert loaded_survey.saturation is not None, "Saturation dict is None" - def test_efficiencies_loaded(self, loaded_survey): assert loaded_survey.completeness is not None, "Completeness function is None" assert loaded_survey.completeness_band is not None, "Completeness band is None" - assert loaded_survey.completeness_band in loaded_survey.bands, ( - f"Completeness band '{loaded_survey.completeness_band}' not in survey bands {loaded_survey.bands}" - ) - assert hasattr(loaded_survey.completeness, "__call__"), "Completeness is not callable" - assert hasattr(loaded_survey.efficiency_classification, "__call__"), "Efficiency classification is not callable" - assert hasattr(loaded_survey.efficiency_detection, "__call__"), "Efficiency detection is not callable" - + assert ( + loaded_survey.completeness_band in loaded_survey.bands + ), f"Completeness band '{loaded_survey.completeness_band}' not in survey bands {loaded_survey.bands}" + assert hasattr( + loaded_survey.completeness, "__call__" + ), "Completeness is not callable" + assert hasattr( + loaded_survey.efficiency_classification, "__call__" + ), "Efficiency classification is not callable" + assert hasattr( + loaded_survey.efficiency_detection, "__call__" + ), "Efficiency detection is not callable" def test_extinction_behavior(self, loaded_survey): @@ -189,9 +267,9 @@ def test_extinction_behavior(self, loaded_survey): lb_high = np.linspace(80, 90, len(la_high)) # Convert those coordinates to healpix pixels - from astropy.coordinates import SkyCoord - from astropy import units as u import healpy as hp + from astropy import units as u + from astropy.coordinates import SkyCoord nside_ebv = hp.npix2nside(len(loaded_survey.ebv_map)) # Convert coordinates to healpix pixels @@ -208,31 +286,42 @@ def test_extinction_behavior(self, loaded_survey): frame="galactic", ) - pix_plane = hp.ang2pix(nside_ebv, coord_plane.l.degree, coord_plane.b.degree, lonlat=True) - pix_high = hp.ang2pix(nside_ebv, coord_high.l.degree, coord_high.b.degree, lonlat=True) + pix_plane = hp.ang2pix( + nside_ebv, coord_plane.l.degree, coord_plane.b.degree, lonlat=True + ) + pix_high = hp.ang2pix( + nside_ebv, coord_high.l.degree, coord_high.b.degree, lonlat=True + ) for band in loaded_survey.bands: ext_plane = loaded_survey.get_extinction(band, pix_plane) ext_high = loaded_survey.get_extinction(band, pix_high) mean_plane = np.mean(ext_plane) mean_high = np.mean(ext_high) - assert mean_plane > mean_high, ( - f"Extinction should be higher in the galactic plane than at high latitude for band '{band}'" - ) - - def test_completeness_behavior(self, loaded_survey, saturation_magnitudes, bright_magnitudes, faint_magnitudes, base_maglim): + assert ( + mean_plane > mean_high + ), f"Extinction should be higher in the galactic plane than at high latitude for band '{band}'" + + def test_completeness_behavior( + self, + loaded_survey, + saturation_magnitudes, + bright_magnitudes, + faint_magnitudes, + base_maglim, + ): assert loaded_survey.completeness is not None, "Completeness function is None" # Test that completeness is ~1 for bright stars and ~0 for faint stars completeness_band = loaded_survey.completeness_band assert completeness_band is not None, "Completeness band is None" - assert completeness_band in loaded_survey.bands, ( - f"Completeness band '{completeness_band}' not in survey bands {loaded_survey.bands}" - ) - assert completeness_band in loaded_survey.maglim_maps, ( - f"Completeness band '{completeness_band}' does not have a maglim map" - ) - + assert ( + completeness_band in loaded_survey.bands + ), f"Completeness band '{completeness_band}' not in survey bands {loaded_survey.bands}" + assert ( + completeness_band in loaded_survey.maglim_maps + ), f"Completeness band '{completeness_band}' does not have a maglim map" + sat = loaded_survey.saturation[completeness_band] # work only with magnitudes above or below saturation @@ -242,62 +331,82 @@ def test_completeness_behavior(self, loaded_survey, saturation_magnitudes, brigh # Verify completeness behavior in each regime if len(sat_mag) > 0: - comp_sat = loaded_survey.get_completeness(completeness_band, sat_mag, base_maglim) - assert np.all(comp_sat == 0.0), ( - f"Completeness should be 0 for magnitudes below saturation in band '{completeness_band}'" + comp_sat = loaded_survey.get_completeness( + completeness_band, sat_mag, base_maglim ) + assert np.all( + comp_sat == 0.0 + ), f"Completeness should be 0 for magnitudes below saturation in band '{completeness_band}'" if len(bright_mag) > 0: - comp_bright = loaded_survey.get_completeness(completeness_band, bright_mag, base_maglim) - assert np.all(comp_bright > 0.9), ( - f"Completeness should be near 1 for magnitudes well above saturation in band '{completeness_band}'" + comp_bright = loaded_survey.get_completeness( + completeness_band, bright_mag, base_maglim ) + assert np.all( + comp_bright > 0.9 + ), f"Completeness should be near 1 for magnitudes well above saturation in band '{completeness_band}'" if len(faint_mag) > 0: - comp_faint = loaded_survey.get_completeness(completeness_band, faint_mag, base_maglim) - assert np.all(comp_faint < 0.1), ( - f"Completeness should be near 0 for magnitudes well below saturation in band '{completeness_band}'" + comp_faint = loaded_survey.get_completeness( + completeness_band, faint_mag, base_maglim ) - - def test_log_photo_error_behavior(self, loaded_survey, saturation_magnitudes, bright_magnitudes, faint_magnitudes, base_maglim): - assert loaded_survey.log_photo_error is not None, "Log photo error function is None" + assert np.all( + comp_faint < 0.1 + ), f"Completeness should be near 0 for magnitudes well below saturation in band '{completeness_band}'" + + def test_log_photo_error_behavior( + self, + loaded_survey, + saturation_magnitudes, + bright_magnitudes, + faint_magnitudes, + base_maglim, + ): + assert ( + loaded_survey.log_photo_error is not None + ), "Log photo error function is None" # Test that log photo error behaves reasonably across magnitude ranges for band in loaded_survey.bands: sat = loaded_survey.saturation[band] sys_error = loaded_survey.sys_error[band] - assert sys_error > 0, f"Systematic error should be positive for band '{band}'" + assert ( + sys_error > 0 + ), f"Systematic error should be positive for band '{band}'" # work only with magnitudes above or below saturation sat_mag = saturation_magnitudes[saturation_magnitudes < sat] bright_mag = bright_magnitudes[bright_magnitudes > sat] faint_mag = faint_magnitudes[faint_magnitudes > sat] - bright_mag_mean, faint_mag_mean = None, None + bright_mag_mean, faint_mag_mean = None, None if len(sat_mag) > 0: err_sat = loaded_survey.get_photo_error(band, sat_mag, base_maglim) - assert np.all(err_sat > 5.0), ( - f"Photo errors should be large for magnitudes below saturation in band '{band}'" - ) + assert np.all( + err_sat > 5.0 + ), f"Photo errors should be large for magnitudes below saturation in band '{band}'" if len(bright_mag) > 0: - err_bright = loaded_survey.get_photo_error(band, bright_mag, base_maglim) - assert np.all(err_bright < 3*sys_error), ( - f"Photo errors should be close to systematic error for bright magnitudes in band '{band}'" + err_bright = loaded_survey.get_photo_error( + band, bright_mag, base_maglim ) + assert np.all( + err_bright < 3 * sys_error + ), f"Photo errors should be close to systematic error for bright magnitudes in band '{band}'" bright_mag_mean = np.mean(err_bright) if len(faint_mag) > 0: err_faint = loaded_survey.get_photo_error(band, faint_mag, base_maglim) - assert np.all(err_faint > 20*sys_error), ( - f"Photo errors should be large for faint magnitudes in band '{band}'" - ) + assert np.all( + err_faint > 20 * sys_error + ), f"Photo errors should be large for faint magnitudes in band '{band}'" faint_mag_mean = np.mean(err_faint) - + if faint_mag_mean is not None and bright_mag_mean is not None: - assert faint_mag_mean > bright_mag_mean, ( - f"Mean photo error should increase with magnitude in band '{band}'" - ) + assert ( + faint_mag_mean > bright_mag_mean + ), f"Mean photo error should increase with magnitude in band '{band}'" - error_at_maglim = loaded_survey.get_photo_error(band, base_maglim, base_maglim) - snr_at_maglim = 1 / error_at_maglim - assert np.isclose(snr_at_maglim, 5.0, atol = 0.25), ( - f"Photo error at maglim should correspond to SNR=5 for band '{band}'" + error_at_maglim = loaded_survey.get_photo_error( + band, base_maglim, base_maglim ) - + snr_at_maglim = 1 / error_at_maglim + assert np.isclose( + snr_at_maglim, 5.0, atol=0.25 + ), f"Photo error at maglim should correspond to SNR=5 for band '{band}'" From 5e89f7060779058b15e92f124a55c508097caf32 Mon Sep 17 00:00:00 2001 From: psferguson Date: Wed, 17 Jun 2026 14:35:42 -0700 Subject: [PATCH 12/29] Address PR #47 review: unified bands API, release-namespacing, SNR cut, isochrone masses Responds to MatthieuPE's review on the roman_multisurvey PR. API simplification: - Collapse survey_bands+bands into one `bands` arg (list | {survey: bands} dict) - Fold _complete_shared into the public complete_data; inject() delegates to it - Make `survey` a required arg of detect_flag (drop the primary fallback) Release-everywhere namespacing (Decision 1): - Add Survey.namespace ({name}_{release}); injector keys surveys by it so the same survey at two releases yields distinct, non-colliding columns - _load_survey accepts a {"survey":, "release":} spec dict; _inject_one_survey derives the namespace from survey.namespace - `primary` is now the primary Survey; namespace string is primary_namespace - Model: single-survey isochrone path is release-aware; _build_iso strips `release` before the ugali factory SNR cut (Decision 2): the ref-band S/N>=5 cut is baked into both selection- function curves, so remove the redundant re-application in _inject_one_survey and correct the comment/docstring. Isochrone/mass: - Raise _MASS_STEPS 1000 -> 4000 (convergence check: ~600 vs ~220 distinct masses for a 5000-star stream; documented) - Collapse single/multi isochrone builders into one _build_isochrones path - sample_multisurvey accepts optional masses and returns (mags, masses); complete_catalog exposes a `mass` column and reuses a provided one Tests: release-namespaced column updates; new multi-survey complete_data, unified-bands, mandatory-survey, and isochrone-mass tests. 35 passed. Co-Authored-By: Claude Opus 4.8 (1M context) --- docs/source/multisurvey.md | 6 +- streamobs/columns.py | 12 +- streamobs/model.py | 187 +++++++++++++------ streamobs/observed.py | 367 +++++++++++++++++++------------------ streamobs/surveys.py | 11 ++ tests/conftest.py | 36 ++++ tests/test_model.py | 88 +++++++-- tests/test_observed.py | 83 ++++++++- 8 files changed, 521 insertions(+), 269 deletions(-) diff --git a/docs/source/multisurvey.md b/docs/source/multisurvey.md index d3d753c..ec3f6f8 100644 --- a/docs/source/multisurvey.md +++ b/docs/source/multisurvey.md @@ -36,10 +36,10 @@ inj = StreamInjector(["lsst", "roman"]) # Single survey: `bands` is the shorthand (defaults to ['r', 'g']). out = inj.inject(df, bands=["r", "g"], stream_config=cfg, seed=42) -# Several surveys: give the bands per survey. +# Several surveys: give the bands per survey as a {survey: [bands]} dict. out = inj.inject( df, - survey_bands={"lsst": ["r", "g"], "roman": ["F106", "F158"]}, + bands={"lsst": ["r", "g"], "roman": ["F106", "F158"]}, stream_config=cfg, seed=42, ) @@ -106,7 +106,7 @@ from streamobs.observed import StreamInjector scene = yaml.safe_load(open("config/scenes/roman_rubin_demo.yaml")) inj = StreamInjector(scene["surveys"]) # {"lsst": "lsst", "roman": "roman"} cat = inj.inject( - df, survey_bands=scene["survey_bands"], # {"lsst": [...], "roman": [...]} + df, bands=scene["survey_bands"], # {"lsst": [...], "roman": [...]} stream_config=scene["stream"], seed=42, ) ``` diff --git a/streamobs/columns.py b/streamobs/columns.py index 86845dd..bc6b680 100644 --- a/streamobs/columns.py +++ b/streamobs/columns.py @@ -3,10 +3,14 @@ These centralize the naming convention so the injector is not hard-coded to specific bands. Injected catalogs are **always** survey-namespaced — -``__true`` (true / noiseless), ``__obs`` (observed / -noisy), ``__err`` (reported error), and ``_flag_observed`` -— produced by :class:`~streamobs.observed.StreamInjector` whether it serves one -survey or several (e.g. ``lsst_r_obs``, ``roman_F158_obs``). +``__true`` (true / noiseless), ``__obs`` +(observed / noisy), ``__err`` (reported error), and +``_flag_observed`` — produced by +:class:`~streamobs.observed.StreamInjector` whether it serves one survey or +several. The namespace is the survey's :attr:`~streamobs.surveys.Survey.namespace` +(``{name}_{release}``), so it includes the release on every column kind +(e.g. ``lsst_yr5_r_obs``, ``roman_dc2_F158_obs``) and the same survey at two +releases never collides. The ``survey`` argument therefore identifies the namespace. ``survey=None`` is retained only as a low-level fallback that yields the bare ``_…`` / diff --git a/streamobs/model.py b/streamobs/model.py index eb01720..a429c37 100644 --- a/streamobs/model.py +++ b/streamobs/model.py @@ -195,10 +195,18 @@ def _iso_mag_columns(self): cols += [true_col(band_1, name), true_col(band_2, name)] return cols - def _sample_iso_mags(self, n, dist): - """Sample isochrone magnitudes as a ``{__true: values}`` dict.""" - mags = self.isochrone.sample_multisurvey(n, dist) - return {true_col(band, name): vals for (name, band), vals in mags.items()} + def _sample_iso_mags(self, n, dist, masses=None): + """Sample isochrone magnitudes as a ``{column: values}`` dict. + + Returns each survey's ``__true`` columns plus the shared + ``mass`` column (the initial masses used for every band). When ``masses`` + is given it is used directly instead of an IMF draw, so the sampled + magnitudes reproduce those exact stars. + """ + mags, masses = self.isochrone.sample_multisurvey(n, dist, masses=masses) + cols = {true_col(band, name): vals for (name, band), vals in mags.items()} + cols["mass"] = masses + return cols def complete_catalog( self, @@ -280,7 +288,14 @@ def complete_catalog( # Columns this method can fill using the configured model # Magnitude columns are survey-namespaced (__true). mag_cols = self._iso_mag_columns() - all_cols = ("phi1", "phi2", "dist") + tuple(mag_cols) + ("mu1", "mu2", "rv") + # The isochrone also produces the shared initial-mass column. + mass_cols = ("mass",) if self.isochrone is not None else () + all_cols = ( + ("phi1", "phi2", "dist") + + tuple(mag_cols) + + mass_cols + + ("mu1", "mu2", "rv") + ) target_cols = ( list(all_cols) if columns_to_add is None @@ -371,17 +386,19 @@ def complete_catalog( ) self._info(verbose, f"Filled {len(idx)} dist values.") - # magnitudes (need dist and isochrone) + # magnitudes + shared initial mass (need dist and isochrone) requested_mags = [c for c in mag_cols if c in target_cols] - if requested_mags: - # Only touch rows that are missing a requested band; existing values + want_mass = "mass" in target_cols and self.isochrone is not None + fill_targets = requested_mags + (["mass"] if want_mass else []) + if fill_targets: + # Only touch rows that are missing a requested column; existing values # are preserved (never overwritten). - missing = {c: self._missing_idx(df, c) for c in requested_mags} + missing = {c: self._missing_idx(df, c) for c in fill_targets} to_fill = {c: idx for c, idx in missing.items() if len(idx) > 0} if not to_fill: self._info( verbose, - f"{requested_mags} already present; no sampling performed.", + f"{fill_targets} already present; no sampling performed.", ) else: # Verify distance availability @@ -390,10 +407,16 @@ def complete_catalog( "dist is required to sample apparent magnitudes; include 'dist' in `columns_to_add`, provide it in the catalog, or pass `dist=`." ) dist_vals = df["dist"].to_numpy() + # Reuse a fully-present input `mass` column as the initial masses + # so the sampled magnitudes reproduce the user's simulation stars; + # otherwise draw fresh masses from the IMF. + masses_in = None + if "mass" in df.columns and df["mass"].notna().all(): + masses_in = df["mass"].to_numpy() # One shared mass draw -> all bands; the newly filled cells are # mutually colour-consistent. Assign only the missing rows so any # bands/values already present are left untouched. - mags = self._sample_iso_mags(N, dist_vals) + mags = self._sample_iso_mags(N, dist_vals, masses=masses_in) for col, idx in to_fill.items(): pos = df.index.get_indexer(idx) if col not in df.columns: @@ -401,7 +424,7 @@ def complete_catalog( df.loc[idx, col] = np.asarray(mags[col])[pos] self._info( verbose, - f"Filled magnitudes for {sorted(to_fill)} (missing rows only).", + f"Filled {sorted(to_fill)} (missing rows only).", ) # velocities (need phi1 and velocity model) @@ -653,9 +676,16 @@ class IsochroneModel(ConfigurableModel): :data:`ROMAN_VEGA_TO_AB`); other bands pass through unchanged. """ - # Defaults for the shared isochrone mass grid (see ugali Isochrone.sample) + # Defaults for the shared isochrone mass grid (see ugali Isochrone.sample). + # Masses are drawn from this discretized grid, so ``_MASS_STEPS`` bounds the + # number of *distinct* masses a stream can contain. A convergence check + # (g/r magnitude percentiles + distinct-mass count for a 5000-star stream) + # showed 1000 steps yields only ~220 distinct masses (granular CMD) and + # ~0.03 mag median scatter, while 4000 steps roughly triples the distinct + # masses (~600) and tightens convergence to <0.015 mag — for a negligible + # one-time grid-sampling cost. Override per call via ``mass_steps=``. _MASS_MIN = 0.1 - _MASS_STEPS = 1000 + _MASS_STEPS = 4000 def __init__(self, config, **kwargs): super().__init__(config, **kwargs) @@ -663,50 +693,71 @@ def __init__(self, config, **kwargs): def create_isochrone(self, config): """Construct the underlying ``ugali`` isochrone(s) from configuration. + Both configuration forms are normalized to a single ``{namespace: + factory_cfg}`` mapping and built through the same loop — a legacy flat + config simply becomes a one-entry mapping — so there is no separate + single- vs. multi-survey code path. + Parameters ---------- config : dict Isochrone factory configuration. A ``surveys`` key selects the multi-survey form; otherwise the single-survey (legacy) form is used. """ - self.multi_survey = "surveys" in config - if self.multi_survey: - self._create_multisurvey_isochrones(config) - else: - self._create_single_isochrone(config) + survey_configs, shared = self._normalize_iso_config(config) + self._build_isochrones(survey_configs, shared) + + def _normalize_iso_config(self, config): + """Coerce either config form into ``({namespace: factory_cfg}, shared)``. + + Multi-survey: the ``surveys`` mapping is returned verbatim (its keys are + the column namespaces) with the top-level keys as shared stellar params. + Single-survey (legacy flat): a one-entry mapping keyed by + ``{survey}_{release}`` (or just ``{survey}``), matching + :attr:`streamobs.surveys.Survey.namespace`, with no shared params. + """ + if "surveys" in config: + self.multi_survey = True + shared = {k: v for k, v in config.items() if k != "surveys"} + return dict(config["surveys"]), shared + + self.multi_survey = False + if "distance_modulus" in config: + warnings.warn( + 'Please use the "distance_modulus" section of the configuration ' + "file, instead of the isochrone section, to define a distance modulus." + ) + survey = config.get("survey") + release = config.get("release") + namespace = f"{survey}_{release}" if release else survey + return {namespace: dict(config)}, {} def _build_iso(self, factory_config): - """Build one ``ugali`` isochrone with its distance modulus reset to 0.""" + """Build one ``ugali`` isochrone with its distance modulus reset to 0. + + ``release`` is a column-namespacing concept (it distinguishes survey + versions in the output column names), not a ``ugali`` factory argument, + so it is stripped before the isochrone is constructed. + """ import ugali.isochrone + factory_config = {k: v for k, v in factory_config.items() if k != "release"} iso = ugali.isochrone.factory(**factory_config) iso.params["distance_modulus"].set_bounds([0, 50]) iso.distance_modulus = 0 return iso - def _create_single_isochrone(self, config): - """Build a single isochrone from a legacy (flat) isochrone config.""" - if "distance_modulus" in config: - warnings.warn( - 'Please use the "distance_modulus" section of the configuration ' - "file, instead of the isochrone section, to define a distance modulus." - ) - self.iso = self._build_iso(config) - self.survey_name = config.get("survey") - self.band_1 = config.get("band_1") - self.band_2 = config.get("band_2") - # Unified bookkeeping so the shared helpers work in both modes. - self.surveys = [self.survey_name] - self.isos = {self.survey_name: self.iso} - self.survey_bands = {self.survey_name: (self.band_1, self.band_2)} - - def _create_multisurvey_isochrones(self, config): - """Build one isochrone per survey, sharing the top-level stellar params.""" - shared = {k: v for k, v in config.items() if k != "surveys"} + def _build_isochrones(self, survey_configs, shared): + """Build one isochrone per namespace, sharing the top-level stellar params. + + Drives both configuration forms (a legacy flat config is just a + one-entry ``survey_configs``). The first entry is the primary isochrone + that drives the shared mass draw and the legacy :meth:`sample`. + """ self.isos = {} self.survey_bands = {} self.surveys = [] - for name, scfg in config["surveys"].items(): + for name, scfg in survey_configs.items(): factory_config = {**shared, **scfg} self.isos[name] = self._build_iso(factory_config) self.survey_bands[name] = (scfg.get("band_1"), scfg.get("band_2")) @@ -777,24 +828,48 @@ def _add_distance_modulus(abs_mag, distance_modulus): return abs_mag return abs_mag + np.asarray(distance_modulus, dtype=float) - def sample_multisurvey(self, nstars, distance_modulus, rng=None, **kwargs): + def sample_multisurvey( + self, nstars, distance_modulus, rng=None, masses=None, **kwargs + ): """Sample apparent magnitudes for every ``(survey, band)``. - A single shared draw of initial masses (see :meth:`sample_masses`) is - interpolated into each survey's bands, so the same physical star is - consistent across surveys. + A single shared set of initial masses is interpolated into each survey's + bands, so the same physical star is consistent across surveys. The masses + are drawn from the shared IMF (:meth:`sample_masses`) unless supplied via + ``masses``. + + Parameters + ---------- + nstars : int + Number of stars (and the required length of ``masses`` if given). + distance_modulus : float or array-like + Distance modulus per star (broadcast if scalar). + rng : numpy.random.Generator, optional + Used only when ``masses`` is None. + masses : array-like, optional + Initial stellar masses to use directly — e.g. an external + simulation's masses — instead of drawing from the IMF. Must have + length ``nstars``. Returns ------- - dict - ``{(survey_name, band): apparent_magnitude_array}``. + dict, numpy.ndarray + ``{(survey_name, band): apparent_magnitude_array}`` and the initial + masses used (shape ``(nstars,)``). """ - masses = self.sample_masses( - nstars, - rng=rng, - mass_min=kwargs.get("mass_min"), - mass_steps=kwargs.get("mass_steps"), - ) + if masses is None: + masses = self.sample_masses( + nstars, + rng=rng, + mass_min=kwargs.get("mass_min"), + mass_steps=kwargs.get("mass_steps"), + ) + else: + masses = np.asarray(masses, dtype=float) + if len(masses) != int(nstars): + raise ValueError( + f"masses has length {len(masses)} but nstars={int(nstars)}." + ) out = {} for name in self.surveys: band_1, band_2 = self.survey_bands[name] @@ -803,9 +878,9 @@ def sample_multisurvey(self, nstars, distance_modulus, rng=None, **kwargs): abs_2 = self._to_ab(band_2, abs_2) out[(name, band_1)] = self._add_distance_modulus(abs_1, distance_modulus) out[(name, band_2)] = self._add_distance_modulus(abs_2, distance_modulus) - return out + return out, masses - def sample(self, nstars, distance_modulus, rng=None, **kwargs): + def sample(self, nstars, distance_modulus, rng=None, masses=None, **kwargs): """Simulate magnitudes in the two bands of the (primary) isochrone. Draws *exactly* ``nstars`` stars: a fixed set of initial masses is drawn @@ -831,7 +906,9 @@ def sample(self, nstars, distance_modulus, rng=None, **kwargs): this returns the primary survey's two bands; use :meth:`sample_multisurvey` to get every survey's bands. """ - mags = self.sample_multisurvey(nstars, distance_modulus, rng=rng, **kwargs) + mags, _ = self.sample_multisurvey( + nstars, distance_modulus, rng=rng, masses=masses, **kwargs + ) return ( mags[(self.survey_name, self.band_1)], mags[(self.survey_name, self.band_2)], diff --git a/streamobs/observed.py b/streamobs/observed.py index 5dec240..f546770 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -37,12 +37,12 @@ class StreamInjector: ---------- surveys : dict ``{namespace: Survey}`` for every survey this injector serves. The - namespace is the column prefix (``lsst_r_obs``, ``roman_F158_obs``, ...). - primary : str - Namespace of the survey whose footprint drives the shared sky placement - and whose ``_save_injected_data`` is used. The primary - :class:`~streamobs.surveys.Survey` itself is available via the ``survey`` - property (``surveys[primary]``), used by the mask/coordinate helpers. + namespace is the survey's ``{name}_{release}`` and is the column prefix + (``lsst_yr5_r_obs``, ``roman_dc2_F158_obs``, ...). + primary : Survey + The survey whose footprint drives the shared sky placement and whose + ``_save_injected_data`` is used (also available as ``survey``). Its + namespace string is :attr:`primary_namespace`. mask_cache : dict (class attribute) Cache of previously created HEALPix masks to avoid recomputation. _last_gc_frame : GreatCircleICRSFrame or None @@ -51,16 +51,21 @@ class StreamInjector: Examples -------- - Single survey (columns namespaced by the survey's name): + Single survey (columns namespaced ``{name}_{release}``): >>> injector = StreamInjector('lsst', release='dc2') - >>> out = injector.inject(df, bands=['r', 'g']) # -> lsst_r_obs, ... + >>> out = injector.inject(df, bands=['r', 'g']) # -> lsst_dc2_r_obs, ... - Several surveys at once: + Several surveys at once — each spec carries its release; the namespace is + derived from it, so bands are keyed by ``{name}_{release}``: - >>> injector = StreamInjector({'lsst': 'lsst', 'roman': 'roman'}) + >>> injector = StreamInjector([ + ... {'survey': 'lsst', 'release': 'dc2'}, + ... {'survey': 'roman', 'release': 'dc2'}, + ... ]) >>> out = injector.inject( - ... df, survey_bands={'lsst': ['r', 'g'], 'roman': ['F106', 'F158']}, + ... df, + ... bands={'lsst_dc2': ['r', 'g'], 'roman_dc2': ['F106', 'F158']}, ... stream_config=scene['stream'], seed=42, ... ) """ @@ -99,54 +104,88 @@ def __init__(self, survey, primary=None, **kwargs): self.survey_names = list(self.surveys) if not self.survey_names: raise ValueError("At least one survey is required.") - self.primary = primary if primary is not None else self.survey_names[0] - if self.primary not in self.surveys: + self._primary = primary if primary is not None else self.survey_names[0] + if self._primary not in self.surveys: raise ValueError( - f"primary='{self.primary}' is not one of {self.survey_names}." + f"primary='{self._primary}' is not one of {self.survey_names}." ) # Instance attribute to store the last used gc_frame self._last_gc_frame = None @property - def survey(self): + def primary(self): """The primary :class:`~streamobs.surveys.Survey`. - Mask, coordinate and footprint helpers operate on this survey. + Drives the shared sky placement; mask, coordinate and footprint helpers + operate on it. Its column namespace is :attr:`primary_namespace`. """ - return self.surveys[self.primary] + return self.surveys[self._primary] + + @property + def primary_namespace(self): + """Column namespace (``{name}_{release}``) of the primary survey.""" + return self._primary + + @property + def survey(self): + """Alias for :attr:`primary` — the primary :class:`~streamobs.surveys.Survey`.""" + return self.surveys[self._primary] @classmethod def _normalize_surveys(cls, surveys, **kwargs): - """Coerce the ``surveys`` argument into a ``{namespace: Survey}`` dict.""" + """Coerce the ``surveys`` argument into a ``{namespace: Survey}`` dict. + + The namespace key is always the survey's own + :attr:`~streamobs.surveys.Survey.namespace` (``{name}_{release}``), so + the same survey at two releases yields two distinct entries. Accepted + forms: a single spec (name string, ``Survey``, or + ``{"survey": ..., "release": ...}`` dict), a list of specs, or a + ``{key: spec}`` mapping (the keys are only containers — the canonical + namespace is re-derived from each loaded survey). + """ if isinstance(surveys, (str, Survey)): - survey = cls._load_survey(surveys, **kwargs) - return {survey.name: survey} - if isinstance(surveys, (list, tuple)): - out = {} - for spec in surveys: - survey = cls._load_survey(spec, **kwargs) - out[survey.name] = survey - return out - if isinstance(surveys, dict): - return { - name: cls._load_survey(spec, **kwargs) for name, spec in surveys.items() - } - raise ValueError( - "surveys must be a survey name, a Survey, a {name: spec} dict, " - "or a list of specs." - ) + specs = [surveys] + elif isinstance(surveys, dict) and "survey" in surveys: + # A single spec dict, e.g. {"survey": "lsst", "release": "yr5"}. + specs = [surveys] + elif isinstance(surveys, dict): + # A {key: spec} mapping; namespace is re-derived per loaded survey. + specs = list(surveys.values()) + elif isinstance(surveys, (list, tuple)): + specs = list(surveys) + else: + raise ValueError( + "surveys must be a survey name, a Survey, a spec dict, a list " + "of specs, or a {key: spec} dict." + ) + out = {} + for spec in specs: + survey = cls._load_survey(spec, **kwargs) + out[survey.namespace] = survey + return out @staticmethod def _load_survey(spec, **kwargs): - """Resolve a single survey spec (name string or Survey) to a Survey.""" + """Resolve a single survey spec to a Survey. + + Accepts a :class:`~streamobs.surveys.Survey`, a survey-name string + (loaded with the shared ``**kwargs``, e.g. ``release=``), or a spec + ``dict`` such as ``{"survey": "lsst", "release": "yr5"}`` (forwarded to + :meth:`Survey.load`, taking precedence over the shared ``**kwargs``). + """ if isinstance(spec, Survey): return spec if isinstance(spec, str): return Survey.load(survey=spec, **kwargs) - raise ValueError("Each survey spec must be a string or Survey instance.") + if isinstance(spec, dict): + return Survey.load(**{**kwargs, **spec}) + raise ValueError( + 'Each survey spec must be a Survey, a name string, or a ' + '{"survey": ..., "release": ...} dict.' + ) - def inject(self, data, survey_bands=None, bands=None, stream_config=None, **kwargs): + def inject(self, data, bands=None, stream_config=None, **kwargs): """ Add observed quantities from every survey into a single catalog. @@ -165,15 +204,12 @@ def inject(self, data, survey_bands=None, bands=None, stream_config=None, **kwar anything missing is sampled from ``stream_config``. An all-empty frame of length ``N`` is accepted (geometry and magnitudes are then sampled for ``N`` rows). - survey_bands : dict, optional - ``{survey_name: [bands]}`` — bands to inject for each survey. Keys - must match the surveys this injector was built with. For a single - survey you may instead pass ``bands`` (below). - bands : list of str, optional - Convenience shorthand for the single-survey case: the bands to inject - for the (only) survey. Ignored when ``survey_bands`` is given. If - neither is provided and there is exactly one survey, defaults to - ``['r', 'g']``. + bands : list of str or dict, optional + Bands to inject. A ``{survey_name: [bands]}`` dict selects bands per + survey (the multi-survey form; keys must match the surveys this + injector was built with). A plain list/tuple is the single-survey + shorthand, applied to the only survey. If omitted and there is + exactly one survey, defaults to ``['r', 'g']``. stream_config : dict, optional The ``stream`` section consumed by :class:`~streamobs.model.StreamModel`. Required when any coordinate @@ -192,10 +228,11 @@ def inject(self, data, survey_bands=None, bands=None, stream_config=None, **kwar HEALPix nside parameter. Default is 4096. detection_mag_cut : list of str, optional Non-reference bands to apply the explicit SNR>=5 cut to. The - reference band (``survey.completeness_band``) is always cut via - the selection functions, so the default here is every injected - band *except* the reference band. Net effect: every injected band - must have SNR >= 5, with the reference band counted once. + reference band (``survey.completeness_band``) is never cut here — + its SNR cut is already baked into the survey's selection + functions — so the default is every injected band *except* the + reference band. Net effect: every injected band must have + SNR >= 5, with the reference band's cut owned by the curves. save : bool, optional Whether to save the output data. Default is False. folder : str or Path, optional @@ -224,27 +261,24 @@ def inject(self, data, survey_bands=None, bands=None, stream_config=None, **kwar Raises ------ ValueError - If required columns are missing, or if ``survey_bands`` references an - unknown survey, or if neither ``survey_bands`` nor ``bands`` can be - resolved. + If required columns are missing, if ``bands`` (as a dict) references + an unknown survey, or if a list ``bands`` is given for a multi-survey + injector. """ - survey_bands = self._resolve_survey_bands(survey_bands, bands) - - # Load data - data = self._load_data(data) + survey_bands = self._resolve_survey_bands(bands) # Set the seed for reproducibility seed = kwargs.pop("seed", None) rng = np.random.default_rng(seed) # Shared sky placement + shared true-magnitude fill (masses sampled once - # across all surveys). - data = self._complete_shared( + # across all surveys). This is the same completion exposed publicly as + # complete_data(); pass the already-resolved {survey: bands} dict through. + data = self.complete_data( data, - survey_bands, + bands=survey_bands, stream_config=stream_config, rng=rng, - seed=seed, **kwargs, ) @@ -258,7 +292,6 @@ def inject(self, data, survey_bands=None, bands=None, stream_config=None, **kwar data, list(survey_bands[name]), survey=self.surveys[name], - survey_namespace=name, rng=child_rng, **kwargs, ) @@ -270,53 +303,55 @@ def inject(self, data, survey_bands=None, bands=None, stream_config=None, **kwar # Return data (do NOT store as instance attribute to avoid conflicts between runs) return data - def _resolve_survey_bands(self, survey_bands, bands): - """Normalize the ``survey_bands`` / ``bands`` arguments to a dict. + def _resolve_survey_bands(self, bands): + """Normalize the ``bands`` argument to a ``{survey_name: [bands]}`` dict. + + ``bands`` may be: - ``survey_bands`` wins if given (validated against the known surveys). - Otherwise ``bands`` is accepted only when there is a single survey; if - neither is given and there is one survey, defaults to ``['r', 'g']``. + - a ``{survey_name: [bands]}`` dict (validated against the known + surveys) — the multi-survey form; + - a list/tuple of band names — allowed only when the injector serves a + single survey, applied to that survey; + - ``None`` — defaults to ``['r', 'g']`` for the single-survey case. """ - if survey_bands is not None: - unknown = set(survey_bands) - set(self.surveys) + if isinstance(bands, dict): + unknown = set(bands) - set(self.surveys) if unknown: raise ValueError( - f"survey_bands references unknown surveys {sorted(unknown)}; " + f"bands references unknown surveys {sorted(unknown)}; " f"available: {self.survey_names}." ) - return {name: list(b) for name, b in survey_bands.items()} + return {name: list(b) for name, b in bands.items()} if len(self.survey_names) != 1: raise ValueError( - "Pass survey_bands={name: [bands]} when the injector serves " + "Pass bands={survey_name: [bands]} when the injector serves " f"multiple surveys ({self.survey_names})." ) if bands is None: bands = ["r", "g"] - return {self.primary: list(bands)} + return {self._primary: list(bands)} - def _inject_one_survey( - self, data, bands, survey, survey_namespace, rng=None, seed=None, **kwargs - ): + def _inject_one_survey(self, data, bands, survey, rng=None, seed=None, **kwargs): """Add one survey's observed magnitudes, errors and detection flags. This holds the per-band observational logic. It assumes ``data`` already carries ``ra``/``dec`` and the true-magnitude columns - (``true_col(band, survey_namespace)``) for the requested bands; it does - **not** sample positions or true magnitudes. + (``true_col(band, survey.namespace)``) for the requested bands; it does + **not** sample positions or true magnitudes. The column namespace is + taken directly from ``survey.namespace`` (``{name}_{release}``). Parameters ---------- data : pandas.DataFrame - Catalog with ``ra``/``dec`` and ``true_col(band, survey_namespace)`` + Catalog with ``ra``/``dec`` and ``true_col(band, survey.namespace)`` for every requested band. bands : list of str Bands to process for this survey. survey : Survey - The survey supplying maglim maps, completeness and error curves. - survey_namespace : str - Column-naming namespace ⇒ ``__obs`` / - ``__err`` / ``_flag_observed``. + The survey supplying maglim maps, completeness and error curves; its + ``namespace`` is the column prefix ⇒ ``__obs`` / + ``__err`` / ``_flag_observed``. rng : numpy.random.Generator, optional Random generator for the noise draw and detection sampling. seed : int, optional @@ -333,6 +368,9 @@ def _inject_one_survey( if rng is None: rng = np.random.default_rng(seed) + # Column namespace for this survey (``{name}_{release}``). + survey_namespace = survey.namespace + verbose = kwargs.get("verbose", True) perfect_galstarsep = kwargs.pop("perfect_galstarsep", False) @@ -476,33 +514,24 @@ def _inject_one_survey( # Apply SNR cuts. # - # The SNR>=SNR_min cut on the *reference* band (``survey.completeness_band``) - # is owned by the survey's selection functions — they are estimated with - # that cut already applied. We therefore apply it to the reference band - # exactly **once** here, to both flags. (``get_completeness`` bakes it in, - # so for ``flag_observed`` this is idempotent; ``get_detection_efficiency`` - # does not, so for ``flag_perfect`` this line is what supplies it.) See - # the "S/N cut ownership" note in docs/source/roman_multisurvey_plan.md - # for the path to folding it into the efficiency curve itself (option a). - # - # Every *other* injected band gets the cut applied explicitly below. + # The reference band (``survey.completeness_band``) is NOT cut here: the + # survey's selection functions are defined on true stars detected at + # S/N >= SNR_min, so that cut is already baked into BOTH curves — + # ``get_completeness`` (detection x classification) and + # ``get_detection_efficiency`` (detection only). Re-applying it to the + # reference band would double-count it, so we only cut the *other* + # injected bands explicitly below. SNR_min = 5.0 ref_band = survey.completeness_band - if ref_band in bands: - SNR_ref = 1.0 / data[err_col(ref_band, survey_namespace)] - flag_observed &= SNR_ref >= SNR_min - if perfect_galstarsep: - flag_perfect &= SNR_ref >= SNR_min - # Non-reference bands. Default: every injected band except the reference - # band (whose cut is handled above via the selection functions). + # band (whose cut is owned by the selection functions). detection_mag_cut = kwargs.get( "detection_mag_cut", [b for b in bands if b != ref_band] ) for band in detection_mag_cut: if band == ref_band: - # The reference band's SNR cut is already applied above. + # The reference band's SNR cut is owned by the selection functions. continue if band not in bands: if verbose: @@ -559,7 +588,6 @@ def _load_data(self, data): def complete_data( self, data, - survey_bands=None, bands=None, stream_config=None, dist=None, @@ -585,12 +613,11 @@ def complete_data( Input catalog (or path). May contain only stream coordinates (``phi1``/``phi2`` or ``ra``/``dec``), an all-empty frame of length ``N``, or any subset of the target columns. - survey_bands : dict, optional - ``{survey_name: [bands]}`` — the true-magnitude columns to ensure per - survey. For a single survey you may instead pass ``bands``; if neither - is given and there is exactly one survey, defaults to ``['r', 'g']``. - bands : list of str, optional - Single-survey shorthand for ``survey_bands={primary: bands}``. + bands : list of str or dict, optional + Bands whose true-magnitude columns to ensure. A + ``{survey_name: [bands]}`` dict selects bands per survey (multi-survey + form); a plain list/tuple is the single-survey shorthand. If omitted + and there is exactly one survey, defaults to ``['r', 'g']``. stream_config : dict, optional :class:`~streamobs.model.StreamModel` config used to sample any missing geometry / true magnitudes. Required only when something is @@ -621,11 +648,11 @@ def complete_data( >>> df = pd.DataFrame({'phi1': [-5, 0, 5], 'phi2': [0, 0, 0]}) >>> out = injector.complete_data(df, bands=['r', 'g'], stream_config=cfg) >>> out = injector.complete_data( - ... df, survey_bands={'lsst': ['r', 'g'], 'roman': ['F106', 'F158']}, + ... df, bands={'lsst': ['r', 'g'], 'roman': ['F106', 'F158']}, ... stream_config=cfg, seed=42, ... ) """ - survey_bands = self._resolve_survey_bands(survey_bands, bands) + survey_bands = self._resolve_survey_bands(bands) data = self._load_data(data).copy() rng = kwargs.pop("rng", None) @@ -633,15 +660,49 @@ def complete_data( if rng is None: rng = np.random.default_rng(seed) - return self._complete_shared( - data, - survey_bands, - stream_config=stream_config, - rng=rng, - seed=seed, - dist=dist, - **kwargs, - ) + verbose = kwargs.get("verbose", True) + + # Positions and masses are drawn *once* so all surveys describe the same + # physical stars (the isochrone produces every survey's + # ``__true`` column from one shared mass draw). Existing + # columns are preserved (only missing values are filled). ``ra``/``dec`` + # are placed using the primary survey's footprint. ``dist`` (a float or + # per-row vector) overrides the model's distance sampling when given. + true_cols = [] + for name, name_bands in survey_bands.items(): + true_cols += [true_col(b, name) for b in name_bands] + + have_radec = "ra" in data.columns and "dec" in data.columns + have_phi = "phi1" in data.columns and "phi2" in data.columns + missing_true = [c for c in true_cols if c not in data.columns] + + # Sample stream geometry and/or the shared true magnitudes from the model. + need_phi = not have_radec and not have_phi + if need_phi or missing_true: + if stream_config is None: + raise ValueError( + "stream_config is required to sample stream geometry/magnitudes." + ) + stream_model = StreamModel(stream_config) + cols_to_add = [] + if need_phi: + cols_to_add += ["phi1", "phi2"] + # `dist` is needed before magnitudes; the model fills it (from the + # distance_modulus model or the supplied `dist`) if absent. + cols_to_add += ["dist"] + missing_true + data = stream_model.complete_catalog( + data, + columns_to_add=cols_to_add, + inplace=True, + verbose=verbose, + dist=dist, + ) + + # Convert (phi1, phi2) -> (ra, dec) using the primary survey footprint. + if not have_radec: + data = self._ensure_radec(data, rng=rng, seed=seed, **kwargs) + + return data def _ensure_radec(self, data, rng=None, seed=None, **kwargs): """Ensure ``ra``/``dec`` are present, converting from (phi1, phi2) if needed. @@ -1098,7 +1159,7 @@ def sample_measured_magnitudes(self, mag_true, mag_err, **kwargs): return mag_obs - def detect_flag(self, pix, mag=None, band="r", survey=None, **kwargs): + def detect_flag(self, pix, survey, mag=None, band="r", **kwargs): """ Apply the survey selection to determine detection flags for stars. @@ -1113,9 +1174,9 @@ def detect_flag(self, pix, mag=None, band="r", survey=None, **kwargs): Magnitude(s). Default is None. band : str, optional Band to consider for detection. Default is 'r'. - survey : Survey, optional - Survey whose completeness/detection-efficiency curves to use. - Defaults to the primary survey. + survey : Survey + Survey whose completeness/detection-efficiency curves to use + (required). **kwargs Additional keyword arguments: @@ -1142,9 +1203,6 @@ def detect_flag(self, pix, mag=None, band="r", survey=None, **kwargs): seed = kwargs.pop("seed", None) rng = np.random.default_rng(seed) - if survey is None: - survey = self.survey - # Select the appropriate magnitude and map depending on the band maglim = survey.get_maglim(band, pixel=pix) @@ -1333,60 +1391,3 @@ def plot_stream_in_mask(self, data, mask_type, ebv_threshold=0.2, **kwargs): data["ra"], data["dec"], mask, output_folder=kwargs.get("output_folder") ) return fig, ax - - def _complete_shared( - self, - data, - survey_bands, - stream_config=None, - rng=None, - seed=None, - dist=None, - **kwargs, - ): - """Fill shared geometry, ``ra``/``dec`` and per-survey true magnitudes. - - Positions and masses are drawn *once* so all surveys describe the same - physical stars (the isochrone produces every survey's - ``__true`` column from one shared mass draw). Existing - columns are preserved (only missing values are filled). ``ra``/``dec`` - are placed using the primary survey's footprint. ``dist`` (a float or - per-row vector) overrides the model's distance sampling when given. - """ - verbose = kwargs.get("verbose", True) - - true_cols = [] - for name, bands in survey_bands.items(): - true_cols += [true_col(b, name) for b in bands] - - have_radec = "ra" in data.columns and "dec" in data.columns - have_phi = "phi1" in data.columns and "phi2" in data.columns - missing_true = [c for c in true_cols if c not in data.columns] - - # Sample stream geometry and/or the shared true magnitudes from the model. - need_phi = not have_radec and not have_phi - if need_phi or missing_true: - if stream_config is None: - raise ValueError( - "stream_config is required to sample stream geometry/magnitudes." - ) - stream_model = StreamModel(stream_config) - cols_to_add = [] - if need_phi: - cols_to_add += ["phi1", "phi2"] - # `dist` is needed before magnitudes; the model fills it (from the - # distance_modulus model or the supplied `dist`) if absent. - cols_to_add += ["dist"] + missing_true - data = stream_model.complete_catalog( - data, - columns_to_add=cols_to_add, - inplace=True, - verbose=verbose, - dist=dist, - ) - - # Convert (phi1, phi2) -> (ra, dec) using the primary survey footprint. - if not have_radec: - data = self._ensure_radec(data, rng=rng, seed=seed, **kwargs) - - return data diff --git a/streamobs/surveys.py b/streamobs/surveys.py index bb97a47..a790314 100644 --- a/streamobs/surveys.py +++ b/streamobs/surveys.py @@ -138,6 +138,17 @@ def __post_init__(self): if self.sys_error is None: self.sys_error = {} + @property + def namespace(self) -> str: + """Column-prefix namespace for this survey. + + ``"{name}_{release}"`` when a release is set (e.g. ``"lsst_yr5"``, + ``"roman_dc2"``), otherwise just ``"{name}"``. This is the prefix used + for every injected column (``__obs`` etc.), so the same + survey at two releases produces distinct, non-colliding columns. + """ + return f"{self.name}_{self.release}" if self.release else self.name + @property def log_photo_error(self) -> Optional[Callable]: """Backward-compatible alias for the *catalog* (reported) error model.""" diff --git a/tests/conftest.py b/tests/conftest.py index fe4913b..deb08bc 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -59,6 +59,7 @@ def minimal_stream_config(): "isochrone": { "name": "Marigo2017", # isochrone set name "survey": "lsst", # survey for filter set + "release": "yr4", # release -> namespaces true columns as lsst_yr4_* "age": 12.0, # Age in Gyr of the population "z": 0.0006, # Metallicity of the population "band_1": "g", # first band for color-magnitude @@ -165,6 +166,41 @@ def mock_injector(mock_survey, verbose): return StreamInjector(survey=mock_survey, verbose=verbose) +@pytest.fixture(scope="session") +def mock_multisurvey_injector(verbose): + """Injector serving two LSST releases (distinct namespaces lsst_yr4/lsst_yr5).""" + from streamobs.observed import StreamInjector + + return StreamInjector( + [ + {"survey": "lsst", "release": "yr4"}, + {"survey": "lsst", "release": "yr5"}, + ], + verbose=verbose, + ) + + +@pytest.fixture(scope="session") +def multisurvey_stream_config(stream_config_with_distance): + """StreamModel config with a MULTI-survey isochrone keyed by namespace. + + Both namespaces are backed by the same ugali survey (``lsst``) and bands, so + a shared mass draw yields identical true magnitudes across them — exactly the + 'same physical star' invariant the injector relies on. + """ + cfg = dict(stream_config_with_distance) + cfg["isochrone"] = { + "name": "Marigo2017", + "age": 12.0, + "z": 0.0006, + "surveys": { + "lsst_yr4": {"survey": "lsst", "band_1": "g", "band_2": "r"}, + "lsst_yr5": {"survey": "lsst", "band_1": "g", "band_2": "r"}, + }, + } + return cfg + + @pytest.fixture(scope="session") def stream_catalog(stream_config_with_distance): from streamobs.model import StreamModel diff --git a/tests/test_model.py b/tests/test_model.py index 8045a37..3f3003b 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -134,8 +134,8 @@ def test_full_model(self, stream_config_with_distance): "phi1", "phi2", "dist", - "lsst_g_true", - "lsst_r_true", + "lsst_yr4_g_true", + "lsst_yr4_r_true", } # Not adding mu1, mu2, rv since not implemented yet self._verify_catalogue_content(samples, expected_columns) @@ -147,8 +147,8 @@ def test_complete_catalog(self, sample_catalog_phi, stream_config_with_distance) "phi1", "phi2", "dist", - "lsst_g_true", - "lsst_r_true", + "lsst_yr4_g_true", + "lsst_yr4_r_true", } # Not adding mu1, mu2, rv since not implemented yet self._verify_catalogue_content(completed_catalog, expected_columns) assert len(completed_catalog) == len( @@ -157,7 +157,7 @@ def test_complete_catalog(self, sample_catalog_phi, stream_config_with_distance) # Verify that I can add a targeted column (e.g. dist) to the input catalog and complete the rest partial_catalog = completed_catalog.drop( - columns=["lsst_r_true", "dist", "lsst_g_true"] + columns=["lsst_yr4_r_true", "dist", "lsst_yr4_g_true"] ).reset_index(drop=True) completed_catalog = model.complete_catalog( catalog=partial_catalog, @@ -173,8 +173,8 @@ def test_complete_catalog(self, sample_catalog_phi, stream_config_with_distance) partial_catalog ), f"Completed catalog should have the same number of rows as the input catalog" assert ( - "lsst_r_true" not in completed_catalog.columns - ), "Column 'lsst_r_true' should not be added when not requested" + "lsst_yr4_r_true" not in completed_catalog.columns + ), "Column 'lsst_yr4_r_true' should not be added when not requested" # --------------------------------------------------------------------------- @@ -192,7 +192,7 @@ class TestCompleteCatalogPermutations: columns and individual NaN rows are never overwritten). """ - MAGS = {"lsst_g_true", "lsst_r_true"} + MAGS = {"lsst_yr4_g_true", "lsst_yr4_r_true"} def test_empty_frame_fills_all_model_columns(self, stream_config_with_distance): """size=N with no catalog -> geometry, dist, and both bands are filled.""" @@ -230,12 +230,12 @@ def test_existing_band_preserved_when_filling_other( """Providing one band and requesting both leaves the provided one intact.""" model = StreamModel(stream_config_with_distance) g = np.array([20.0, 21.0, 22.0]) - df = pd.DataFrame({"dist": [16.0] * 3, "lsst_g_true": g.copy()}) + df = pd.DataFrame({"dist": [16.0] * 3, "lsst_yr4_g_true": g.copy()}) out = model.complete_catalog( catalog=df, columns_to_add=list(self.MAGS), verbose=False ) - assert np.allclose(out["lsst_g_true"].to_numpy(), g), "present band overwritten" - assert out["lsst_r_true"].notna().all(), "missing band not filled" + assert np.allclose(out["lsst_yr4_g_true"].to_numpy(), g), "present band overwritten" + assert out["lsst_yr4_r_true"].notna().all(), "missing band not filled" def test_present_columns_skip_sampling(self, stream_config_with_distance): """Both bands present -> values are returned untouched.""" @@ -243,23 +243,23 @@ def test_present_columns_skip_sampling(self, stream_config_with_distance): g = np.array([20.0, 21.0]) r = np.array([19.0, 19.5]) df = pd.DataFrame( - {"dist": [16.0, 16.0], "lsst_g_true": g.copy(), "lsst_r_true": r.copy()} + {"dist": [16.0, 16.0], "lsst_yr4_g_true": g.copy(), "lsst_yr4_r_true": r.copy()} ) out = model.complete_catalog( catalog=df, columns_to_add=list(self.MAGS), verbose=False ) - assert np.allclose(out["lsst_g_true"].to_numpy(), g) - assert np.allclose(out["lsst_r_true"].to_numpy(), r) + assert np.allclose(out["lsst_yr4_g_true"].to_numpy(), g) + assert np.allclose(out["lsst_yr4_r_true"].to_numpy(), r) def test_partial_rows_only_missing_filled(self, stream_config_with_distance): """A band with some NaN rows keeps its finite rows; only NaNs are filled.""" model = StreamModel(stream_config_with_distance) g = np.array([20.0, np.nan, 22.0]) - df = pd.DataFrame({"dist": [16.0] * 3, "lsst_g_true": g.copy()}) + df = pd.DataFrame({"dist": [16.0] * 3, "lsst_yr4_g_true": g.copy()}) out = model.complete_catalog( - catalog=df, columns_to_add=["lsst_g_true"], verbose=False + catalog=df, columns_to_add=["lsst_yr4_g_true"], verbose=False ) - filled = out["lsst_g_true"].to_numpy() + filled = out["lsst_yr4_g_true"].to_numpy() assert filled[0] == 20.0 and filled[2] == 22.0, "finite rows overwritten" assert np.isfinite(filled[1]), "NaN row not filled" @@ -318,3 +318,57 @@ def test_mags_without_dist_or_phi_raises(self, minimal_stream_config): model.complete_catalog( catalog=df, columns_to_add=list(self.MAGS), verbose=False ) + + +# --------------------------------------------------------------------------- +# IsochroneModel — shared initial masses (user-supplied + `mass` column) +# --------------------------------------------------------------------------- + + +@pytest.mark.model +class TestIsochroneMasses: + """The shared initial masses can be reused/supplied and surface as `mass`.""" + + G = "lsst_yr4_g_true" + R = "lsst_yr4_r_true" + + def test_sample_multisurvey_returns_and_reuses_masses( + self, stream_config_with_distance + ): + """Replaying the returned masses reproduces identical magnitudes.""" + iso = StreamModel(stream_config_with_distance).isochrone + mags1, masses = iso.sample_multisurvey(50, 16.8, rng=np.random.default_rng(0)) + assert masses.shape == (50,) + # Supplying those masses (no rng) is deterministic and reproduces mags1. + mags2, masses2 = iso.sample_multisurvey(50, 16.8, masses=masses) + assert np.allclose(masses, masses2) + for key in mags1: + assert np.allclose(mags1[key], mags2[key]), f"{key} not reproduced" + + def test_sample_multisurvey_masses_length_validated( + self, stream_config_with_distance + ): + iso = StreamModel(stream_config_with_distance).isochrone + with pytest.raises(ValueError): + iso.sample_multisurvey(50, 16.8, masses=np.ones(49)) + + def test_complete_catalog_exposes_mass_column(self, stream_config_with_distance): + """A completed catalog carries the shared `mass` column.""" + model = StreamModel(stream_config_with_distance) + out = model.complete_catalog(catalog=None, size=20, verbose=False) + assert "mass" in out.columns + assert out["mass"].notna().all() + assert np.issubdtype(out["mass"].dtype, np.floating) + + def test_input_mass_column_drives_magnitudes(self, stream_config_with_distance): + """Providing a `mass` column makes the sampled mags match those masses.""" + model = StreamModel(stream_config_with_distance) + iso = model.isochrone + _, masses = iso.sample_multisurvey(15, 16.8, rng=np.random.default_rng(3)) + df = pd.DataFrame({"dist": [16.8] * 15, "mass": masses}) + out = model.complete_catalog( + catalog=df, columns_to_add=[self.G, self.R], verbose=False + ) + direct, _ = iso.sample_multisurvey(15, 16.8, masses=masses) + assert np.allclose(out[self.G].to_numpy(), direct[("lsst_yr4", "g")]) + assert np.allclose(out[self.R].to_numpy(), direct[("lsst_yr4", "r")]) diff --git a/tests/test_observed.py b/tests/test_observed.py index 3ca6973..ad67419 100644 --- a/tests/test_observed.py +++ b/tests/test_observed.py @@ -105,12 +105,12 @@ def _verify_injected_catalog_content( expected_columns=[ "ra", "dec", - "lsst_g_true", - "lsst_r_true", - "lsst_g_obs", - "lsst_r_obs", - "lsst_flag_observed", - "lsst_flag_perfect_galstarsep", + "lsst_yr4_g_true", + "lsst_yr4_r_true", + "lsst_yr4_g_obs", + "lsst_yr4_r_obs", + "lsst_yr4_flag_observed", + "lsst_yr4_flag_perfect_galstarsep", ], ): """Helper method to verify the content of the injected catalog.""" @@ -135,7 +135,9 @@ def test_injection_partialinput( self, mock_injector, stream_catalog, stream_config_with_distance, verbose ): """Test injection with a catalog that has some missing columns.""" - data_without_mag = stream_catalog.drop(columns=["lsst_g_true", "lsst_r_true"]) + data_without_mag = stream_catalog.drop( + columns=["lsst_yr4_g_true", "lsst_yr4_r_true"] + ) injected_catalog = mock_injector.inject( data_without_mag, perfect_galstarsep=True, @@ -230,3 +232,70 @@ def compare_gc_frames(gc1, gc2): assert len(masks_before) > len( masks ), "Mask cache should have had entries before clearing" + + +# --------------------------------------------------------------------------- +# complete_data + bands/survey API +# --------------------------------------------------------------------------- + + +@pytest.mark.observed +class TestCompleteDataAndAPI: + """complete_data (single + multi survey) and the unified bands/survey API.""" + + def test_complete_data_single_survey(self, mock_injector, stream_config_with_distance): + """complete_data fills ra/dec + true mags and preserves existing columns.""" + df = pd.DataFrame({"phi1": [-3.0, 0.0, 3.0], "phi2": [0.0, 0.0, 0.0]}) + out = mock_injector.complete_data( + df, bands=["g", "r"], stream_config=stream_config_with_distance, seed=1 + ) + for col in ["ra", "dec", "lsst_yr4_g_true", "lsst_yr4_r_true"]: + assert col in out.columns, f"missing {col}" + assert out[["lsst_yr4_g_true", "lsst_yr4_r_true"]].notna().all().all() + # Input is not mutated (complete_data works on a copy). + assert "ra" not in df.columns + + def test_complete_data_multisurvey( + self, mock_multisurvey_injector, multisurvey_stream_config + ): + """Multi-survey complete_data fills every namespace from ONE mass draw. + + Both namespaces are backed by the same ugali survey/bands, so the shared + masses must yield identical true magnitudes across them. + """ + df = pd.DataFrame({"phi1": [-3.0, 0.0, 3.0], "phi2": [0.0, 0.0, 0.0]}) + out = mock_multisurvey_injector.complete_data( + df, + bands={"lsst_yr4": ["g", "r"], "lsst_yr5": ["g", "r"]}, + stream_config=multisurvey_stream_config, + seed=7, + ) + for col in [ + "ra", + "dec", + "lsst_yr4_g_true", + "lsst_yr4_r_true", + "lsst_yr5_g_true", + "lsst_yr5_r_true", + ]: + assert col in out.columns, f"missing {col}" + # Same physical star across surveys -> identical true mags. + assert np.allclose(out["lsst_yr4_g_true"], out["lsst_yr5_g_true"]) + assert np.allclose(out["lsst_yr4_r_true"], out["lsst_yr5_r_true"]) + + def test_bands_list_rejected_for_multisurvey(self, mock_multisurvey_injector): + """A plain list of bands is ambiguous for a multi-survey injector.""" + df = pd.DataFrame({"phi1": [0.0], "phi2": [0.0]}) + with pytest.raises(ValueError): + mock_multisurvey_injector.complete_data(df, bands=["g", "r"]) + + def test_bands_dict_unknown_survey_raises(self, mock_injector): + """A bands dict referencing an unknown namespace is rejected.""" + df = pd.DataFrame({"phi1": [0.0], "phi2": [0.0]}) + with pytest.raises(ValueError): + mock_injector.complete_data(df, bands={"nope": ["g"]}) + + def test_detect_flag_requires_survey(self, mock_injector): + """`survey` is now a required argument of detect_flag.""" + with pytest.raises(TypeError): + mock_injector.detect_flag(0, mag=np.array([20.0]), band="r") From 6674845e022287477875e5315632b6b426acd62a Mon Sep 17 00:00:00 2001 From: psferguson Date: Wed, 17 Jun 2026 14:52:48 -0700 Subject: [PATCH 13/29] Docs: sync with release-namespacing; tolerant completeness-column loader Doc staleness introduced by the PR #47 behavior changes: - column_convention.md / quickstart.md / multisurvey.md: column examples are now release-namespaced ({name}_{release}); state the namespacing rule. Quickstart Example 3 (lsst/yr1) no longer errors on copy-paste. - Correct the false "the dict key is the column namespace" claim in multisurvey.md, the StreamInjector.__init__ docstring, and roman_rubin_demo.yaml (keys are containers; namespace is re-derived from each Survey). - Document the {"survey":,"release":} spec-dict input form, the bands-dict validation, the mass column / user-supplied masses, _MASS_STEPS, and primary/primary_namespace. - Reword the S/N "applied once" text: the reference-band cut is owned by the selection-function curves, not re-applied by the injector. - Note the multi-survey isochrone requirement that surveys: keys equal the injector namespaces. Code: - set_completeness now accepts both "classification_eff" and the legacy misspelled "classifiction_eff" header, so the correct spelling documented in new_survey.md works without breaking the current (misspelled) data package. Also fixed the docstring's stale "eff_star" -> "detection_eff". Co-Authored-By: Claude Opus 4.8 (1M context) --- config/scenes/roman_rubin_demo.yaml | 8 +-- docs/source/column_convention.md | 16 ++++-- docs/source/multisurvey.md | 83 +++++++++++++++++++++-------- docs/source/quickstart.md | 28 +++++----- streamobs/observed.py | 22 ++++---- streamobs/surveys.py | 17 ++++-- 6 files changed, 117 insertions(+), 57 deletions(-) diff --git a/config/scenes/roman_rubin_demo.yaml b/config/scenes/roman_rubin_demo.yaml index 1b0bbae..fb1413a 100644 --- a/config/scenes/roman_rubin_demo.yaml +++ b/config/scenes/roman_rubin_demo.yaml @@ -15,9 +15,11 @@ # The same physical stars carry both `lsst__*` and `roman__*` # columns; each band's errors / detection come from that survey's own maps. -# Surveys to inject. The mapping KEY is the column namespace (lsst_r_obs, ...). -# Each value is a survey spec: a survey-name string here (loaded via -# Survey.load); could also be a {name, release} once the loader supports it. +# Surveys to inject. The column namespace is each survey's own {name}_{release} +# (here just `lsst` / `roman` since these are loaded without a release) — the +# mapping keys below are NOT used as the namespace; they are containers only. +# Each value is a survey spec: a survey-name string (loaded via Survey.load), or +# a {"survey": ..., "release": ...} dict. surveys: lsst: lsst roman: roman diff --git a/docs/source/column_convention.md b/docs/source/column_convention.md index d8a376d..068b9c9 100644 --- a/docs/source/column_convention.md +++ b/docs/source/column_convention.md @@ -6,9 +6,16 @@ survey. ## The scheme -For a survey with namespace `` (the survey's name, or the key you gave it -when constructing a multi-survey `StreamInjector`) and a photometric band -``: +Every column is prefixed with the survey's **namespace**, which is +`{name}_{release}` (e.g. `lsst_yr5`, `roman_dc2`), or just `{name}` when the +survey was loaded without a release. The namespace is always derived from the +`Survey` itself ({attr}`streamobs.surveys.Survey.namespace`) and includes the +release on **every** column kind, so the same survey at two releases produces +distinct, non-colliding columns. When you construct a multi-survey injector from +a `{key: spec}` dict the keys are containers only — they do **not** become the +namespace (it is re-derived from each loaded `Survey`). + +For a survey with namespace `` and a photometric band ``: | Column | Meaning | |---|---| @@ -20,7 +27,8 @@ when constructing a multi-survey `StreamInjector`) and a photometric band Plus the shared, un-namespaced sky coordinates `ra`, `dec`. -Examples: `lsst_r_obs`, `lsst_g_err`, `roman_F158_true`, `lsst_flag_observed`. +Examples (LSST loaded with `release="yr5"`, Roman with `release="dc2"`): +`lsst_yr5_r_obs`, `lsst_yr5_g_err`, `roman_dc2_F158_true`, `lsst_yr5_flag_observed`. These names are produced by the helpers in `streamobs.columns` (`true_col`, `obs_col`, `err_col`, `flag_col`, `perfect_flag_col`), which take a diff --git a/docs/source/multisurvey.md b/docs/source/multisurvey.md index ec3f6f8..faaae22 100644 --- a/docs/source/multisurvey.md +++ b/docs/source/multisurvey.md @@ -14,21 +14,32 @@ Pass one survey, or several: ```python from streamobs.observed import StreamInjector -# One survey (loaded by name; `release` etc. forwarded to Survey.load) +# One survey (loaded by name; `release` etc. forwarded to Survey.load). +# Its namespace is "{name}_{release}", here "lsst_dc2". inj = StreamInjector("lsst", release="dc2") -# Several surveys: {namespace: spec}, where spec is a survey name or a Survey. -# The dict key is the column namespace. -inj = StreamInjector({"lsst": "lsst", "roman": "roman"}, primary="lsst") +# Several surveys as a list of specs — each spec is a survey name, a Survey, or a +# {"survey": ..., "release": ...} dict. The namespace is derived from each loaded +# Survey ("lsst_dc2", "roman_dc2"), NOT from any key you supply. +inj = StreamInjector([ + {"survey": "lsst", "release": "dc2"}, + {"survey": "roman", "release": "dc2"}, +]) -# Or a list — each survey is namespaced by its own name. +# A list of plain names loads each release-less, so the namespace is the bare +# name ("lsst", "roman"). inj = StreamInjector(["lsst", "roman"]) ``` +- The namespace (the column prefix) is always the survey's own + `{name}_{release}` ({attr}`streamobs.surveys.Survey.namespace`). A `{key: spec}` + dict is also accepted, but the keys are containers only — the namespace is + re-derived from each `Survey`, not taken from the key. - `primary` selects the survey whose footprint drives the shared sky placement (defaults to the first survey). -- `inj.surveys` is the `{namespace: Survey}` mapping; `inj.survey` is the primary - `Survey`. +- `inj.surveys` is the `{namespace: Survey}` mapping; `inj.primary` (alias + `inj.survey`) is the primary `Survey`, and `inj.primary_namespace` its namespace + string. ## Injecting @@ -36,15 +47,19 @@ inj = StreamInjector(["lsst", "roman"]) # Single survey: `bands` is the shorthand (defaults to ['r', 'g']). out = inj.inject(df, bands=["r", "g"], stream_config=cfg, seed=42) -# Several surveys: give the bands per survey as a {survey: [bands]} dict. +# Several surveys: give the bands per survey as a {namespace: [bands]} dict, +# keyed by each survey's namespace ({name}_{release}). out = inj.inject( df, - bands={"lsst": ["r", "g"], "roman": ["F106", "F158"]}, + bands={"lsst_dc2": ["r", "g"], "roman_dc2": ["F106", "F158"]}, stream_config=cfg, seed=42, ) ``` +A plain list is rejected for a multi-survey injector (it is ambiguous), and a +`bands` dict referencing an unknown namespace raises `ValueError`. + `df` may already contain `ra`/`dec` or `phi1`/`phi2`, may be a fully empty frame of length *N*, or any subset — anything missing is sampled from `stream_config` (see *Completing a catalog* below). The output carries shared @@ -53,8 +68,8 @@ of length *N*, or any subset — anything missing is sampled from `stream_config ``` ra, dec, -lsst_r_true, lsst_r_obs, lsst_r_err, lsst_g_true, ..., lsst_flag_observed, -roman_F106_true, roman_F106_obs, ..., roman_flag_observed +lsst_dc2_r_true, lsst_dc2_r_obs, lsst_dc2_r_err, lsst_dc2_g_true, ..., lsst_dc2_flag_observed, +roman_dc2_F106_true, roman_dc2_F106_obs, ..., roman_dc2_flag_observed ``` Useful `inject` keyword arguments: @@ -87,13 +102,23 @@ stream: age: 12.0 z: 0.0006 surveys: - lsst: {survey: lsst, band_1: g, band_2: r} - roman: {survey: roman, band_1: F106, band_2: F158} + lsst_dc2: {survey: lsst, band_1: g, band_2: r} + roman_dc2: {survey: roman, band_1: F106, band_2: F158} +``` + +```{important} +Each `surveys:` **key is the column namespace** the isochrone produces +(`__true`), and it must match the injecting survey's namespace +`{name}_{release}` — otherwise the true-magnitude columns the model emits won't +line up with the columns the injector looks for. Here the inner `survey:` is the +*ugali* filter set (no release), while the key carries the release. (In the +single-survey flat form the namespace is derived as `{survey}_{release}` for you; +in the multi-survey form you spell it out as the key.) ``` -A single-survey isochrone (the flat `survey`/`band_1`/`band_2` form) is just the -one-survey case of the same machinery and produces `__true` -identically. +A single-survey isochrone (the flat `survey`/`band_1`/`band_2` form, optionally +with `release:`) is just the one-survey case of the same machinery and produces +`__true` identically. A complete, runnable example — the surveys, per-survey bands, the multi-survey isochrone, and the shared stream geometry — is provided as a *scene* config in @@ -160,15 +185,29 @@ and request another, the supplied band is left untouched and only the missing on is filled (newly-filled cells still come from one shared mass draw, so they are mutually colour-consistent). +### Stellar masses (the `mass` column) + +When an isochrone is configured, the shared **initial masses** drawn for the stars +are surfaced as a single un-namespaced `mass` column (one mass per star, shared by +all surveys — the same physical star). You can also go the other way and supply +your own masses: pass a fully-populated `mass` column in the input catalog and the +isochrone uses *those* masses instead of drawing fresh ones, so the sampled +magnitudes reproduce your simulation's exact stars. At the model level +{meth}`streamobs.model.IsochroneModel.sample_multisurvey` accepts a `masses=` +array and returns the masses it used. The mass grid resolution is controlled by +`IsochroneModel._MASS_STEPS` (default 4000) and a per-call `mass_steps=` override. + ## S/N cut ownership The reference band (`survey.completeness_band`, e.g. LSST `r`) is special: the -survey's **selection functions are estimated with the SNR ≥ 5 cut already -applied** in that band. The injector therefore applies the reference-band cut -exactly **once**, and the explicit `detection_mag_cut` loop applies SNR ≥ 5 to -every *other* injected band (its default is all injected bands except the -reference band). Net effect: a star must have SNR ≥ 5 in every injected band to -be flagged observed, with the reference band counted once. +survey's **selection-function curves are estimated on true stars detected at +SNR ≥ 5** in that band, so the cut is already baked into both the completeness +and detection-efficiency curves. The injector therefore does **not** re-apply a +SNR cut to the reference band (doing so would double-count it); the explicit +`detection_mag_cut` loop applies SNR ≥ 5 only to the *other* injected bands (its +default is all injected bands except the reference band). Net effect: a star must +have SNR ≥ 5 in every injected band to be flagged observed, with the reference +band's cut owned entirely by the selection-function curves. ## See also diff --git a/docs/source/quickstart.md b/docs/source/quickstart.md index 9564a99..50386c4 100644 --- a/docs/source/quickstart.md +++ b/docs/source/quickstart.md @@ -73,15 +73,16 @@ injector = observed.StreamInjector(lsst_survey) # Create or load your mock stream data. # Here we create a simple test dataset. Could instead contain (ra, dec) to skip # the coordinate transformation. True (noiseless) magnitudes are passed in as -# survey-namespaced __true columns (the survey's name is its -# namespace; here "lsst"). Alternatively, omit the magnitudes and pass a -# `stream_config=` so the injector samples them from an isochrone. +# survey-namespaced __true columns, where the namespace is +# "{name}_{release}" — here the survey is lsst/yr1, so "lsst_yr1". +# Alternatively, omit the magnitudes and pass a `stream_config=` so the injector +# samples them from an isochrone. rng = np.random.default_rng(42) mock_data = pd.DataFrame({ - 'phi1': rng.uniform(-5, 5, 1000), # Stream longitude - 'phi2': rng.uniform(-1, 1, 1000), # Stream latitude - 'lsst_g_true': rng.uniform(18, 28, 1000), # true g-band apparent magnitude - 'lsst_r_true': rng.uniform(18, 28, 1000), # true r-band apparent magnitude + 'phi1': rng.uniform(-5, 5, 1000), # Stream longitude + 'phi2': rng.uniform(-1, 1, 1000), # Stream latitude + 'lsst_yr1_g_true': rng.uniform(18, 28, 1000), # true g-band apparent magnitude + 'lsst_yr1_r_true': rng.uniform(18, 28, 1000), # true r-band apparent magnitude }) # Apply survey effects: footprint, extinction, photometric errors @@ -94,7 +95,7 @@ observed_data = injector.inject( ) print(f"Input stars: {len(mock_data)}") -print(f"Detected stars: {int(observed_data['lsst_flag_observed'].sum())}") +print(f"Detected stars: {int(observed_data['lsst_yr1_flag_observed'].sum())}") ``` ### What the Injector Does @@ -108,12 +109,13 @@ The `StreamInjector` applies several observational effects: The output dataframe includes (all magnitude/flag columns are **survey-namespaced** -as `_...`; for the LSST survey loaded above the namespace is `lsst`): +as `_...`, where the namespace is `{name}_{release}`; for the LSST/yr1 +survey loaded above it is `lsst_yr1`): - `ra`, `dec`: Sky coordinates -- `lsst_g_true`, `lsst_r_true`: True (noiseless) apparent magnitudes -- `lsst_g_obs`, `lsst_r_obs`: Observed (noisy) magnitudes -- `lsst_g_err`, `lsst_r_err`: Reported photometric uncertainties -- `lsst_flag_observed`: Detection and classification flag (`True`=detected & classified as a star, `False`=not detected or not classified as a star) +- `lsst_yr1_g_true`, `lsst_yr1_r_true`: True (noiseless) apparent magnitudes +- `lsst_yr1_g_obs`, `lsst_yr1_r_obs`: Observed (noisy) magnitudes +- `lsst_yr1_g_err`, `lsst_yr1_r_err`: Reported photometric uncertainties +- `lsst_yr1_flag_observed`: Detection and classification flag (`True`=detected & classified as a star, `False`=not detected or not classified as a star) ## Next Steps diff --git a/streamobs/observed.py b/streamobs/observed.py index f546770..9b7511f 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -79,17 +79,19 @@ def __init__(self, survey, primary=None, **kwargs): Parameters ---------- survey : str, Survey, dict, or list - One survey or several. Accepted forms: - - - a survey-name string (e.g. ``'lsst'``) or a pre-loaded - :class:`~streamobs.surveys.Survey` — a single survey, namespaced - by its own name; - - a ``{namespace: spec}`` dict, where ``spec`` is a name string or a - ``Survey`` and the key is the column namespace; - - a list/tuple of specs, each namespaced by its survey's name. + One survey or several. Every survey is namespaced by its own + :attr:`~streamobs.surveys.Survey.namespace` (``{name}_{release}``, + or just ``{name}`` with no release). Accepted forms: + + - a survey-name string (e.g. ``'lsst'``), a + ``{"survey": ..., "release": ...}`` spec dict, or a pre-loaded + :class:`~streamobs.surveys.Survey` — a single survey; + - a list/tuple of such specs; + - a ``{key: spec}`` dict — the keys are containers only and are + **ignored**; the namespace is re-derived from each loaded survey. primary : str, optional - Namespace of the survey that drives the shared sky placement. - Defaults to the first survey. + Namespace (``{name}_{release}``) of the survey that drives the shared + sky placement. Defaults to the first survey. **kwargs Forwarded to :meth:`Survey.load` for any ``spec`` given as a name string (e.g. ``release``). diff --git a/streamobs/surveys.py b/streamobs/surveys.py index a790314..be1c704 100644 --- a/streamobs/surveys.py +++ b/streamobs/surveys.py @@ -1397,8 +1397,9 @@ def set_completeness(filename, delta_saturation=-10.4, selection="both"): Path to CSV file with columns: - 'delta_mag' : Magnitude difference from limit (mag - maglim) - - 'eff_star' : Detection efficiency only - - 'classifiction_eff' : Classification efficiency only + - 'detection_eff' : Detection efficiency only + - 'classification_eff' : Classification efficiency only (the legacy + misspelled header 'classifiction_eff' is also accepted) - 'classification_detection_eff' : Combined efficiency delta_saturation : float, optional @@ -1406,8 +1407,9 @@ def set_completeness(filename, delta_saturation=-10.4, selection="both"): selection : str, optional Which efficiency to use: - - 'detected' : Detection efficiency only (column 'eff_star') - - 'classified' : Classification efficiency only (column 'classifiction_eff') + - 'detected' : Detection efficiency only (column 'detection_eff') + - 'classified' : Classification efficiency only (column + 'classification_eff', or legacy 'classifiction_eff') - 'both' : Combined detection and classification (column 'classification_detection_eff') Default is 'both'. @@ -1436,7 +1438,12 @@ def set_completeness(filename, delta_saturation=-10.4, selection="both"): if selection == "detected": efficiencies = data["detection_eff"] elif selection == "classified": - efficiencies = data["classifiction_eff"] + # Prefer the correct spelling; fall back to the legacy misspelled + # header ("classifiction_eff") in older/Zenodo data packages. + if "classification_eff" in data.dtype.names: + efficiencies = data["classification_eff"] + else: + efficiencies = data["classifiction_eff"] elif selection == "both": efficiencies = data["classification_detection_eff"] else: From 1ac8d37087c6809541e49bbf48f44058b035cea4 Mon Sep 17 00:00:00 2001 From: psferguson Date: Wed, 17 Jun 2026 14:56:23 -0700 Subject: [PATCH 14/29] Fix SplineStreamModel instantiation and plot_inject namespaced columns - SplineStreamModel._create_model called an undefined self._create_distance(); rename to self._create_distance_modulus() (model.py:981). This made every spline-stream run (e.g. bin/generate_spline_stream.py) raise AttributeError. - plotting.plot_inject read bare, non-namespaced columns (flag_observed, r_obs, ...) and so failed on the injector's {name}_{release}-namespaced output; derive the namespace from survey.namespace and use it for all flag/true/obs columns. Tests: test_spline_model.py (instantiate + sample, skipped if the spline data file is absent) and test_plotting.py (plot_inject smoke test on namespaced output). 37 passed. Co-Authored-By: Claude Opus 4.8 (1M context) --- streamobs/model.py | 2 +- streamobs/plotting.py | 34 ++++++++++++++++++--------------- tests/test_plotting.py | 29 ++++++++++++++++++++++++++++ tests/test_spline_model.py | 39 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 88 insertions(+), 16 deletions(-) create mode 100644 tests/test_plotting.py create mode 100644 tests/test_spline_model.py diff --git a/streamobs/model.py b/streamobs/model.py index a429c37..d25f9b9 100644 --- a/streamobs/model.py +++ b/streamobs/model.py @@ -978,6 +978,6 @@ def _create_model(self): """Instantiate spline-specific components and common sub-models.""" self.density = self._create_linear_density() self.track = self._create_track() - self.distance_modulus = self._create_distance() + self.distance_modulus = self._create_distance_modulus() self.isochrone = self._create_isochrone() self.velocity = self._create_velocity() diff --git a/streamobs/plotting.py b/streamobs/plotting.py index b17e59d..49d0d97 100644 --- a/streamobs/plotting.py +++ b/streamobs/plotting.py @@ -94,13 +94,14 @@ def plot_inject(data, survey, bands=None, range=None, **kwargs): Parameters ---------- data : pandas.DataFrame or dict-like - Data containing the injected stream. Must have columns: + Data containing the injected stream, with columns namespaced by the + survey's ``namespace`` (``{name}_{release}``, e.g. ``lsst_yr5``). Must have: - 'ra', 'dec': Sky coordinates in degrees - - 'flag_observed': Boolean flag for detected stars - - '_true': True magnitudes for each band - - '_obs': Observed magnitudes for each band + - '_flag_observed': Boolean flag for detected stars + - '__true': True magnitudes for each band + - '__obs': Observed magnitudes for each band survey : Survey - Survey object containing magnitude limit maps and other properties. + Survey object; supplies the column namespace and the magnitude-limit maps. bands : list of str, optional Bands to use for HR diagram. Default is ['g', 'r']. Will use first two bands if more are provided. @@ -132,22 +133,25 @@ def plot_inject(data, survey, bands=None, range=None, **kwargs): raise ValueError("Need at least 2 bands for HR diagram") band1, band2 = bands[0], bands[1] + # Injected columns are namespaced by the survey ({name}_{release}). + ns = survey.namespace + # Check required columns required_cols = [ "ra", "dec", - flag_col(), - true_col(band1), - true_col(band2), - obs_col(band1), - obs_col(band2), + flag_col(ns), + true_col(band1, ns), + true_col(band2, ns), + obs_col(band1, ns), + obs_col(band2, ns), ] missing_cols = [col for col in required_cols if col not in data.columns] if missing_cols: raise ValueError(f"Missing required columns: {missing_cols}") # Get detection flags - sel = data[flag_col()].astype(bool) + sel = data[flag_col(ns)].astype(bool) # Create figure fig, ax = plt.subplots(1, 3, figsize=(14, 6)) @@ -207,8 +211,8 @@ def plot_inject(data, survey, bands=None, range=None, **kwargs): # --- Panel 2: HR diagram with true magnitudes --- ax[1].set_title("HR diagram using True magnitudes") - color_true = data[true_col(band1)] - data[true_col(band2)] - mag_true = data[true_col(band1)] + color_true = data[true_col(band1, ns)] - data[true_col(band2, ns)] + mag_true = data[true_col(band1, ns)] ax[1].scatter( color_true, @@ -236,8 +240,8 @@ def plot_inject(data, survey, bands=None, range=None, **kwargs): ax[2].set_title("HR diagram using sampled observed magnitudes") # Convert measured magnitudes to numeric, handling "BAD_MAG" strings - mag1_obs = pd.to_numeric(data[obs_col(band1)], errors="coerce") - mag2_obs = pd.to_numeric(data[obs_col(band2)], errors="coerce") + mag1_obs = pd.to_numeric(data[obs_col(band1, ns)], errors="coerce") + mag2_obs = pd.to_numeric(data[obs_col(band2, ns)], errors="coerce") # Mask out bad measurements mask_good = (~mag1_obs.isna()) & (~mag2_obs.isna()) diff --git a/tests/test_plotting.py b/tests/test_plotting.py new file mode 100644 index 0000000..3c07228 --- /dev/null +++ b/tests/test_plotting.py @@ -0,0 +1,29 @@ +""" +tests/test_plotting.py +====================== +Smoke test for ``streamobs.plotting.plot_inject``. + +Guards against the regression where ``plot_inject`` read bare, non-namespaced +columns (``flag_observed``, ``r_obs``, ...) and so raised "Missing required +columns" on the injector's now-namespaced (``{name}_{release}``) output. +""" + +import matplotlib + +matplotlib.use("Agg") # headless backend for tests + +import pytest + +from streamobs.plotting import plot_inject + + +@pytest.mark.observed +class TestPlotInject: + def test_plot_inject_namespaced_columns(self, mock_injector, stream_catalog, verbose): + """plot_inject consumes the namespaced injector output without error.""" + cat = mock_injector.inject(stream_catalog, bands=["g", "r"], verbose=verbose) + # mock_injector is LSST/yr4 -> namespace lsst_yr4; columns are lsst_yr4_*. + fig, ax = plot_inject(cat, mock_injector.survey, bands=["g", "r"]) + assert fig is not None + assert len(ax) == 3 + matplotlib.pyplot.close(fig) diff --git a/tests/test_spline_model.py b/tests/test_spline_model.py new file mode 100644 index 0000000..1b8a080 --- /dev/null +++ b/tests/test_spline_model.py @@ -0,0 +1,39 @@ +""" +tests/test_spline_model.py +========================== +Regression test for ``streamobs.model.SplineStreamModel``. + +Guards against the bug where ``_create_model`` called an undefined +``_create_distance()`` (now ``_create_distance_modulus()``), which made every +spline-stream instantiation raise ``AttributeError``. +""" + +import os + +import pytest +import yaml + +from streamobs.model import SplineStreamModel + +REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +CFG = os.path.join(REPO, "config", "atlas_spline_config.yaml") + + +@pytest.mark.model +class TestSplineStreamModel: + def test_instantiate_and_sample(self): + """Constructing + sampling a spline stream must not raise (was AttributeError).""" + if not os.path.exists(CFG): + pytest.skip("atlas_spline_config.yaml not present") + cfg = yaml.safe_load(open(CFG))["stream"] + # The spline density/track read an external interpolation file; skip if + # the (gitignored / downloaded) data is not available locally. + data_file = cfg.get("filename", "").lstrip("./") + if data_file and not os.path.exists(os.path.join(REPO, data_file)): + pytest.skip(f"spline data file {data_file} not present") + + model = SplineStreamModel(cfg) # previously raised AttributeError here + df = model.sample(25) + assert len(df) == 25 + for col in ("phi1", "phi2"): + assert col in df.columns From a623b9c5106a4d822909299007feeb8257fee85e Mon Sep 17 00:00:00 2001 From: psferguson Date: Wed, 17 Jun 2026 14:59:56 -0700 Subject: [PATCH 15/29] Docs: use des/yr6 (not y6) for the DES release identifier The DES survey config is name=des, release=yr6 (namespace des_yr6) and the data directory is data/surveys/des_yr6/, matching the LSST yr* convention. DES.md told users to load release='y6' and use a des_y6/ folder, which fails (no des_y6 config). Standardize the release/dir on yr6 in DES.md and the new_survey.md example. (Data-file basenames in the package remain des_y6_*; that's a separate data-package rename.) Co-Authored-By: Claude Opus 4.8 (1M context) --- docs/source/DES.md | 4 ++-- docs/source/new_survey.md | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/source/DES.md b/docs/source/DES.md index 163274f..01fa2f8 100644 --- a/docs/source/DES.md +++ b/docs/source/DES.md @@ -7,8 +7,8 @@ We have added the DES Y6 Gold as a supported survey to use with streamobs. The survey dataset is described in [Bechtol et al. 2025](https://arxiv.org/abs/2501.05739), and the catalogs can are documented/publically available from [DESDM](https://des.ncsa.illinois.edu/releases). -The maglim, completeness, and photoerror files should be downloaded and placed in the `data/surveys/des_y6/` folder and loaded in the following manner: +The maglim, completeness, and photoerror files should be downloaded and placed in the `data/surveys/des_yr6/` folder and loaded in the following manner: ``` -des_y6= surveys.Survey.load(survey = 'des', release='y6') +des_yr6 = surveys.Survey.load(survey='des', release='yr6') ``` Any questions about the creation of these survey specific files can be addressed to Peter Ferguson. \ No newline at end of file diff --git a/docs/source/new_survey.md b/docs/source/new_survey.md index 07a0d24..fd29661 100644 --- a/docs/source/new_survey.md +++ b/docs/source/new_survey.md @@ -20,7 +20,7 @@ Add magnitude limit maps for each band: * Example: ``` - des_y6_g_band_nside_128.hsp + des_yr6_g_band_nside_128.hsp ``` * Optional: survey-specific completeness and photometric error files. If not provided, the default files in `data/others/` will be used. From 44ab9c8a969bf3baa55f6080d87f068944c076ab Mon Sep 17 00:00:00 2001 From: psferguson Date: Wed, 17 Jun 2026 15:02:12 -0700 Subject: [PATCH 16/29] Docs: correct complete_catalog preserve-vs-overwrite docstring The Notes claimed magnitudes (like velocities) overwrite whole columns. In fact phi1/phi2/dist, magnitudes, and the shared mass column fill only missing rows (the preserve-existing contract); only velocities are recomputed wholesale. Co-Authored-By: Claude Opus 4.8 (1M context) --- streamobs/model.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/streamobs/model.py b/streamobs/model.py index d25f9b9..0ae3884 100644 --- a/streamobs/model.py +++ b/streamobs/model.py @@ -277,10 +277,12 @@ def complete_catalog( - Dependencies: 'phi2' and 'dist' require 'phi1'. Magnitudes require 'dist' and an isochrone model. Velocities require 'phi1' and a velocity model. - - Existing non-null values are preserved; only missing rows are filled, - except for magnitudes and velocities where the method intentionally - overwrites the whole columns to keep internal consistency (e.g., - colors and kinematic coherence across rows). + - Existing non-null values are preserved: only the missing rows are + filled for ``phi1``/``phi2``/``dist``, the magnitude columns, and the + shared ``mass`` column (supplying some bands and requesting others + fills only the missing ones, colour-consistently). Velocities are the + exception — ``mu1``/``mu2``/``rv`` are recomputed for the whole columns + to keep kinematic coherence across rows. - When ``catalog`` is a CSV path and ``inplace`` is True, the original file is overwritten. """ From 11dcbfe3e17b2c294d2cc3377f6886abfee9cdc0 Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Thu, 18 Jun 2026 15:50:01 +0200 Subject: [PATCH 17/29] Removing release from mag true --- streamobs/columns.py | 27 +++++++++++++++++---------- tests/test_model.py | 38 +++++++++++++++++++------------------- tests/test_observed.py | 24 ++++++++++++------------ 3 files changed, 48 insertions(+), 41 deletions(-) diff --git a/streamobs/columns.py b/streamobs/columns.py index bc6b680..be3eb96 100644 --- a/streamobs/columns.py +++ b/streamobs/columns.py @@ -23,26 +23,33 @@ """ -def true_col(band, survey=None): +def true_col(band, survey_namespace=None): """Column holding the *true* (noiseless) apparent magnitude for ``band``.""" - return f"{survey}_{band}_true" if survey else f"{band}_true" + # Split survey_namespace "{name}_{release}" into survey and release if needed + if isinstance(survey_namespace, str): + survey_name = survey_namespace.split("_")[0] + else: + survey_name = None + + return f"{survey_name}_{band}_true" if survey_name else f"{band}_true" -def obs_col(band, survey=None): + +def obs_col(band, survey_namespace=None): """Column holding the *observed* (noisy) magnitude for ``band``.""" - return f"{survey}_{band}_obs" if survey else f"{band}_obs" + return f"{survey_namespace}_{band}_obs" if survey_namespace else f"{band}_obs" -def err_col(band, survey=None): +def err_col(band, survey_namespace=None): """Column holding the reported magnitude error for ``band``.""" - return f"{survey}_{band}_err" if survey else f"{band}_err" + return f"{survey_namespace}_{band}_err" if survey_namespace else f"{band}_err" -def flag_col(survey=None): +def flag_col(survey_namespace=None): """Column holding the detection flag (band-independent).""" - return f"{survey}_flag_observed" if survey else "flag_observed" + return f"{survey_namespace}_flag_observed" if survey_namespace else "flag_observed" -def perfect_flag_col(survey=None): +def perfect_flag_col(survey_namespace=None): """Column holding the perfect star/galaxy-separation flag (band-independent).""" - return f"{survey}_flag_perfect_galstarsep" if survey else "flag_perfect_galstarsep" + return f"{survey_namespace}_flag_perfect_galstarsep" if survey_namespace else "flag_perfect_galstarsep" diff --git a/tests/test_model.py b/tests/test_model.py index 3f3003b..3a95214 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -134,8 +134,8 @@ def test_full_model(self, stream_config_with_distance): "phi1", "phi2", "dist", - "lsst_yr4_g_true", - "lsst_yr4_r_true", + "lsst_g_true", + "lsst_r_true", } # Not adding mu1, mu2, rv since not implemented yet self._verify_catalogue_content(samples, expected_columns) @@ -147,8 +147,8 @@ def test_complete_catalog(self, sample_catalog_phi, stream_config_with_distance) "phi1", "phi2", "dist", - "lsst_yr4_g_true", - "lsst_yr4_r_true", + "lsst_g_true", + "lsst_r_true", } # Not adding mu1, mu2, rv since not implemented yet self._verify_catalogue_content(completed_catalog, expected_columns) assert len(completed_catalog) == len( @@ -157,7 +157,7 @@ def test_complete_catalog(self, sample_catalog_phi, stream_config_with_distance) # Verify that I can add a targeted column (e.g. dist) to the input catalog and complete the rest partial_catalog = completed_catalog.drop( - columns=["lsst_yr4_r_true", "dist", "lsst_yr4_g_true"] + columns=["lsst_r_true", "dist", "lsst_g_true"] ).reset_index(drop=True) completed_catalog = model.complete_catalog( catalog=partial_catalog, @@ -173,8 +173,8 @@ def test_complete_catalog(self, sample_catalog_phi, stream_config_with_distance) partial_catalog ), f"Completed catalog should have the same number of rows as the input catalog" assert ( - "lsst_yr4_r_true" not in completed_catalog.columns - ), "Column 'lsst_yr4_r_true' should not be added when not requested" + "lsst_r_true" not in completed_catalog.columns + ), "Column 'lsst_r_true' should not be added when not requested" # --------------------------------------------------------------------------- @@ -192,7 +192,7 @@ class TestCompleteCatalogPermutations: columns and individual NaN rows are never overwritten). """ - MAGS = {"lsst_yr4_g_true", "lsst_yr4_r_true"} + MAGS = {"lsst_g_true", "lsst_r_true"} def test_empty_frame_fills_all_model_columns(self, stream_config_with_distance): """size=N with no catalog -> geometry, dist, and both bands are filled.""" @@ -230,12 +230,12 @@ def test_existing_band_preserved_when_filling_other( """Providing one band and requesting both leaves the provided one intact.""" model = StreamModel(stream_config_with_distance) g = np.array([20.0, 21.0, 22.0]) - df = pd.DataFrame({"dist": [16.0] * 3, "lsst_yr4_g_true": g.copy()}) + df = pd.DataFrame({"dist": [16.0] * 3, "lsst_g_true": g.copy()}) out = model.complete_catalog( catalog=df, columns_to_add=list(self.MAGS), verbose=False ) - assert np.allclose(out["lsst_yr4_g_true"].to_numpy(), g), "present band overwritten" - assert out["lsst_yr4_r_true"].notna().all(), "missing band not filled" + assert np.allclose(out["lsst_g_true"].to_numpy(), g), "present band overwritten" + assert out["lsst_r_true"].notna().all(), "missing band not filled" def test_present_columns_skip_sampling(self, stream_config_with_distance): """Both bands present -> values are returned untouched.""" @@ -243,23 +243,23 @@ def test_present_columns_skip_sampling(self, stream_config_with_distance): g = np.array([20.0, 21.0]) r = np.array([19.0, 19.5]) df = pd.DataFrame( - {"dist": [16.0, 16.0], "lsst_yr4_g_true": g.copy(), "lsst_yr4_r_true": r.copy()} + {"dist": [16.0, 16.0], "lsst_g_true": g.copy(), "lsst_r_true": r.copy()} ) out = model.complete_catalog( catalog=df, columns_to_add=list(self.MAGS), verbose=False ) - assert np.allclose(out["lsst_yr4_g_true"].to_numpy(), g) - assert np.allclose(out["lsst_yr4_r_true"].to_numpy(), r) + assert np.allclose(out["lsst_g_true"].to_numpy(), g) + assert np.allclose(out["lsst_r_true"].to_numpy(), r) def test_partial_rows_only_missing_filled(self, stream_config_with_distance): """A band with some NaN rows keeps its finite rows; only NaNs are filled.""" model = StreamModel(stream_config_with_distance) g = np.array([20.0, np.nan, 22.0]) - df = pd.DataFrame({"dist": [16.0] * 3, "lsst_yr4_g_true": g.copy()}) + df = pd.DataFrame({"dist": [16.0] * 3, "lsst_g_true": g.copy()}) out = model.complete_catalog( - catalog=df, columns_to_add=["lsst_yr4_g_true"], verbose=False + catalog=df, columns_to_add=["lsst_g_true"], verbose=False ) - filled = out["lsst_yr4_g_true"].to_numpy() + filled = out["lsst_g_true"].to_numpy() assert filled[0] == 20.0 and filled[2] == 22.0, "finite rows overwritten" assert np.isfinite(filled[1]), "NaN row not filled" @@ -329,8 +329,8 @@ def test_mags_without_dist_or_phi_raises(self, minimal_stream_config): class TestIsochroneMasses: """The shared initial masses can be reused/supplied and surface as `mass`.""" - G = "lsst_yr4_g_true" - R = "lsst_yr4_r_true" + G = "lsst_g_true" + R = "lsst_r_true" def test_sample_multisurvey_returns_and_reuses_masses( self, stream_config_with_distance diff --git a/tests/test_observed.py b/tests/test_observed.py index ad67419..45d2198 100644 --- a/tests/test_observed.py +++ b/tests/test_observed.py @@ -105,8 +105,8 @@ def _verify_injected_catalog_content( expected_columns=[ "ra", "dec", - "lsst_yr4_g_true", - "lsst_yr4_r_true", + "lsst_g_true", + "lsst_r_true", "lsst_yr4_g_obs", "lsst_yr4_r_obs", "lsst_yr4_flag_observed", @@ -136,7 +136,7 @@ def test_injection_partialinput( ): """Test injection with a catalog that has some missing columns.""" data_without_mag = stream_catalog.drop( - columns=["lsst_yr4_g_true", "lsst_yr4_r_true"] + columns=["lsst_g_true", "lsst_r_true"] ) injected_catalog = mock_injector.inject( data_without_mag, @@ -249,9 +249,9 @@ def test_complete_data_single_survey(self, mock_injector, stream_config_with_dis out = mock_injector.complete_data( df, bands=["g", "r"], stream_config=stream_config_with_distance, seed=1 ) - for col in ["ra", "dec", "lsst_yr4_g_true", "lsst_yr4_r_true"]: + for col in ["ra", "dec", "lsst_g_true", "lsst_r_true"]: assert col in out.columns, f"missing {col}" - assert out[["lsst_yr4_g_true", "lsst_yr4_r_true"]].notna().all().all() + assert out[["lsst_g_true", "lsst_r_true"]].notna().all().all() # Input is not mutated (complete_data works on a copy). assert "ra" not in df.columns @@ -273,15 +273,15 @@ def test_complete_data_multisurvey( for col in [ "ra", "dec", - "lsst_yr4_g_true", - "lsst_yr4_r_true", - "lsst_yr5_g_true", - "lsst_yr5_r_true", + "lsst_g_true", + "lsst_r_true", ]: assert col in out.columns, f"missing {col}" - # Same physical star across surveys -> identical true mags. - assert np.allclose(out["lsst_yr4_g_true"], out["lsst_yr5_g_true"]) - assert np.allclose(out["lsst_yr4_r_true"], out["lsst_yr5_r_true"]) + + # Verify that we have a single column for each true magnitude, not one per survey. + assert out[["lsst_g_true", "lsst_r_true"]].notna().all().all() + + def test_bands_list_rejected_for_multisurvey(self, mock_multisurvey_injector): """A plain list of bands is ambiguous for a multi-survey injector.""" From 78053b8183e11e9c4c61745ef9fc70a89fdf59f4 Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Thu, 18 Jun 2026 15:55:04 +0200 Subject: [PATCH 18/29] move tutorial to the doc + order the surveys doc --- .../tutorial_generate_datamocks.ipynb | 970 +++++++++ .../examples/tutorial_inject_stream.ipynb | 1932 ++++++++++++++++ docs/source/index.rst | 14 +- docs/source/{ => surveys}/DES.md | 0 docs/source/{ => surveys}/LSST.md | 0 docs/source/{ => surveys}/roman.md | 0 notebooks/tutorial_generate_datamocks.ipynb | 931 -------- notebooks/tutorial_inject_stream.ipynb | 1938 ----------------- 8 files changed, 2913 insertions(+), 2872 deletions(-) create mode 100644 docs/source/examples/tutorial_generate_datamocks.ipynb create mode 100644 docs/source/examples/tutorial_inject_stream.ipynb rename docs/source/{ => surveys}/DES.md (100%) rename docs/source/{ => surveys}/LSST.md (100%) rename docs/source/{ => surveys}/roman.md (100%) delete mode 100644 notebooks/tutorial_generate_datamocks.ipynb delete mode 100644 notebooks/tutorial_inject_stream.ipynb diff --git a/docs/source/examples/tutorial_generate_datamocks.ipynb b/docs/source/examples/tutorial_generate_datamocks.ipynb new file mode 100644 index 0000000..57effa8 --- /dev/null +++ b/docs/source/examples/tutorial_generate_datamocks.ipynb @@ -0,0 +1,970 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "394f3750", + "metadata": {}, + "source": [ + "# Streamobs: generate stream mocks\n", + "\n", + "Generate stellar stream mock catalogs from configuration files and complete existing tables with missing columns.\n", + "**Streamobs** allows sampling of the following quantities:\n", + "\n", + "* (`phi1`, `phi2`): stellar coordinates in the stream frame\n", + "* `dist`: distance modulus of stars\n", + "* `{survey}_{band}`: apparent magnitude in a given photometric band of a chosen survey\n", + "\n", + "Future versions may also include sampling of proper motions and velocities.\n", + "\n", + "Streamobs can further convert these intrinsic quantities into **observed quantities**.\n", + "For more details, see the notebook *`tutorial_inject_stream.ipynb`*.\n", + "\n", + "**In this tutorial, you’ll learn to:**\n", + "\n", + "* Define model components: density, track, distance modulus, isochrone\n", + "* Build or load a configuration and sample a mock catalog\n", + "* Complete partial catalogs (e.g., by adding magnitudes)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "94d3f015", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "import pandas as pd\n", + "import yaml\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a54fd20b", + "metadata": {}, + "outputs": [], + "source": [ + "# Import necessary modules form streamobs\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "from streamobs.utils import parse_config\n", + "from streamobs.model import StreamModel" + ] + }, + { + "cell_type": "markdown", + "id": "f5492fdd", + "metadata": {}, + "source": [ + "# 1) Build a stream configuration\n", + "\n", + "To set up a stream model, we use a configuration file or dictionary that defines all necessary components. It can include:\n", + "\n", + "* **density** – samples `phi1` values along the stream\n", + "* **track** – gives `phi2` as a function of `phi1` (center + spread, using a Gaussian or Uniform sampler)\n", + "* **distance_modulus** – defines $DM(phi1)$ for computing apparent magnitudes\n", + "* **isochrone** – samples the color–magnitude diagram (required to generate magnitudes)\n", + "\n", + "You can choose how each quantity depends on `phi1` (e.g., constant, linear, spline, etc.).\n", + "\n", + "**Notes:**\n", + "\n", + "* To generate magnitudes, you need at least both `dist` and `isochrone`.\n", + "* The velocity model is currently a placeholder (returns NaN).\n", + "* Samplers and functions are selected using the `type` keyword (e.g., `\"Uniform\"`, `\"CubicSplineInterpolation\"`).\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3d2810e8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'density': {'type': 'Uniform', 'xmin': -9.0, 'xmax': 9.0}, 'track': {'center': {'type': 'Constant', 'value': 0.0}, 'spread': {'type': 'Constant', 'value': 0.2}, 'sampler': 'Gaussian'}, 'isochrone': {'name': 'Marigo2017', 'survey': 'lsst', 'age': 12.0, 'z': 0.0006, 'band_1': 'g', 'band_2': 'r', 'band_1_detection': True}, 'distance_modulus': {'center': {'type': 'Constant', 'value': 16.5}, 'spread': {'type': 'Constant', 'value': 0.0}}}\n" + ] + } + ], + "source": [ + "# Build a config dictionary directly\n", + "\n", + "config = { \n", + " # Density model\n", + " 'density': {'type': 'Uniform', 'xmin': -9.0, 'xmax': 9.0}, \n", + "\n", + " # Track model\n", + " 'track': {'center': {'type': 'Constant', 'value': 0.0}, # center line of the stream in degrees\n", + " 'spread': {'type': 'Constant', 'value': 0.2}, # spread of the stream in degrees\n", + " 'sampler': 'Gaussian'}, # how to sample across the stream\n", + "\n", + " # Isochrone model\n", + " 'isochrone': {'name': 'Marigo2017', # isochrone set name\n", + " 'survey': 'lsst', # survey for filter set\n", + " 'age': 12.0, # Age in Gyr of the population\n", + " 'z': 0.0006, # Metallicity of the population\n", + " 'band_1': 'g', # first band for color-magnitude\n", + " 'band_2': 'r', # second band for color-magnitude\n", + " 'band_1_detection': True}, \n", + "\n", + " # Distance modulus model. Here an example of a constant distance modulus\n", + " 'distance_modulus': {'center': {'type': 'Constant', 'value': 16.5}, \n", + " 'spread': {'type': 'Constant', 'value': 0.0}, \n", + " }\n", + "}\n", + "\n", + "# or load from a config file\n", + "#config_path = os.path.join(base_dir, 'config', 'toy1_config.yaml')\n", + "#config = parse_config(config_path)['stream']\n", + "\n", + "print(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e33bd732", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Generated 4500 stars\n", + "\n", + "First 5 stars:\n", + " phi1 phi2 dist mu1 mu2 rv lsst_g_true lsst_r_true \\\n", + "0 4.739512 0.015756 16.5 None None None 28.982359 27.582928 \n", + "1 -1.499554 -0.343139 16.5 None None None 27.581603 26.354772 \n", + "2 8.207016 -0.176948 16.5 None None None 26.265005 25.228614 \n", + "3 0.680482 -0.088033 16.5 None None None 27.004769 25.868177 \n", + "4 4.064195 0.077374 16.5 None None None 27.373922 26.179369 \n", + "\n", + " mass \n", + "0 0.158219 \n", + "1 0.246747 \n", + "2 0.387048 \n", + "3 0.299648 \n", + "4 0.265148 \n" + ] + } + ], + "source": [ + "# Create stream model and generate stars\n", + "stream_model = StreamModel(config)\n", + "stream_df = stream_model.sample(4500)\n", + "\n", + "# The dataframe contains: phi1, phi2, distance, magnitudes, etc.\n", + "print(f\"✓ Generated {len(stream_df)} stars\")\n", + "print(\"\\nFirst 5 stars:\")\n", + "print(stream_df.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1d7e82f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Color-Magnitude Diagram')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Quick look: sky track, 1D density, CMD\n", + "fig, ax = plt.subplots(1, 3, figsize=(16, 5))\n", + "\n", + "# Stream on the sky\n", + "ax[0].scatter(stream_df['phi1'], stream_df['phi2'], s=1, color='blue')\n", + "ax[0].set_xlabel('phi1 (deg)')\n", + "ax[0].set_ylabel('phi2 (deg)')\n", + "ax[0].set_title('Stream on the sky')\n", + "\n", + "# 1D density\n", + "ax[1].hist(stream_df['phi1'], bins=50, color='green')\n", + "ax[1].set_xlabel('phi1 (deg)')\n", + "ax[1].set_ylabel('Number of stars')\n", + "ax[1].set_title('1D Density along the stream')\n", + "\n", + "# Color-magnitude diagram\n", + "ax[2].scatter(stream_df['lsst_g_true'] - stream_df['lsst_r_true'], stream_df['lsst_g_true'], s=1, color='red')\n", + "ax[2].set_xlabel('g - r (mag)')\n", + "ax[2].set_ylabel('g (mag)')\n", + "ax[2].invert_yaxis()\n", + "ax[2].set_title('Color-Magnitude Diagram')" + ] + }, + { + "cell_type": "markdown", + "id": "168afb7e", + "metadata": {}, + "source": [ + "\n", + "## 2) Spline-based configuration\n", + "\n", + "You can model a more realistic stream shape using cubic splines, particularly for:\n", + "\n", + "* **Linear density:** $\\sqrt{2\\pi} \\times \\text{peak intensity} \\times \\text{spread}$\n", + "* **Distance modulus**\n", + "* **Track and width**\n", + "\n", + "In this example, we use data from `data/patrick_2022_splines.csv` and select `stream == 'phoenix'`.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e9da4d2a", + "metadata": {}, + "outputs": [], + "source": [ + "# Nodes and values for the spline-based stream model (from Patrick et al. 2022, for Phoenix stream)\n", + "# One may read these from a CSV file instead of hardcoding them, cf to config/atlas_spline_config.yaml\n", + "intensity_nodes = np.array([-13., -9.75, -8.125, -4.1640625, -3.25, -1.625, 1.625, 6.5, 8.125, 13.])\n", + "intensity_node_values = np.array([2.35582279e-07, 2.65789495e-02, 5.94765580e-02, 7.20106921e-02, 9.96003626e-02, 4.68656926e-02, 7.42352023e-02, 4.75688845e-06, 1.73046024e-02, 4.08879937e-08])\n", + "spread_nodes = np.array([-13. , 13.])\n", + "spread_node_values = np.array([0.0992389, 0.17083177])\n", + "center_nodes = np.array([-13., 4.33333333, 13.])\n", + "center_node_values = np.array([0.19313599, 0.07139282, 0.60245054])\n", + "distance_nodes = np.array([-13., 13.])\n", + "distance_node_values = np.array([16.38285347, 16.1136374])\n", + "\n", + "\n", + "config_spline = {\n", + " # Density model using cubic splines from CSV\n", + " 'density': {\n", + " 'type': 'lineardensitycubicsplineinterpolation',\n", + " 'intensity_nodes': intensity_nodes,\n", + " 'intensity_node_values': intensity_node_values,\n", + " 'spread_nodes': spread_nodes,\n", + " 'spread_node_values': spread_node_values,\n", + " },\n", + "\n", + " # Track model: center and spread as cubic splines\n", + " 'track': {\n", + " 'center': {'type': 'CubicSplineInterpolation', 'nodes': center_nodes, 'node_values': center_node_values},\n", + " 'spread': {'type': 'CubicSplineInterpolation', 'nodes': spread_nodes, 'node_values': spread_node_values},\n", + " },\n", + "\n", + " # Isochrone model\n", + " 'isochrone': {\n", + " 'name': 'Marigo2017',\n", + " 'survey': 'lsst',\n", + " 'age': 13.0,\n", + " 'z': 0.0004,\n", + " 'band_1': 'g',\n", + " 'band_2': 'r',\n", + " 'band_1_detection': True\n", + " },\n", + "\n", + " # Distance modulus model as a cubic spline (flat default)\n", + " 'distance_modulus': {\n", + " 'center': {'type': 'CubicSplineInterpolation', 'nodes': distance_nodes, 'node_values': distance_node_values},\n", + " 'spread': {'type': 'Constant', 'value': 0.0},\n", + " },\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "23c7702c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Generated 4000 stars with spline density\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "phi1", + "rawType": "float64", + "type": "float" + }, + { + "name": "phi2", + "rawType": "float64", + "type": "float" + }, + { + "name": "dist", + "rawType": "float64", + "type": "float" + }, + { + "name": "mu1", + "rawType": "object", + "type": "unknown" + }, + { + "name": "mu2", + "rawType": "object", + "type": "unknown" + }, + { + "name": "rv", + "rawType": "object", + "type": "unknown" + }, + { + "name": "lsst_g_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_r_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "mass", + "rawType": "float64", + "type": "float" + } + ], + "ref": "d007671a-6101-4a50-8e4e-82e0f09f1e6e", + "rows": [ + [ + "0", + "11.025280252802528", + "0.20626557354003772", + "16.13408456498815", + null, + null, + null, + "27.7644816168389", + "26.51873899940819", + "0.18983716370004305" + ], + [ + "1", + "-3.9565895658956585", + "0.14146075800342955", + "16.2892138001359", + null, + null, + null, + "28.58534409749938", + "27.239461847045433", + "0.1561991316389716" + ], + [ + "2", + "11.894468944689446", + "0.6132655443134546", + "16.12508458176822", + null, + null, + null, + "26.288612354033567", + "25.24616941488484", + "0.3151574015567824" + ], + [ + "3", + "-3.7683476834768346", + "-0.1844970196719441", + "16.287264656297666", + null, + null, + null, + "28.440218852073944", + "27.112678803317245", + "0.16279667600017295" + ], + [ + "4", + "3.0900009000089987", + "0.24731635252121673", + "16.216250131207815", + null, + null, + null, + "26.21148903281383", + "25.189500675081582", + "0.33681009618743" + ] + ], + "shape": { + "columns": 9, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
phi1phi2distmu1mu2rvlsst_g_truelsst_r_truemass
011.0252800.20626616.134085NoneNoneNone27.76448226.5187390.189837
1-3.9565900.14146116.289214NoneNoneNone28.58534427.2394620.156199
211.8944690.61326616.125085NoneNoneNone26.28861225.2461690.315157
3-3.768348-0.18449716.287265NoneNoneNone28.44021927.1126790.162797
43.0900010.24731616.216250NoneNoneNone26.21148925.1895010.336810
\n", + "
" + ], + "text/plain": [ + " phi1 phi2 dist mu1 mu2 rv lsst_g_true lsst_r_true \\\n", + "0 11.025280 0.206266 16.134085 None None None 27.764482 26.518739 \n", + "1 -3.956590 0.141461 16.289214 None None None 28.585344 27.239462 \n", + "2 11.894469 0.613266 16.125085 None None None 26.288612 25.246169 \n", + "3 -3.768348 -0.184497 16.287265 None None None 28.440219 27.112679 \n", + "4 3.090001 0.247316 16.216250 None None None 26.211489 25.189501 \n", + "\n", + " mass \n", + "0 0.189837 \n", + "1 0.156199 \n", + "2 0.315157 \n", + "3 0.162797 \n", + "4 0.336810 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Optional: sample using the spline-based config\n", + "stream_model_spline = StreamModel(config_spline)\n", + "stream_df_spline = stream_model_spline.sample(4000)\n", + "\n", + "print(f\"✓ Generated {len(stream_df_spline)} stars with spline density\")\n", + "stream_df_spline.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3cfc1b7b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Color-Magnitude Diagram')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "fig, ax = plt.subplots(1, 3, figsize=(16, 5))\n", + "\n", + "# plotting the stream on the sky \n", + "ax[0].scatter(stream_df_spline['phi1'], stream_df_spline['phi2'], s=1, color='blue', label = \"Generated stars\")\n", + "x_val = np.sort(stream_df_spline['phi1'].values)\n", + "spline_val = scipy.interpolate.CubicSpline(center_nodes, center_node_values)(x_val)\n", + "ax[0].plot(x_val, spline_val, color='orange', lw=2, label='Spline track model')\n", + "ax[0].set_xlabel('phi1 (deg)')\n", + "ax[0].set_ylabel('phi2 (deg)')\n", + "ax[0].set_title('Stream on the sky')\n", + "ax[0].legend()\n", + "\n", + "# Plotting the 1D density along the stream\n", + "ax[1].hist(stream_df_spline['phi1'], bins=50, color='green')\n", + "ax[1].set_xlabel('phi1 (deg)')\n", + "ax[1].set_ylabel('Number of stars')\n", + "ax[1].set_title('1D Density along the stream')\n", + "\n", + "# plotting Color magnitude diagram\n", + "ax[2].scatter(stream_df_spline['lsst_g_true'] - stream_df_spline['lsst_r_true'], stream_df_spline['lsst_g_true'], s=1, color='red')\n", + "ax[2].set_xlabel('g - r (mag)')\n", + "ax[2].set_ylabel('g (mag)')\n", + "ax[2].invert_yaxis()\n", + "ax[2].set_title('Color-Magnitude Diagram')\n" + ] + }, + { + "cell_type": "markdown", + "id": "f3c615f0", + "metadata": {}, + "source": [ + "# 3) Complete an existing catalog\n", + "\n", + "`StreamModel.complete_catalog` fills only the requested columns while preserving existing values (except for magnitudes and velocities, which are regenerated together for consistency).\n", + "\n", + "* **Dependencies:**\n", + "\n", + " * `phi2` and `dist` require `phi1`\n", + " * `mags` require both `dist` and `isochrone`\n", + "* **Input formats:** can be a `DataFrame`, `dict`, path to a CSV file, or `None` (with a specified `size` to generate the full catalog)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d37bb8b8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Catalog with missing columns:\n", + " phi1 phi2 mass\n", + "0 4.739512 0.015756 0.158219\n", + "1 -1.499554 -0.343139 0.246747\n", + "2 8.207016 -0.176948 0.387048\n", + "3 0.680482 -0.088033 0.299648\n", + "4 4.064195 0.077374 0.265148\n" + ] + } + ], + "source": [ + "# Let's build a catalog with missing columns to complete\n", + "# Here for example we keep only 'phi1' and 'phi2', and drop others\n", + "stream_df_sub = stream_df.drop(columns=['lsst_r_true', 'dist', 'lsst_g_true', 'mu1', 'mu2', 'rv' ]).reset_index(drop=True)\n", + "print(\"\\nCatalog with missing columns:\")\n", + "print(stream_df_sub.head())" + ] + }, + { + "cell_type": "markdown", + "id": "5050d977", + "metadata": {}, + "source": [ + "## Fill every missing columns" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7e98fa35", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Velocity model not defined; skipping velocities.\n", + "Filled 4500 dist values.\n", + "Filled ['lsst_g_true', 'lsst_r_true'] (missing rows only).\n", + " phi1 phi2 mass dist lsst_g_true lsst_r_true\n", + "0 4.739512 0.015756 0.158219 16.5 28.982359 27.582928\n", + "1 -1.499554 -0.343139 0.246747 16.5 27.581603 26.354772\n", + "2 8.207016 -0.176948 0.387048 16.5 26.265005 25.228614\n", + "3 0.680482 -0.088033 0.299648 16.5 27.004769 25.868177\n", + "4 4.064195 0.077374 0.265148 16.5 27.373922 26.179369\n" + ] + } + ], + "source": [ + "# Now we can use `complete_catalog` to fill in the missing columns amoung ['phi1', 'phi2', 'dist', 'mag_g', 'mag_r', 'mu1', 'mu2', 'rv']\n", + "completed_catalog = stream_model.complete_catalog(\n", + " catalog=stream_df_sub,\n", + " save_path=None,\n", + " inplace=False,\n", + " verbose=True\n", + ")\n", + "print(completed_catalog.head())" + ] + }, + { + "cell_type": "markdown", + "id": "c06d8f12", + "metadata": {}, + "source": [ + "## Fill only specific columns" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "16346874", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filled 4500 dist values.\n", + "Filled ['lsst_g_true', 'lsst_r_true'] (missing rows only).\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "phi1", + "rawType": "float64", + "type": "float" + }, + { + "name": "phi2", + "rawType": "float64", + "type": "float" + }, + { + "name": "mass", + "rawType": "float64", + "type": "float" + }, + { + "name": "dist", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_g_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_r_true", + "rawType": "float64", + "type": "float" + } + ], + "ref": "79b6798b-b980-4de3-8531-2a56ecd130d3", + "rows": [ + [ + "0", + "4.739512423369664", + "0.015756036881542725", + "0.15821932808348718", + "16.5", + "28.982359282612535", + "27.582928243106654" + ], + [ + "1", + "-1.4995537541860102", + "-0.34313914865180417", + "0.2467473213129864", + "16.5", + "27.58160257151765", + "26.354771943829558" + ], + [ + "2", + "8.207016077647587", + "-0.17694832788772316", + "0.3870483021720901", + "16.5", + "26.265005093492725", + "25.228613667509745" + ], + [ + "3", + "0.680482431735463", + "-0.08803296498191172", + "0.2996478341804267", + "16.5", + "27.004768617316408", + "25.86817690917701" + ], + [ + "4", + "4.064195004545283", + "0.07737374131135481", + "0.2651475187479373", + "16.5", + "27.373921684570384", + "26.17936949484345" + ] + ], + "shape": { + "columns": 6, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
phi1phi2massdistlsst_g_truelsst_r_true
04.7395120.0157560.15821916.528.98235927.582928
1-1.499554-0.3431390.24674716.527.58160326.354772
28.207016-0.1769480.38704816.526.26500525.228614
30.680482-0.0880330.29964816.527.00476925.868177
44.0641950.0773740.26514816.527.37392226.179369
\n", + "
" + ], + "text/plain": [ + " phi1 phi2 mass dist lsst_g_true lsst_r_true\n", + "0 4.739512 0.015756 0.158219 16.5 28.982359 27.582928\n", + "1 -1.499554 -0.343139 0.246747 16.5 27.581603 26.354772\n", + "2 8.207016 -0.176948 0.387048 16.5 26.265005 25.228614\n", + "3 0.680482 -0.088033 0.299648 16.5 27.004769 25.868177\n", + "4 4.064195 0.077374 0.265148 16.5 27.373922 26.179369" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Example: fill only magnitudes\n", + "subset = stream_df_sub.copy()\n", + "completed_mags = stream_model.complete_catalog(\n", + " catalog=subset,\n", + " columns_to_add=[\"lsst_g_true\", \"lsst_r_true\"],\n", + " inplace=False,\n", + " verbose=True,\n", + ")\n", + "completed_mags.head()" + ] + }, + { + "cell_type": "markdown", + "id": "c1b81722", + "metadata": {}, + "source": [ + "*Note: the distance modulus is also added, since it is needed to convert absolute magnitude sampled from the isochrone, to apparent magnitudes (`mag_g`and `mag_r` here).*" + ] + }, + { + "cell_type": "markdown", + "id": "e4cd4bc5", + "metadata": {}, + "source": [ + "## Tips and Troubleshooting\n", + "\n", + "* If magnitudes are missing or NaN, make sure your config includes both `distance_modulus` and `isochrone` sections.\n", + "* To keep colors consistent, `complete_catalog` regenerates both `mag_g` and `mag_r` whenever one needs to be computed.\n", + "* Column names are automatically standardized (e.g., `'g_mag'` → `'mag_g'`); see `_standardize_columns_name`.\n", + "* The velocity model is currently a placeholder and returns NaN values." + ] + }, + { + "cell_type": "markdown", + "id": "ad8600ce", + "metadata": {}, + "source": [ + "# Conclusion\n", + "\n", + "Streamobs provides a flexible framework to build and complete stellar stream mock catalogs, from simple analytic models to spline-based configurations.\n", + "Future updates will include proper motions, velocities, and improved documentation for easier user adoption.\n", + "\n", + "You can find more informations in the [full documentation](https://lsstdesc.github.io/streamobs/)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "streamsim_dev", + "language": "python", + "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.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/examples/tutorial_inject_stream.ipynb b/docs/source/examples/tutorial_inject_stream.ipynb new file mode 100644 index 0000000..9d61350 --- /dev/null +++ b/docs/source/examples/tutorial_inject_stream.ipynb @@ -0,0 +1,1932 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ef83a9a9", + "metadata": {}, + "source": [ + "# Injecting stream mocks into a survey\n", + "\n", + "This short tutorial shows how to:\n", + "- Load a survey (e.g., LSST yr5) and inspect completeness/error models\n", + "- Create a `StreamInjector` and inject photometric effects + detection flags\n", + "- Plot against the footprint and visualize injected magnitudes\n", + "\n", + "This is useful for people who want to convert their dynamical simulation results into realistic survey data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9b899efa", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "import pandas as pd\n", + "import yaml\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cf16899f", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "from streamobs import surveys, observed\n", + "from streamobs.model import StreamModel" + ] + }, + { + "cell_type": "markdown", + "id": "17059e52", + "metadata": {}, + "source": [ + "## 1) Load the survey (cached)\n", + "We load LSST yr5 once; the data is cached for efficiency (bands, depth maps, extinction, completeness, and photometric error models)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "27cdcd2b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading survey data for 'lsst_yr4'...\n", + " Loading config from: lsst_yr4.yaml\n", + "\n", + "======================================================================\n", + "LOADING SURVEY DATA FILES\n", + "======================================================================\n", + "Survey data directory: /Users/pelissier/Documents/Codes/packages/streamobs/streamobs/../data/surveys/lsst_yr4\n", + "\n", + "Fallback directory for shared data files: /Users/pelissier/Documents/Codes/packages/streamobs/streamobs/../data/others\n", + "\n", + "Available bands: g, i, r, u, y, z\n", + "\n", + "\n", + "Loading survey properties...\n", + "Loading magnitude limit maps...\n", + " ✓ Success for g-band magnitude limit\n", + " ⚠ Warning: 'maglim_map_i' not specified in config (skipping i-band)\n", + " ✓ Success for r-band magnitude limit\n", + " ⚠ Warning: 'maglim_map_u' not specified in config (skipping u-band)\n", + " ⚠ Warning: 'maglim_map_y' not specified in config (skipping y-band)\n", + " ⚠ Warning: 'maglim_map_z' not specified in config (skipping z-band)\n", + "\n", + "Loading completeness/efficiency function...\n", + " Loading Completeness/efficiency function...\n", + " File: lsst_stellar_efficiency_cutr.csv\n", + " ✓ Success\n", + " Loading Detection efficiency function...\n", + " File: lsst_stellar_efficiency_cutr.csv\n", + " ✓ Success\n", + " Loading Classification efficiency function...\n", + " File: lsst_stellar_efficiency_cutr.csv\n", + " ✓ Success\n", + "\n", + "Loading photometric error model...\n", + " Loading Photometric error model (catalog / reported)...\n", + " File: lsst_photoerror_r.csv\n", + " ✓ Success\n", + "\n", + "Loading band-independent maps...\n", + " Loading E(B-V) extinction map...\n", + " File: ebv_sfd98_lowres_nside_512_ring_equatorial.fits\n", + " ✓ Success\n", + " ⚠ Warning: 'coverage' not specified in config (skipping)\n", + "\n", + "Building coverage map from magnitude limit maps...\n", + " ✓ Built coverage map (nside=128, 133236 pixels covered)\n", + "\n", + "Survey properties summary:\n", + " g-band:\n", + " Extinction coefficient: 3.661\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " i-band:\n", + " Extinction coefficient: 2.054\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " r-band:\n", + " Extinction coefficient: 2.701\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " u-band:\n", + " Extinction coefficient: 4.757\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " y-band:\n", + " Extinction coefficient: 1.308\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " z-band:\n", + " Extinction coefficient: 1.590\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + "\n", + "======================================================================\n", + "SURVEY DATA LOADED SUCCESSFULLY\n", + "======================================================================\n", + "\n", + "✓ Survey 'lsst_yr4' loaded and cached successfully\n" + ] + } + ], + "source": [ + "lsst_yr4= surveys.Survey.load(survey = 'lsst', release='yr4')" + ] + }, + { + "cell_type": "markdown", + "id": "42801958", + "metadata": {}, + "source": [ + "### Completeness and photometric error\n", + "Both depend on magnitude relative to the local limit (delta_mag = mag - maglim). We can visualize them for the r-band at a chosen magnitude limit." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9b85555b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mag_r_test = np.linspace(15,31, 1000)\n", + "maglim_r_dc2 = 26.8\n", + "completeness_val = lsst_yr4.get_completeness('r', mag_r_test, maglim_r_dc2)\n", + "mag_error_val = lsst_yr4.get_photo_error('r', mag_r_test, maglim_r_dc2)\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(12, 5))\n", + "ax[0].plot(mag_r_test, completeness_val, label='Completeness')\n", + "ax[0].axvline(maglim_r_dc2, color='red', linestyle='--', label='Magnitude Limit')\n", + "ax[0].set_xlabel('Apparent r-band magnitude')\n", + "ax[0].set_ylabel('Completeness')\n", + "ax[0].set_title('LSST DC2 Completeness Function')\n", + "ax[0].grid()\n", + "ax[0].legend() \n", + "\n", + "ax[1].plot(mag_r_test, mag_error_val, label='Photometric Error', color='orange')\n", + "ax[1].axvline(maglim_r_dc2, color='red', linestyle='--', label='Magnitude Limit')\n", + "ax[1].set_yscale('log')\n", + "ax[1].set_xlabel('Apparent r-band magnitude')\n", + "ax[1].set_ylabel('Photometric Error (mag)')\n", + "ax[1].set_title('LSST DC2 Photometric Error Model')\n", + "ax[1].grid()\n", + "ax[1].legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "23ed125c", + "metadata": {}, + "source": [ + "### Cache manipulation\n", + "Once a survey has been loaded, it's stored in the cache. You can use commands to check which surveys are stored.\n", + "To force reloading of a survey, you must clear the cache first." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fd3a37c5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Using cached survey data for 'lsst_yr4'\n", + "Current cache content: ['lsst_yr4']\n", + "✓ Cleared cached survey 'lsst_yr4'\n", + "Cache content after clearing 'lsst': []\n" + ] + } + ], + "source": [ + "# Once a survey has been loaded once, it can be reused directly from the cache\n", + "lsst_yr4 = surveys.Survey.load(survey = 'lsst', release='yr4') # reuses the cached survey object\n", + "\n", + "# Check the cache content\n", + "\n", + "print(\"Current cache content: \", surveys.SurveyFactory.list_cached_surveys())\n", + "\n", + "surveys.SurveyFactory.clear_cache(survey = 'lsst', release='yr4')\n", + "# surveys.SurveyFactory.clear_cache(survey = 'lsst') # to clear all releases of 'lsst'\n", + "# surveys.SurveyFactory.clear_cache() # to clear the entire cache\n", + "print(\"Cache content after clearing 'lsst': \", surveys.SurveyFactory.list_cached_surveys())" + ] + }, + { + "cell_type": "markdown", + "id": "ba80c280", + "metadata": {}, + "source": [ + "## 2) Create an injector\n", + "The `StreamInjector` class wraps Survey objects and uses their properties to inject observational effects into a dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6fd1866e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading survey data for 'lsst_yr4'...\n", + " Loading config from: lsst_yr4.yaml\n", + "\n", + "======================================================================\n", + "LOADING SURVEY DATA FILES\n", + "======================================================================\n", + "Survey data directory: /Users/pelissier/Documents/Codes/packages/streamobs/streamobs/../data/surveys/lsst_yr4\n", + "\n", + "Fallback directory for shared data files: /Users/pelissier/Documents/Codes/packages/streamobs/streamobs/../data/others\n", + "\n", + "Available bands: g, i, r, u, y, z\n", + "\n", + "\n", + "Loading survey properties...\n", + "Loading magnitude limit maps...\n", + " ✓ Success for g-band magnitude limit\n", + " ⚠ Warning: 'maglim_map_i' not specified in config (skipping i-band)\n", + " ✓ Success for r-band magnitude limit\n", + " ⚠ Warning: 'maglim_map_u' not specified in config (skipping u-band)\n", + " ⚠ Warning: 'maglim_map_y' not specified in config (skipping y-band)\n", + " ⚠ Warning: 'maglim_map_z' not specified in config (skipping z-band)\n", + "\n", + "Loading completeness/efficiency function...\n", + " Loading Completeness/efficiency function...\n", + " File: lsst_stellar_efficiency_cutr.csv\n", + " ✓ Success\n", + " Loading Detection efficiency function...\n", + " File: lsst_stellar_efficiency_cutr.csv\n", + " ✓ Success\n", + " Loading Classification efficiency function...\n", + " File: lsst_stellar_efficiency_cutr.csv\n", + " ✓ Success\n", + "\n", + "Loading photometric error model...\n", + " Loading Photometric error model (catalog / reported)...\n", + " File: lsst_photoerror_r.csv\n", + " ✓ Success\n", + "\n", + "Loading band-independent maps...\n", + " Loading E(B-V) extinction map...\n", + " File: ebv_sfd98_lowres_nside_512_ring_equatorial.fits\n", + " ✓ Success\n", + " ⚠ Warning: 'coverage' not specified in config (skipping)\n", + "\n", + "Building coverage map from magnitude limit maps...\n", + " ✓ Built coverage map (nside=128, 133236 pixels covered)\n", + "\n", + "Survey properties summary:\n", + " g-band:\n", + " Extinction coefficient: 3.661\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " i-band:\n", + " Extinction coefficient: 2.054\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " r-band:\n", + " Extinction coefficient: 2.701\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " u-band:\n", + " Extinction coefficient: 4.757\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " y-band:\n", + " Extinction coefficient: 1.308\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + " z-band:\n", + " Extinction coefficient: 1.590\n", + " Saturation limit: 16.0 mag\n", + " Systematic error: 0.0050 mag\n", + "\n", + "======================================================================\n", + "SURVEY DATA LOADED SUCCESSFULLY\n", + "======================================================================\n", + "\n", + "✓ Survey 'lsst_yr4' loaded and cached successfully\n" + ] + } + ], + "source": [ + "# Create an injector using the Survey object\n", + "stream_injector = observed.StreamInjector(lsst_yr4)\n", + "\n", + "# Or using survey name and release (this will create the survey object internally)\n", + "stream_injector = observed.StreamInjector(survey=\"lsst\", release=\"yr4\")" + ] + }, + { + "cell_type": "markdown", + "id": "8b2a38b7", + "metadata": {}, + "source": [ + "## 3) Inject different dataset types\n", + "\n", + "To convert a stream catalog into realistic survey data, you need:\n", + "- Sky coordinates (ra, dec)\n", + "- True apparent magnitudes of the stars\n", + "\n", + "However, **Streamobs** can **automatically sample these quantities** if they're missing, allowing incomplete datasets to be converted into realistic survey data.\n", + "\n", + "Streamobs uses the magnitude limit at each star's location to estimate:\n", + "- The photometric error\n", + "- The observed magnitude\n", + "- Whether the object is detected and classified as a star\n", + "\n", + "The output of the `inject()` method is a DataFrame containing:\n", + "\n", + "- `ra`, `dec`: positions of the stream's stars on the sky\n", + "- `mag_{band}`: true apparent magnitude in a given band\n", + "- `mag_{band}_obs`: observed magnitude in a given band\n", + "- `magerr_{band}`: photometric error on the observed magnitude (in mag). Includes both systematic and statistical errors.\n", + "- `flag_observed`: 1 if the star has been detected by the survey and classified as a star. By default includes an SNR cut (SNR = 1/magerr > 5) in g and r bands.\n", + "\n", + "The output can optionally include:\n", + "- `phi1`, `phi2`: position of stars in the stream frame\n", + "- `dist`: distance modulus of the stars" + ] + }, + { + "cell_type": "markdown", + "id": "914ce4ec", + "metadata": {}, + "source": [ + "### Dataset with only (phi1, phi2) coordinates\n", + "\n", + "If you only provide stream coordinates, Streamobs will:\n", + "\n", + "**1. Sample apparent magnitudes:**\n", + "\n", + "This is done using an isochrone and distance modulus model, which must be provided in a configuration dictionary. See `tutorial_generate_datamocks.ipynb` for more details.\n", + "\n", + "**2. Convert (phi1, phi2) → (ra, dec):**\n", + "\n", + "If you don't provide (ra, dec) columns, Streamobs will randomly place the stream on the sky. You can restrict the placement using the `mask_type` argument to ensure the stream falls within:\n", + "- The survey's footprint\n", + "- Regions with low dust extinction\n", + "- Areas meeting a minimum magnitude limit in a given band\n", + "- Any combination of the above\n", + "\n", + "Streamobs searches uniformly across the sky for a reference frame where a specified fraction of the stream (`percentile_threshold`) lies inside the mask. For more details, see the documentation of the `StreamInjector._find_gc_frame()` method.\n", + "\n", + "Alternatively, you can provide your own `gala.coordinates.GreatCircleICRSFrame` object via the `gc_frame` argument." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ed0abceb", + "metadata": {}, + "outputs": [], + "source": [ + "N = 1000\n", + "seed = 42\n", + "\n", + "rng = np.random.default_rng(seed)\n", + "\n", + "# Replace with your actual data\n", + "data_test = pd.DataFrame({\n", + " 'phi1': rng.uniform(-5, 5, N),\n", + " 'phi2': rng.uniform(-1, 1, N),\n", + "})\n", + "\n", + "\n", + "# Since our data set does not have magnitudes, we need to provide an isochrone and distance model \n", + "# - cf tutorial_generate_datamocks.ipynb\n", + "# This step can be skipped if the input data already has magnitudes in the desired bands\n", + "\n", + "isochrone_config = {'isochrone':{'name': 'Marigo2017', # isochrone set name\n", + " 'survey': 'lsst', # survey for filter set\n", + " 'age': 12.0, # Age in Gyr of the population\n", + " 'z': 0.0006, # Metallicity of the population\n", + " 'band_1': 'g', # first band for color-magnitude\n", + " 'band_2': 'r', # second band for color-magnitude\n", + " 'band_1_detection': True},\n", + "}\n", + "\n", + "distance_modulus_config = {'distance_modulus': {'center': {'type': 'Constant', 'value': 16.5}, \n", + " 'spread': {'type': 'Constant', 'value': 0.0}, \n", + " }}\n", + "\n", + "stream_config = {**isochrone_config, **distance_modulus_config}" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cf4994dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filled 1000 dist values.\n", + "Filled ['lsst_g_true', 'lsst_r_true'] (missing rows only).\n", + "Building new mask for ['ebv', 'footprint']...\n", + " Resampling ebv from nside=512 to nside=128\n", + "✓ Mask created: valid pixels fraction = 0.5\n", + " Cached with key: ('lsst', ('ebv', 'footprint'), 0.2)\n", + "Found suitable great circle frame after 2 trials with 100.00% points inside the mask.\n", + "Applying dust correction for r-band on observed magnitudes.\n", + "Applying dust correction for g-band on observed magnitudes.\n", + "Applying detection cut on g-band with SNR >= 5.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n", + "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n" + ] + } + ], + "source": [ + "mask_type = ['footprint', 'ebv'] # Restrict to survey footprint and apply extinction mask\n", + "\n", + "# By default the bands used for detection are (g and r)\n", + "# You can also add perfect_galstarsep=True to get bolean flag related to\n", + "# detection only (no classification).\n", + "injected_data_full = stream_injector.inject(data_test, seed=seed, mask_type=mask_type, stream_config=stream_config, verbose=True, perfect_galstarsep=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4b064c1f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['phi1', 'phi2', 'dist', 'lsst_g_true', 'lsst_r_true', 'ra', 'dec',\n", + " 'lsst_yr4_r_obs', 'lsst_yr4_r_err', 'lsst_yr4_g_obs', 'lsst_yr4_g_err',\n", + " 'lsst_yr4_flag_observed', 'lsst_yr4_flag_perfect_galstarsep'],\n", + " dtype='object')\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "phi1", + "rawType": "float64", + "type": "float" + }, + { + "name": "phi2", + "rawType": "float64", + "type": "float" + }, + { + "name": "dist", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_g_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_r_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "ra", + "rawType": "float64", + "type": "float" + }, + { + "name": "dec", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_r_obs", + "rawType": "object", + "type": "unknown" + }, + { + "name": "lsst_yr4_r_err", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_g_obs", + "rawType": "object", + "type": "unknown" + }, + { + "name": "lsst_yr4_g_err", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_flag_observed", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "lsst_yr4_flag_perfect_galstarsep", + "rawType": "bool", + "type": "boolean" + } + ], + "ref": "16ac805e-0469-44d4-b956-a36067ee93cb", + "rows": [ + [ + "0", + "2.7395604855596334", + "-0.8758737869196895", + "16.5", + "30.303280724323006", + "28.747044825349548", + "309.2953942380719", + "-10.749590498519837", + "27.94450115002072", + "2.839884927096569", + "27.617721407305552", + "10.000001249999922", + "False", + "False" + ], + [ + "1", + "-0.6112156024794768", + "-0.0834759169269721", + "16.5", + "29.728132639588573", + "28.23706116860197", + "310.2683786555398", + "-14.058956233016271", + "27.607723876818635", + "1.4081374219582061", + "28.5689654329395", + "10.000001249999922", + "False", + "False" + ], + [ + "2", + "3.5859791991138246", + "-0.7419398856359165", + "16.5", + "28.225967217524378", + "26.90261977410061", + "308.7572935618984", + "-10.07569919353105", + "26.892840518625263", + "0.3412351245318386", + "28.8451710606833", + "1.3184116118589486", + "False", + "False" + ], + [ + "3", + "1.973680290593639", + "-0.6953465796848486", + "16.5", + "29.38559718605284", + "27.93565790812836", + "309.51600359134665", + "-11.50602746286123", + "BAD_MAG", + "1.0610851133467605", + "26.72698260587372", + "10.000001249999922", + "False", + "False" + ], + [ + "4", + "-4.058226521123505", + "0.26456562606042033", + "16.5", + "28.29109171685917", + "26.960775009646518", + "311.7243037291042", + "-17.22723336556269", + "26.483796611811186", + "0.40904825757417285", + "27.505772836877462", + "1.9325848090410778", + "False", + "False" + ] + ], + "shape": { + "columns": 13, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
phi1phi2distlsst_g_truelsst_r_trueradeclsst_yr4_r_obslsst_yr4_r_errlsst_yr4_g_obslsst_yr4_g_errlsst_yr4_flag_observedlsst_yr4_flag_perfect_galstarsep
02.739560-0.87587416.530.30328128.747045309.295394-10.74959027.9445012.83988527.61772110.000001FalseFalse
1-0.611216-0.08347616.529.72813328.237061310.268379-14.05895627.6077241.40813728.56896510.000001FalseFalse
23.585979-0.74194016.528.22596726.902620308.757294-10.07569926.8928410.34123528.8451711.318412FalseFalse
31.973680-0.69534716.529.38559727.935658309.516004-11.506027BAD_MAG1.06108526.72698310.000001FalseFalse
4-4.0582270.26456616.528.29109226.960775311.724304-17.22723326.4837970.40904827.5057731.932585FalseFalse
\n", + "
" + ], + "text/plain": [ + " phi1 phi2 dist lsst_g_true lsst_r_true ra dec \\\n", + "0 2.739560 -0.875874 16.5 30.303281 28.747045 309.295394 -10.749590 \n", + "1 -0.611216 -0.083476 16.5 29.728133 28.237061 310.268379 -14.058956 \n", + "2 3.585979 -0.741940 16.5 28.225967 26.902620 308.757294 -10.075699 \n", + "3 1.973680 -0.695347 16.5 29.385597 27.935658 309.516004 -11.506027 \n", + "4 -4.058227 0.264566 16.5 28.291092 26.960775 311.724304 -17.227233 \n", + "\n", + " lsst_yr4_r_obs lsst_yr4_r_err lsst_yr4_g_obs lsst_yr4_g_err \\\n", + "0 27.944501 2.839885 27.617721 10.000001 \n", + "1 27.607724 1.408137 28.568965 10.000001 \n", + "2 26.892841 0.341235 28.845171 1.318412 \n", + "3 BAD_MAG 1.061085 26.726983 10.000001 \n", + "4 26.483797 0.409048 27.505773 1.932585 \n", + "\n", + " lsst_yr4_flag_observed lsst_yr4_flag_perfect_galstarsep \n", + "0 False False \n", + "1 False False \n", + "2 False False \n", + "3 False False \n", + "4 False False " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(injected_data_full.columns)\n", + "injected_data_full.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a45cb263", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "160 stars detected out of 1000\n", + "160 stars classified as stars out of 1000\n" + ] + } + ], + "source": [ + "# If you want to work only with detected and classified stars\n", + "detected_data = injected_data_full[injected_data_full['lsst_yr4_flag_observed']]\n", + "print(len(detected_data), \"stars detected out of\", len(injected_data_full))\n", + "\n", + "# When applying the perfect galstar separation, all detected stars are\n", + "# classified as stars, so we have:\n", + "classified_data = injected_data_full[injected_data_full['lsst_yr4_flag_observed']]\n", + "print(len(classified_data), \"stars classified as stars out of\", len(injected_data_full))" + ] + }, + { + "cell_type": "markdown", + "id": "7b973847", + "metadata": {}, + "source": [ + "Streamobs has automatically sampled the missing columns (positions and apparent magnitudes) and estimated observational quantities.\n", + "\n", + "You can verify the injection behavior with some useful plots:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b8b2a9e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the injected stream in the survey mask\n", + "stream_injector.plot_stream_in_mask(injected_data_full, mask_type=mask_type)" + ] + }, + { + "cell_type": "markdown", + "id": "a58b7a71", + "metadata": {}, + "source": [ + "The stream lies entirely within the chosen mask." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "8d27ae09", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from streamobs.plotting import plot_inject\n", + "\n", + "# Plot results\n", + "fig, ax = plot_inject(injected_data_full, lsst_yr4, bands=['g', 'r'], save=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "67f7a59f", + "metadata": {}, + "source": [ + "### Dataset containing (ra, dec) coordinates and distance modulus\n", + "\n", + "Streamobs only needs to sample the missing magnitudes, so you must provide a configuration dictionary for the isochrone model." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b9520ac9", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "dist", + "rawType": "float64", + "type": "float" + }, + { + "name": "ra", + "rawType": "float64", + "type": "float" + }, + { + "name": "dec", + "rawType": "float64", + "type": "float" + } + ], + "ref": "723058b4-3dd6-4dd8-9ed8-e27548aad589", + "rows": [ + [ + "0", + "16.5", + "309.2953942380719", + "-10.749590498519837" + ], + [ + "1", + "16.5", + "310.2683786555398", + "-14.058956233016271" + ], + [ + "2", + "16.5", + "308.7572935618984", + "-10.07569919353105" + ], + [ + "3", + "16.5", + "309.51600359134665", + "-11.50602746286123" + ], + [ + "4", + "16.5", + "311.7243037291042", + "-17.22723336556269" + ] + ], + "shape": { + "columns": 3, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
distradec
016.5309.295394-10.749590
116.5310.268379-14.058956
216.5308.757294-10.075699
316.5309.516004-11.506027
416.5311.724304-17.227233
\n", + "
" + ], + "text/plain": [ + " dist ra dec\n", + "0 16.5 309.295394 -10.749590\n", + "1 16.5 310.268379 -14.058956\n", + "2 16.5 308.757294 -10.075699\n", + "3 16.5 309.516004 -11.506027\n", + "4 16.5 311.724304 -17.227233" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let's build a data set containing only (ra, dec) coordinates\n", + "data_set_radec = injected_data_full.drop(columns=[col for col in injected_data_full.columns if col not in ['ra', 'dec', 'dist']])\n", + "data_set_radec.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8dcef84a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance modulus model not defined; skipping distances.\n", + "Filled ['lsst_g_true', 'lsst_r_true'] (missing rows only).\n", + "Applying dust correction for r-band on observed magnitudes.\n", + "Applying dust correction for g-band on observed magnitudes.\n", + "Applying detection cut on g-band with SNR >= 5.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n", + "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "dist", + "rawType": "float64", + "type": "float" + }, + { + "name": "ra", + "rawType": "float64", + "type": "float" + }, + { + "name": "dec", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_g_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_r_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_r_obs", + "rawType": "object", + "type": "unknown" + }, + { + "name": "lsst_yr4_r_err", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_g_obs", + "rawType": "object", + "type": "unknown" + }, + { + "name": "lsst_yr4_g_err", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_flag_observed", + "rawType": "bool", + "type": "boolean" + } + ], + "ref": "8826e32e-e1e6-43c6-adca-911ec967c02f", + "rows": [ + [ + "0", + "16.5", + "309.2953942380719", + "-10.749590498519837", + "22.307506629159345", + "21.958447547282443", + "21.95570880527", + "0.006555110409349731", + "22.315016874806194", + "0.007064702039654374", + "True" + ], + [ + "1", + "16.5", + "310.2683786555398", + "-14.058956233016271", + "31.24638120357998", + "29.588484390590427", + "27.54332178290005", + "10.000001249999922", + "30.05040478123035", + "10.000001249999922", + "False" + ], + [ + "2", + "16.5", + "308.7572935618984", + "-10.07569919353105", + "28.129791646241713", + "26.820849958858858", + "26.81159920708018", + "0.322714968027792", + "28.015568670315044", + "1.148001045000444", + "False" + ], + [ + "3", + "16.5", + "309.51600359134665", + "-11.50602746286123", + "29.071967670345582", + "27.66131258227355", + "29.617694290417134", + "0.8361615683575233", + "28.525325873069807", + "4.297743130499477", + "False" + ], + [ + "4", + "16.5", + "311.7243037291042", + "-17.22723336556269", + "30.19232787401504", + "28.648052066699986", + "26.83668353341164", + "3.1909560196197595", + "26.780332948411118", + "10.000001249999922", + "False" + ] + ], + "shape": { + "columns": 10, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
distradeclsst_g_truelsst_r_truelsst_yr4_r_obslsst_yr4_r_errlsst_yr4_g_obslsst_yr4_g_errlsst_yr4_flag_observed
016.5309.295394-10.74959022.30750721.95844821.9557090.00655522.3150170.007065True
116.5310.268379-14.05895631.24638129.58848427.54332210.00000130.05040510.000001False
216.5308.757294-10.07569928.12979226.82085026.8115990.32271528.0155691.148001False
316.5309.516004-11.50602729.07196827.66131329.6176940.83616228.5253264.297743False
416.5311.724304-17.22723330.19232828.64805226.8366843.19095626.78033310.000001False
\n", + "
" + ], + "text/plain": [ + " dist ra dec lsst_g_true lsst_r_true lsst_yr4_r_obs \\\n", + "0 16.5 309.295394 -10.749590 22.307507 21.958448 21.955709 \n", + "1 16.5 310.268379 -14.058956 31.246381 29.588484 27.543322 \n", + "2 16.5 308.757294 -10.075699 28.129792 26.820850 26.811599 \n", + "3 16.5 309.516004 -11.506027 29.071968 27.661313 29.617694 \n", + "4 16.5 311.724304 -17.227233 30.192328 28.648052 26.836684 \n", + "\n", + " lsst_yr4_r_err lsst_yr4_g_obs lsst_yr4_g_err lsst_yr4_flag_observed \n", + "0 0.006555 22.315017 0.007065 True \n", + "1 10.000001 30.050405 10.000001 False \n", + "2 0.322715 28.015569 1.148001 False \n", + "3 0.836162 28.525326 4.297743 False \n", + "4 3.190956 26.780333 10.000001 False " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "injected_data = stream_injector.inject(data_set_radec, seed=seed, mask_type=None, stream_config=isochrone_config, verbose=True)\n", + "injected_data.head()" + ] + }, + { + "cell_type": "markdown", + "id": "b967882a", + "metadata": {}, + "source": [ + "### Dataset containing (ra, dec) and true apparent magnitudes\n", + "\n", + "The dataset already contains all the required quantities, so you don't need to provide a configuration dictionary or mask type." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ee217a87", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "lsst_g_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_r_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "ra", + "rawType": "float64", + "type": "float" + }, + { + "name": "dec", + "rawType": "float64", + "type": "float" + } + ], + "ref": "1aedcd3a-566a-4001-94b7-813e35a10c0e", + "rows": [ + [ + "0", + "30.303280724323006", + "28.747044825349548", + "309.2953942380719", + "-10.749590498519837" + ], + [ + "1", + "29.728132639588573", + "28.23706116860197", + "310.2683786555398", + "-14.058956233016271" + ], + [ + "2", + "28.225967217524378", + "26.90261977410061", + "308.7572935618984", + "-10.07569919353105" + ], + [ + "3", + "29.38559718605284", + "27.93565790812836", + "309.51600359134665", + "-11.50602746286123" + ], + [ + "4", + "28.29109171685917", + "26.960775009646518", + "311.7243037291042", + "-17.22723336556269" + ] + ], + "shape": { + "columns": 4, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lsst_g_truelsst_r_trueradec
030.30328128.747045309.295394-10.749590
129.72813328.237061310.268379-14.058956
228.22596726.902620308.757294-10.075699
329.38559727.935658309.516004-11.506027
428.29109226.960775311.724304-17.227233
\n", + "
" + ], + "text/plain": [ + " lsst_g_true lsst_r_true ra dec\n", + "0 30.303281 28.747045 309.295394 -10.749590\n", + "1 29.728133 28.237061 310.268379 -14.058956\n", + "2 28.225967 26.902620 308.757294 -10.075699\n", + "3 29.385597 27.935658 309.516004 -11.506027\n", + "4 28.291092 26.960775 311.724304 -17.227233" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let's build a dataset containing (ra, dec) coordinates and magnitudes\n", + "data_set_radecmag = injected_data_full.drop(columns=[col for col in injected_data_full.columns if col not in ['ra', 'dec', 'lsst_g_true', 'lsst_r_true']])\n", + "data_set_radecmag.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4d0dbbe1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Applying dust correction for r-band on observed magnitudes.\n", + "Applying dust correction for g-band on observed magnitudes.\n", + "Applying detection cut on g-band with SNR >= 5.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n", + "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "lsst_g_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_r_true", + "rawType": "float64", + "type": "float" + }, + { + "name": "ra", + "rawType": "float64", + "type": "float" + }, + { + "name": "dec", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_r_obs", + "rawType": "object", + "type": "unknown" + }, + { + "name": "lsst_yr4_r_err", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_g_obs", + "rawType": "object", + "type": "unknown" + }, + { + "name": "lsst_yr4_g_err", + "rawType": "float64", + "type": "float" + }, + { + "name": "lsst_yr4_flag_observed", + "rawType": "bool", + "type": "boolean" + } + ], + "ref": "34356f28-8110-4141-8ae1-7776ef3a209b", + "rows": [ + [ + "0", + "30.303280724323006", + "28.747044825349548", + "309.2953942380719", + "-10.749590498519837", + "27.94450115002072", + "2.839884927096569", + "BAD_MAG", + "10.000001249999922", + "False" + ], + [ + "1", + "29.728132639588573", + "28.23706116860197", + "310.2683786555398", + "-14.058956233016271", + "27.607723876818635", + "1.4081374219582061", + "28.532156217238942", + "10.000001249999922", + "False" + ], + [ + "2", + "28.225967217524378", + "26.90261977410061", + "308.7572935618984", + "-10.07569919353105", + "26.892840518625263", + "0.3412351245318386", + "28.0957683802766", + "1.3184116118589486", + "False" + ], + [ + "3", + "29.38559718605284", + "27.93565790812836", + "309.51600359134665", + "-11.50602746286123", + "BAD_MAG", + "1.0610851133467605", + "28.380888666489522", + "10.000001249999922", + "False" + ], + [ + "4", + "28.29109171685917", + "26.960775009646518", + "311.7243037291042", + "-17.22723336556269", + "26.483796611811186", + "0.40904825757417285", + "26.483845022977533", + "1.9325848090410778", + "False" + ] + ], + "shape": { + "columns": 9, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lsst_g_truelsst_r_trueradeclsst_yr4_r_obslsst_yr4_r_errlsst_yr4_g_obslsst_yr4_g_errlsst_yr4_flag_observed
030.30328128.747045309.295394-10.74959027.9445012.839885BAD_MAG10.000001False
129.72813328.237061310.268379-14.05895627.6077241.40813728.53215610.000001False
228.22596726.902620308.757294-10.07569926.8928410.34123528.0957681.318412False
329.38559727.935658309.516004-11.506027BAD_MAG1.06108528.38088910.000001False
428.29109226.960775311.724304-17.22723326.4837970.40904826.4838451.932585False
\n", + "
" + ], + "text/plain": [ + " lsst_g_true lsst_r_true ra dec lsst_yr4_r_obs \\\n", + "0 30.303281 28.747045 309.295394 -10.749590 27.944501 \n", + "1 29.728133 28.237061 310.268379 -14.058956 27.607724 \n", + "2 28.225967 26.902620 308.757294 -10.075699 26.892841 \n", + "3 29.385597 27.935658 309.516004 -11.506027 BAD_MAG \n", + "4 28.291092 26.960775 311.724304 -17.227233 26.483797 \n", + "\n", + " lsst_yr4_r_err lsst_yr4_g_obs lsst_yr4_g_err lsst_yr4_flag_observed \n", + "0 2.839885 BAD_MAG 10.000001 False \n", + "1 1.408137 28.532156 10.000001 False \n", + "2 0.341235 28.095768 1.318412 False \n", + "3 1.061085 28.380889 10.000001 False \n", + "4 0.409048 26.483845 1.932585 False " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "injected_data = stream_injector.inject(data_set_radecmag, seed=seed, mask_type=None, stream_config=None, verbose=True)\n", + "injected_data.head()" + ] + }, + { + "cell_type": "markdown", + "id": "f7bd2b3a", + "metadata": {}, + "source": [ + "## 4) Usage example\n", + "\n", + "This can be useful for comparing analysis results between the ideal case of dynamic simulations and the more realistic case of observed data.\n", + "\n", + "For example, we can calculate the 1D density along the stream and its power spectrum." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c3d933ce", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_power_spectrum(data, fig=None, ax=None, phi1_bin_edges=None, label=None):\n", + " \"\"\"Plot 1D density along phi1 and its power spectrum.\"\"\"\n", + " if fig is None or ax is None:\n", + " fig, ax = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + " # Compute 1D density along phi1\n", + " phi1 = np.array(data['phi1'])\n", + " if phi1_bin_edges is None:\n", + " phi1_bin_edges = np.linspace(np.min(phi1), np.max(phi1), 50)\n", + " counts, _ = np.histogram(phi1, bins=phi1_bin_edges)\n", + " bin_centers = 0.5 * (phi1_bin_edges[:-1] + phi1_bin_edges[1:])\n", + "\n", + " # Compute power spectrum using cross-spectral density method from scipy\n", + " from scipy.signal import csd\n", + " fs = 1.0 / (bin_centers[1] - bin_centers[0]) # Sampling frequency\n", + " k, Pxx = csd(counts, counts, nperseg=len(counts), fs=fs)\n", + "\n", + " # Plot density\n", + " ax[0].plot(bin_centers, counts, drawstyle='steps-mid', label=label)\n", + " ax[0].set_xlabel('phi1 (deg)')\n", + " ax[0].set_ylabel('Star counts')\n", + " ax[0].set_title('1D Density along phi1')\n", + "\n", + " # Plot power spectrum (1/k, P(k)) in log-log scale\n", + " ax[1].loglog(1/k, Pxx, label=label)\n", + " ax[1].set_xlabel('1/k (deg)')\n", + " ax[1].set_ylabel('P(k)')\n", + " ax[1].set_title('Power Spectrum of 1D Density')\n", + "\n", + " for a in ax.flatten():\n", + " a.grid()\n", + " if label is not None:\n", + " a.legend()\n", + " return fig, ax" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "077e5872", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/9j/zk4h50g505d635j69p9tgwbc0000gp/T/ipykernel_10726/3483219967.py:25: RuntimeWarning: divide by zero encountered in divide\n", + " ax[1].loglog(1/k, Pxx, label=label)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the power spectrum of all stars vs. detected stars only\n", + "phi1_bin_edges = np.linspace(-7, 7, 50)\n", + "fig, ax = plot_power_spectrum(injected_data_full, label='All data', phi1_bin_edges=phi1_bin_edges)\n", + "fig, ax = plot_power_spectrum(injected_data_full[injected_data_full['lsst_yr4_flag_observed']], fig=fig, ax=ax, label='Detected data', phi1_bin_edges=phi1_bin_edges)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "6acd2421", + "metadata": {}, + "source": [ + "## 5) Conclusion\n", + "\n", + "Streamobs provides a method for converting data mocks into realistic observed data for a given survey, with minimal computational cost. This can be easily achieved with just a few commands, helping to bridge the gap between simulations and observational challenges in the field of stellar streams.\n", + "\n", + "\n", + "You can find more informations in the [full documentation](https://lsstdesc.github.io/streamobs/)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "streamsim_dev", + "language": "python", + "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.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/index.rst b/docs/source/index.rst index b4ae8ba..e95d6f5 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -86,13 +86,21 @@ Documentation Contents multisurvey citation + .. toctree:: + :maxdepth: 1 + :caption: Examples + + examples/tutorial_generate_datamocks + examples/tutorial_inject_stream + .. toctree:: :maxdepth: 2 :caption: Surveys supported - DES - LSST - roman + surveys/DES + surveys/LSST + surveys/Roman + .. toctree:: :maxdepth: 2 diff --git a/docs/source/DES.md b/docs/source/surveys/DES.md similarity index 100% rename from docs/source/DES.md rename to docs/source/surveys/DES.md diff --git a/docs/source/LSST.md b/docs/source/surveys/LSST.md similarity index 100% rename from docs/source/LSST.md rename to docs/source/surveys/LSST.md diff --git a/docs/source/roman.md b/docs/source/surveys/roman.md similarity index 100% rename from docs/source/roman.md rename to docs/source/surveys/roman.md diff --git a/notebooks/tutorial_generate_datamocks.ipynb b/notebooks/tutorial_generate_datamocks.ipynb deleted file mode 100644 index 41717ad..0000000 --- a/notebooks/tutorial_generate_datamocks.ipynb +++ /dev/null @@ -1,931 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "394f3750", - "metadata": {}, - "source": [ - "# Streamobs: generate stream mocks\n", - "\n", - "Generate stellar stream mock catalogs from configuration files and complete existing tables with missing columns.\n", - "**Streamobs** allows sampling of the following quantities:\n", - "\n", - "* (`phi1`, `phi2`): stellar coordinates in the stream frame\n", - "* `dist`: distance modulus of stars\n", - "* `mag_{band}`: apparent magnitude in a given photometric band of a chosen survey\n", - "\n", - "Future versions may also include sampling of proper motions and velocities.\n", - "\n", - "Streamobs can further convert these intrinsic quantities into **observed quantities**.\n", - "For more details, see the notebook *`tutorial_inject_stream.ipynb`*.\n", - "\n", - "**In this tutorial, you’ll learn to:**\n", - "\n", - "* Define model components: density, track, distance modulus, isochrone\n", - "* Build or load a configuration and sample a mock catalog\n", - "* Complete partial catalogs (e.g., by adding magnitudes)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "94d3f015", - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "import os\n", - "import pandas as pd\n", - "import yaml\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import scipy\n", - "\n", - "# Set the base directory \n", - "base_dir = os.path.abspath(os.path.join(os.getcwd(), '..'))\n", - "os.chdir(base_dir) # to be able to find ./config/myfile.yaml\n", - "\n", - "# Add base directory to the Python path for imports\n", - "sys.path.append(base_dir)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a54fd20b", - "metadata": {}, - "outputs": [], - "source": [ - "# Import necessary modules form streamobs\n", - "%load_ext autoreload\n", - "%autoreload 2\n", - "from streamobs.utils import parse_config\n", - "from streamobs.model import StreamModel" - ] - }, - { - "cell_type": "markdown", - "id": "f5492fdd", - "metadata": {}, - "source": [ - "# 1) Build a stream configuration\n", - "\n", - "To set up a stream model, we use a configuration file or dictionary that defines all necessary components. It can include:\n", - "\n", - "* **density** – samples `phi1` values along the stream\n", - "* **track** – gives `phi2` as a function of `phi1` (center + spread, using a Gaussian or Uniform sampler)\n", - "* **distance_modulus** – defines $DM(phi1)$ for computing apparent magnitudes\n", - "* **isochrone** – samples the color–magnitude diagram (required to generate magnitudes)\n", - "\n", - "You can choose how each quantity depends on `phi1` (e.g., constant, linear, spline, etc.).\n", - "\n", - "**Notes:**\n", - "\n", - "* To generate magnitudes, you need at least both `dist` and `isochrone`.\n", - "* The velocity model is currently a placeholder (returns NaN).\n", - "* Samplers and functions are selected using the `type` keyword (e.g., `\"Uniform\"`, `\"CubicSplineInterpolation\"`).\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3d2810e8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'density': {'type': 'Uniform', 'xmin': -9.0, 'xmax': 9.0}, 'track': {'center': {'type': 'Constant', 'value': 0.0}, 'spread': {'type': 'Constant', 'value': 0.2}, 'sampler': 'Gaussian'}, 'isochrone': {'name': 'Marigo2017', 'survey': 'lsst', 'age': 12.0, 'z': 0.0006, 'band_1': 'g', 'band_2': 'r', 'band_1_detection': True}, 'distance_modulus': {'center': {'type': 'Constant', 'value': 16.5}, 'spread': {'type': 'Constant', 'value': 0.0}}}\n" - ] - } - ], - "source": [ - "# Build a config dictionary directly\n", - "\n", - "config = { \n", - " # Density model\n", - " 'density': {'type': 'Uniform', 'xmin': -9.0, 'xmax': 9.0}, \n", - "\n", - " # Track model\n", - " 'track': {'center': {'type': 'Constant', 'value': 0.0}, # center line of the stream in degrees\n", - " 'spread': {'type': 'Constant', 'value': 0.2}, # spread of the stream in degrees\n", - " 'sampler': 'Gaussian'}, # how to sample across the stream\n", - "\n", - " # Isochrone model\n", - " 'isochrone': {'name': 'Marigo2017', # isochrone set name\n", - " 'survey': 'lsst', # survey for filter set\n", - " 'age': 12.0, # Age in Gyr of the population\n", - " 'z': 0.0006, # Metallicity of the population\n", - " 'band_1': 'g', # first band for color-magnitude\n", - " 'band_2': 'r', # second band for color-magnitude\n", - " 'band_1_detection': True}, \n", - "\n", - " # Distance modulus model. Here an example of a constant distance modulus\n", - " 'distance_modulus': {'center': {'type': 'Constant', 'value': 16.5}, \n", - " 'spread': {'type': 'Constant', 'value': 0.0}, \n", - " }\n", - "}\n", - "\n", - "# or load from a config file\n", - "#config_path = os.path.join(base_dir, 'config', 'toy1_config.yaml')\n", - "#config = parse_config(config_path)['stream']\n", - "\n", - "print(config)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "e33bd732", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Generated 4500 stars\n", - "\n", - "First 5 stars:\n", - " phi1 phi2 dist mu1 mu2 rv mag_g mag_r\n", - "0 7.375317 0.250945 16.5 None None None 29.112133 27.696447\n", - "1 -1.858344 -0.044748 16.5 None None None 27.423636 26.221278\n", - "2 -2.456239 -0.097661 16.5 None None None 24.906618 24.124551\n", - "3 -6.244392 0.156078 16.5 None None None 26.278365 25.239959\n", - "4 -4.599183 0.059099 16.5 None None None 27.078485 25.930319\n" - ] - } - ], - "source": [ - "# Create stream model and generate stars\n", - "stream_model = StreamModel(config)\n", - "stream_df = stream_model.sample(4500)\n", - "\n", - "# The dataframe contains: phi1, phi2, distance, magnitudes, etc.\n", - "print(f\"✓ Generated {len(stream_df)} stars\")\n", - "print(\"\\nFirst 5 stars:\")\n", - "print(stream_df.head())" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1d7e82f8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Color-Magnitude Diagram')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Quick look: sky track, 1D density, CMD\n", - "fig, ax = plt.subplots(1, 3, figsize=(16, 5))\n", - "\n", - "# Stream on the sky\n", - "ax[0].scatter(stream_df['phi1'], stream_df['phi2'], s=1, color='blue')\n", - "ax[0].set_xlabel('phi1 (deg)')\n", - "ax[0].set_ylabel('phi2 (deg)')\n", - "ax[0].set_title('Stream on the sky')\n", - "\n", - "# 1D density\n", - "ax[1].hist(stream_df['phi1'], bins=50, color='green')\n", - "ax[1].set_xlabel('phi1 (deg)')\n", - "ax[1].set_ylabel('Number of stars')\n", - "ax[1].set_title('1D Density along the stream')\n", - "\n", - "# Color-magnitude diagram\n", - "ax[2].scatter(stream_df['mag_g'] - stream_df['mag_r'], stream_df['mag_g'], s=1, color='red')\n", - "ax[2].set_xlabel('g - r (mag)')\n", - "ax[2].set_ylabel('g (mag)')\n", - "ax[2].invert_yaxis()\n", - "ax[2].set_title('Color-Magnitude Diagram')" - ] - }, - { - "cell_type": "markdown", - "id": "168afb7e", - "metadata": {}, - "source": [ - "\n", - "## 2) Spline-based configuration\n", - "\n", - "You can model a more realistic stream shape using cubic splines, particularly for:\n", - "\n", - "* **Linear density:** $\\sqrt{2\\pi} \\times \\text{peak intensity} \\times \\text{spread}$\n", - "* **Distance modulus**\n", - "* **Track and width**\n", - "\n", - "In this example, we use data from `data/patrick_2022_splines.csv` and select `stream == 'phoenix'`.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e9da4d2a", - "metadata": {}, - "outputs": [], - "source": [ - "# Nodes and values for the spline-based stream model (from Patrick et al. 2022, for Phoenix stream)\n", - "# One may read these from a CSV file instead of hardcoding them, cf to config/atlas_spline_config.yaml\n", - "intensity_nodes = np.array([-13., -9.75, -8.125, -4.1640625, -3.25, -1.625, 1.625, 6.5, 8.125, 13.])\n", - "intensity_node_values = np.array([2.35582279e-07, 2.65789495e-02, 5.94765580e-02, 7.20106921e-02, 9.96003626e-02, 4.68656926e-02, 7.42352023e-02, 4.75688845e-06, 1.73046024e-02, 4.08879937e-08])\n", - "spread_nodes = np.array([-13. , 13.])\n", - "spread_node_values = np.array([0.0992389, 0.17083177])\n", - "center_nodes = np.array([-13., 4.33333333, 13.])\n", - "center_node_values = np.array([0.19313599, 0.07139282, 0.60245054])\n", - "distance_nodes = np.array([-13., 13.])\n", - "distance_node_values = np.array([16.38285347, 16.1136374])\n", - "\n", - "\n", - "config_spline = {\n", - " # Density model using cubic splines from CSV\n", - " 'density': {\n", - " 'type': 'lineardensitycubicsplineinterpolation',\n", - " 'intensity_nodes': intensity_nodes,\n", - " 'intensity_node_values': intensity_node_values,\n", - " 'spread_nodes': spread_nodes,\n", - " 'spread_node_values': spread_node_values,\n", - " },\n", - "\n", - " # Track model: center and spread as cubic splines\n", - " 'track': {\n", - " 'center': {'type': 'CubicSplineInterpolation', 'nodes': center_nodes, 'node_values': center_node_values},\n", - " 'spread': {'type': 'CubicSplineInterpolation', 'nodes': spread_nodes, 'node_values': spread_node_values},\n", - " },\n", - "\n", - " # Isochrone model\n", - " 'isochrone': {\n", - " 'name': 'Marigo2017',\n", - " 'survey': 'lsst',\n", - " 'age': 13.0,\n", - " 'z': 0.0004,\n", - " 'band_1': 'g',\n", - " 'band_2': 'r',\n", - " 'band_1_detection': True\n", - " },\n", - "\n", - " # Distance modulus model as a cubic spline (flat default)\n", - " 'distance_modulus': {\n", - " 'center': {'type': 'CubicSplineInterpolation', 'nodes': distance_nodes, 'node_values': distance_node_values},\n", - " 'spread': {'type': 'Constant', 'value': 0.0},\n", - " },\n", - "}\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "23c7702c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Generated 4000 stars with spline density\n" - ] - }, - { - "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "phi1", - "rawType": "float64", - "type": "float" - }, - { - "name": "phi2", - "rawType": "float64", - "type": "float" - }, - { - "name": "dist", - "rawType": "float64", - "type": "float" - }, - { - "name": "mu1", - "rawType": "object", - "type": "unknown" - }, - { - "name": "mu2", - "rawType": "object", - "type": "unknown" - }, - { - "name": "rv", - "rawType": "object", - "type": "unknown" - }, - { - "name": "mag_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r", - "rawType": "float64", - "type": "float" - } - ], - "ref": "261acb8f-e0bc-4548-8a27-7c2ccc4e3ff6", - "rows": [ - [ - "0", - "1.858628586285862", - "0.028439848701638515", - "16.22900033178502", - null, - null, - null, - "29.43290797051653", - "27.97559490649988" - ], - [ - "1", - "2.8455984559845593", - "0.24636654368293825", - "16.218780787572378", - null, - null, - null, - "30.699529434956283", - "29.08595892852513" - ], - [ - "2", - "0.9704597045970456", - "-0.08063192814148298", - "16.23819684470135", - null, - null, - null, - "29.436960664925884", - "27.980322972499454" - ], - [ - "3", - "-2.2078120781207815", - "-0.1701447004691512", - "16.271106146191162", - null, - null, - null, - "29.511623329971812", - "28.04950351652886" - ], - [ - "4", - "-8.09479094790948", - "0.07429268642285727", - "16.332062658325682", - null, - null, - null, - "22.619377003021913", - "22.2087987174911" - ] - ], - "shape": { - "columns": 8, - "rows": 5 - } - }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
phi1phi2distmu1mu2rvmag_gmag_r
01.8586290.02844016.229000NoneNoneNone29.43290827.975595
12.8455980.24636716.218781NoneNoneNone30.69952929.085959
20.970460-0.08063216.238197NoneNoneNone29.43696127.980323
3-2.207812-0.17014516.271106NoneNoneNone29.51162328.049504
4-8.0947910.07429316.332063NoneNoneNone22.61937722.208799
\n", - "
" - ], - "text/plain": [ - " phi1 phi2 dist mu1 mu2 rv mag_g mag_r\n", - "0 1.858629 0.028440 16.229000 None None None 29.432908 27.975595\n", - "1 2.845598 0.246367 16.218781 None None None 30.699529 29.085959\n", - "2 0.970460 -0.080632 16.238197 None None None 29.436961 27.980323\n", - "3 -2.207812 -0.170145 16.271106 None None None 29.511623 28.049504\n", - "4 -8.094791 0.074293 16.332063 None None None 22.619377 22.208799" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Optional: sample using the spline-based config\n", - "stream_model_spline = StreamModel(config_spline)\n", - "stream_df_spline = stream_model_spline.sample(4000)\n", - "\n", - "print(f\"✓ Generated {len(stream_df_spline)} stars with spline density\")\n", - "stream_df_spline.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "3cfc1b7b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Color-Magnitude Diagram')" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "fig, ax = plt.subplots(1, 3, figsize=(16, 5))\n", - "\n", - "# plotting the stream on the sky \n", - "ax[0].scatter(stream_df_spline['phi1'], stream_df_spline['phi2'], s=1, color='blue', label = \"Generated stars\")\n", - "x_val = np.sort(stream_df_spline['phi1'].values)\n", - "spline_val = scipy.interpolate.CubicSpline(center_nodes, center_node_values)(x_val)\n", - "ax[0].plot(x_val, spline_val, color='orange', lw=2, label='Spline track model')\n", - "ax[0].set_xlabel('phi1 (deg)')\n", - "ax[0].set_ylabel('phi2 (deg)')\n", - "ax[0].set_title('Stream on the sky')\n", - "ax[0].legend()\n", - "\n", - "# Plotting the 1D density along the stream\n", - "ax[1].hist(stream_df_spline['phi1'], bins=50, color='green')\n", - "ax[1].set_xlabel('phi1 (deg)')\n", - "ax[1].set_ylabel('Number of stars')\n", - "ax[1].set_title('1D Density along the stream')\n", - "\n", - "# plotting Color magnitude diagram\n", - "ax[2].scatter(stream_df_spline['mag_g'] - stream_df_spline['mag_r'], stream_df_spline['mag_g'], s=1, color='red')\n", - "ax[2].set_xlabel('g - r (mag)')\n", - "ax[2].set_ylabel('g (mag)')\n", - "ax[2].invert_yaxis()\n", - "ax[2].set_title('Color-Magnitude Diagram')\n" - ] - }, - { - "cell_type": "markdown", - "id": "f3c615f0", - "metadata": {}, - "source": [ - "# 3) Complete an existing catalog\n", - "\n", - "`StreamModel.complete_catalog` fills only the requested columns while preserving existing values (except for magnitudes and velocities, which are regenerated together for consistency).\n", - "\n", - "* **Dependencies:**\n", - "\n", - " * `phi2` and `dist` require `phi1`\n", - " * `mags` require both `dist` and `isochrone`\n", - "* **Input formats:** can be a `DataFrame`, `dict`, path to a CSV file, or `None` (with a specified `size` to generate the full catalog)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "d37bb8b8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Catalog with missing columns:\n", - " phi1 phi2\n", - "0 7.375317 0.250945\n", - "1 -1.858344 -0.044748\n", - "2 -2.456239 -0.097661\n", - "3 -6.244392 0.156078\n", - "4 -4.599183 0.059099\n" - ] - } - ], - "source": [ - "# Let's build a catalog with missing columns to complete\n", - "# Here for example we keep only 'phi1' and 'phi2', and drop others\n", - "stream_df_sub = stream_df.drop(columns=['mag_r', 'dist', 'mag_g', 'mu1', 'mu2', 'rv' ]).reset_index(drop=True)\n", - "print(\"\\nCatalog with missing columns:\")\n", - "print(stream_df_sub.head())" - ] - }, - { - "cell_type": "markdown", - "id": "5050d977", - "metadata": {}, - "source": [ - "## Fill every missing columns" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "7e98fa35", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Velocity model not defined; skipping velocities.\n", - "Filled 4500 dist values.\n", - "Filled magnitudes for 4500 rows.\n", - " phi1 phi2 dist mag_g mag_r\n", - "0 7.375317 0.250945 16.5 32.103113 30.363368\n", - "1 -1.858344 -0.044748 16.5 30.179186 28.636327\n", - "2 -2.456239 -0.097661 16.5 25.450919 24.559246\n", - "3 -6.244392 0.156078 16.5 31.283494 29.621596\n", - "4 -4.599183 0.059099 16.5 30.907213 29.285877\n" - ] - } - ], - "source": [ - "# Now we can use `complete_catalog` to fill in the missing columns amoung ['phi1', 'phi2', 'dist', 'mag_g', 'mag_r', 'mu1', 'mu2', 'rv']\n", - "completed_catalog = stream_model.complete_catalog(\n", - " catalog=stream_df_sub,\n", - " save_path=None,\n", - " inplace=False,\n", - " verbose=True\n", - ")\n", - "print(completed_catalog.head())" - ] - }, - { - "cell_type": "markdown", - "id": "c06d8f12", - "metadata": {}, - "source": [ - "## Fill only specific columns" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "16346874", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Filled 4500 dist values.\n", - "Filled magnitudes for 4500 rows.\n" - ] - }, - { - "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "phi1", - "rawType": "float64", - "type": "float" - }, - { - "name": "phi2", - "rawType": "float64", - "type": "float" - }, - { - "name": "dist", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r", - "rawType": "float64", - "type": "float" - } - ], - "ref": "9e664412-10a4-40f2-8cd5-d60ecab0ed7a", - "rows": [ - [ - "0", - "7.375316617497113", - "0.25094470862288215", - "16.5", - "26.996639642781176", - "25.86116919520827" - ], - [ - "1", - "-1.8583440099193211", - "-0.044747965470281675", - "16.5", - "30.776760595884873", - "29.16948623646113" - ], - [ - "2", - "-2.4562386975601243", - "-0.09766058175733809", - "16.5", - "28.153413187735644", - "26.840933323666828" - ], - [ - "3", - "-6.244392012633449", - "0.15607780086870238", - "16.5", - "24.726490587598946", - "23.978470377452336" - ], - [ - "4", - "-4.599182587276114", - "0.05909872157949739", - "16.5", - "28.40054473602201", - "27.05946982607113" - ] - ], - "shape": { - "columns": 5, - "rows": 5 - } - }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
phi1phi2distmag_gmag_r
07.3753170.25094516.526.99664025.861169
1-1.858344-0.04474816.530.77676129.169486
2-2.456239-0.09766116.528.15341326.840933
3-6.2443920.15607816.524.72649123.978470
4-4.5991830.05909916.528.40054527.059470
\n", - "
" - ], - "text/plain": [ - " phi1 phi2 dist mag_g mag_r\n", - "0 7.375317 0.250945 16.5 26.996640 25.861169\n", - "1 -1.858344 -0.044748 16.5 30.776761 29.169486\n", - "2 -2.456239 -0.097661 16.5 28.153413 26.840933\n", - "3 -6.244392 0.156078 16.5 24.726491 23.978470\n", - "4 -4.599183 0.059099 16.5 28.400545 27.059470" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Example: fill only magnitudes\n", - "subset = stream_df_sub.copy()\n", - "completed_mags = stream_model.complete_catalog(\n", - " catalog=subset,\n", - " columns_to_add=[\"mag_g\", \"mag_r\"],\n", - " inplace=False,\n", - " verbose=True,\n", - ")\n", - "completed_mags.head()" - ] - }, - { - "cell_type": "markdown", - "id": "c1b81722", - "metadata": {}, - "source": [ - "*Note: the distance modulus is also added, since it is needed to convert absolute magnitude sampled from the isochrone, to apparent magnitudes (`mag_g`and `mag_r` here).*" - ] - }, - { - "cell_type": "markdown", - "id": "e4cd4bc5", - "metadata": {}, - "source": [ - "## Tips and Troubleshooting\n", - "\n", - "* If magnitudes are missing or NaN, make sure your config includes both `distance_modulus` and `isochrone` sections.\n", - "* To keep colors consistent, `complete_catalog` regenerates both `mag_g` and `mag_r` whenever one needs to be computed.\n", - "* Column names are automatically standardized (e.g., `'g_mag'` → `'mag_g'`); see `_standardize_columns_name`.\n", - "* The velocity model is currently a placeholder and returns NaN values." - ] - }, - { - "cell_type": "markdown", - "id": "ad8600ce", - "metadata": {}, - "source": [ - "# Conclusion\n", - "\n", - "Streamobs provides a flexible framework to build and complete stellar stream mock catalogs, from simple analytic models to spline-based configurations.\n", - "Future updates will include proper motions, velocities, and improved documentation for easier user adoption.\n", - "\n", - "You can find more informations in the [full documentation](https://lsstdesc.github.io/streamobs/)." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "streamsim_dev", - "language": "python", - "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.11.14" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/tutorial_inject_stream.ipynb b/notebooks/tutorial_inject_stream.ipynb deleted file mode 100644 index 135ea65..0000000 --- a/notebooks/tutorial_inject_stream.ipynb +++ /dev/null @@ -1,1938 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "ef83a9a9", - "metadata": {}, - "source": [ - "# Injecting stream mocks into a survey\n", - "\n", - "This short tutorial shows how to:\n", - "- Load a survey (e.g., LSST yr5) and inspect completeness/error models\n", - "- Create a `StreamInjector` and inject photometric effects + detection flags\n", - "- Plot against the footprint and visualize injected magnitudes\n", - "\n", - "This is useful for people who want to convert their dynamical simulation results into realistic survey data." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9b899efa", - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "import os\n", - "import pandas as pd\n", - "import yaml\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Set the base directory \n", - "base_dir = os.path.abspath(os.path.join(os.getcwd(), '..'))\n", - "os.chdir(base_dir) # to be able to find ./config/myfile.yaml\n", - "\n", - "# Add base directory to the Python path for imports\n", - "sys.path.append(base_dir)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cf16899f", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "from streamobs import surveys, observed\n", - "from streamobs.model import StreamModel" - ] - }, - { - "cell_type": "markdown", - "id": "17059e52", - "metadata": {}, - "source": [ - "## 1) Load the survey (cached)\n", - "We load LSST yr5 once; the data is cached for efficiency (bands, depth maps, extinction, completeness, and photometric error models)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "27cdcd2b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading survey data for 'lsst_yr4'...\n", - " Loading config from: lsst_yr4.yaml\n", - "\n", - "======================================================================\n", - "LOADING SURVEY DATA FILES\n", - "======================================================================\n", - "Survey data directory: /Users/pelissier/Documents/Codes/packages/streamobs/streamobs/../data/surveys/lsst_yr4\n", - "\n", - "Fallback directory for shared data files: /Users/pelissier/Documents/Codes/packages/streamobs/streamobs/../data/others\n", - "\n", - "Available bands: g, i, r, u, y, z\n", - "\n", - "\n", - "Loading survey properties...\n", - "Loading magnitude limit maps...\n", - " ✓ Success for g-band magnitude limit\n", - " ⚠ Warning: 'maglim_map_i' not specified in config (skipping i-band)\n", - " ✓ Success for r-band magnitude limit\n", - " ⚠ Warning: 'maglim_map_u' not specified in config (skipping u-band)\n", - " ⚠ Warning: 'maglim_map_y' not specified in config (skipping y-band)\n", - " ⚠ Warning: 'maglim_map_z' not specified in config (skipping z-band)\n", - "\n", - "Loading completeness/efficiency function...\n", - " Loading Completeness/efficiency function...\n", - " File: lsst_stellar_efficiency_cutr.csv\n", - " ✓ Success\n", - " Loading Detection efficiency function...\n", - " File: lsst_stellar_efficiency_cutr.csv\n", - " ✓ Success\n", - " Loading Classification efficiency function...\n", - " File: lsst_stellar_efficiency_cutr.csv\n", - " ✓ Success\n", - "\n", - "Loading photometric error model...\n", - " Loading Photometric error model...\n", - " File: lsst_photoerror_r.csv\n", - " ✓ Success\n", - "\n", - "Loading band-independent maps...\n", - " Loading E(B-V) extinction map...\n", - " File: ebv_sfd98_lowres_nside_512_ring_equatorial.fits\n", - " ✓ Success\n", - " ⚠ Warning: 'coverage' not specified in config (skipping)\n", - "\n", - "Building coverage map from magnitude limit maps...\n", - " ✓ Built coverage map (nside=128, 133236 pixels covered)\n", - "\n", - "Survey properties summary:\n", - " g-band:\n", - " Extinction coefficient: 3.661\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " i-band:\n", - " Extinction coefficient: 2.054\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " r-band:\n", - " Extinction coefficient: 2.701\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " u-band:\n", - " Extinction coefficient: 4.757\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " y-band:\n", - " Extinction coefficient: 1.308\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " z-band:\n", - " Extinction coefficient: 1.590\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - "\n", - "======================================================================\n", - "SURVEY DATA LOADED SUCCESSFULLY\n", - "======================================================================\n", - "\n", - "✓ Survey 'lsst_yr4' loaded and cached successfully\n" - ] - } - ], - "source": [ - "lsst_yr4= surveys.Survey.load(survey = 'lsst', release='yr4')" - ] - }, - { - "cell_type": "markdown", - "id": "42801958", - "metadata": {}, - "source": [ - "### Completeness and photometric error\n", - "Both depend on magnitude relative to the local limit (delta_mag = mag - maglim). We can visualize them for the r-band at a chosen magnitude limit." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9b85555b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mag_r_test = np.linspace(15,31, 1000)\n", - "maglim_r_dc2 = 26.8\n", - "completeness_val = lsst_yr4.get_completeness('r', mag_r_test, maglim_r_dc2)\n", - "mag_error_val = lsst_yr4.get_photo_error('r', mag_r_test, maglim_r_dc2)\n", - "\n", - "fig, ax = plt.subplots(1, 2, figsize=(12, 5))\n", - "ax[0].plot(mag_r_test, completeness_val, label='Completeness')\n", - "ax[0].axvline(maglim_r_dc2, color='red', linestyle='--', label='Magnitude Limit')\n", - "ax[0].set_xlabel('Apparent r-band magnitude')\n", - "ax[0].set_ylabel('Completeness')\n", - "ax[0].set_title('LSST DC2 Completeness Function')\n", - "ax[0].grid()\n", - "ax[0].legend() \n", - "\n", - "ax[1].plot(mag_r_test, mag_error_val, label='Photometric Error', color='orange')\n", - "ax[1].axvline(maglim_r_dc2, color='red', linestyle='--', label='Magnitude Limit')\n", - "ax[1].set_yscale('log')\n", - "ax[1].set_xlabel('Apparent r-band magnitude')\n", - "ax[1].set_ylabel('Photometric Error (mag)')\n", - "ax[1].set_title('LSST DC2 Photometric Error Model')\n", - "ax[1].grid()\n", - "ax[1].legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "23ed125c", - "metadata": {}, - "source": [ - "### Cache manipulation\n", - "Once a survey has been loaded, it's stored in the cache. You can use commands to check which surveys are stored.\n", - "To force reloading of a survey, you must clear the cache first." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fd3a37c5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Using cached survey data for 'lsst_yr4'\n", - "Current cache content: ['lsst_yr4']\n", - "✓ Cleared cached survey 'lsst_yr4'\n", - "Cache content after clearing 'lsst': []\n" - ] - } - ], - "source": [ - "# Once a survey has been loaded once, it can be reused directly from the cache\n", - "lsst_yr4 = surveys.Survey.load(survey = 'lsst', release='yr4') # reuses the cached survey object\n", - "\n", - "# Check the cache content\n", - "\n", - "print(\"Current cache content: \", surveys.SurveyFactory.list_cached_surveys())\n", - "\n", - "surveys.SurveyFactory.clear_cache(survey = 'lsst', release='yr4')\n", - "# surveys.SurveyFactory.clear_cache(survey = 'lsst') # to clear all releases of 'lsst'\n", - "# surveys.SurveyFactory.clear_cache() # to clear the entire cache\n", - "print(\"Cache content after clearing 'lsst': \", surveys.SurveyFactory.list_cached_surveys())" - ] - }, - { - "cell_type": "markdown", - "id": "ba80c280", - "metadata": {}, - "source": [ - "## 2) Create an injector\n", - "The `StreamInjector` class wraps Survey objects and uses their properties to inject observational effects into a dataset." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6fd1866e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading survey data for 'lsst_yr4'...\n", - " Loading config from: lsst_yr4.yaml\n", - "\n", - "======================================================================\n", - "LOADING SURVEY DATA FILES\n", - "======================================================================\n", - "Survey data directory: /Users/pelissier/Documents/Codes/packages/streamobs/streamobs/../data/surveys/lsst_yr4\n", - "\n", - "Fallback directory for shared data files: /Users/pelissier/Documents/Codes/packages/streamobs/streamobs/../data/others\n", - "\n", - "Available bands: g, i, r, u, y, z\n", - "\n", - "\n", - "Loading survey properties...\n", - "Loading magnitude limit maps...\n", - " ✓ Success for g-band magnitude limit\n", - " ⚠ Warning: 'maglim_map_i' not specified in config (skipping i-band)\n", - " ✓ Success for r-band magnitude limit\n", - " ⚠ Warning: 'maglim_map_u' not specified in config (skipping u-band)\n", - " ⚠ Warning: 'maglim_map_y' not specified in config (skipping y-band)\n", - " ⚠ Warning: 'maglim_map_z' not specified in config (skipping z-band)\n", - "\n", - "Loading completeness/efficiency function...\n", - " Loading Completeness/efficiency function...\n", - " File: lsst_stellar_efficiency_cutr.csv\n", - " ✓ Success\n", - " Loading Detection efficiency function...\n", - " File: lsst_stellar_efficiency_cutr.csv\n", - " ✓ Success\n", - " Loading Classification efficiency function...\n", - " File: lsst_stellar_efficiency_cutr.csv\n", - " ✓ Success\n", - "\n", - "Loading photometric error model...\n", - " Loading Photometric error model...\n", - " File: lsst_photoerror_r.csv\n", - " ✓ Success\n", - "\n", - "Loading band-independent maps...\n", - " Loading E(B-V) extinction map...\n", - " File: ebv_sfd98_lowres_nside_512_ring_equatorial.fits\n", - " ✓ Success\n", - " ⚠ Warning: 'coverage' not specified in config (skipping)\n", - "\n", - "Building coverage map from magnitude limit maps...\n", - " ✓ Built coverage map (nside=128, 133236 pixels covered)\n", - "\n", - "Survey properties summary:\n", - " g-band:\n", - " Extinction coefficient: 3.661\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " i-band:\n", - " Extinction coefficient: 2.054\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " r-band:\n", - " Extinction coefficient: 2.701\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " u-band:\n", - " Extinction coefficient: 4.757\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " y-band:\n", - " Extinction coefficient: 1.308\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - " z-band:\n", - " Extinction coefficient: 1.590\n", - " Saturation limit: 16.0 mag\n", - " Systematic error: 0.0050 mag\n", - "\n", - "======================================================================\n", - "SURVEY DATA LOADED SUCCESSFULLY\n", - "======================================================================\n", - "\n", - "✓ Survey 'lsst_yr4' loaded and cached successfully\n" - ] - } - ], - "source": [ - "# Create an injector using the Survey object\n", - "stream_injector = observed.StreamInjector(lsst_yr4)\n", - "\n", - "# Or using survey name and release (this will create the survey object internally)\n", - "stream_injector = observed.StreamInjector(survey=\"lsst\", release=\"yr4\")" - ] - }, - { - "cell_type": "markdown", - "id": "8b2a38b7", - "metadata": {}, - "source": [ - "## 3) Inject different dataset types\n", - "\n", - "To convert a stream catalog into realistic survey data, you need:\n", - "- Sky coordinates (ra, dec)\n", - "- True apparent magnitudes of the stars\n", - "\n", - "However, **Streamobs** can **automatically sample these quantities** if they're missing, allowing incomplete datasets to be converted into realistic survey data.\n", - "\n", - "Streamobs uses the magnitude limit at each star's location to estimate:\n", - "- The photometric error\n", - "- The observed magnitude\n", - "- Whether the object is detected and classified as a star\n", - "\n", - "The output of the `inject()` method is a DataFrame containing:\n", - "\n", - "- `ra`, `dec`: positions of the stream's stars on the sky\n", - "- `mag_{band}`: true apparent magnitude in a given band\n", - "- `mag_{band}_obs`: observed magnitude in a given band\n", - "- `magerr_{band}`: photometric error on the observed magnitude (in mag). Includes both systematic and statistical errors.\n", - "- `flag_observed`: 1 if the star has been detected by the survey and classified as a star. By default includes an SNR cut (SNR = 1/magerr > 5) in g and r bands.\n", - "\n", - "The output can optionally include:\n", - "- `phi1`, `phi2`: position of stars in the stream frame\n", - "- `dist`: distance modulus of the stars" - ] - }, - { - "cell_type": "markdown", - "id": "914ce4ec", - "metadata": {}, - "source": [ - "### Dataset with only (phi1, phi2) coordinates\n", - "\n", - "If you only provide stream coordinates, Streamobs will:\n", - "\n", - "**1. Sample apparent magnitudes:**\n", - "\n", - "This is done using an isochrone and distance modulus model, which must be provided in a configuration dictionary. See `tutorial_generate_datamocks.ipynb` for more details.\n", - "\n", - "**2. Convert (phi1, phi2) → (ra, dec):**\n", - "\n", - "If you don't provide (ra, dec) columns, Streamobs will randomly place the stream on the sky. You can restrict the placement using the `mask_type` argument to ensure the stream falls within:\n", - "- The survey's footprint\n", - "- Regions with low dust extinction\n", - "- Areas meeting a minimum magnitude limit in a given band\n", - "- Any combination of the above\n", - "\n", - "Streamobs searches uniformly across the sky for a reference frame where a specified fraction of the stream (`percentile_threshold`) lies inside the mask. For more details, see the documentation of the `StreamInjector._find_gc_frame()` method.\n", - "\n", - "Alternatively, you can provide your own `gala.coordinates.GreatCircleICRSFrame` object via the `gc_frame` argument." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ed0abceb", - "metadata": {}, - "outputs": [], - "source": [ - "N = 1000\n", - "seed = 42\n", - "\n", - "rng = np.random.default_rng(seed)\n", - "\n", - "# Replace with your actual data\n", - "data_test = pd.DataFrame({\n", - " 'phi1': rng.uniform(-5, 5, N),\n", - " 'phi2': rng.uniform(-1, 1, N),\n", - "})\n", - "\n", - "\n", - "# Since our data set does not have magnitudes, we need to provide an isochrone and distance model \n", - "# - cf tutorial_generate_datamocks.ipynb\n", - "# This step can be skipped if the input data already has magnitudes in the desired bands\n", - "\n", - "isochrone_config = {'isochrone':{'name': 'Marigo2017', # isochrone set name\n", - " 'survey': 'lsst', # survey for filter set\n", - " 'age': 12.0, # Age in Gyr of the population\n", - " 'z': 0.0006, # Metallicity of the population\n", - " 'band_1': 'g', # first band for color-magnitude\n", - " 'band_2': 'r', # second band for color-magnitude\n", - " 'band_1_detection': True},\n", - "}\n", - "\n", - "distance_modulus_config = {'distance_modulus': {'center': {'type': 'Constant', 'value': 16.5}, \n", - " 'spread': {'type': 'Constant', 'value': 0.0}, \n", - " }}\n", - "\n", - "stream_config = {**isochrone_config, **distance_modulus_config}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cf4994dd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Building new mask for ['ebv', 'footprint']...\n", - " Resampling ebv from nside=512 to nside=128\n", - "✓ Mask created: valid pixels fraction = 0.5\n", - " Cached with key: ('lsst', ('ebv', 'footprint'), 0.2)\n", - "Found suitable great circle frame after 2 trials with 100.00% points inside the mask.\n", - "Filled 1000 dist values.\n", - "Filled magnitudes for 1000 rows.\n", - "Applying dust correction for r-band on observed magnitudes.\n", - "Applying dust correction for g-band on observed magnitudes.\n", - "Applying detection cut on g-band with SNR >= 5.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n", - "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n" - ] - } - ], - "source": [ - "mask_type = ['footprint', 'ebv'] # Restrict to survey footprint and apply extinction mask\n", - "\n", - "# By default the bands used for detection are (g and r)\n", - "# You can also add perfect_galstarsep=True to get bolean flag related to\n", - "# detection only (no classification).\n", - "injected_data_full = stream_injector.inject(data_test, seed=seed, mask_type=mask_type, stream_config=stream_config, verbose=True, perfect_galstarsep=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4b064c1f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index(['phi1', 'phi2', 'ra', 'dec', 'dist', 'mag_g', 'mag_r', 'mag_r_obs',\n", - " 'magerr_r', 'mag_g_obs', 'magerr_g', 'flag_observed',\n", - " 'flag_perfect_galstarsep'],\n", - " dtype='object')\n" - ] - }, - { - "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "phi1", - "rawType": "float64", - "type": "float" - }, - { - "name": "phi2", - "rawType": "float64", - "type": "float" - }, - { - "name": "ra", - "rawType": "float64", - "type": "float" - }, - { - "name": "dec", - "rawType": "float64", - "type": "float" - }, - { - "name": "dist", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r_obs", - "rawType": "object", - "type": "unknown" - }, - { - "name": "magerr_r", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_g_obs", - "rawType": "object", - "type": "unknown" - }, - { - "name": "magerr_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "flag_observed", - "rawType": "bool", - "type": "boolean" - }, - { - "name": "flag_perfect_galstarsep", - "rawType": "bool", - "type": "boolean" - } - ], - "ref": "33c302ea-690b-40ec-8153-075f534d2cf5", - "rows": [ - [ - "0", - "2.7395604855596334", - "-0.8758737869196895", - "309.2953942380719", - "-10.749590498519837", - "16.5", - "22.41028559822249", - "22.04785117105655", - "22.047965100015663", - "0.006780662663910697", - "22.40793655484874", - "0.007394955933706518", - "True", - "True" - ], - [ - "1", - "-0.6112156024794768", - "-0.0834759169269721", - "310.2683786555398", - "-14.058956233016271", - "16.5", - "30.09666434308648", - "28.56270340660659", - "BAD_MAG", - "2.2499339737548634", - "BAD_MAG", - "10.000001249999922", - "False", - "False" - ], - [ - "2", - "3.5859791991138246", - "-0.7419398856359165", - "308.7572935618984", - "-10.07569919353105", - "16.5", - "25.879838917277812", - "24.909216526278534", - "24.86027855525841", - "0.05692261634238516", - "25.897460616148617", - "0.13978607106581661", - "True", - "True" - ], - [ - "3", - "1.973680290593639", - "-0.6953465796848486", - "309.51600359134665", - "-11.50602746286123", - "16.5", - "29.537286842398476", - "28.06884640249528", - "27.360182617693045", - "1.2852614904749817", - "BAD_MAG", - "10.000001249999922", - "False", - "False" - ], - [ - "4", - "-4.058226521123505", - "0.26456562606042033", - "311.7243037291042", - "-17.22723336556269", - "16.5", - "32.383469302092514", - "30.618814364101716", - "30.102987661447727", - "10.000001249999922", - "29.018531595304196", - "10.000001249999922", - "False", - "False" - ] - ], - "shape": { - "columns": 13, - "rows": 5 - } - }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
phi1phi2radecdistmag_gmag_rmag_r_obsmagerr_rmag_g_obsmagerr_gflag_observedflag_perfect_galstarsep
02.739560-0.875874309.295394-10.74959016.522.41028622.04785122.0479650.00678122.4079370.007395TrueTrue
1-0.611216-0.083476310.268379-14.05895616.530.09666428.562703BAD_MAG2.249934BAD_MAG10.000001FalseFalse
23.585979-0.741940308.757294-10.07569916.525.87983924.90921724.8602790.05692325.8974610.139786TrueTrue
31.973680-0.695347309.516004-11.50602716.529.53728728.06884627.3601831.285261BAD_MAG10.000001FalseFalse
4-4.0582270.264566311.724304-17.22723316.532.38346930.61881430.10298810.00000129.01853210.000001FalseFalse
\n", - "
" - ], - "text/plain": [ - " phi1 phi2 ra dec dist mag_g mag_r \\\n", - "0 2.739560 -0.875874 309.295394 -10.749590 16.5 22.410286 22.047851 \n", - "1 -0.611216 -0.083476 310.268379 -14.058956 16.5 30.096664 28.562703 \n", - "2 3.585979 -0.741940 308.757294 -10.075699 16.5 25.879839 24.909217 \n", - "3 1.973680 -0.695347 309.516004 -11.506027 16.5 29.537287 28.068846 \n", - "4 -4.058227 0.264566 311.724304 -17.227233 16.5 32.383469 30.618814 \n", - "\n", - " mag_r_obs magerr_r mag_g_obs magerr_g flag_observed \\\n", - "0 22.047965 0.006781 22.407937 0.007395 True \n", - "1 BAD_MAG 2.249934 BAD_MAG 10.000001 False \n", - "2 24.860279 0.056923 25.897461 0.139786 True \n", - "3 27.360183 1.285261 BAD_MAG 10.000001 False \n", - "4 30.102988 10.000001 29.018532 10.000001 False \n", - "\n", - " flag_perfect_galstarsep \n", - "0 True \n", - "1 False \n", - "2 True \n", - "3 False \n", - "4 False " - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "print(injected_data_full.columns)\n", - "injected_data_full.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a45cb263", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "175 stars detected out of 1000\n", - "229 stars classified as stars out of 1000\n" - ] - } - ], - "source": [ - "# If you want to work only with detected and classified stars\n", - "detected_data = injected_data_full[injected_data_full['flag_observed']]\n", - "print(len(detected_data), \"stars detected out of\", len(injected_data_full))\n", - "\n", - "# When applying the perfect galstar separation, all detected stars are\n", - "# classified as stars, so we have:\n", - "classified_data = injected_data_full[injected_data_full['flag_perfect_galstarsep']]\n", - "print(len(classified_data), \"stars classified as stars out of\", len(injected_data_full))" - ] - }, - { - "cell_type": "markdown", - "id": "7b973847", - "metadata": {}, - "source": [ - "Streamobs has automatically sampled the missing columns (positions and apparent magnitudes) and estimated observational quantities.\n", - "\n", - "You can verify the injection behavior with some useful plots:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b8b2a9e7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot the injected stream in the survey mask\n", - "stream_injector.plot_stream_in_mask(injected_data_full, mask_type=mask_type)" - ] - }, - { - "cell_type": "markdown", - "id": "a58b7a71", - "metadata": {}, - "source": [ - "The stream lies entirely within the chosen mask." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8d27ae09", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from streamobs.plotting import plot_inject\n", - "\n", - "# Plot results\n", - "fig, ax = plot_inject(injected_data_full, lsst_yr4, bands=['g', 'r'], save=False)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "67f7a59f", - "metadata": {}, - "source": [ - "### Dataset containing (ra, dec) coordinates and distance modulus\n", - "\n", - "Streamobs only needs to sample the missing magnitudes, so you must provide a configuration dictionary for the isochrone model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b9520ac9", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "ra", - "rawType": "float64", - "type": "float" - }, - { - "name": "dec", - "rawType": "float64", - "type": "float" - }, - { - "name": "dist", - "rawType": "float64", - "type": "float" - } - ], - "ref": "ff5212ca-d34e-491f-b4e7-34d96296f415", - "rows": [ - [ - "0", - "309.2953942380719", - "-10.749590498519837", - "16.5" - ], - [ - "1", - "310.2683786555398", - "-14.058956233016271", - "16.5" - ], - [ - "2", - "308.7572935618984", - "-10.07569919353105", - "16.5" - ], - [ - "3", - "309.51600359134665", - "-11.50602746286123", - "16.5" - ], - [ - "4", - "311.7243037291042", - "-17.22723336556269", - "16.5" - ] - ], - "shape": { - "columns": 3, - "rows": 5 - } - }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecdist
0309.295394-10.74959016.5
1310.268379-14.05895616.5
2308.757294-10.07569916.5
3309.516004-11.50602716.5
4311.724304-17.22723316.5
\n", - "
" - ], - "text/plain": [ - " ra dec dist\n", - "0 309.295394 -10.749590 16.5\n", - "1 310.268379 -14.058956 16.5\n", - "2 308.757294 -10.075699 16.5\n", - "3 309.516004 -11.506027 16.5\n", - "4 311.724304 -17.227233 16.5" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Let's build a data set containing only (ra, dec) coordinates\n", - "data_set_radec = injected_data_full.drop(columns=[col for col in injected_data_full.columns if col not in ['ra', 'dec', 'dist']])\n", - "data_set_radec.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8dcef84a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Filled magnitudes for 1000 rows.\n", - "Applying dust correction for r-band on observed magnitudes.\n", - "Applying dust correction for g-band on observed magnitudes.\n", - "Applying detection cut on g-band with SNR >= 5.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n", - "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n" - ] - }, - { - "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "ra", - "rawType": "float64", - "type": "float" - }, - { - "name": "dec", - "rawType": "float64", - "type": "float" - }, - { - "name": "dist", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r_obs", - "rawType": "object", - "type": "unknown" - }, - { - "name": "magerr_r", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_g_obs", - "rawType": "object", - "type": "unknown" - }, - { - "name": "magerr_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "flag_observed", - "rawType": "bool", - "type": "boolean" - } - ], - "ref": "1b915fd5-2ecf-4324-b162-4a711ffb1a04", - "rows": [ - [ - "0", - "309.2953942380719", - "-10.749590498519837", - "16.5", - "32.521346463815334", - "30.744441115985055", - "29.293112729845497", - "10.000001249999922", - "30.86475618175217", - "10.000001249999922", - "False" - ], - [ - "1", - "310.2683786555398", - "-14.058956233016271", - "16.5", - "24.734569829732266", - "23.985160827622764", - "24.01278629565161", - "0.02622826493322956", - "24.70709873065739", - "0.05101851502840772", - "True" - ], - [ - "2", - "308.7572935618984", - "-10.07569919353105", - "16.5", - "32.17821752177512", - "30.43179924022367", - "28.18609564167872", - "10.000001249999922", - "30.938083741992", - "10.000001249999922", - "False" - ], - [ - "3", - "309.51600359134665", - "-11.50602746286123", - "16.5", - "27.876296288583674", - "26.605324661905662", - "26.34971117465026", - "0.30642224799556955", - "27.251424168831704", - "0.8752637405918557", - "False" - ], - [ - "4", - "311.7243037291042", - "-17.22723336556269", - "16.5", - "29.845461560741406", - "28.340735430827536", - "BAD_MAG", - "2.0512189654525854", - "29.20169053361813", - "10.000001249999922", - "False" - ] - ], - "shape": { - "columns": 10, - "rows": 5 - } - }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecdistmag_gmag_rmag_r_obsmagerr_rmag_g_obsmagerr_gflag_observed
0309.295394-10.74959016.532.52134630.74444129.29311310.00000130.86475610.000001False
1310.268379-14.05895616.524.73457023.98516124.0127860.02622824.7070990.051019True
2308.757294-10.07569916.532.17821830.43179928.18609610.00000130.93808410.000001False
3309.516004-11.50602716.527.87629626.60532526.3497110.30642227.2514240.875264False
4311.724304-17.22723316.529.84546228.340735BAD_MAG2.05121929.20169110.000001False
\n", - "
" - ], - "text/plain": [ - " ra dec dist mag_g mag_r mag_r_obs magerr_r \\\n", - "0 309.295394 -10.749590 16.5 32.521346 30.744441 29.293113 10.000001 \n", - "1 310.268379 -14.058956 16.5 24.734570 23.985161 24.012786 0.026228 \n", - "2 308.757294 -10.075699 16.5 32.178218 30.431799 28.186096 10.000001 \n", - "3 309.516004 -11.506027 16.5 27.876296 26.605325 26.349711 0.306422 \n", - "4 311.724304 -17.227233 16.5 29.845462 28.340735 BAD_MAG 2.051219 \n", - "\n", - " mag_g_obs magerr_g flag_observed \n", - "0 30.864756 10.000001 False \n", - "1 24.707099 0.051019 True \n", - "2 30.938084 10.000001 False \n", - "3 27.251424 0.875264 False \n", - "4 29.201691 10.000001 False " - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "injected_data = stream_injector.inject(data_set_radec, seed=seed, mask_type=None, stream_config=isochrone_config, verbose=True)\n", - "injected_data.head()" - ] - }, - { - "cell_type": "markdown", - "id": "b967882a", - "metadata": {}, - "source": [ - "### Dataset containing (ra, dec) and true apparent magnitudes\n", - "\n", - "The dataset already contains all the required quantities, so you don't need to provide a configuration dictionary or mask type." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ee217a87", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "ra", - "rawType": "float64", - "type": "float" - }, - { - "name": "dec", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r", - "rawType": "float64", - "type": "float" - } - ], - "ref": "d43a8bc4-2f8f-4305-b37f-43f60a58b24b", - "rows": [ - [ - "0", - "309.2953942380719", - "-10.749590498519837", - "22.41028559822249", - "22.04785117105655" - ], - [ - "1", - "310.2683786555398", - "-14.058956233016271", - "30.09666434308648", - "28.56270340660659" - ], - [ - "2", - "308.7572935618984", - "-10.07569919353105", - "25.879838917277812", - "24.909216526278534" - ], - [ - "3", - "309.51600359134665", - "-11.50602746286123", - "29.537286842398476", - "28.06884640249528" - ], - [ - "4", - "311.7243037291042", - "-17.22723336556269", - "32.383469302092514", - "30.618814364101716" - ] - ], - "shape": { - "columns": 4, - "rows": 5 - } - }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecmag_gmag_r
0309.295394-10.74959022.41028622.047851
1310.268379-14.05895630.09666428.562703
2308.757294-10.07569925.87983924.909217
3309.516004-11.50602729.53728728.068846
4311.724304-17.22723332.38346930.618814
\n", - "
" - ], - "text/plain": [ - " ra dec mag_g mag_r\n", - "0 309.295394 -10.749590 22.410286 22.047851\n", - "1 310.268379 -14.058956 30.096664 28.562703\n", - "2 308.757294 -10.075699 25.879839 24.909217\n", - "3 309.516004 -11.506027 29.537287 28.068846\n", - "4 311.724304 -17.227233 32.383469 30.618814" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Let's build a dataset containing (ra, dec) coordinates and magnitudes\n", - "data_set_radecmag = injected_data_full.drop(columns=[col for col in injected_data_full.columns if col not in ['ra', 'dec', 'mag_r', 'mag_g']])\n", - "data_set_radecmag.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4d0dbbe1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Applying dust correction for r-band on observed magnitudes.\n", - "Applying dust correction for g-band on observed magnitudes.\n", - "Applying detection cut on g-band with SNR >= 5.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n", - "/opt/anaconda3/envs/streamsim_dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log10\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n" - ] - }, - { - "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "ra", - "rawType": "float64", - "type": "float" - }, - { - "name": "dec", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_r_obs", - "rawType": "object", - "type": "unknown" - }, - { - "name": "magerr_r", - "rawType": "float64", - "type": "float" - }, - { - "name": "mag_g_obs", - "rawType": "object", - "type": "unknown" - }, - { - "name": "magerr_g", - "rawType": "float64", - "type": "float" - }, - { - "name": "flag_observed", - "rawType": "bool", - "type": "boolean" - } - ], - "ref": "1f28c454-967d-4d6a-874a-c21b708f4ae2", - "rows": [ - [ - "0", - "309.2953942380719", - "-10.749590498519837", - "22.41028559822249", - "22.04785117105655", - "22.04578695083129", - "0.006780662663910697", - "22.407400041724532", - "0.007394955933706518", - "True" - ], - [ - "1", - "310.2683786555398", - "-14.058956233016271", - "30.09666434308648", - "28.56270340660659", - "BAD_MAG", - "2.2499339737548634", - "28.14720185886775", - "10.000001249999922", - "False" - ], - [ - "2", - "308.7572935618984", - "-10.07569919353105", - "25.879838917277812", - "24.909216526278534", - "24.86731781932736", - "0.05692261634238516", - "25.84792954355696", - "0.13978607106581661", - "True" - ], - [ - "3", - "309.51600359134665", - "-11.50602746286123", - "29.537286842398476", - "28.06884640249528", - "27.256386029436264", - "1.2852614904749817", - "27.049345526486707", - "10.000001249999922", - "False" - ], - [ - "4", - "311.7243037291042", - "-17.22723336556269", - "32.383469302092514", - "30.618814364101716", - "BAD_MAG", - "10.000001249999922", - "31.739698274969236", - "10.000001249999922", - "False" - ] - ], - "shape": { - "columns": 9, - "rows": 5 - } - }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
radecmag_gmag_rmag_r_obsmagerr_rmag_g_obsmagerr_gflag_observed
0309.295394-10.74959022.41028622.04785122.0457870.00678122.40740.007395True
1310.268379-14.05895630.09666428.562703BAD_MAG2.24993428.14720210.000001False
2308.757294-10.07569925.87983924.90921724.8673180.05692325.847930.139786True
3309.516004-11.50602729.53728728.06884627.2563861.28526127.04934610.000001False
4311.724304-17.22723332.38346930.618814BAD_MAG10.00000131.73969810.000001False
\n", - "
" - ], - "text/plain": [ - " ra dec mag_g mag_r mag_r_obs magerr_r \\\n", - "0 309.295394 -10.749590 22.410286 22.047851 22.045787 0.006781 \n", - "1 310.268379 -14.058956 30.096664 28.562703 BAD_MAG 2.249934 \n", - "2 308.757294 -10.075699 25.879839 24.909217 24.867318 0.056923 \n", - "3 309.516004 -11.506027 29.537287 28.068846 27.256386 1.285261 \n", - "4 311.724304 -17.227233 32.383469 30.618814 BAD_MAG 10.000001 \n", - "\n", - " mag_g_obs magerr_g flag_observed \n", - "0 22.4074 0.007395 True \n", - "1 28.147202 10.000001 False \n", - "2 25.84793 0.139786 True \n", - "3 27.049346 10.000001 False \n", - "4 31.739698 10.000001 False " - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "injected_data = stream_injector.inject(data_set_radecmag, seed=seed, mask_type=None, stream_config=None, verbose=True)\n", - "injected_data.head()" - ] - }, - { - "cell_type": "markdown", - "id": "f7bd2b3a", - "metadata": {}, - "source": [ - "## 4) Usage example\n", - "\n", - "This can be useful for comparing analysis results between the ideal case of dynamic simulations and the more realistic case of observed data.\n", - "\n", - "For example, we can calculate the 1D density along the stream and its power spectrum." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c3d933ce", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_power_spectrum(data, fig=None, ax=None, phi1_bin_edges=None, label=None):\n", - " \"\"\"Plot 1D density along phi1 and its power spectrum.\"\"\"\n", - " if fig is None or ax is None:\n", - " fig, ax = plt.subplots(1, 2, figsize=(12, 5))\n", - "\n", - " # Compute 1D density along phi1\n", - " phi1 = np.array(data['phi1'])\n", - " if phi1_bin_edges is None:\n", - " phi1_bin_edges = np.linspace(np.min(phi1), np.max(phi1), 50)\n", - " counts, _ = np.histogram(phi1, bins=phi1_bin_edges)\n", - " bin_centers = 0.5 * (phi1_bin_edges[:-1] + phi1_bin_edges[1:])\n", - "\n", - " # Compute power spectrum using cross-spectral density method from scipy\n", - " from scipy.signal import csd\n", - " fs = 1.0 / (bin_centers[1] - bin_centers[0]) # Sampling frequency\n", - " k, Pxx = csd(counts, counts, nperseg=len(counts), fs=fs)\n", - "\n", - " # Plot density\n", - " ax[0].plot(bin_centers, counts, drawstyle='steps-mid', label=label)\n", - " ax[0].set_xlabel('phi1 (deg)')\n", - " ax[0].set_ylabel('Star counts')\n", - " ax[0].set_title('1D Density along phi1')\n", - "\n", - " # Plot power spectrum (1/k, P(k)) in log-log scale\n", - " ax[1].loglog(1/k, Pxx, label=label)\n", - " ax[1].set_xlabel('1/k (deg)')\n", - " ax[1].set_ylabel('P(k)')\n", - " ax[1].set_title('Power Spectrum of 1D Density')\n", - "\n", - " for a in ax.flatten():\n", - " a.grid()\n", - " if label is not None:\n", - " a.legend()\n", - " return fig, ax" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "077e5872", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/9j/zk4h50g505d635j69p9tgwbc0000gp/T/ipykernel_32025/3483219967.py:25: RuntimeWarning: divide by zero encountered in divide\n", - " ax[1].loglog(1/k, Pxx, label=label)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Compare the power spectrum of all stars vs. detected stars only\n", - "phi1_bin_edges = np.linspace(-7, 7, 50)\n", - "fig, ax = plot_power_spectrum(injected_data_full, label='All data', phi1_bin_edges=phi1_bin_edges)\n", - "fig, ax = plot_power_spectrum(injected_data_full[injected_data_full['flag_observed']], fig=fig, ax=ax, label='Detected data', phi1_bin_edges=phi1_bin_edges)\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "id": "6acd2421", - "metadata": {}, - "source": [ - "## 5) Conclusion\n", - "\n", - "Streamobs provides a method for converting data mocks into realistic observed data for a given survey, with minimal computational cost. This can be easily achieved with just a few commands, helping to bridge the gap between simulations and observational challenges in the field of stellar streams.\n", - "\n", - "\n", - "You can find more informations in the [full documentation](https://lsstdesc.github.io/streamobs/)." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "streamsim_dev", - "language": "python", - "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.11.14" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 27f8490f1c1e7be76c229f967b1a59774a5af113 Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Thu, 18 Jun 2026 15:57:31 +0200 Subject: [PATCH 19/29] black + isort --- streamobs/columns.py | 8 ++++++-- streamobs/observed.py | 2 +- tests/test_observed.py | 12 +++++------- tests/test_plotting.py | 4 +++- 4 files changed, 15 insertions(+), 11 deletions(-) diff --git a/streamobs/columns.py b/streamobs/columns.py index be3eb96..0529ffb 100644 --- a/streamobs/columns.py +++ b/streamobs/columns.py @@ -31,7 +31,7 @@ def true_col(band, survey_namespace=None): survey_name = survey_namespace.split("_")[0] else: survey_name = None - + return f"{survey_name}_{band}_true" if survey_name else f"{band}_true" @@ -52,4 +52,8 @@ def flag_col(survey_namespace=None): def perfect_flag_col(survey_namespace=None): """Column holding the perfect star/galaxy-separation flag (band-independent).""" - return f"{survey_namespace}_flag_perfect_galstarsep" if survey_namespace else "flag_perfect_galstarsep" + return ( + f"{survey_namespace}_flag_perfect_galstarsep" + if survey_namespace + else "flag_perfect_galstarsep" + ) diff --git a/streamobs/observed.py b/streamobs/observed.py index 9b7511f..86d04bd 100644 --- a/streamobs/observed.py +++ b/streamobs/observed.py @@ -183,7 +183,7 @@ def _load_survey(spec, **kwargs): if isinstance(spec, dict): return Survey.load(**{**kwargs, **spec}) raise ValueError( - 'Each survey spec must be a Survey, a name string, or a ' + "Each survey spec must be a Survey, a name string, or a " '{"survey": ..., "release": ...} dict.' ) diff --git a/tests/test_observed.py b/tests/test_observed.py index 45d2198..f1e478f 100644 --- a/tests/test_observed.py +++ b/tests/test_observed.py @@ -135,9 +135,7 @@ def test_injection_partialinput( self, mock_injector, stream_catalog, stream_config_with_distance, verbose ): """Test injection with a catalog that has some missing columns.""" - data_without_mag = stream_catalog.drop( - columns=["lsst_g_true", "lsst_r_true"] - ) + data_without_mag = stream_catalog.drop(columns=["lsst_g_true", "lsst_r_true"]) injected_catalog = mock_injector.inject( data_without_mag, perfect_galstarsep=True, @@ -243,7 +241,9 @@ def compare_gc_frames(gc1, gc2): class TestCompleteDataAndAPI: """complete_data (single + multi survey) and the unified bands/survey API.""" - def test_complete_data_single_survey(self, mock_injector, stream_config_with_distance): + def test_complete_data_single_survey( + self, mock_injector, stream_config_with_distance + ): """complete_data fills ra/dec + true mags and preserves existing columns.""" df = pd.DataFrame({"phi1": [-3.0, 0.0, 3.0], "phi2": [0.0, 0.0, 0.0]}) out = mock_injector.complete_data( @@ -277,11 +277,9 @@ def test_complete_data_multisurvey( "lsst_r_true", ]: assert col in out.columns, f"missing {col}" - + # Verify that we have a single column for each true magnitude, not one per survey. assert out[["lsst_g_true", "lsst_r_true"]].notna().all().all() - - def test_bands_list_rejected_for_multisurvey(self, mock_multisurvey_injector): """A plain list of bands is ambiguous for a multi-survey injector.""" diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 3c07228..989e3db 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -19,7 +19,9 @@ @pytest.mark.observed class TestPlotInject: - def test_plot_inject_namespaced_columns(self, mock_injector, stream_catalog, verbose): + def test_plot_inject_namespaced_columns( + self, mock_injector, stream_catalog, verbose + ): """plot_inject consumes the namespaced injector output without error.""" cat = mock_injector.inject(stream_catalog, bands=["g", "r"], verbose=verbose) # mock_injector is LSST/yr4 -> namespace lsst_yr4; columns are lsst_yr4_*. From 3566fd06b73c75ef0e50867039082d36d213db95 Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Thu, 18 Jun 2026 16:24:06 +0200 Subject: [PATCH 20/29] complete documentation about lsst --- .../_static/lsst_dc2/LSST_efficiencies.png | Bin 0 -> 111090 bytes docs/source/_static/lsst_dc2/LSST_errors.png | Bin 0 -> 61881 bytes .../_static/lsst_dc2/depth_maps_yr1.png | Bin 0 -> 127410 bytes .../_static/lsst_dc2/depth_maps_yr4.png | Bin 0 -> 121020 bytes docs/source/surveys/LSST.md | 126 +++++++++++++++++- 5 files changed, 122 insertions(+), 4 deletions(-) create mode 100644 docs/source/_static/lsst_dc2/LSST_efficiencies.png create mode 100644 docs/source/_static/lsst_dc2/LSST_errors.png create mode 100644 docs/source/_static/lsst_dc2/depth_maps_yr1.png create mode 100644 docs/source/_static/lsst_dc2/depth_maps_yr4.png diff --git a/docs/source/_static/lsst_dc2/LSST_efficiencies.png b/docs/source/_static/lsst_dc2/LSST_efficiencies.png new file mode 100644 index 0000000000000000000000000000000000000000..41945a7e03371108ca2fc867d9aa02e004696e5a GIT binary patch literal 111090 zcmaI8WmH>T7cCszA-Fp&F2RcjrxYvF;_gt~-QA_dAyAy+Qrx8l3dP+@aVzfkwC{7j zaesXo$w|mKoU>)^z1Es@u0*LS%VD9Dp@TpmECqS#w;&KA83=@ckBSU@gX8K-3cLxq z%Di_~cd&5vFm^TvDH*#u+Bvw|S)0(fn>)K$JAB~bfN*hevC&w$x;nZDadO)Ke`jzw zI9qb2I=^=Yu7c($uk8W?anS#L!FhfbcL%|NKnl`O4bSYu6%Stx%{%eaA34IJ9q(uo zCwxwnq-%nrTdz6~=348%wC%UXbg=C&`hS`C@i+>kktw>y^QJ-D>v+R?y}Cvn1c7)Y zD>&p`AEXiUTxa_n^Uwxm?Bt$PK-CD4rpR7w&owFW-`Q2+QON&w)`ss5FZh2at5q1og8u(5jV|HoDVWZt9lZ3R zt!n%XIAU#VY*6A8s4@2ccS|);Z(rZpX&=s3yzp_U%L8yUf(4Zl{Xfn4JBoC7N^jm^ z0+)Kb^GZ#3{Rdei<5Rnu&j#?}-w5oLi`xdnm|n}FK!b!mPiexj$bb9f=H|v1NJY3C z{og)M%{*0p`;7m8|FrQogB8@&fWN1++s;4;WqO9F17dH_cjzGyT%esKTt=V|ZAbjs zf=)2aYMKAWP5ZJ%TFTp7$YS(UP)V+L`OKiJP|o`nN7^r)cQ%-mLIgfnhfr;8(pCR^ z`%3M4WO~`y?o2*gog?r6ZkwaotitQrVL(7Yu)gHbHQ+Xz6`$sItT-P;-xQFh-$6t4HwL19! zn@P*5s^(@)3=Ao4ZS5S>u7^Ju*wkXnHgoS=U70~foBdHF+-8wBdE_5j;HU#0AhTce zV?=$fj4pO3tK9wmS%wXDT3VXtMi{Zi5^!m%(1?g;TM=oXv&y^;d~GZ7z`x;wxXiy1 zbUnUQ&PIiT^O?}ao*!KPo9Nd3Z{J>v{28V%w-;D;L;&ox#O>fSzPZi0s`CogVj$9eFFk!6!?lKtznWd4neoonT6IcXGQ%;DdyXMzdb^I;`klc2_rE z99W$!nqUjmfrSo~0tY>o1|7fpA^Ly)+_(D#+-$M!9Wea7^8zd^=n`YjF~H!<;^XTt zgsVrK>3#4<(Ypni#Fv;l&%=}OLC2_G$TO~Iuf7~rfzU29NvaXNzvc*XTQeP_nktNJ zQSo5x{6j+9g8>33*vSQV3LulxL3+$&1L_0&!J^6Zg_EpJIFiAInSLEtz@Uk|(A}sK zf{$ayzWbywK|*(MQQKl}H|o+$&nk~TYho0N-E()GWp=cc8NFluT`rmzAebPNo?gfR=35I@`Iot>R#9T+V=ec{5+V1GXiKYx?v<}TZ7 zkyr24pKvWg4Wq&KW?PJW~doTe={nF;FBb=U>D0=vfpRYBUZhh{=KXJJdLw8tt!(1q-&n&JpX7 zl*WvnFjXzW4xw|4v*kn6Jn0+big70Y9?x^(qc!1Hy}le^>d7C7XtJJlQOP1&3zIe(3tK>|C<@h1DJ z79}zPQZNTeFb5);{aBu5F2Gyq6*a z0|QLV%+|AC8^yD@Cnw;EVg|0?mrU`^zpH+>_x5#jbE_C|oRlHvyI+2xn7+OdLH(ie zy%0v0UKAf8wXydNo%9}FmT3Gtk(i4@rek0^f2q0oEC zgo#SA!`)%V*s~nl)awh;8d461jOza7NUi*EtzgYvDgp@1tX0^>L4AhI=z3=qc?aIb zEST8qqp`u7umP!o8pz;;;y^j?Q)nh*O1gLjA4@>>%2ty~`WlK&2RMu~&^ zU8R<6(y+B1N3dR_%(#!FV;wv(8m&Adx=!L7z3#v+?hFVVB%xGgi~bc{Vu!Q*LU)~c z0p8<`X!vURWd{|M9MS%U%Zgr3f*1n77>PR}gL!?QDTF^_09xwVF&4iwWHQhlgF-`T zZ{a_oEMrRj{0ioM;7kMjUTf1kL%$h^o~h#XHW*ROf?ekjZ2nYVyXvahp>b;Af$xcc zq~UrLHL*@(X-YFj(eMi#|%wbVtD)S}?S=h?uu+FfSpg>?s4Y2`v{Z_E(F;Hc_RHq`J`r?VOs1&7$8kG^iAcz?wfwAJqu zNQc6kTjDA#@_9+E#xP#KC!9<$Og`{1jLv7hN(fP9k3+(}ao3H> zfE+k`op}XWu4;?Sh1)fWo(8!jzlYiYiVz1OGI6A~3Q?y)z785p-4&mt_o3CUr`1;O zwjBvHdj$tfcN{JJ-TWRG!+6->{3+gx>K7PI7Xf|#4@Y;^hDqz+Zi&8RI}|`(bf>x_ zj6OO9^YgOjpUA1uX{+?8cM?Y*2GNk&SnOKaJQ46BuU|moXvxU@tmGp8x@q=)X(c7N26fsasF%wWQ$?ZJ(Z}8S&K;|9YsYN{7D?G=WJU59X>6Is1b4^+!13l4rlCBRAgNCSEy5CbJzuH6i&IIMorip%96OrJg;ub!T$3+A2>;gp}E_oX< zaIqdjAaQeaZ?9?xrkxQ<5=~?y1)ly>bRS5P3dzG#7SV>Ml_Y}PX{6=lFR1##*JPOP z&#_z!0h`~5!{*SJ3ZA>&Z_Gd48NdM^u!;V;`gR0!0OQ@bhvT;IT>H6hl--Z8il};e zUqtr)d;_owBNgH#YW236(%YU)B&Otj>nr+dcyN9U6^_(TUy|hCP-4*@0oEQ}FT_~{ zl^&-*^j)UYURd$)^VlLtOF4z+9x5antg9MZTP6~X!XfiWp9_!FR#j2J^!XEkn{vq1e#Hv9-rJS3 zCoKmgel5Q^o3aLjXS|W%M!Xs#zZ%3jdM!*T7?V+68#?+SyN_DeR$|q>^(~s*kuVpX z=S#dx>rNc1Xjp!)ZYcb<0zs=XY&2_a*VDTPweTgX1%%-2&R?DAG!r}JZhgZAc*JS9C@f>x_>Kf0w<}2JYHnZ>9DCXT&k)3>XPXLK`W2i?l_`q zy{UW)KN0StCt{Q_S4;uw&(L1B@Sak%a-REwSFan&m?n!&+RnaptJoA#1k0Y$>5a=3 zrH07gYK-OmWR@Oz6`AUsuem%t9Vb=%K}31~CEYt=_@8@b(J-dc3nFMxu;io2p@1F; zB!6|-_tzwxo?};6MJMuu7SN)J<5Q@SpS)Xn1~5i4(MB>CvQzx(g)8r=!t!wl}ATGrAut%CzwW5bj#`CgfBC^ZD+)NR?Y+1bWlD$i6(xoTfjg z7fpp@$?pD|Gm6Zctn?I$h7FgldZQf58QS(La4*Yr<=YLsk>;HLzVJ7pIy$^sau_oI zs6Sij!o$t&t9YLQ#E3k?3LrO2w$d{FAG8b%MKdPyii&*`1yZ{9?X!-L^Da)nYw5^4 ztqD)>;YjNJ$)9Jx71N~DzDD^&P-B$#+Y0!jcsQ<99e@_ z*g4Y6RVli$+RRM3sVMm1$xJHzYJ*pK{l3WAuKbQnZBe@DQ+VNMN`$1x%WUT< z3zZf^#^q%EnYRmjIFF1FzC)A9U?P4cf~Sh*gbRHKlc1xQyA!9bw<1oc1~~VqVW>UF zp<_B>*jlDTt=*JJ5d?>u$yRe~qJRBH==u2;-<92m;+wQwA z9`$z32(?b#1=8R07k}eie$4gfFYJlQ$(ufU1_rA}Ythkb#o5<;QzccB`$@ea zCZ|)|oSSzJPthvu`yLo@>pU@NVTNpjw)M}U&?wV`#;gXiQ7na_$le7{X_r@>r?PzK z{>4IY@Ej+i7$;-dC?Q%gxgnn z!5cK#OHDU;m|Y!WXfJXpQazm=!GT&6v^sMbwRfw-Gh^NH6N*Xu3(@2i4$#QA0a{8@ zKrDsJeN4LB8_|<=`HF&3EU?5(F=Y@nl|%?cX39oTO&C1{KVTZR*(h<=bUd2Nq2k`B z-j0^LsZ>MhSw2#-l<-76o_&JLZ%!IJveO6+tddF+Eq%BY666uLpA@_@t?v8e{0cM5 zMTaN>)}3+7{5PI66W$g+2Hd&FhPU+S6Zg8lJ`i*Y+q-jmfLL!FV@gW;%pK%B9v%AA&^SLw!<10R_#d0qVc zSRGlFTRN0A_*JvjL$O~%P+uyc2KRG?Mkb-+(t|7Gq-#j9t5gGqu(XqmlfJ2LFbj!p z!N6&&CZ1`T=Bmafye5}^;EIzt5`E5HzCrIDOJSVNM0*T7XLE__feKI6U9l+1YXwlC z0)DJ9bjmp4hR8!hFBJUwtSY>J;t7@XoFLYZ}V(p`)9FRP@y#s)pDzB-g zsVqKQBLCZM;)}g06abfCCu0>Cr&dq^I_q=NLHtAPzS2g#VkUZGLX{~x*z5ea@%Fd0 zvCiK;At(^Ld9Jndi;D~8W>;8Y$Hn)q+8Z<4U!W!f)L?Sr2$mMFVG8LSU&1-UAtO#a z9ll&r94hw8m5KwBg(qEma$TUr_`Vth!OAz#@N&EFv4qj}0uP$eGJOP!Emn*X#9_k=Oi)1_2{yDaO!2K_>1bTXix0ovx1$PJafyyZszL4oEfScb;TLj& z+4A>f#qQSi0!P2=_!4nKF@iLbjxdsmG%(d*AIw*b7)e_O9*a6n{ZP$Juz+YH&k`K5 zhNHgk<|dZ-?U+SS*&lxBta+VzX`u+B``R=Xy4(NJ_|4aLb%Gd;c5IDGUBq{*=+8Nb zSU_wg0~mkNkjM>3sFH7)LaqF)dg-d0cy>k};`G{tEiIje-?$k9E*}dkD~8|wm8Sjo z(a}ntt&Gx=vPbQ-sBj`OZZlK>Y>EZ8ThqR9ta3koht=3Jb=z4d@%zL2mg`lYEI-kg zWbo%R#~zMjogI#_4II5jYucWe@Mh+mta<8d9ATXAE_Jm9r-;~^mOU@EHSWm}>8Yr^ zAjj1D0U5ISbyeFpJI8sa8&NB&nJtO*F9hKy2Wbcv*_mA5uVXnLNagiJv2bX(q2An>kLvQK)U5e^HE%$*F7BEa260@5r5ku zCC&B*tM?Zog0#|--%Xl+TB6+opYBH;m1pbk;dEbZ+zU_@Liia7O{`e@*Zn7U{aIBj zn9z&%w;Z>hfw6zxf)BDL;yU_Mlbo<^&{D}zIobBco$QFmyzzxtq zJzLwipDilh%B0g|ZWgGBkV8X`0|&vAFCoKJz*K! z6QR<5;!kHd?H4~4TOR&=KLg_2**4pYo2`Vcyypi-X*FpzHMJc0Buh4fb`s9^Q}_#S z(YpG2Tx#mI!rAK2=BF>Xhw%UI|Nx)=V z_g-m)q=XzO(b+`6v;%1w+%3(nr&EPnhjCu9k2sTBeI(x$5Cas&e3dWep%ihXURxowZK-bGK zdP(MBv%jgTMwTC!vm!cnYHMxDJg`tXQU&)dh+Z$h68t?M_11%G)CAR=6or0_mrMs5 z@jeBaxHuESx`5a*f90`MMMc^ctykkifEo3(P{nGU6~Rwf>{nH2g%OsS4^=}_A((ep znZ#QkR1hVc$CON-TbJWV{D|%`iQE#y4?WZ1^QUw4-idiN!3dv2zMaI5jni+z?>`Q3$T#1)qa;46mV<+tUPT{paFD4kkbo1u0$64D(Vrp z5~DqTLB&hXsb|0WVcc~B-Fp}2l7l-2IP91mjXi4HR@19Ns+;2j&?Q*{ zALSWa9-CmUVG*>l;v_Ht}4E5A3WKO5~T-tr|^8fi8mW2q(4n2VLloha#yI zthym&hi#~5MLZ}NB(?bptmH&VgoFF|mm7NiOQlp+Vv-Ad=vNY03H|fOdDm5lO}7d2 zeCLOpuW$SQ-R#y-f@yakT<1=OR#orvSC@lJz>Qx!Zp8`o+VPtn%vQPK!3ErYH#`M) z3l!7A*q&mgEF<2g!($S1Cw}|yKbl^mlPxFmV?UF;Lh+N@ANTz;jOU&@%|MyH zLp7L=cPTti7AYwFM<>+Q6xUB^0sM}2!RUHe&|t5p79A%(wau}n4p9dh1Km)Q$DW0~ zlOKEMT!ZRTh4ZLf9W45S!;an2Sfv(&LtJr3QPfM&Y9*3RWy@n;DHDu|mKobQxG{lB z_eKZq{O(gtX@F|Qn4_T9Mvv|uk(p-2+|QeXd9K)m6W=zpzrH>lLB?ImG#bZhB&N-i zhecoov+Ub*WpOcHh&otg-}uv=J_3|pGD*~t*glx`TCT-8AhdbkF{YZ91O|2+x7mfs zqD-%4w80aK-!G_1P0;MOkGbIy0ZDM_vM0Tn&z9m>P7E1qJ# z@KaLi83q3AGS}H0WG}k@d(Bd`IHj6&9<+l<7@qjVz z83}n>Z0+O-2~|>H?Ec$I*5PhoxA?V4o{PtcPNw&fp9m*Tg#1yGY;8LM1}!bVslz z2%PC1W>qi)x>sCw6gaJ7y8N|~Z;v0nybs}HkjIZNfT~X{2_lj~LsC`QpI$*IdhUMz z_)ybg?(5ti&G!ncx<|koNd&?Nuh6q%8uDV`Ak^)7tA@%GSrwjBW0A!E25i+A-ksJ} zJ|e?U4ucHRIwZ>Azh7{Ou4{_k3jJ8pvM-_aVEJ)oplqSi;== zg^8&t#O3#!qR*cj7x@4dj*_F9a_#V$pG7f!&vj&iWedc%p7bSGycoCdJ}P4 zmP2^6orhe+=EuS8&{8kkd@S;L&z-d-{cWaOi_$e6jN<8o4dxZ9iCBy{2y#y$RhU;d z`(?COt7223@6586(w7Dlzh&3ZA9r{#=B7d^+Wn;eyf{Z}RQT-2ckb{f$4_9NZ|56f zf#TTNvFEY|bJoYB%_s`#P6M3Oo8K!R;qnTnB0YUaeV2t@UrH-o--74xqG9V+nrP@0 zGbFf4flQ|77{?thzQP|CZ@#WwWo!hLs#i`iFV$AvMFd(;@0J~gZi7$2jFpxxTTr?FmQY!+0E>73a zFVw{Y`C^gTT||qC{$o^qUi-Qll^vzGP*fd6EdAJZ+~+`9>fg;-ZD!=(-sMbfCj+~h zgLL*KyQ^BEkPrckD&nuN`((A-`^hT5Y4gIH%VCCmUe&d3vNNR5Zt;#J+(>>xL(rVuS?_P((My&u z7Kuz@$&RIUsLISWdk-OF08i~Hge<*#x*p2)so^OF3%fd&Gk&3l?mOJA$FnYTbg-`n zGLViI_UdYsurF|dQY48bT)c-OS&@-9HXCM_tP5C^a?ERrpUIp0IQhK34;B9$8k4?> z#i2pIv^jfE*rkVNS^P}K{S;Y%fGf5owOcrZG`*(ZPPkq1BWQC^N5%rFiqv>&HH>+? zE*?9qR1Oe)42uI=6t0(KrRV?O`Z z?rO8U;Kq~$vSAcEa*dC#8yc;h{LY3;UATm4vBI!1a+kZ1zsG+Fle+S0W5Ms4m0o#(87%jN(NmZ{y%esgW;XnVd-%#%;z|;eoJ4g)jn0PTztkuU zGAUutKBpBmBHpf7J#5_0jCk_q9^p45&VK%|cQN7D2&dKkW+9q_U4;$!IpqdH9mB=s%UTRZP{6X8-y`_dj|w=$e|=v$HaP)cu) z=l_Vedz-nW{J@wbN6Y+HwHp;L(1lv1rznR3}!-Cf1#g4=c&1$2^bj>{>4e4z*Slu5&jqO z-njG0C%w%ZShjjoJ3(UWmtjJi>(3Tm3?&wu zK4HTg@kZaaCGOSjY#yk_0bNA7;EElsU@Or8LXc~Knj{{SMrdR#nL|)W!Yw+Wpce9G zX`73KtUaR0Rlw&-im`Cx=KW|TvM!i>pA&$IbF34jZ~j%O)4gUk5UC^LZ?*(sEI32# zJMr__r{T~!|FZU(vcQD*x3nHs&LF6eshfG`=-r`M*h>0LY5KQJihELc#5Y)NBvIj+ zl!4(gd#b-v)r>IMdh%tf;eKE6Z+wIHbY_rD^E3F+zV4(%9?-nDl$Z#kwfp%TQoE*U z|F->|S}IXog(oE_^(E()D!q?g>7pxrwzgq|CmRTinS`442l_WP_8o>kSJ&04*VdNsI!0%MwR-5gqn4O*T23>NvYEYC<C0EdDM(9;693QErA6oP@BIg*+TPvSstDU?X#M{1c{JnpakEmd}r@W-QD&J3xp|%T!S#ke{_f)xnom*OQBwGR`jP zl-Ulq)v0p)Op+XZx<@TZEnKEKNKXgLjfn~e0u5wX?srzjPhU5?%K3=H!-lqE7Uqmq zJ?$h+zcO$FNtUd)4DC`OH4!3j zF_V>}Ti2wgQ9s4nf&cA<>~hBudDjl2b+4mV{|r|Y-^}%kftc40kZ&TlOxFbYqbWF9 zdfV3zYl;&koBIYIw=(vUCK`G!{OI^{qg^#BwN-ig3i(j!g5^X)^Nj=Se~uGG!z7&2 zr0TXM>UJb2!X${r2*~JTHUOEA^c!ARV<1?)wDW3W(K|iYo!8Ah5q39yKJzsHIlyHr ze64@UU4oV3?@3BZ^sM_9S+WGz$#l{4!LQ%$0;5b^cq1t1``JZMqyG<_xj{PFISlh$ zUk&dV+QQpLGLVt`P1?;)3+<YOz|-^ zuo9nQSb5W`e`~k-7NR|vx7gF_jT2buY=UGfA2I+njSN0y1EA^br{tqos_j>6I3Ux! z7-K3|MgZAcD)L7LPdi^#}QTN79T29O;_ zwzlS-Cm27K3()dyApGdAA!!%d!^=*a7tep9((Vlt?~2R&6VER&`tlXyALL~bL8Om3 zRyTbbU)6hggv%2(kB~s9pf6Meu^8%EojlOanV7c`nDxpMYpU$hSSJ+feakXgs<#J? zRn5QXB!W2ziW?4ac~9M~`cN7V8lxghAGszc{S_LGpxliF9=DQbedw!z z>3%}>dg$lMksSM*yY{t7VN@a9?Co_zRh^Gg3HB@ zy5Jp;cV#b0LF;3#7$#$M;e2&IVU)`qd{K??dW>8zZyZ;KPf&j=b$*vqp_NXWJhQ z%bWDQ_dcUy|K_Hp3*;edr5LxOfgSgi(W_~T@Xc2%maPWLx$Q}vx1G|i6|eSE{vyX(GA$sYHuIf9KRR; z@LRIQ#*P^%niu;-vO=C>a&KhiNzsrwC?0A!?L%@GA-m=2_L#%NO?eMtutFCTEb0UB z<@;m?LyBg;OfwKD>s`;3aQW%YG-~Mn!MFrKGf-33^05N)%O!MuL5<@l(2o@H^Y{UZe{_pc|cp`O} zDOz)$mg1`-O;`cT7hyI_;BzxfjNJIHc&xq~PlVZAXQKr;fH$TlDC?8L?=8R&$QnDF zaUvHJpZy~|4g)Q7@sjLZSbLu-z$CobGis>)u&%ZopiZ}jO+^rC`rkiOCUzwkAwsb9 zzc+oh3DDXG6ufl%kOs0^83kle3%?s1-kZwmBNxVMaxVU3; zpkQ*_lK$MBgm%E^FSafHMW%PN))>{YK;DKvcox-V(G5_i$&5Vz%=bLHyqo`-7v{BY z4_2zB1k>W;HWGHW0g?tA7!caXelqBY?}yxD%fEhHdBM{0;=S%!5+`69+zbF98Z0`S zN6YG*^OQ$jzcGfKu5X2CboPmB^vJZA5FzBOe_FoXOPTkH`z3*kPZrqJ=BDe0o{&nU zrIv!RLImrI-iCQH8+4xNqp<|={y_NB=(z#bJ+l-0RgHaE2 zRHjxBsV*F4-ZIQ$tzix{Nt0&B6}b>Yy+fVhzn^^WwH>ip14=GRmHzI|($km$RNNh_ zS061YY8}pJ-VeJ`^>L=<^%b^|QE<+=5p-$!qa`dmii2*ZPQkH}a98Qu1*1Qja&+PX zvm(OQ6Z)iR_-hnP<&X^)b>m)Sv7T-ivo;Y5s{Jk%rw=K8!5i*~nBb|}q2}J#>Y>oq z4>05mK4NAbkDrx*dwahx1d1R^NjKlnwm|Gf41`-h8)V6_$aM-MV2?zv%+A0iXdk`` zyG+Y7@xJ-YWfQ#L$Qm7tHnQ!x^^0Xxw~cyr>N`6S0-0(_vRDk27|Z&KOOpo(Umvc% zWI&1W^nXWKzWl^0NKtmWE>^=;mR&FAX+sDzaspamO=Ak3j?9O8bi3~& z4PUi;+XD3L7_IM%py&}8( zpHQBtJvwRVY|NKe>tZ&p(xs(yhNAZ0V&1IrBx*jf&S1Q3A(X2h#3Jg0&_6gM#%zE< z)tf!cJI1LaK1tTBb{7vDxM-g!^P;uU%0A)F;iwJLqzW;JwAG_$%&f}(c!%#m#L-)IlNv&M_Hb zbOj1h!K)Y=J1Qhw6+ZDGNd~J1K&%nEcD1j6U09Z4e>AivJ5#K?-sNi($bfPfVJLg{ zt_)DjAbYal@cCoo;+C2GExsv5l9hX5Y><3Msl)e7#z*|UST7n4(owtDE<7n9Scg@3 zKlT(2|FHJE8U(_48{+sJ$^}@J64j1GSzDu2A=Tjg4jv$`s%Y|x2IOyTBI~s}>?5jK zn_++km+8@hDZ1;m)IjTZAXa0@{>nwr{@Wlg{-(`2S~U~!l@W5+J{RovY-CI zx@S-0@c{tbQ4#$D%ibJ14T6Hf+*j7A&%APtD|Pp9K(ZW0!|N+vsg#V_MX#+aQI{Ra zbFa7tiDRZ}9iE(!jSHtW#=bbKCyPsqEG_w0l2jUIF;HS6>B?!xIi_YW5UJxUvSp)} z%-wFF8~lo(E8B;h=!+Lh7eOxOP3F!^tlm6iWy!Rqpvy4En$Afd(Cnr{zGJxKE!kGE%6-p>E3QY|-O@5@(A1Y$cl< zLNC_XbDm>>^JVoE^7PTK+aZsu16SZOFK`K2S@yZ+Zsx3>ZM(Cm@A_4Q>Tz8~{FE>g zMH?}jtOf!f9RM`5SG+bppAE>W;hKr9Kt>X{@s1?hVqOXRNj+F5fKCVKv5XIWkYYPH z0aWL=Ejq&pnEN*xuou?!9DF~vnNMI3Ia)vGTQX=0WWLl1Rr0|J?#>Wfq4dZBXyGF03PBbMVP+F6SB>eW-e8br}q3UCoIFL`WfbKJ;E2?6s3 z6cAs%3+Z~&n(;Kr9V8}8YMBgOa48tY!;Xe+tCE3eDNc-_r|($m5cVci*&oY9zRRK$ zuiI%8;r+Gf;^BEzWGnf&)vk#ku$7mdza>CoJ&!k1S0ln3D`=^GM*P&!I;irHllE2a zRDT@$Nk)`omyd*JOFhf2TtC1L$kf>+F)Oss)Y0wcj36~H;xH?Y()kF z;y=|uv_Jc|M$hI&FwOe%uO2}GFUOd{j64z4^Awau!Cb)45B}b?^K~@&Xmj7^qh)IH zhPtcG;-;c6A0+sGf3P3XG{&?jSBab-^!ur~+uu$*X2?b%8Lo7}dusXw9iRr`0F8U@ zpOw?}lQ5t%LS);AX6c-ave0H~3_R9hB>!pVP!OncKv<0iTCrb@2<^62Co=Yw4z_87 zM|$`82N%HL%8$^Xbg%anfE*xgiV2uAuE-{w^ym#LUrgk_`f?gzC1MPgQ8vQ3YAW6T z3IkX4o`Eb=_z|bY?8vA5Ncgo2_-Rs{oYK;2LIV>k6CK13(Q<$w7A@iV6qVf0B&j?xVuki ze=i5fHP(k82*xWpff^^&gLl-snGm|?I87$lr#e}&OQ zN^-lQ#2XxXIPW%uB(A#WEpaa(_`-r>a0U1Vp=M*jtR7!&s4ZuSO9`X_WD-6asDY@u zEJ0Bvu%Zv|0nP@nAmJ`}oA{d>&q~9t&cZ&L{fmDw;y!Hy8E)QKD{^7iJq|i$x<#DY zukkBUWzKU6wNwlH4uxrgU|9^Q%>^!o+?C0KXI7R(xV)si`9s@!xLYIbaX$)PD(^A1zx3RFs0|x?`pvWA!SgGdFPEUXkge z((OEe;$D?4n94V)m%a~pMNnofqqQ=SrPi@!pz)#gFCN#I(MFNXjuQ>z6(*vC&32Ri z6?uz}UflTKIA6K79M7p3owaD(TOnb!M^`Rt{Ti2~-ckkeeP{FzJ3T_Yv@=n~1MU)7 zM>tjBSv5x1r(26N`0`td7`pyF1#f z8kg7(uUO|CS@*E22Gm90Rqu`*Q>#QU#t*A)qu=7;Ho^fr9#CGX>4J~4K0}{%KuVEd~x(Xa>Tf&n+fuGcdx!>5UZgK9MX`tibmky7JL$J&z{5xX1rc zNj^OV;QXKyv$y!cM8_~Jpq}M&{921L-29{qEOfkfxoDO^NNCF$zWK#YE!NUPI1<`n zOyx;Fitr(5kYoi0iHfw@dcFXryU4~}l0_PdpkPksSs;vWyqJme66N(uc~to8lF$hL zclrHlF8=O~#6GW=JzbpG%1=H4 z#SDwC`0Z(XRYWCb!bsnbQH&O@QQ!DgOHWL6Icg)}HllOn{2K;iZ~T{o7h3ie9b?-; zKkw510L94x*Sfw6;XFXV=uo8lo-of_ME#pNSMfuSN=5LuI01>Pd0#oZJ;jaDyWSJe zVA{Id9(iRzqYK^hC4f5%@d2wEu6DsgF>-Oz>eza5Od%gl49gz?bSv2g zNU}!`2S4AL3)eIky@aD>PDtG`jGB}cco9eG<#Ti!HVSubwLcqWG444m9U45xR zmf1+4`8C2{P+QNd!f4?!aLws2#o%>?&Xfz(_FV(!Pn{d>2Y8u?5^l=GhdJL;sWTW5 zM{_ZZMUYhHnjP+CD>F8ISSerRxBkgM68GQ{hYA#d11%-v5^w@ht+th~I-yaedi?=} z&b~EP4#7AlXJ)mv5j54@AG^?P~=7r57&eU6*X0@$(w9Af@9mhTzQzpPaX)gpn*0S(l&>72rLXzrbGi;;# zx-t5M2au+H>aZucuhV+dILnq;+1UCI7wR>axOsSzl9PXS!r{8T{f7of z`zuB6g#j*$vQ;u|8{a^?ht;QIBRvQxy=&5ZM*V1l0vb-N`O%849q*bdWab<2bM=Zd zur!6|suf(^K>pD5&c0Ko(TV{i!ArYYSzQ2;y%jYCUvgcxp-=8OK&O%Zf}~UvyX3JW zP7jn!W6Q9V$p1T3`7@D%th7pvRl_-ZKG_Dp;XuA#%i$@Se7e6W>l}hG%T~SaD-Sl3 z^l$k4!r#h0y2El`y7ppBd`ijkHMp5>&X1uWbqw&k5DZlbAg=wmLuWRM?_bTlPzShx zwO^i*k>mf(39mqH*Zvv01Fl{j0tf(E2jV4(J4Z@0J{zT!C+-Lpd*>?FZYBC*EOVcp z;o2@CDoux3T^OV0-D#zaqmg-YzIps&H+u>AV*p~0{DkBK7k4+?5WjW8YimbG7x?do z25kCYDIh#H5zgs|o%QCjWG^Ugw)hDU+^lH>@5Gg>=yu;cHsrk?^;sjm$)tY1;=+08 z3cTCLAD0BYp{}nIFx!I$7@A8I3x-hlca1k>($hTukOFC}*H}@KuN^~ebd9UF@mHr5 zTSeEZ1{b^8v}WC{m9Emf zS|5F=)cgXK7RCAZg9_6$P_Uyi?5;8#0GLwOUZ8R3?42^j{dha>%bl$2PS@|}B(=8JLCPsk%#B`#E!MsUiW^rIJc-T+F$ z(1U@az-PxV&Z<{&9X9+Xa)lMXp>6-*jMSF3g(7d1Z!&EOV|{mH7w>W0*FP@yVRq`DD!odYoaS)XF^Lil2wzTNei?p3icNIKud?=!K0^SI zt;CfT6ig}q-gJtR=a&2`!eKZ_5e3_3^;1rycoC_fr)8^L)8Yq|aO-t(tk|oqnJq6= zr~4x>{fWBv+$`U39Riluwzn{ul5#n3=9m%7_`1hS&Zg}Vg@)Ji{P)Jtb5xWu&gr-D z8iSlP&mhC{1_v*W!5)3#=z=~25IX4kg|edQcv2`rlVVSTzw|M+*AJezFNPG)B>Uzp z3vTqq-P69Ggh`j0%SjgGEuV2ixuOS}S-B>f69W{GuK$dm`V$R=8=YWaKpn28V@aQY zbzhh&@>3;a)kdIRp2OzJ!$e%QE6P*dx~R?X&)woRIjP3VsJ#pA^%5zaXgzmigofXc z3pJ0OUm2W@tRw4v>x{ZZ$F>~#Z$q!7B>rj|kfPpY3TNz_gUDnuTJVh0YKA1GxI5^WG7M|NG;z^M1n4p&J|HPN@gkceF z`xyS2*US7J7SR#6?MgJ)u3x8rGFf62E)tSkx%NpS+&Xk=`J;SR+ZO)Ho1vDP^U9efhER7&|j_ZlxvH@ce?Pt6u<{E6R{9FYcd< zD+^r~&LeyCYJD2Y|9t(_pSjI7|qc7Bt zlJY&u^?Ot?8ha@&_vb$+{>H)1#QYBdL9s`@hn6Vsig=l-bp#zzdfMZ6lY31YC!|hY z#*4ou-Os|=!Z@bvxwJ|uj>IXdHHO4+9lqKW;<5<^vIySDpB5=A$A)m~-D=nt8ZG2G zP7lc0eq5z4cA1ltots;2m;2VOn(Q|AWx@Xri9q)1L(N|I#wRhO$hOwPZn2{X6K=g?#z?e(&@-@8+qsf~ZcJ0?T>TFI?@cTv18 zQ89Yv?~sWX(Aht*ymwIh5zgDyq>C7$h0Eo z?1EGxa?7XX(84ixmB{|30FUH{-#5Qvk0Jd7mmNX~s<1Ryk7;G^Nyh3W<)%;aT_!+d zxDN`Mgp27l*Uhs>`|>?E?dOw3xo55gKeFCbE5gEJds?_n2Y8ik6L)4*3f}R64Iqsq zWs=2R)?a(se#JFhIxZb%eHdi9)Ib9G<2%h{EZMd=c7<_L+rQ2|XKQKc*Jb37>LaBW4~1VD5gMeP!fNt~)L^W+L=|H@%M!y5$Y6BbV{ z>Mrj>dr=Ra+Sa{ki9^zF27Ss~)D2n+$Yd0# ztUt*ybM)Cov~Ea)22ib#2tt?cfC#^0y@f9M4^?==#et@ZZ+q2|G_vfi@uC-|e@-f{ zGDng~oysqf_hAGt_`Z*43@KqeBEH?k9Q4CEtj%kRR;6-GKlV+y80J4?@d-^z1>g>2 zKTa5XdSq+YqmTp}qgdT6IR7YS&)eyF-2>`K^Lvl>@m2LVPgTX4M(@UQR_a-Kvy#&w zB_BPNg{UYd*VRvM)#eu9Eeuafe+J+ZlnH-F zF(u}Y?@8*j*)ji%Y;s&pmqnw)RUUqxtbhNUsMipINK^VU@2i|w`O15H`UPV=<<#)W z>mDi5y9*tCIm>;~2PeryH-|HHiCN!RLGz&iTi+Rzi@|F)pP?kkG;jl@>K|cUHG^AZ zoccvY!SSEHT7Ie!gWIQ`+r*G141_y>PIJtbzSqeWX{iz_yVaODit9Xx=1>#ma>5_L zOO1;))I)tsyIGcB6LMu&g3k2DovTqKQnOfJOtquK%MF@;ZCsNP#Ch5X3PtrptHQBm zkLu0%%F4>_Hr1P*rIV-q1*u5gZrgHRYOYaT#>dQj5Eco31tUgCl;@IfAp2cZFY=M7 zO+x(O_u%GOHj$gxPBXkSk>dp}5w(P}*+Klzq}U$#1XpuMk_fMvE|D)}PQSTCz(BiE zVGxed)zhO08d-WxPh5?@zF4~WFC_hWPwWgc{2Jw&vhtPb^mjk8n3PGdn^dFZ3_dzv zk#~)hyImHjdGh^%=&a1AoUU0iHv@o^zCRjfx0~n-Z&;;($QOi0G%AYOXBoL7$9hT0 zwAKDO-n60qaL;)yd81+3e9~0G*G==}5PCu?g|M)0BsZ&h)Xh1xD3;)C zUmZUOt%74@D}p4a=}^3%n)a99+&tDpaoAIh;jE0_y2fUA)lvBZ6h9S^@hd+%Eajd$ z7kn2F#Mb3nxI!fJzGZCArT4Z0K0o38!ydYMGCf&1*)=qUMio4Q+dm*?UUB_N3!AkpPJfd zw(+w_cLP{xY8A0APRa8RIDoQqWz znzjrmbX*LYQ+6E1mErsTU9w#+St18lBSZVtZi1xf_NJG!uLnPP+Ie#{N;tJGJ6v$5 z_{8U5G9@bfiXqSA1bWZ!&sVuojV-*$wfra*#j+%)2a8?f6PU~W-xt4y&dYozzMX~R z${LBbW$luxFEKz{-+WN3xGPaS)8W*8Z&0{uMy95!dH*f!bSVBk0YJeZBwH*Fy)QY4 zJ|?>VE{4H$qJGQkD7b@?os>_m~iaV zf-?Mn+ih!Mcv0uX$#vwjLQuQ$b4EQB-Ky?V?@?isvaEi^Ipg(kJm{ng681^9OZ|IY zGaSvsb9Mjw0tU$Eoe(G!+?n^@j3Bdx!_?h?^SH}>(v>%Z#V(lz&o4^u_7G1s;ZTJu zTtJF{mN;&%SR+WSw9SI+IY~1OP7%4NT@T)pm*Tp^QuJFFk$*CF@f;Y@{JIMc80=0+RX_aD~*s?MOMqlQz*>%`W zJf}C`TruswiqhhEb&w7=M0@sP#G;I~h7LLx&PV6MGP~glK|gKC*&Q^nUh04M ztK63O+qZ9IHa z$hcO2l^T}aSLJT_8=w&_9;ymLqo^X3f+mF|+rZ=fagSMOQR}Q2Hj7$J_rB!f;zFWG`tzfD+xC1n zt11~4k6{4Tg-e3RbROew)I3y#ey6(zJSNp7@7}$Ge;9OuxI>MvA(&X|01+p-N0aV% z^jqJ@25sQUu;i@!MMQNf92F->2WM9ZZ*D$XFdM9dS}&hwEuOBG?p>7q@T0E<+pRMT zRKDnxTU8JdaC$($MvX^`Q-I>6t8^F%6q(39ys&h3yiq)y{`z&OViZ-2Q`Ky`_xhtD zp}p0SAdv}Atm67@0tM}cTqN-HV!L_kF2+fpiNe~xabrXWv8F_ht~EFJx$b{(Vr%AB zgYK#-zfNz5KR#dH$lZ{BmTBkxiIbSA=E0Sq|Lm%e68#%o-?2M?AsJS0hdf6Gq)V-D zmgVms9}oc%FI?LoQa z{`$CjBT!XID~S9fLUode_%kG;EzSAbN4S%w--L{m&M|JIh-eM|h-)%yZ_^w~d>Mb(nqyueC zzmqLxMDxq5x+i<7qAqOM?;dpL^+})CcMae2I}yEo`*wU%(y)beViz_dH!sg_`|p`{ z{2r?rB71i-Jb%olv*jCG!Bx@NIF0p=;hYm{55H$W6#LUBcwO(_WwVNw%{v8guEx&a zU^j5S{5mGX3*`b{Q>o1w0}-jvM|cVM^)dXax&`UY|6lfUZUq|$NA|VN*pu$-k84c) zj?+@E^FNvUdc`~luGXj$`trM+-V^Kqbj$LAPu@n2QojWdL<&MdCuDM#tuC6a4w+?7 zzKi{rQns7tnEr!t^QDll{!P+~G^ezOqEF_k*fh4bwuts5e>Qq-n0pe_luO&TW;=c3Kw6V-m7Y>hfU?`ED!aP6T6MVQ z>}Z9Q)=0P13-+Bx+?|KX_m8%x1dt7GrD>S>Y_*3+L~K!hyv)Xy)jJDZ0g^{IL{`Sa zl+t77GB>?C`&1dG_TP?nbAmr0h!%FpJkN^flnz`itptNT7k3o+#VM<#q<{aHgVRBe z{Mz2h$%&G!43dhJ^ts2RFLjd16MP6rC76iO^0mcHXLRTu_Ut&R$g|Vq+5FB4iyL9JrO_;id|O{8l#<*w8<5*`fYr^oD-(*=$zgR?@p=W*;kcRvPkG z!Q(c&_M()v0tpY8h%!HF1Ql@gzb&FxR5(kyFaa(6e7mvSOoX7G(JC?Z`cimg?lBiH zuM&u!l=l{%j(mor!9x|bQL2$+Us7yVyf0Z)ROGZ>!CSv6S72C*Ic(xe6d4(bK=QOz zAIwDYgC1=C`PuOenv3d8Rs7VZPqoYYOv~=$Gx;4%>qmvaj&ajdz6xffo(KYr;c(B6 zLX0P;$&QKomwh_5Xx_W$=-_Vi>(VnnLRCztZz9Qv+S46WBC)keEO)t}EicR5ux&#x z9Ph^7r>g{?s+XOqouzBh^nNNYu+3Xv+2cNYzJ)VYGUA8QHK1t6J+`Z8^5uT3VOw70 zu{UBn3udN+(!fMJr?;&mhMwQ+&qJS+txg&tySwEbS72}VNG)%$w_0@chd0}b90^E2 zVo4uus+@2so{>%ABrZLAV}1GTVF7^JAG;{riQC#rZz)->TUXUVdTp8D8ZQK4rTR~(|UB6-0 zJ9qELj~^!%S(h3<1~ptZPRsARpH3c!S<)0pktxB6z8n*Vc4GgsjU^Z-Lm-0TQ;j)PyZI;%Tsz!kU?X;f1>m7DJy)m_OJ)&RL_=m^TH!(X=xijoQ{hPJbu85pSd25 zBUG_+D>ztijrk+Jb3JLQuw(1`c%82*ZstdoxiDtGaJ1pCn(*R=vxIh+AJmepz+S7@ zhDw8gFpb#LhxyTHJ>)`Xvmb~-1<2fKG)8biPYzKc(T(W2FI`j$pY%BD5j@f^*J zfZ|fuMGYS~N7d7z^f!DC9uG>P+rWF%#QE=kB|$V_VD=%|JU~0h3V@H6stWsG&3pS4 zv<5|g3$?W%(6sT9E=d_J9!B2r_6}A+ z&f{lcd^{7$tArERqFbAv1}!e5wQgCK%g9fSone<4w^4m|73f2NIO)B;nUk4`Kw!SP zBJ^ZVC7NF3lFV$K1-js}Kkck9pCC>cxou4P^*RpkOYskT1W~za0>lT|lfo!)3^e$p zr)Hp~eEG^1tIeqvM8F!V3O3mP+;7r<+jX(m@rO_^@;+$J;^+EjNcqOc$M?^Pk)YSc zt!F>+;p3~9?s^jX_Hp1Crma0JE(xy{god&u@?ITB*Yp#bvd*kgB?ZS~FfWLyy!;|e zgu_HVt&NRMo^Rv93?b-l6n739n41=#GM^t@kdu>p499i2W(9!|c<>#8K;IpV_C#pf zhtthFb%1sSE2+?K?G`ocpSGBmfb_@}{F!E6b z2t+;TOOH7}+iz0QEH>A!t<;n{#Gap@hgpH>}8hYmB!u{*z zhC>{zfW+V9kvA+;%518?afOw%BF-t}A-I(mLcV%nA#Sdg_YJAxN*qiDab3ICn#^y# zxs)9@ByLU;EY>$z*>y4##n)fuZ2mn}gxG$#sBoB9mCWqfJSAG*X43EYI%q=QJIF(a zyZI?exs5(q-xDuXt>(EpJo^~L93PI!67H4!0~saf)xF=W+mRKoz$l9v!1x@tQryJ! zpqv&Y4muzNLF;3%fuObhP(cgmh?hJZV5>h|NWDR~vSB*jsCB22&*x3`((qbsN^(_uIr+?MBa=u7RM9p%59<(;6 z0N*2)b=0AJ!z=*>MO}G<1H+WK`?s0)mYc+(iYq7qg)H7KiK)1f59h`eJ$?r^OF2!$ zkftSM{>gk=GrZCc#xg!3;W-2aUphLh7QUyTZCQnVwFxg!f0#Psn8U`Ml%G7g`Jngh zZ*IB~oeRWFUrH?7eENR={K@}xsb8Nq6&<|9W^t*Uo$$}0@>eQ2mUQ_geYDf8XJ`IY zJDYflD=H%^UY!b3uLox6q1YCDEJnEI3~8}wu79?3!+D}!xDFjdx&f)m!t94ky{nIMLnV|rq3w#aC}x)tr8lSat|#gs zlWEsICf5iI*>37X5W~Q-qFN21K|%_`wp>%|8-v!v&+467_Om{zWGr>e-!Z}1)D@_z zeMyM}Y#blYUy)FWweGokq5er+%9q=c@ukC<&_)8Bd4pS^i$)N+>bRI2?#25TdI}%y zGQxjEL;u07_-dycHkGqtnl)4dOT6a-I`k=UIh@Zs-?1oL$`qc@%l?mlherU9d`CDela%aQCWMbe~u26p-n7y~=7JI9n zz^`k!Y4Af9*Vm%GnOS!Iv5KOL=VK<%DUB}OtzG8i+?_1bqwp(05`Cx~-}|BHu%;%hA3#OU0| z-?%((bGgF*ktZqIzh#T`2o6T+chaD+@$l8KERr@P+K&RQ$$536;74BOlQyAnvufh3 z2viSw1;>Buk^sV_XVc{_Z5@5f6H>0>` zBazjs)c=r_f0q2Ej|c%YA(_>!^2p5>53@d5C&0tx^dPUGJadQ5C#@*Y*Xhjk(5kjW zsV%P2q8_+h?<_~wRtba?LKKlCX#?YAJ?nV7?C zyHtZMmbTKmo}z}r{=o;<;j0_wcA3Qcmw$op;-{lfDS%0MQ zRlzipg^q-OM;C9@V$gl$br7(GTu=sC!p(nSE$s_6zWo%z%h7p`ovY$3S0^A7Mh9DDty+XH&q_&S-Uq5t{zpV!9s=ghwdr=dTHZ_ zGQBm~>av}UUMSnCqQ3(c7%z`mw5|nxocfJrzfy7QKKBcD&8f)7S<*)oq&7&FvCQYW z_zsveROiQRJn6`+IAP)odRNpT?RT+ zl2%(kT)bsfNsvEd86l)+iOrqB0^ZgYwS{kP9U zoT6lax)hF9f~Z-yE3t_8D!$)qO^RQa=k9%Y5T}Nu42eFW#`dj7BUg@|-%_O^@$>sv z!qnz`d>&rTBIBFZW&_#qr29$0&7A9?Gx}Co!rMafir+a~(deIx!g^=K!k_ZYq}Qcn zC1W~hLZ%YVb)4_szq?VLB;Xr<592S~sF2n?wJB!xf$%KbBBVB`OYGYV;6u-JR;O2%hgrV|?S2ll%;OaC;B{c3RfCBa+o@|3&7XP^1b z*_I8EoT*K8P8m5E$|#Lu|A=*#DK$)lYlXw{uudWN%}xEs3$yp-kVz;X|ja;mjU zg<|4r=fuNB;38B1vqEACHoCm+{hQSRM^v|Xa`%wtO4FL9#}t=8tf$@M&B#nwA;Aug z_MdRBbK4;Mx_;!Q{#T|HB0EwywuZpAQu`LGdciHWFDY{O+#G<(=C!@dAbxLJ_Jf+! z;0lQw&e4(!R9=)S)ZJe<*Ped@I4}439~7CJ$RB=hOz1wH22U-sW{e~;sh4hkjOjt$ zJUKx?n&R6*8A;u*zc?`laz`JC|6%sLZnQ>EqAl_d+12Kxd@nEstc~fp55zMW?0rfl zLnQsrc3$A3dm{!bauS@p~8eK$5{0wZK{{pJ@ID&@Z@ zmHCeGLb}e%ArP`-de~VY@%~jg1N zp;+v2ciOf85zca>!ufG$NARhwwm=eae)GzSjwj~UM-mgHEe)?4Eq$LhcNR%0InN^HM^)l z=U$FkvJs1oeff>3Gyt&Sxv6h53Z(MieN6+B(J}+dcqY(TXOx{MOGCLo9FOt*?W8+U zm)B^Bw1@vy7PLi#q#wmEyTr{XrQ~Gx@+V=ha=TP18!Du|0KfYO-}Y1Gt(($eS&!)r zvt<6WSnBFgD}=6vwL}$^wR-LuQ^HBewiKOWT}fV)>-5!$AH4%4Zl-_nXi_&_=uIpq z`vKJ%_!35x{*+veuFh|DqyUY#IrhUpd5)I=&L%*Ml)!)E$xw}=oL~dSbegq>YD-vH z;TkEGcFy~Ou$Fj1^NOC7Qx1xh2+=H=e-#{LjL_#En*{OviBk1L-uFpm`dGUr9~%vF znUWYo9w#|DL-nQh%D)R#TZ-&|_&x+uG0N)Y;YWyosvp-kzl}W)^tvKnOo%b?estm6 zVIyP%%WwX3mUj8k- z{H2lS1kUg5PzIfjT&1p(V!L;gq`NsOJZz3}<&cX1tzS=1q-Ka2dtN1N%&ol6@td0y ztZK%gipWQ_iG4wtMC(g8{zu9QudQK8!+{y2Gvx%jkL_a1DsJn?6heV-h0ON&;Y)kP3<=AMq@s7m?w=4-UW4 zfUj$HoLdP$Lx4z5arhE|mu8m%{@K=Dzop%jEB6Bb6G+b!|69c%Sj8=S?JEUL)WB3q z4Z}IUe(~A+v7ki{y%uhP5gExKDJNXPj|YE0`oE~`!j=Ka4|X*}gLn*t3jW~qSmTu@ z>(%QnvmYb}zpNbZzEx7y}xWw-yQhXsI+A?$t?&$lqIQem`+a3X_sV%bAGPFLt&WU$fZC zoeVZim=7@Gp4xtX=8?~`yo@c2r90VeDSqJ7AZ*am7oYZ_pC((Jt` z@6J$JhfIpL)C)WZ+tox)5f$mV$E4U89WT4}P!cxcMzhhmR6`G!o{u?sG^AXli@}8= z4IU9uh*`0%EGK#~GLetuiwesYBC-%KE{cu^v=OOlgQNhqY(Tr!bJSW#t|8W$gc!y7 zh$&G;++BhIv~Cyc@bi_>U<(JHNnNddD-|*7N-WJ`@uF&OR`E!dH#O}Xq|FNQad%Bk zO&4pFvSo|S8Z3lU#kpXM*_QEKWZ!Y^i&^g1+FyF8*qn)V2lwkdl_v$Q*SiN%YEkWh zxw%|-?%bF;SK>O@@H_A3i(0)2%-Pml8p$GNvgj`sjq~r7H@Wn8L7TZpTYuRT?IsqFRqg(drVI6mRMNP|4%Cv{W0Blzb=naR0Rpjq)ofC}3GmaE(hd)GQ2 zVDM>IO12>70IjWLa!G;aPP`3m7S~a&$q#8f$Z#g49YT73K4z_la<{>rp0#{BQ&eYg zYr*W7d&^$XiXhCK3)I_J436Nz#Q4q#C);xM+U8AhVB6Ex^GOp&OP3`cT-FZJ4@qVY|ke5vL%|O@Q6pb zYE|*M=_xNS0(gE0vzuBHx2|IXvn$5T-ZYk+QsdJ|DVdv6WI0}0r+>oTtn}c&sR3Kw z)r+(Y(^U;$E!zk3W^g-~s6V!4C$_nCekBQ}KWXX#T7+9=Hu`7vC-T@C88NkU{^fe4 z7zk(@vWj8Nb0nZRaqHaA>*lm0$HowNp?=W!UB%>A-^GDGuSmTdhR13|af--6Pwtu> zY&eZ*9GZ0S#luS>8sIV=ul2Tq2+9ScM?U$t%Qb@RaWBj+%PylV?u`)uBT)|(UVF{S zMfL7~U%NeECkR|wXpLN3qB5zQCik3cw&VG}ZWFAUFI8yy>~+HcEt!HTev$^s;1s&! z9GM5JuU~8y(-ua|E+$47MRi@y(D0P_dSsRb4C(t-=|~SLQ?K}j#QTpQ-DSQg{P6}B z`R%8;2PpcP*+g%xHJ6zkqv4kKj@1X*Mma47_u2LD4;FXDTPMVuEwpStbgEDv$NKy0 zqH(i$+4%WM16gwYXfNVI3H!J)Feu3K22K2%H<2&|aCY2dGGy>u;g@@MBV{&t#KfI} zID}K~b>d=gHGcb_A2UOZJB%~k6O%WIP%Vj9@%-%6<;SFLfVO#(_vZq%Rdfy}eDahxWS5zf(lSHmEb-dVgW&0?V+IhE#Y zH!~;&?}-m>-|;TDy1X2HSq+yWVuLgs{O~dx*sy8$x>Da`_h=@`Q4gP%K%5fPT5dtX zA77(F{g*FaTEH8JM@Rov;`KW{n%?P?-e@-HuNYZ#AM@QGhni*U{-l2#T0uWse)*}? z$)-Hdz0Y{r%5fc_x%>EZcX;+!sWpJfExMYL^D7=p{j7J=#3*5?*{=$FY9{Yhegz#p5n8c_N6VPabEVQYd~Z zkNx%gK1TT{lx!b&GJ42l4@|XFn+J16J{C)B+(;QdMuml^Iychl>FIgSB`A}SlVc$s zi!wC&RW$XP6<77v6uv8j577YX8?H8C%+&ey+1MWp-wn5}ZLjGO#k!f9mrqu{y4HOS z4*t+176`#|l|@$y$~U2Y-R2-X`^vzq1r~hx<1jZ&gZsH4i-Cw`VJV7 z=@k*nR_uBZg-?cZdbAQd`ceQ^Jm!vaEM&6(dkb(@{?O1+MHyO$PfDc>J-Ktdbv`Zg z?73YX3!Z3kv1&yR2gZtq%SReF;<1?*;ZR{@ve}wxhw+$Lh?C!%{&wX6Q^GjO)M(Ub zUS3`alnY`nWgCl@|9Mx6eJAr2+Pe84xf$~BKlpU6QPkNHh86-Rg#HV>S!rjpSkKfdS^^B zG(iEzS3av`t6uyD7tfG0b5v)@jzLq%In#(qu{tM#Xigkd-gUyF*A#hrZ<}URE#pyy zs6EfM)ivi*e)@(Dq}iW{i$!Z_Uc4Qe`J1ju!*$_%3mi#&gy&kt@Z%n#;m^wla8Y^S z(i^*duhcR#i|u6cMrR3Z%TFL%EuF4M@%w`csp;#SQDvR`V~z9vXs!Ci4s$&19aKYM zO@sQul{Vap7Z8 zHzt{3xnxzskLVUpPJHI(=ih;7BnJlv*Y)e|yTj&j5ECJq!K9Vg5A#AT0{sI!3q6EO z-aqd`@Y)O}99`s#k0-fEFMJW0IzdoZ-?cxT0An51lPWTNXy%NnBx>*$IeD-KAJDi1 zMU(+_$>;5@@(Hq-g=pvUkxe-4vr7ZnKr(Ld+HHM%%hgBx0n&Z-7yrxGuaC|yrD<@k zSI=HT2$lQl7nww`E62*@{IrD0sZdZ-Y8L+tZ*2)0$BmP5@84hko-T>n-;qV8TSd1R zil3i922uRk;jBANr)Cm=xNqjEZFLpolV;@~`d$=xc;os&xLeJx{Y{4aO_uB*L7z7( z&-X)fuRqJbBrqT&Ne7N@_eO=ZmguHI>7%m|Fmy#eD>&|@6>SNu_&k`fa2y~9|<5}97tVcH7XT*4fWcCfKfBa2T= z3^I1A!9hP1c7A<-SLH>pGP5rQK0ZEBtMDVEqNcYz;Wl1EI~cU6JJ>JZQ@)xxGLt7= z9HMT^FE@U{v}04gq0wT^7niHYofyQP;?;RGR6)g2%650@+U>#bVzc=rF*!@$jR@IsE-m zqdA)IhM0mW1_e9560RrTcc2Q%h=@;1GtHSynFU{{pHGRZa_$6QuWe|EXS64M`V?XU zV9OA6#4*RgLojoVsQ$nUvcRv0;$Bg?#K%vw(lFx}eT(445$61iSYEc1fT<@cw{N#X z{9#($+l9V2Zp(MkJh7^=CsEEr-{I7v|E9pC21J)Fj`!A*p$v-t9f6p;tN|iffeAM|6_S7Y<&(wSuJOV(@PP+b!(GEbfc@DyWt@E6M&t=| z5zw=o(Xt5>2ewBI$Ln>~TOIT(4Ebx%FEBO3WegZL^DZ1XxsJmtBSdKnnoDfjKE*2I%wRf6TNC> zOQz!+1N2zW-yf2Ex=oQ}k+zM*LAXS%aBIWBuBNHt+EHm|xBS?mp4q*cB*%T=Z*R0z zVzCf;K9gT?iU`;_`ED0aVWH4edltZGlkPN1%9KybpT%8PI))4l0$JSPR9HqAW z8=Wy(`bpa~?Oh;*G34IsH5U+%R|>0+OcVVVdY8mE>VIY#qCE?GSbHGL!N=b731BAN z0EQ7bqe(#@gkgi1kkr8x7NS{le@vH;6%)y$hzNj@?SsdgV%3jyPzONzCrPxuU5fzQPE#OG!(WTDlpnT3JwWjWy^XHRTCW@eWgC|DBb_; z8QSMToZPrEveA*oW- z+GODUmS&pRe7?|=#Wat+y@8e8>ZPnGMD97$+e2|4KEBSA!yUbqTYuJ$jZf(-n%dAQ zt8y&EbNK1M9>y2wAwahS^=K+LbqK{^iX|?>bN-b9i>gk86x?YTzOc!m6n<|e4vW)r z{+7Q&@`OLXa@br8y1=;owvC1{U%B20@;T6$E9iC+tR0`9u%bTOv#(kHj+gnd`f}Cx z_pyK^>^=qXa`%S2_jsLn#YVqBa8??BufkB6een)Blo$wLOXZ1}>AoE~1$vm`ZqTod z;wlInCQH#%miG_dy7p>IIzwiQ4(^If>qg%{v~mQBQsbA-V0?1A)%-y_UuF_>AaUUy zA9*_>d=xp1Z??&3Q<#@oBXhO=64d|#dVqmE^IpOOr@1porL6{sA3qNw$Cs~OO^@0a zJN`I;u|!41Me;077h-&+Pfi(!cnOY95@65x`***aHV!coB5F2B0Pw%{H zWLj@?)Q=FB>Xti2Z6=pnA`U1NYh^3l7!3!enq{~)GLcKV8|D5ftOy#_pkC6diS znEv~NbH#=eZHo4N%dI<>GXB79y@)HHHbP@Nl+6jfnmjz;H)_`O68s@zZxrt!;!y7u zO`KBI)KqqIa%xDE@S7|yq@bXfn(InL*hOLq|JesD1fEV;pgq6@kjAyYEp_((#`4Z+)z)xfsuGc zy%plZE$|*Q@Mo_AxS43)>aPZGkHlGayRTE5=Y12tVL}Nf{s{k^fmA_yOe@(^s|~Bp z2|}yky7HCZ&tBL4{8|3ic6f)!wkaTuL&x{OI@|NzTO7d$Kk+hYhR0a1Nx;?~}5! zvIVzrpK<_+@9^*t5%8er&7-HK>=Xn*oy0*9%uaNx-Mve(QzhmRX2TZ%oavXibdmIO zS~_JLhY%*ZK(wSYp3bYFq;%6ispFWhPBSYz`<2Fd9d({y3l zdvO~k-PC6oM_d*;oN5T4{{p z?iRgoZ*klcQT&wEH#@6BO)OYm&~nf3mKX)%MnMs29(_JFw&zuzey*>eQ*C%=Bh6S5z|MgZ&WThCY~A-r@aU(-pJcAD4jGQWR$56k9<;9zV- zh_u%7P+`6imfP2XfrKt|ZMuzTkK)t#o457b`G6J@w`0n5Iol_J9nQqObfVMzJsVt0pTQQ{|k30Gi|z}FXb|$fCw<;d9W?S1&1>hGNh%(_{%zg(L zxVX4zSOH>NG~hXu!o!s(crmx#kMuPkDLYHirg)cObGrhyu7g{-+~S*~e!&Tgyv~*v zLkl$eNs_i&ayy6lFuKJ&R;uAg{(X`*&51(UQxLfHD z)b1ye)WAXQiB6lWuuu9{%dKA!->tr7W8CDBqs4_hm@(JXB!=bz46S6En*zEn1rJF5 z{r#a8DyVaI8j`QUhvFZmA!>V2yG%{3U|8qw_^EG7n?X%Y?M{XiBVuZCku#}pN^N7Z z>F>dMDoiAtChh^LoFoDfM$D}LEWv-eHN+}NVD#FuULv&hfJfyv)nH4o`0-wq!06D% z$k5{Az z1pIJAT^I*&R z;{|MEV;dAc#RTK}j}L?^M|V>obySL>3t3%t;4yDB`Taz3c230MS3oRdx3ucZ@^S(4 zf{|J`?w>33YG!6;;c;=DUlZ8DHW!?o>}Y*tfB_cCK|d9OdY6p*kR zvt=w!cx50vM2fob<@Xy~H>8+TaB3Otl(hr4-;pDpi_V&+REA_VQh{aFrbNFfMA(nF zW)v4{03;t0F9PGbxxe38?K0c{L5+HDVF3--i9TJ5|Hg9wJu7$@FMbKYz$)?HcR~m9 z&XbKetk`S`c#VyXOJg+xAMd0D0!{uZ(s`(W_M=7`0m87+=hllCFVJ8Q(1%MFB$p-{ z#GNMU@#*R5|EvrXqv0AaFR_5ubR2*R+W--Cfw!q)!O=>dTZj1b#?70pF!+26jyr!1 zF{CD?ey3h&+O$EjnN36PJ%9r5sH?l2pZPL~yI&-Wz!q_yP;hYI!M#YsQdMyGT058p z5_)>V%o1^N z(Tr&^`eH*0rVO7X=CK|Poh$4D0^~ZMC;%x z?)nEcAv+`s!zJbQQ$8>F)mBbUy%G>Bgv+q7#Ky+Hhuxc-^gri-!U&!7&&kP*Xog!a zke_tJlHa^}u{@Zc2pLs8GzESt;7m~Y3JFj|R21RB@Gz%_hQ|H>qv}1txorFY@sE)Z zl9kK|AtY21k`d9cSIS;dB4j3I6iJj-w(PA4Wrw0NGD|X3sHg}T|JT+1eE-Msdye}# zj{9!-e6H&{&-eLyzsCDQ-4UI!v9Y;}KF7=G`Fm~EXy_a{d4QzyW>`Q`To+9lAWNJcO!Vi52WYTj?*pf%goH< zir}VE$qPb3jJtO2>YJ=}eu`_IaeX`W>s6_BtMLcFwG|KIn~qIPsG@tkSy(8(L(+m& z<@xPFW7&fub1}AikL^365m95_ym_l)sU^?L`d^LDzr^dbY53Yc zP3`@YP=L3!-ox8knYM4=ZsqKJB2Pb8`TbLu)1E(uPrk4!jlQDS1!w=w(9qEL?RuXM zoL#rm=;#n!y%A2$Ag1qC;B)nCp$Fg+Q-TElsN*J8{uoi5JTcKb){ootOi~87HXc^y zH_(Yoe-h(WwC$Dxb+CHND1UQPN}0hx-v{|(mK7J_cLQXt9zwh zB>XvK@$8|ev|Jo;L?KPE^6Kw*r)fLFqd!?Yy3|jHH^rZFJ?@|HkQ$gyeD$a_74$sK z;qmg`WoBdj*uqv=dXocE(`OFW7xA&lSLe*hlQs0lKaJNfE`M8Ld*P*uG^fII4c*t< znOPo2(n#pC|8&fg(!2~LhBMGg{9%8Lc;_60swi1#zKO0?Sl*W}J7WL)tonK-QZS8H zxRtktLX{+{`$oZt)P^CZ^I; zPkYPq6kq?AEwDY9!D{cFmeb9DDqH%r_9veI|EHmj#vi!AfrMYEY594+ojXa`_G(Z) z{`+a3v+vC8!hX6QJo@yC|FRiF_4^%VvHlv&<9Z<%DL7f0_ZPfck$>|}$v^!6?&&ra z6&2^fvP~&R0z$NfUjVmRy11ARzeyJ+DP`xCTZ(qti$CMy&inOEgj12M^Bn#C@AGe_ zOBDB>%243Qafvhx48h*z+a2oPwlj>lbHZU(8Li_Pr%&4Vm36;-r`;43NfkRQePU=W zF_fI9=F}0xlZHESy`6;&i5NP^!o>-wJ$Vj7R!g}gKsUjwTnuRwP+^cK8m($H1P@{Xq=>1}a+hd36|nj^MEzr5`3^S^tdsZbG;V{6kR{1^DEHFBHNufOB}puK)6Qe$tYfAlef<9xlYhlREte_}*oKvz^ND7#{a_6`US;+>h%VX+Q5VR~JEe9~vZ~IphY}i&HiID8<-5mSR2LXZZf|Y+W1D6tx>jwue zgyFbOaz>3llVe_|*oPNc0}G6Oe0GJ%ghB867gxs-AUF7b->t8X?XOIn6@T+W$B!qb z_ID~tTFGWdPuD5LvwLxM+&dy|TmEKK&V?+4^HQXZPx*X_i|13rS`QkzIlmK;$aT4m zWe6tAsw-VhQc_Y0yJYm+w}_iJsh>D>k;8hY3Qm;J&TQ=LrmJf>9v;3TA#t`k2$5-P zz|db8~YI0VX;Q8ESaOM7unBfh?m3CpdrrSFlHvKD`5x1^dSyfw-Hiq%^F8S0z9kxiqg zyPE&-K0m2t6T9PwRl0z*DxZqtW{FsG<1ddls88ad8*Cikg8{<`-#1f zoc`&>kIFb3CzJE>J)yw_LX2I71T!~3e-tDWj&(X%1im~fec&@ULbks4$DC9jEvUuP zh6fOiR%I7LlX!V_zt3TSZgv?5MmPfJe$;I=zIt`MXcfSn(EHpjW6V2O!Gh=iRzC$p zXomYzkjraMjYqoW{c6+=zyI3LoygiuL9)5^Yv17|u3sC+41J7;-g7O8FXfznaU(pF zwC2QVb@8&a^VjpYC~68z)BRa*=efMDPHHrxclWuXxqngtg)DHT!a>1Zd52<3B)<9x z;2D84@%dc^CerRRef0Kk69e^c?7b8HzQmG(lnPvS$<=a0>YL$%bYYZYPe^5E|a0jTE1f{3J4Gx|rYRZ@yBKBA!S6zjjS# zO8U{J9kxRpVWLOmw#u*^2bqtycl5`Pt;*Eo6cqc;_XrQ5$HKGH&=CG8a?Z`o?b2i$ zD@h52?0pGn@Mr8!o#Ex>jd=QNc2GL;NB~}h?z`yRXZ!hW(iVU%_aDPa`x&7$V8bpH zemz$s@!NaWo4F_H^G{n%vCl7mn_4{HC8LqyIbX#^m)ky^e^hLfM9@3bWVbdSjH!^_ zRX}$}S!YsfDlkMnlE-p&X};v?)7CK7J&fD88&&d2Y*z`PYXGuiWM`*VS63&jK~Ygr z)fdT0BPjfkt4Ji73-9&6y4l&;;cspxQBqNzf1U(fK|#755z$q3*}l(~=oFqjk)b4x z_f#8`NRfYcT$I8(P_f#`I)y z$(@{>#LiZ;U=7P&{!B;oRx|y@<9Gm)5OILWOT6Z-ZZ_xD3CJuge%p|GW|(hyadT`!PO_UGK|V|bE7IRUc4BA z{CBj_v|Q5rr;WV-3QG_pqjG1phm)7LHy9C(-{7*y#_M&JVOm zU%vc3=vh~@Rr#j!VBnv~OS9wB&Oj4MzdpK!E5ckgA$ISi_~`XG*3* zz{^daNnZ$RgfDP2AEj>Y{blmb{{Ge+oeW9)w_NDlH47Jdiq3M9k&#`xe7T8md>|)# z;i158#r1$&0k>}tJlk6u)7sL)_JJb(CEE1(y28RjGSX9*Pc0bEvWlm)ugDjs|N;9YO6N>E-j6`xWz2%HMcV{F%kW9 zH~~EeN-WtAII};msYxp?E?!*eC9?Dpu?P3>Z$_}5jD*sh(WLNik%=1ZayqE?@^Z71 zN|dxt@tg)b{g0w#hl?f@yIgn;AH+2@Jfa{c8+A+Ib+anBO=v8Y&>|k^>xv>L%DG)PJ?-IWC7ML)DR#io(42mzDhFOSEGtL*M zq|3y>?D6-{k8zwg8mCT$L`2X(IOy{BebX1%ATjPBr<>BrBPl7Q z$Y|r}JJH^4v2U+tpNwp8O1Q{eD*jvIPS6np;kq4v$oO(y9n3PT-(O&!lVwlOGiqw( zI^o{sUmS8Jmw$CxmVPk3@uANZlKkU$hIa(~;&7tGB?U9fuDU;+V7^7D68r`R?8Q+2h6nOu1$i4#H$R zdEJHYIFp(>ItaGXlKwoR)7zCSBSV4vb8D`K>Gn^y$93f!?Hzdkehg!d)Gu9FtBtk&auA1=NM_;%s1W@FpsH4uLDfIWJ{Cs((r!yR*dvJX1(b zjRJvGuU{u8x-N(AM>J@z=TXaKWo1***3&ACxu-qpKdqCQ8CJXP`{KjkhQ$bdiQR&f zPWXsHbM%MGiIqrD~4VK ztv#x58CVJ!yqRxUnCI@(4j-FTfXl~fR#+tUeL0&C0iRCy*`{!WML6G~I(c2Rr(Z-$ ziU~hQ1yGcWo7;8ew<8^wtTx}$c4p=q5G5G^FB-sbNP=Sxo-h?ReWC<{jIh&Sa!r}v zj?B-5Z^>)@Ly?QksaFUjm z_R`mG!9;m)-Q80SKeJvbuCTFQF~b4c_~s2gsl@IL$0`g8OYry-bm7pmD_h&+_HNc5 zpzr$hi5G(=5UMaOr^VjscRaIQ!pt~tCOfCw#@6EY<&V2ZQ=a}Qotqb&*e-2585eR` zrlDYCtK^f4QgvU>&GH($bd}sR0bw46D-F8l9_tb&J{u|dquMz?&(Slx_vDYB)FfN? zyMIUimKFI4k{3%#WMA)>L)G#o#>N)SVXT_%*BTRcFR?}JWKz^OKBoFhM%%m!REE{W z%P7;{wYgCW=_ls-drpD~(JwSL$d71WfsbMvFYi`~xNuN|+tyYV_RPzLv%C=?OC2~I zS*Eh{#K~Sv3HrDh)QnMeVpo;$rKwhJ#1_D3-gxdfbPWZ71{ZC|f1=+$U?Iu!1 zi!j^3dZa#(a4~{Y#r!jxs*yOc!-o%>)%xuKQyGl)UslEvAhtH&%1gS2vQ3yGGv6%cmXC5+y;;-%4wB4PBQO$`Mh++DfnFWj#3XK^v0 z%e*^jb3S-2>Da3UyQG3xsg)do__prl-R~x3V6&R=xA@xE#o~$+Fzs+}EEN7#PmGGz||YFMnuh zIW}1aQX1aoP-C$c+)e^emp@g}G57hqDDLz7OCZ?K%BreS9DvQ|xPE%cV`L8Lslx1&8XrrvW=pHf(rkOr-9}$!`8s|d z*byC{g9QQyoCmatMPJtax{NBBE-`dDQo`!f;odstg-ZFQ%81aaocR+(vSMfFWj`gOap;m%@eq zemV2#t!tX|q0~#Vno$rNB~>^zRUC1ywndjJ@oso>-8#2_di3w#?5K0~!&=$Gdz<1Y z&3No&uhhGAtg*By+GdaHx(kQM$#mtMRM@C9QsK}lrrJ1Nb?J(XDn0X?0Moh?qV?vd zyLXBTz0{tFDY-_)Axg59KCSVKY3C~~@(!hilbYbbo_rq%z>xswO$BC2?>(zI>fei- z+lXc!hjx+2uJW$Z@eL-j;E)i}vl4suZ0YLiB3%v?;-WTY(qhcSM-+yhLXuUV)f#tmG6jOcv$rVqmV(e)wQ+uXEZS()van>lDFC} zt!nr5+vtD$?6uEJfxepD;b6sxVj+$q{wV&B0-#0!b%Y+-@N$rEhIgr zocsL;S&OsnS7p1KRc!alpHb2ClC3I>{di|zmz@dbq+uVoQ>ed!HzkjNWoS3kwqKs05?`=~m0u_aa zm!Z912k0OSKLbx)QX03v2gGxo8#xN&o#@G*>^pY68e)A2B39y@X+o3+P4q9BRjO4g zlO2~D#$(s-QlQO+G)qAOVgd8*RM;mCR04+TXxzz+S|${yR>-UE&oFFNM^13$r)0jR zdW-`5z-z|=nsdC#C9&VUn1ccipN};;8`&Bd`k2P^x%TTd5=s4&jipDc=m?uM-Mpi+ z;sJ$|q0z4dNu-5*>NyDm*UwMP_8s+l!2ULtHGpHf?RL}XHPltwF_%5}|Mi(l<4R39 zcF9OaMP>;5Y|+-%zD5|B2Ye(XBnZDO0qF|QJUu_8eF1LTtpiUSnY+8Y3F;`AuGHJx zTNYyrNfubjv%1dv|CWT8 z1s;ZXmAj_8EGlt#bK;p-lOJyv58t_HSh8RDNbda#o9t^BhK#-Ao{te7`1Usq=+Nd@ z7Mw7qs&bEh#H&#L6Q8YVb}wsB}nQ%}@94 z!R>EqX`zB-6`YjBP0(Fv%hEv2lW0TZSvKtm=h@1ucwcKQ@72suwMYI?HDMeDzRxd+ zOH3pLHyk}mI~h}<0~2EA`M!eOvU7k+U^?be9x*Xd#-Wo$6o^6bBXHV4b8fCU9$WGE z3x0^#>e4<4ogmBZ#EPFu2ZvK|g-wu&X1Fe3D=*fZ$lu zzyLe`WUt({tT1Sm;0xzhmoGzgmC|GC&o??f^y}bsb(pleDnwpwi|1MsDGEtB63)$%y49yd6v}D0Qy08)x z{+t$ONeANn(pM0JuR4xit7fS21z^oV(Y z2D4?mbnnp+u+@@PQ6gC%8TnIe8{!(tIUI6GOKh`&RNIogudh%!$h-3k2vCZjsR+u= z6(MLnFbTN|y_2a&Z;VW3$KTI>GB7Y;0g?}jKB1*6D^DEh!6~MqtW0kD#32y8yhzW+ zPxZ%T0(S^u8JAJ&JSc_EN~dTRdz%Pt=NT2>fuP>d*?HH4n0w34zhL2P>rvV?HYbqQ$qt8aj<1o)_~13t#Bp` zoEGr?YMi*A(l?9t`I4JkW4c;6BP;7Bp2$#e#!Udm<1G;$uR{{!6_Yw6*haiq=J8Xs0Ho{(qH4ksT8U;z4!+iU($oWPkk zv#bD;2gB4c8?^)}HFFxE8n?OgiK8CTd6-FTx3v7n zUSPW34g9!v@qpk=Zj(h$6_E?PZs?qr<0>a`nTo98tsc%z_VFG^EwTm%xRV2R589svinspYC^%gEvwp;;fDs0$ZevnlNmO~ zxHL#9`s+%2>9LR-VJgAz(Va+^-vOzF=o5+l9%}IHho`5%Z_X?rocf17XY1kha9x_S z%(NzhioDP6H9H2MQK752*nSMXziKqnb%Og+! zQsaWV&mRLTX#U_5{H);+NwxpJT4V^?_bR1c96u#Es*_x%K$E>@KsEZmM^@rBje+{j0`7I0@fSwEkNMjMDyMrgNRm|dEHg7pA$3)h{szR z64sMXbw>yXJJOFYdof;?7`R99(5UiT;6ZhpL@}_l3%h%EDlSa%0|ve zMH+k1h7oZL242P6P^m@%84A8pOnf?GP;3+{_tyda+7i-aqhG(?f_?qv$r}lnqX)wq z;aWn2-w4prc>lNnld8J$b$O(U-4Zs~Q`}D|ZBr^=*89!&&+4 z8D7e=1qRTlzlyhTt56P6JIH`~K0l7dMO9YHBGX`vPr9p_NyJXO-@P0C@W&{D?j0&Ld2#{c7#uPG3dx|mzOl$aq`zq?(zgYk{H z)5zv2PxcIfj;4^^j$YCAR~vo|*0bN3e);GA%WcQ!KdkA$uo0oU9sb)@^2Nk4q1W?1 zlhzCjbvksc=4yh^!mzTsT9k6fwZ?NA#9A-JH_BkNA(5DwnTb9Ab?YZYzw-Zf zhhc(hR@vq_ebHd7VBEkE99qJZJ21}?97DiM`rX3(EVT2B-_D?ony!DpK(Qc}HgP6$Df$^pyd<%ldN@5f84Onv;ZAIZe3&4GbQ^RR z^x%ZOibVUT35J~r1Q~_7S_wv;1lQIH+aI(ZL$&^#D9fSX?$8E4lBAy{YBEX`F_IEg zh2Zab^zYuzR_iG>0O&p(iUDFHnT5z2!H?R2v6ox?`u>nJw2+4qryVQPeS#u{P{ zSU?YFA?SYqQ=5yl?3|n#sOanmFLIfk-Lkh5cC=ggOTlS!Xxj0y@Su)|MAX$CfjN^N zCjcyRqI7~QAO#WI5HF1Cg?jlbOo*5t0ojt(jz?bzh6L!n$YEUQ1bgkqVTy<^j)UUv5D zD8gfWvS7hDE{1XBWSP}ERo?H+%uK?kW$(`-7_hhTsrFTAZGy9kNo+A%!;PrCJaxzL zqyMQC#lo)2lV`_%Efa}H0^1V9cX8h3oOxRG_UXH#vxf=e93+g8&`|ZNnsa$Smw#T& zuOO?7=0HFMDvjlZ3vY%t#Z7+y&X79SxIC)T%xe#~BJK9UGQg{}OMIM2xu%x}O6G z_>h&&vo|x>^ZF6TY?+8nIDDn3+qTL~0#9o*38gzk*@8}(j+U$*CoEc$BPE{`h2`wC zva@%Ih#b%8pU*@ARS}J`!VLb``Y+5yX|G}d#(Nlt73IF~hb6HYeFBN4B1t^{%jhT> z3A&y-Aj*DI)Uk)ea2rvBJmI9$mX9B~q52U4C0H(4+QNsM0Q~mQzh$WjCHM*9dl~{n zX{YA9bmdBDczAfD6vV{9sHko5PZ2TK;Gd4~vKoNkvG$&MezUsJgcVQ3D~0U0sQFI~ zv8~8|^Rapz;I*ysxpVN8Q~X?4d$PZV^PTvS*}si)L5y5}Nw?xeLk_#=I$paaAw+w$ z)HF*ze&%sNkwIakr~+(l##L^DGvn<_6h@!O&2}w5jIer;9hf&Ev%cv&D*Kl&4xd}^ zRzpt?1xibY)9t}U2xctj9NHFZMK0dH;+P9)H(cxAPIq}J+WGFz1BR~Cl14^Gk1{jC zVKES`UD@Nwfak8VT){;>m4;FcqhV)+AM_ht}@&9=;u$E{=#KUA{pfATb^_< z{{0?(4$Q^bb2omX2oS^&0Fg<*`4gAHMJLDkpFfq)pBE*iqC|_viTk{P^$0>zYMZU^ zpYLy0p3lBk5Zqz6ot^#VM1yvWS(yXJ1hC0--#@2jzI|;(Ns2$mrAC&!7r2W~L_`GR zGx{C!Y?P_rQRI66`bd^dSnO_ms>}D~;`-TIza0droVvPy5fJ6p zty^&7+4!ixEGsFgN6Lr9^8GR5I#q6^#a{R89DfOFBvUU zn0DsrMX!x@g_b+qTL8>)2BgFDOe|Ftb~%q|-i}I8_5=b#T8<#0P!Pz#X#az}IBjrC zI`a(n6q<)hpfM%1SyI@Whd(Fdf9~C;d*A z+#17e=!O;+(PHgFTP+nGw_~X#q0Mnk#$k-gsl~-x8AA0wFW;zjA8(;21#f3lBV#5f-%H4kcKu6#F}9j@WTawo(^%WhR4BmJSTrYp>I#53I+?#FXCqni-QnjVqjY05H;F z{L9v@TmNZMAFKB}U$|f(MC$~nX|kd}5n&#Kmx|Kh=Rr%bSD17@;d7+7 z=t5Y_qdw-1B ze-rY}&!xIVuhR*UGq6295Sp7j-Epr>o?gkaI7GtJ{n+E;gzkjh-O5KFF6S=w{UVgGyBoX1aUC9nE*7h+y~S7*p%jv z-s%?eZA}&z`PvVNO$`ehtqPg@sM8>?;9BBKh|xS?u!`8!~fGzIx4_jfwb?>A3bFHyzvfOp1PaIm7$+#u+ ze=iIW1~wgq7=(k#k;_I{vvV`cIrrb+KXT$WH$t@olM(`vlphW~FhkbUtB5eZE+Gq4 zA_z(=5SK(moEW}=h&H3LarQ&8J>dH7zAFQlI+<+%^#%dzVK@Z5{vJFwq-!t+<#S!> zICkJw*6ay(XSAZmGclV71#YxO-@JMu%xxDKiCvIzvS&Qq-EFd3#XHvc4maI8kiu*N z>e06E>4gsmNcE^4`(QAUYp2X)-BruOVXEJpE_AVAa&U~?*~{Z$d4csw|DFSS8|xo` z3)wk1GReM;T&j!PFK>F=RipB+<0A2ThSEj(8vhgC5;H5G~#)d=bd ztQ1g{19BEu*O%>y?o>|)hGaLuJG(5$kBC2(p6wY#E!YA#U{B>RrZ>b7@}q%l^67tY zA@MKduXq!7oPsxyPbe$;G(5}$kVFyM6vfGbn8mJx6=z}r=1}`A934%@Mg;^d9UN|A zKafcG#Pnhiv5b86^=?W^#|fH2bnwU~#FjIBs9kfL9vYJm z<@Sf2dYliQA0vr|(gLRljgF)9oktD`=Tppamg73_AM~bDIMWUIUj63B8T4Z4MDSD< z7emW_8Oz)>2UUe#?iG589_le!2WA69di+Eb^W&xNi3V`hZu83WFm889rpl9g_iE=L zb~7=G1+(Ckkhs9>1n0oSt}aidXg=1}W69)3Cq*PZkN|l3=1nsq?b%X}AL2l1!D*Il zphz)zxUVg`q4cC9I(+eidO>+x;vv|AP&Kq%t;mzZvjWd{?pBN6Oe5Y0M5mYn3mxu$ zhT9;*V$wA-XqOW%PP8rN>x$^W)4XGA=k%+Vi{%AaQmG7#SY8U>ybI z;5c-6l1Pn(NU;1%jfuabP>wT0R`J>p*4EvGT(1U0ft@>32Ru)KFhZFEQ^ziQX(wC& z@glM!nrB+b{a1%7Ih{=I7zfpz`)DWb#xrzA+fWjPEB5{h~A|Q|Io~%svT5N~#HC$Bdu;6Ac6egw1kr>==9v zzK9p55dZdl`%|cKjW~zMNC9gL+t1bdy{b0rYQ6`4iB#X$7h6^DH#ZX4cs~VsO?w>+ zWzV{+-a5Ut{=Qk+x12k+fwf1OjCs7HWYn!n_R4oIysGEY&xzxiKR%#Qa9#dsYiw#t z9MYo9*JERB+hf!4fI)r`<_M=hW3ZVJ5vjV>pIW(Q#!ihO;&-1;4oXf=ZVR6Uk2*&9 zP!C*>+Y)YG=Jv9W-`8So*Y z%_AW`o|r>Iy0*0BC6_6fDJ{+MB(#vsw{sfSiKzPSd@_0Y0I+t;Ftu16a-BJkLX`^ z2`%xf7{V|D=7R7y;MeW?^q{PJd3jlYcYE2^My?&dF^Z1jOMfvhRGVh!Y>gOE1HusQ zJX9I=m79161qhNf^bv$G3vox#Xg6YAMZQ(2-~vp`5?M&$;iR)!55Nai(XFXH(iI^L z%>x6*q+l|#ibp;e3|EgH1BDCfhK~gzAsWYzTap)|Y_xUR2ySNR~}CwcH7!Ni5o z?YNGad%&=#p))k$M7f0X30mMNst^XGG-4~V_+-J@Bz5Zw5;2jObAk&bj4wpS&r5!J zwr_fN7jU<{&u?mUSOir`C>wST8t`YnO(8@UAHsa(_4~`V=^mX~eo+?MZ7eJ=RyR;S zXj{+YPvQK2yZQ-GIb&GPe9WziXbB*+g<(bnLB@M6&hEf<;vWLBfY?YQ`lQx})vcSf zWgktzl0u@5B$#{AS(VgFEy3yMsF8-T=C19;QYUy9nBnTdFGLDz#Y$Gu0qmFH&0Tc7 zid-ndhF=2H-mdJ1+=qD3^`_BOfD&2PF-qn~x8ZDuxNDF~ z_Tw_Vay&<_7BG$=IQ0VFdC+{D(WkSc(`kkx$;TERg-{?)fi(P|m_vlObrqIG?0o}v z4|F|NkhQ|1uqG#}jo8J;;e0+L{zmiSi>0xH2|v5)Dxw;H8ANy)4`?pP#5U{1X7kCY zQI_8S?6~wmbq3Y+zm)YX3kExFzu-{?wNJ)Q3hhZkPKf-PH_YP>`sM;mQ4mzB zLNx?LGy8OHCo#t55!Q83#}qR>I8wH4EM;Ju$}p2f3gL9Tl0_MjO%el;ZL;)N0NCCY#3<#z;@&tuZ*2Zl3GXWTgC>P0rNhWL zq-m7#%9Sg9Ydct3)!;}u0jA^_cJa-ssza_G9)bbu%e&E_SQg^6Q-Nnd8MMz)B5{Y` zckId8Mr7e$y?u*oazptevSdiTy~JVID!(C!9;3U=R?Eu5LJ8u-OSrCCVs-3!UonL@ zPk_m`=}bNP0tt5FDzP8Bi_MR?;Rx%yd>oSr5O@!`Edh!1K1AM2uAcyXOvWOx`0$YQcQ;0mc zAxvKW$=<}OG#<0rLXcODgxbRlZA2G^OA79Hf&j7lq-TQOZvr=&qc<(=PvM5$OSZ{- zd94AvWlOY2Ex(ipy|B%G+;>kSb3(&GC}B2Eqh&?t?n0#Q@$*IT9wsM)gr@H4#4#K5 zxaLfcI;u&H_*FmTU@g6@kMd_!Z1%8iX= zAhA0}a~@lG9QV24ijVNZ^Q&td5u6))MLC$5u0zkxJ&T0jo}plvHL`@r!lJb;2+~33Jd(R%V$Brqs9_X>ai|Xg&rbQmr?|O+9mw`?tE4 zwQF}=7tV8ch{>?TkVwJ{i~i#%wa(xFQVN;5k-SIJarBgwmPWPjBBmYSF<2omKiMyv zrz<_NrR34^D}811x7Y(}pPOWTb4<5+(Ei7feR^T1q^4{sX=#JX5pu1uXo5S+xWWIM11Otp2*BP%9eqpT4l8Oquvcx^RqBJgH z-v~whONQy(mjl*meqH?&&x_FJ;DJS@Camd}&L^JT*2|poo$@r^m}VPuV`V1&@ZNqq z<)OREN$bn852~}FA_kGtUhzLE$Sdyi8O{zX`Bg{v!gddXJ;QOf(c)IerK<8xzqRf@ zkB;7*)6MQ3cF5-|OPqdYrfcdbvQ8tvmJtY7g)eS@-UmojinaO8=M+aI)R*82oD6&A57^n-1|#wAU=T-m|8rc7FxP;Qk?|V#9c(5R zSX=G~xbt4KuLcxT9oVExQ}LWZ>~V!Kr{cDIf=4xz$F!+M_$t|xBQpQ!GA5+?#8&RD zVG1h=q~dhHZa+rN@abmxiNs@}r?q1uTU2(V%fEwz*|B^dym|jcC-I@8iH-{&#ya8- zZo8K;;A^?@SKavQdz_~WZUXmJt@liNcP-Ym1tlnM_qMtY7g2K1&i$vug1EkA#|DV7 zSdPDQU+w8mWXKREV+h?+tG4TAP$X;HzkaE^Qe6cTO``7Jy@o#U^mv4=jZLcWl|={1 zf47@O&A;%sw_j!rM>nmTtH7#b!jqf-Fl1>xGuoq|#KniUo8fBP`&iDE*&7~c9nDH;gke=ga|DwO?%EBOXdfoBUs!BtD zr5r)Dki~Qebc1u3C-0bYbYLT(1g4?m}8xc`Icbu6$xokYVxN(D?f6?NGiz)*G&q^nmBlZf4$|K5zL1h~G)n-l8BVP>2 zL^KS9nX`jCl_(5y9sE2|Ovy;W`y6cd3q|~k%7mr2y)%nDRS-x;em%+MhxO%$M>B^* z(mWz8Y+tHfGE?mSnJGEqYVmTaKJ`n(YRZ;fikl+}D0A!zhEE6hK5k5=4-lp~fUK#k z%oeQ=#$T2U3@$=ty)GJ|bN7-_+HHbX;Vh(}2TEu~&x@jvYPc6h64dozsD+Nhn*X~E zE1K@P(?MAVdE>U{6O{+ouSAx#m2W*ElQc}HFb6AeDlE+-_1 zV*DiIBTe$nDUaWEE&lZ6`nyC&Q zb24$RpzKd~Yp+ye|AFl@hx!d%gu=l5yL%G*^ZH zyZaB=e{Nc;y?VH>?CIBAbCCv#(^7}_a@G|8P_v1(lByqj#5OU8c6Wb~kuKM%Q8CuG z#H(=;xBYqpnWh6M*&^-}Sv!5(bl3ml^u(UFICf)k#C0Ixl*`td-G4St=rzy$cNq_$Jrp1aImIb4~ z6RJDwDz;s`+NNezG&UE}k37vOVWo%XV|=UI3kt*%75yKSJHw(axlbp#BmE|j)7X># zovO5VqDN&}45A!Z9f&tqqM4Pvy6Q!Yzy*TZMAFaI4ffyVr^tXw`yh=8_6E_gl11^X z{}udV)h_)wz35d82xnQ{juq4lA7<5Z2(iN+?GdH3sMW)TliQ=uZQypcUSq~J=#0ImUop>G7cDm=B1Ex6#Z3WD31zXW5p?{Lxik=aJNHSo=f(qFRfqB9$ zNBaRYZ7?A@!4(b9YwypCr-Coxu=zdRy9J?-C4{;W!oH23i_lMCqa#vT2pA?zuC1-@ z!;^y>SgK>;|H*^#F_vu97i!2T#G;$)d~AQ3h)~0(Kv=@e&YmrWDzE8lX4u!SW^jti zkF55JUCMNHL~t@+(ZV{z!s`q7B`~g`>0Rz7CljUF&8qg9j_*$-;Y#8MUQ)KLh$a5L zd!tAGctS;P`Y7$~EjQ@JR2y6WWuUonYJwW?$~wvU?Lf;U|E?P~`K)R>&EXLdYH%Tg z$e{#1`*|72lMe}W$QQ2(&lGe_LQxkJ7vBd?LH5w0hF0}br`?&!K=)&SHi!+jfF5Xn zcF4RO4HMy5N7m~F#6<$<1JaITLLZTtDaBYC^r2Ls8Jl4>A`E=QU4!L{R)GzjIvGZ> zK*Zw%LSj1Jyg`=#s+0vy1lr&cKpbiYh8C1rfHsmcH7v>@*boM7c^GQ zd6S!cJ;eG(%!%dM?2GC`|fn3Pt!0jDfiLVm9lU4$A!R> zRiAwA`w}SQBlBLS8!xxuEjKYSF@_!@VWI+z)I=5-g9UDSzwPa1mFGEaX(BBxO^3V4SYW%>hk;7F#|i#7B=?L93PF+Ywb-{Joh@&@-j?k+{^QBwXpRX zw?9{u7wJ#4$(VUqf3st_codBra(=c$>0xRXA0I4uyS7O)IyP_3(YxOgNM&ztkFV;$ z>P)=u!nE8fau{2s8YAxreBJ!N`VP16>Vo552W@?|7`YJP!kxEQynI^6bsPMv;4aws=HlBAYJsY#B^M z!W8iakwce1kAMdt-eVkmNaE{MMBc3aNsm`#n_H`ItED`c-n}x8w2klnpv>K)mfgD} zKIH6yaDF={dv&#T#+K@*;HQhHlE$bD?*BI2Hl>ufo^|_-icWR5Ybs$mz{`1?FqUh7 z-c#^m1V5Z{ETWsh;$JnuMa^NNH91ksZW8Lw`-*dQhKe!${i^po-y`~o`R0V%2DV(y zVjWg}jK0E1G)zIZYByZvp^ALgEG*)6X3#k+}Kk*j%))xNQTd;RPE* zZp@*-h?^K-P0Ry<;YiSBznYHeUzp`|%Fi2+2;OvW|2NY(h;v%DHPwbX?@hLWt={G` z%rYFD@c(9i_WL=7g=mnj1(N;s`Vtm|jn{UkX>CX{o*;s-Tdcvo;JIx!h%e`P_=N%+xhdV63X|qrmh@QYaQjh=JHCh=h*!d6!iMd ztvtu}v=H7CjO{|00aL%2Jv}`g21@v#t4PA$%&5%B%^iW2r7XY{$ViUONU&NSwkeRkB0Cs2A~OpEd_!yNX2`hjz8(M};tGCUD0RL( zPxxC;3>aNYghfG__vf5L2%YfL5w^m!Li_i#0+d*;7oXHN!7M{!SS#+MOp%uVT5Wj; z=fbxT72=Y%Nr_Yq8IL-CrN~yTJ5l;_8Xff4F4_&VCdHS>Hu5g1$!t6OH3e zAt5Rf;R&{@N~hcpCnLK5M`lk?=UL&p)xW)SLNdp^247{w;k?Q48|^aySS27~N%i0s zJ$M`-x|jrO4CDFcZh_wmo4Fakfr*&(7&ew?uorO<*wr`3wHxekAjXvV_*iOpzkknB zc;@l$D$%#_20EmsMX$svy0F-0*Bi0Gg``-RuxOCDwrfe z!T~%2LT2E(xAcJv?}MNT1>2$0$&>(fTN#3Q-MRRnuMAF(*Xj1RI?xRmojrDJf8j$yrp^_+RG@=3Es?c6eM>S z!5KQfJ9becuHu^+OusOjg+ny^92Fm*Q+7u~KpELHNbon{@PY@19^d5{vLyHWy#IXX z2BnREh~a>7aiPS##+hHgel@|U$;U`dq(4E^G1ciEktzG`^C_nl4M)%=u$Vcq*FYDpPR z2b+>hEP|!#IxKH?yi(e~Yw^c?nFasISZG$((yx8Kdk1E8svPuA@}4aC8vIzymWGe- zO{na*{gj49vy&_aWcPEnGUL<(>fDB%xW}l-0tWGa<}AF59yfr7g`|4HH=;&_A;PO8hTdR?et*7RiIG0B1DWyd8B$sHx`zb ze1C{z$myZX$K(Qx_iK9fiUzGEqAt++k0O9h*o6>&AHk6-c+nmh1}Zdx$512q;k9)1 z#WDa)4uQF!h=3961d<-U!~aF=V1>6YoSB`y4eUvbOCm;ftuKvlCDo&~?kcrbUs_%c zWW0`(3{3<*0M9Wqv&8O-m&llIL&+rEn3#sz7O}CRi{}9aC<0O^VOm4w673iFrHlE0 zk~uhl)DZq4Mjatgg+LbZM*&Zj!A4;cNBWcR7`rqA(orp(jZajR7Ne?>Y6`^(O3V)< z%sgUZ1uqtQ4#i?-6D@c;3>CQM{r2_i+lLgxllvzsDP{f^e6gy#+Wzm6+de+6ag(K0 zQPi_;uM-C7d@W_EPD#iY{wev zt4>l|-VE`ENOtczD*;~&&ge!gno{pyc5ncn{?6cl$QRrMH&HUiiJ;PzD{=X}J9gZH ziJur93q6XLGy*vkFU&dur{`v^_6_>3ZPb*qeoK-_2nii@J{bd6n(%lLercl2LO>OL zO^0#Q!DvtTB_tTIGcR4T=t!0L`#?`mFJZ&!0mYaWmgu{@Vc7c8?HtAVH?vY=_yq@xKdnqfq`T)PMNmv9n2h^}jLDQDVQFM@E~eirqmLnC1ZbOb~C`61~#3l_Vr21f%{D6kq&G81iaN z<(UE>4kI&(o4pw`kMRC8v+s>G#DBIUloOF48|h)69$Q?^=PU8X(q z9<C^MxLA|f;-DI=uJY}sX$Ei09gvWc=4l@Zx1BP*pOR3cjv zLb4Ny%KdnC{eHjy{XggapYy-3^S#cwM)CQ)->>m}KAw-^50=zw{zS`xNyA@XOrU-z z1qt2(6a`h~7>y^2JIPL^tfPPi0@Ah_;8Fd_&i9zZVdo8?;@Sc$^^b4hR(6D(pHkkx zg8&<3wIAhzq<(4zv=pV-y~fx+t0_J;X_<94<1_ z#o-~^{=s&C0i_Q91>T;phGB7^2{_6B2-JolGtL8Up(`j7G_(hUv+kXtut$-g6`L z@Ut6kL@$eBUd*M!eBE63@iW)#$EmXLbTbX~6r}~RsCjktQ9Gmw4viO6ubZgeSS6L= zeoo*`)2rCd>sFrLyCjzWhWSqK9CA^USpSeIG5D(gxx>}BMHp@SUZry_qi+@hJP>V{P{sJsGeMz+f5{B z3s>pr=y3C0M^i*Od;S5xElw5nEo*s{#gaB}+a}0Hx#;Frhb=(tY;(>Ou7VatnilDJ)S&=JXjYpKgSJ;xR8f5WJ__XuEIk|Bvh60r`AzsaoHcdU( z+~qubtdQ~{;cm)x%V8CsOi?Z#M!D#voj>e)V(oqTl}>(HMUVaX0$cI<=o}HCyH57# zI1GSuWR9tkf&D4&h|i!j^pr&l06fc=RqZ{MIohOe7Lv}*FrrD)gF|g5?Rl z`YT6raHQQdHiXKZtWYz{$JSrjx%{l7B!cNIeUCysCm`b4H6=5yL~a#S55(vK^a~hu zS$(Q1e>Fb#K6y2mkyJ@9-Aizj{UfFq*2*R`5WjjN*#fIu*7-RFjf#DR4uTyra+)S$iOo5I z!7@9Sj_vqS?)i0Y@%`v`#@GnITX()~`qjPp>L%uIrL9ZH?4FI9DI7eQL#JjgBqIEp zQ&8COM*q%-$)@&lH=V?;@5pz4`x|!Sl#TscZx9S(I3LP=%@2o zr*~w0v+i)TwSaF=s3(W!UZOmkK@QXa`gG!ziV(X3a7~DJBPjn$E^5S)3_Vv}V~ijX zUH%_Q-Wza3N@VKAy3XpiT&jtU4M981Z@gvX{g#6}zwT1bi67_W7W7XG7`gw*^HsGU zjceY>!+8m#oFDHyTNw0qDSuiWM0vs#5qcqbO?*om-MiQuO!;%R&j-G97T8?B;a9od zGR2~2TVmD|EJ#SrRXCHrZZL|42l3ot7)ijY>eG>0i?_uM=3U?q47pfQj82dm!za%tEyr1sd)jqE})_3b%wEZIq3ue2l4?DW`+1tw1 z1?chAuo+*Xgh9y>hj7#oJi02~^A)ZS0KzhFh~y=-GT634lT}<1^#Gj%@PqQ{ zZEp7fj4|(4kx^6I2=ZJoU=}@xwREM^hxGsdF|liE)V{^UM0)EgRhYKV3jMpuZmwC{ zGSEdG*!HF&Dc3&PU75v-LbG}JIP6@XIg#!I#@y8f5I;^&<0Qk(oytVue zs8>@>Acm+uDeFakSTgVXHa>o^dK>ohm-D;c$H2z;tA$5V_g9^;ot?3EN88Vtnbo?M z>+_5XQl>Yv^ne&g0=YL*~+#QXVDiq)8|{x{M3 zljFd^0B%KjJi4Wy)3@+wZA9OWfTjB8OFR_KL@$b)GZ2hDqHcs_7fL$d&6RjyY2@n1 z1Jmi2#^q!irF2{RxbdizKWCPoBoD@wZ>((6dA!n61eT2A$Frw&fjwOy`n}BU%DFd-c(j3T z-vj2bf9nTOtTx#0xG{2(?9^DP#!d2knE4$9W1}<^y$;&G9Ro9g%_ZCBPo%=o+d0o=j*H8 z_L@{}p=TGRP@qn!>=OQF2mM6dcILZ;V1AJ90;rie(?W);YQVTN2c$=&xlNXwO)#?n zm$jg{SbNLne>Y4dZkV6hIgaG?OG|cX?}0B~s{DAt;nHVHou9bFY3gEg z)IltR(QKAIn?qVz{ck6u3^$5^96R6 za+{hPoO2&2X1Ieonby>>AaDnwIaE2KpJGeVK9YkU+z*0C;vRTZdw|4}VJ{O$NFsf) z$?tvnk{V5~KRh4ciAszLt=p9A&?SMyY%qNAcC~r#-aGxcYFO_#y?%W*V3I{O=JhK; zshB62zjaE&rL7s+93s468{s%h9;tuRz~IFTo7%)$CO&e*X{EMs&+n_(0&ne#J$Gg9 zQ~a4SR`&SbBH@+k%D~r~_l(?l-xhRLVKFaw&o_e^jozEL;8RhMRd;n^f)=!5G^qmB8D*uV0WepiUPXn02cdjc7-10fU*Q#d zqFMX6nqR-Zo#6NvK-2o?3if67!_EUkL#xrYf;qSm=z&Epv3LWA?Hp9NWMyyPzWpN9 zDQJudggS5|3!W02z+8NfkwwQjo3s;9O@cH``YHk`qnu4^LSQ00TzhIU5-6~{v!wMA zwp0uxMFIE@BM2*yweL}R)JQT-&cJ~df`H0~Yme?>p9q;>X{Va9mb$vyneN$UP4zLvX8oDa>mioO zz!CI!u3cOA^X1tW0~fgp92yK1m}NCtHzx~3gC=^TcEFmN0u#uVjHjn~xIu$+-V||4 zTPZh9Ne)2C71+IiF=-j@i%AR^H3p~t+z!G@G z#m_wI^?;ulF`A;1LF=agPnpxmzd^(nA1LKKgnWoWh=lb8oSU;VGiMi;(V_%t3+S8? z=H&Fz&NsOyYTfDwcZ)EX(H+RQ#0G!)`gPFFZHL3J{8a`RXn`j7%_U;p4`thz*oNk2 zKG+6W#OgyHMfjk`rV*&)7^NPZhW%x>^AUXvS@^bZ3?!z^Hl194w=uUm-!F0GNCbdU z#$frBfnu`MkM%C=`cx1aPQG`1cU*sAifHt7eV2R}tXJ$izeyJWfHu zP{=c4MIAoIi#mQvM96z%iE{7NZ`+m8`FRp<84#ZF8DYJLdLU^q(wlk$b%|EFlKTX&k74K5=8I_bVLl8r)a`N;Q*W- zV%YNU7JtCI8uPC4_$fSY+YP&xF-XEPAun>-Pp$%IC_mFCHA*>l+&T%@7&RKMhfq|5 zJ}s~py9Alp8^*5!rVR$s86GYg<m2}EIMBJ^3aqgtDI4_N3xB8qoY~=6RLy(0!k{%%|M70Zo(3PC6Su@J^dNq> zYbnnNu^Ln+YiOOyz5hsX`7vP3N{Tz8!3O6G9iu@KGBi4uW8h7_l@F&HjjMijW!V;MU2 z&+sZaXS{#{iMXQ?qgcXj2eN(FAv}_(RLb`}la-YvMB9?_&^j|%Ae&5;1Dl80x?m>w zr8>^QtDjt3k&?Rh_aEc&ATRU8u&Zh6mv~3$;bN0~zg+c5agMqWv(%3#GE~Y^y)&*F{+mQ+RJK2B zFAESg&G?^QtVMk57wij0ux9~p5y}AZ^Kq>Cqia_UK2{2r+#>82O32LOKa`TRllq#c zC|$DwlKL+C15QUW?BDHBS-iblc&Ov+j=&e!pH;Aep7ZY5aUB^<>51k8#Tj{cL?ev~ z`aSF#O1`Na<`rxI@2Ho$D zX&6xJDy^b-9ih!y)hhlTVy{4O=50#$!x9D%j{>>c|ML-JcHmOFqIC5T+~S>PyncPs z&rf}L^2O+0TIagG<^lp+uDjWGjPmM7+#cDpF*7M6|IVxH0f?KjijZca0BdXDxlQ6q z$Uoo42Q_+G#nw*zYP(cLdqdv9o9%~N^badeid4GZ?*Zn<05ysa|1ayUrG6<&YC|$| zfWV1dEm!Ok22wchjsLfgC5*v^w0PMCq2>5Hbp7$)$L|@n2d!hK3M|PvK=>pG0(<`Zcv&~!SiRrjxpCRDw)DM+ z<;S}#IMb9a#PMhQ-G*Zv@gy7HB_fjla$HZ$QraJxd)in=NQLf2y8YN?1|*apC+>=QMw!l6WNC2fT!fWUF1zA?tzhkLYjg8k zrD6-0<9{e7PrP5|i~mr-Y?ND^5S+&oJ#R%>KPOt8k!2c?+alRc%k{wLf@lF9Cht8T zvQEN`e)|z7fHfFqt>Ka%PK5&!nAd*jBZYg_{`(i~(dfv&?sInP#hgL2ydKl$wa3nE zEikS1Ih2!4UF8?CpFc#v+;?(YvR>Fy zj^zWF*21abw+9>;)$0?hPs*hSaqcPm_vY%-L`7&@C%ztVpg&=K^3nBxL6jBeP~}>d zEB^OaEq*z0u^@Ny?97pgIQng}4!e%Yok_QMJ}~N=`fx(dpsx7?z>(zQ9Fkii5OjcE z6#S&kN9F!QGso&Ry%n%oXMg3nlO08?GO0K0G!^);0KRO7!y9v<4f)j9*XDV%&ZvwR z#Rf-O%bvPJyl$=w##`To}o?5nchw^{F%`yF!s>614H}#u@J+Fq1KX}ntEa?`* z{wHJQgHS>6Ij&Y3p)I;iHc}34z zS$&^n@qXtH7d$4Sc7;loMm#a(&r(L?Y2o*TQh+B&MFDjppTTOMn3#fv1rN~wj;*K1 z0{>%q4-)$QhIs>X_pa5)7zI8Z^GvuORMSsAP_JOz_)rKO{x8Zt&H7AT35Crn8X7b? zM*0upMmBK04PMjy??fMN+^c=jV2hk|brPa3{nY3x{ z-8_WmM1|A$zcz42h;P$?nMW_z*NelB9pC#Om|v?&CN7>B8lT zjKOv6dlLkOnA46uLQFt5-%nb2C36C2p@uehviDKJMU5nQDzc*N)IJLTSd7Ymlk7e2 zLY`&T;9^H**OYMqADSa}( z(7x*d2t6exB{17L4x9H`gnAe15@G`;fywQ!KqM?t+l@n&q!K`5`yXB9%JTQEFbo6H zpKHqNqY+hK@Yhi?-B&rd9yICqz)?C9nerw3QvP}zv2eiIGN zh*TA2Pekn1qu&e)Hr-l`-lIU(8y~V>LI3_*jqh^@9B5BihtrA@BM%^UoPNkH{QUWB z$9nAlll9>fb6+>t!;J{`c5QjEx1ge+tsvtR&=L1HmseC2EgXQ=g&dwK=I8WC61^zC z{U(}!XmH!b8euXgJyPn=qWk zdU~@mIWe&h9UV^mJ$sk&EUx{YT?a3yTMxXKGOH3&4&I#_B5vt09U(@uFzeYwfp#7q zHw+a?NiwPPF>F^IlK9(4%3T$VwQM_zK0oB2@N}tZ>s3FgD0_;Qiu<5|cm7(-E9^Y_ zjJHP~#aJ8iD`}}DJqI0xv_6>9X*@o!O0>30g6Q(B+c|W(BRKc%Q?HEGWYOWq5m*lg ztg{vten2aUU4%gUB&~m~rg2T4RqH#5WRo#z0s)-}f0YY$Shs$`*q(d`2IG2r9&V%8}@G0H26Cg z)kLEjD$*|2COYukr~dvrzGJGO{|Rqc#Vf~0k%?Y1C3T!=JvCV62uGoSVoKN{&>9Qm zvTWT-o2flFrH(E)7VLrUJOWejIcTX0Vl#sYfvhq>B zN1LPyT*sJkzZRDVY*dX2MG0s+SXz3vzw+lLGgW9g4|UhW7Ly@#!!)MZaGrEL6qAgUw$vG*K%h8=q=ftgk${K{C_ZpZG0EHZSoqiSa$Mt8x7?KC z$0=xjEmn1a@Tz;1aR$$OY(k#(ObY`oCFg^M9uN5t-@1Fw@1wgiA-Bck;Y+h$2WvF@ zo)!%-?-V#LdkVQt$4;+SrBU=6j+c3Xx8(HYH6yT%jfI7Ub-HaM4sXFt5Y3a*h<4Zt zq9IILC_X5CVw9X;qsKC;a8(=~Z!ZaHRolOZyM;n2)Kru|u5Ek-$0a)LLwRxW@dO06 zGIE5-kFwt5IqqrYTnUtwpgsh?>P_J{Ug~&9&!WQwZgD~RTbZ=sZL(9JFMSNu?Dgj0 zrR5qb;(fh2##^?rHQjE}kKdm--aEYEdyFP$%YHLzfPZAfL)?V`9G{F4nCNpOUQKY- zE;%eub3H%bvB6L!W>2AfNWAOat}O9OBWpj;J*g8}j3L|$+*9i)UDY0kG2wgkVP3?r zG)I<4J{!EeH82Gx4sf`a5a+rUF{$lYaabFG6MdV8&7c@yw|4=9p77*xU|#(Co(n7t zGP%-1{;$akg#kZ-&k)@G_=GD3#^-WwGG*0xN8tu)? zwg^$C(41yV%`92!6g1uSG?LKq)fp6}#E&glE9}XtYVfC2S5~umq~+i% zP<8COrlL*ib#I8%3Ky{ZsktM5XSili0c1>uU4ryUYc21 zEdpOn;{8h642(9ibaO*MStm+L=TQ#(-g2ZTRe3FM#?E>}>|884@VwB^lfgZHAI#3# zNh&JZ^F6t9@LvL%AO9fslM9R*C^5`BMlq%$Y)UZHP$VD#R%5(M0NgdiV;w$xn55ex zDg$Mau09_e3c-7mRZ|Ps4fYHR3)_z-h%^l(nggeg&RTJ>vfgXb$ig%K|agOXNXX@FN&j2cm)Qb zIuI)VorC``7Ms628@K}0sAS6PaTuQIeK@vYaSy)-o`*0yl>uWMUqn_;j+6-SH9hWN zU~J#3k1_0zAFkx_fr2LB@(zhV#LtzO91tH_4h~}JNPrp4BgteMU~02LXLt8jq6P#J zZohqx=x^|QDLyy}QxU^~5R}zi)Zl~O0FR7Zs9;H@*+;Yk##vlm-X$u^0=jRc$yQ6c&&D!8( zpVvp29fK4`c=B&t;M?+MH1q2fRjHFc3(KYnUWS{o1eUP`$nC_2YPhiG1Ap3Zy|h$) z;miezeqm4ojd`!IE18ebVyVe1C=^K*|H;$#cbuY|>2mq>9$o0y6< zFFpz`!Zdf8Zaic1$j+45#Ej%V9>v`z5zy(9b`nPA+W@FxEo?}i05^ni zZAc&*vAu&Oh(VbPm}L|nI9Qy8afDJ_6LQ~?06?TBcAu)YVj34!nY{(KD%gf87?=@y6B=;fz3anSgrKRtE!jFrJ2$}R{T^-b(>SOn|xe+Ot+qX7?3Xt86@}WqWOvym8 zIFss@J$E0oMsR;t6N}~`#$8_;aSHFl^fv7=zx7o+>p_GeshE+-@)Xo5D&1JU?_uji zE(-kqI6=XN@z(V4iuyk&)~Q%ber)#ghF>wMUUNIvS=FqR^p&M~IZ%`?dGk-YtUfVT z>ti4s-;yMGsoLwAfz;e{eb=mSH0zj^JDly0+}SX*S7U#<+vTggsK|%q)YE98dI1CA z%c#%N?3EA!EdzSL_H@A=aZNCe4I~0trTVAa12~VG9^<0ML0*p!QRq6R>A%Ms1KWaY zE8eIs;drQ>`=u}|+QI`-na}XDh&?|3bdzxqh5T1^rmK@K1_cR2nqg}B3&y^LSpEj_ zQIM1AiJNw0>1@DvU8f%Z;xl%$^YH)9e=AV_fzZc)u{j%PDd4$@`_yhAS9*ylp~4cc zEY!kh5l8EM5P1(@k^q{ZtlI^8`kupY6bx~xQ&Y$Vu~VvmkNPOo;0j@y-h2?tPB&nx zg+$TRi|6QBb{L}VF`xWq&{N+5gq}iXLgJSu;*IoS>Q`V^w;nSUGE~dC&R}m6SGv54 z|L>DdZKrX;hQA_XPut-Foxw92SR{TJN*OylNrrbLVmYKERG~RW6}(Z}gQBjdDEm74 z*dERAJQ97nSCVMCGDCuB5wlkS@A@-HxQ8m#GTi{0XP<4A&!Qv2P+P16FcM(=!S2@f7|yQQ#45 z+_tT5r~NnRYwSAc?q}fU3=zz;?r!~5H-UqIA@?VH{L4lajm1rhvT%X`JmZiSnsbCm<4LM>bWNh`r8eG5CIAHg^%^YDtXOJlXwfC7eUc7xPynSUo0uDRJzWrA38C@G9um>J%;cm0k4_^GeL!+`7 zbmFw|(98PKuDJ!OzgOKh)JRo_9C<#vk84I;;giJ8x?3Wu zm}S#{uagz{`-WY6_+=s$aYjRgF*6Qxaz_F5jn)kb3Of7rt0->V>quIiG*Hrreusti z`j6>Cpl6F63uvf0(q}`7r!!?{vCvFUO4X{e8er-!!R&nl+R$d68CQwlM}?9j2%0ev z*2(ys#VxrM;YXLA9LGsd#d3-2+Jee_eEWY$Zyx9J1p03rAfPO2xr=a&CU1s#=)mRS zBG6tEdp$J2$K27e`G@uq&&7gTV+#lg@oSD>=#3iw_HDf^O~s|j5cI;FpnRUYgO8Jn zQ`LDzWYRnvKZqc8+S<_{OG96;UFo_?Z#`F0oT;@#sbWRB!cke-I&r7cI0``C_ST+_ z*#-sIys6GMjmupAcqCwK)4Q{?QG#dY4p4|$AfOI$j$cgI{68u@-jFcEC70pKQS|1= zlY&DQo9v<$?gtd5=bT*4c;R?tW~I-b6Jtytn!my~^8{+Cc&BT)eYFjcv#tY6#$bgH zhMKHV_sXfby^~#f*y`UUN-8#Y3P?$rOs$-dwxQ)xF?)@x)PJh62&7!FYgn(Iv`XRW zg&vx^5FS5KEA%IN#rkVq|5-j z0Y{E8x>qDs3NZumb0VgoDBQ>k#za`_U95`!zqR{4sp(Jt+owYGX>Q*9Z*d^Uv^9rS zK0iDnG{tM>9<{%OlkLOwgXdvV{n>}?D#QIL!R5c!HwQk_`z^D&Mv0lSof0y-SEF&m z%v-CJwco~HP_tupLzq%9w*uw=$JgZFgU-W^G3d3QVzPjnnb660N_)3Gt<%0UIQN9r zrbj_ZvZ&AhUSc9R^3)WFv1Gly2jX1u212Som}v5L-?zI_DpJoEw+<`?%qA%6;~)7G zdsE^70ymdqL6?+Fg5VlF<|irmVrtTOR65o*X@Xi>*zlZTn~Usg!I;FV)Uk% z%@Maga_{4wlZ8w=isLsR=f%mg{sN4{%eTu~y4j(0q?P{jgBi8(I_OA=aT@py@_1>O zjAR~=4iL*%PLLQr&bC~`vs@|~-SI0~v>82@<}qQmlM)_DWB#hIS@x`@v@tUL+|el& z_`EOgcwtjVA;ah6+m(~JRO$9`eb)UvW>UV&eCEwPF2!rv>bsS^H_FvV{DaxTeg$L! z-~d{UV=nK&Yl_vib)1OTMbd^rdm6uz`_!lErr*ZVXXq#x>)zRbVfIbU?$U{3XFRfq zmX%d!G54sjPP{pozWH~g-3?W@o~XNb8-E*{RKLKJB7`)|(+R5`GujtW`p;rq`1QA1 zesVHb)C4kL=H3_&6G~G9TyId^6T9G-_4Pwof?XAEg2>l8XJZqB@)BrFqvZ&8?gq-c z#3Q~CQw^fwC7z*hxGcoz1Jg+2({5udW3yCIoU7G=ee71~sMGS}BSrho9Lj(j$Yr`z zswEY5Phzv=(;VIJuQ6Dm<$7F4J=+~~nCoFYMk!A<-;_;4r$@ZkP~*n+ymGzc8l1vE zi9#>&sQX43<~_Arr2ud--Cd3x9(L3f=#H81*_{@9u^jio<=c(_=BJtK@-=x7ep*=( zwP%_lg5}Y8l719phMO4tJ%(xgai`QbrLB&d z9g2rF7}=wq{g=Fea8P2|k8Zg^GUO@`&Jj}hP1b|JSbzh?*&~_d1S>#5hA4keFfP_h z*Mj|rvG49{Hx2;5TZC4U<$mYGZB?bc+W;rdRoQK#7bA&Fcm%;cnc*qIqnPjH1TR=1 zb!-)7(er7?2MHTx_#nYO7PBDYK!AB#d=Y9|Xn>hvh`%%Hm#H3p5i+3=At0i>vaLeARGXNQ9kj3_+_ieH|8Un1_NVq#3EO{*4vd_* zW;|gi^K*1<(qQ6F2*S~CZFJia_JG~}#Gx0p@@X)*?^t@3VQ#ZVuj%f^Y~6LMZ4PNy zg!kV!mJ2^K|CVO86kCbPl^n|o6`DPpL+_lsU@G-;uyunKO-`4G=qZ;Wu7=!QzI&%OWN)nuQWfq25@v(rD-hR$z}|ysl1O|4cKu6;ksp4TWaDr_k4kp4LipZ4 zPH88!))(zRa6lHYz!zt#uY+BhCl(w^iY&azu;H@su3d5tK@sWs%Dobnxjf6Jdds?< zcnxNF4OzuA<;U!-BpIB{bvYetAH04r!x#A~?`0sP@~qv=ttaj7YlY_%L-v;>JnmRY zj0(@q*IBoNDk=O3^5!e(L?MRcH`>W63BiGD={=D>sDP5H*)#H^KFZWVm`rl9iAf=9 zY1h)gtOGi?z7u^OlqAHom{C0@L^Q%Y;-Rm=@8dw78O@(k%GAa~?6t)Zs=Oy2e(+gMrs7LM;=y_6sMh({j^ z9Sq2>AfglMBplp9q9P3Gj;kmdNsJSbP^VnVA|Xrw4OSz50Y8UTSTkgCagh@Z9Z=He zDB=%&3MV8)(kj9wV*sZk7K~m6372pJ-euQav<9t$md7^KW}4l7UU-jhw*10Iw?3p( zl#by@qtO#DkTPhY7_9w=_qsaSWpW>VyxMS+FV5o}!?N&lexbY8ywcL94n4A}rg5ci zjRuMfHF*oUdCm0CI9xot2@5oo18AoGiy#YQ#_4QkVIdFO)66-0bcM_~yH@$&XQ=ay)6vp$@hA2M zP&m1`xY*m-g5`NcMYX56n1Wqf#j@;>NPZi717>1pAim{@GY?{J);A%6Aqu!N16Z=P z!_L7_`uEfi0%cbO7d!~&hTYH_66Ts8Lu7QcJaTiC31tZYjsCb24^u0Os#QKf4sIfT zAOdY#D+X6g+qdU@n5_0%{zrtPa3aNM7c_-@Ou>Gz$&LaQnF)$|m<_HJy7v!g=ooH$ z)_+i_I%0<`4To$L_wkTZ%tr-u)fxBl>$Z8!4^}6coX9sm{_=ZpQr8B7AbzTczBEC! zLf3g7-u~3|1A4=QyWbp%s5e&tX93aw(~ORdwA z!xv4gtuq%t`)-00bq$3RYnum?EQ?VS&)K?FJ|Gi?PF#jx!R5)4PCL^CgWSy+s}%C@ z*%MKnms%4AJU0}C#TI}Mv#rV^!GnWlph)TH=nN(}K4tV>OV2cV&;35XkWk4{ciU^F z0s;arg~~pfg<1nCsWmI?diD1F<0nhsve!^>HSGFyZN*DNOKaDg^N+iVt)l=%1(DzT z5(XgD6sLZ#pS0B`A_(R=VPIg8U6a@0Epm6+#T0+x@2}=-JtLCK6OW7fJ4f#4A3|b@ zr=!1BW#?M1ca!tUxhC79XWZA?Y}z!fFF5l&wP@$2iN75KE~jI**3plDx0F_k-O3?V zRu0g8+aKXiGrJ@u`}TCIYyNIx<#y+tkWwl&>QC?FwaHWXnU#Cwx>6bwm~KMepYZjK z?^;3U8aKH?RZ%hG-a(fU6)G8&kPTy<55(;6PA;j4-ad$9k47=lV#VcyO$j$Y|LcW; z>1mN-gIq9V+1N}y3olPs|FkZ5)R+!09xi@~N&?oBUqx zU)hXPn~=JR{pujlNBgMpvH7coIH1VTospS&7lg|4P}IDH!u};D8uyqUVZjXk1fg@X z$h67Ov6>e$PZ2CF`@@&f$!$h2t$Fk0n1oGzdI`Wb5x3p>-cO*LvL@dSXtUixWTgHveDBr`ux7l`Sh~IQ~wsm_JL`- zwjCih+4Aq}PdDyn7ZqILQj2Egm+G`A4AGZvj%@ z@Y6*z3a+bl`|RR9lVf79;@uM@hol3`^gZpu8~u~moB)+MW~bd!r(w{7Kb`Q$^Ktjh zwzf8fdJ=IHrtp*(ZdHtKYQOJY?`aCX=J0%IdDw8$giV^-RIN&NwtS^q{|2+=!ilYX zudWW=PZp|lkBCBx1kLa3@HC{^NJ;%o%ujwOHn%O>KBE8A<|Emw1nhk#wnSu$R_WR6 z92`RgO0kWpJ%Db|VO#Gim!45o4a;R)1R;`T6x6JqgjVcN z(!ML?%Ap@~&C=!=7?n!(UC_#IkKcDr)>gRN40PYXmNT7eFOc;%2dN|@2@UOC$X>-hxko#s%*5;T z#NE5>xJ5{%Yi`RIIh zZ+6=D^UJK8_?q6FqG>NttjbFnbKY_DS4|JcXvo@cR_wg&Q%{#2469eca{Hs}2h}G? zD|C9kh7B1YMcsV!Fi=1zKn|f}IEXJ#m5hcK~q@KGrJ;ET{RT_;tO>klVZU~gPZBA>MEtwf~dUwUUd~}$Q zKf(1$x{&SXf}>HWY9!B(^&OutMtG?PMBP_^#HIc8Vs*Lb)>@kz4>e*pi629_$%=Ov@ zF+l+V1Gj3()_0-G1VUlcK4&=oEj!<#P| z`Lo{t(Z;_wyQ@#u>V3EzBb$FV*Di%C_swc1dZjg7xeD=3;j+Ca%EdS|TnLu}_4$t@ z59;$2whzJ#uujIo`;pim6_$ep=TFf-DQ}<`d)y z7V;MU_f{LWweqfg>~ZThhv0j?bH*Kvl|$96>t#207-*ckIDO;x-6Sd>CGX{RWvA6o zn#EZ?!RNO>v>|b_!_d(_YOc}x3GXut=fvuqekDp$U3GG=Z4)*5xf&N{`Um2k849f& zU7EU~QfXd&Bl_9{_n(u@kp}BjXJoqfA0)fT>}P&~Q15Ao&r7?@n>z}oWVM0=0){Z8 z7OHp$Zwr_@Onet&o<~s@3SjZDhxZG1dLh*;a)2?G8|0Yoa|qfQ($06SY+J8sqP_dx zmxf{Lj;tZ`3)yU~jVfC<547)gst6Ht-SXx@Hk(SFQH#u|12pPSVBBjs{}EtQZ-;l~ z(YF}b@kIFyFX^^TKDg}pN!kGgD=5KTs@IKw0(U^)~xKL$#Vmi(XA6;gOt06 zDpTHH+8SVRXDB^V4sdzb(R)$AWpMx{&Rv;cq6bbJ5(Sa(byP%T3IyYNuAGjFy#rT9 z?-9e1WNh$_j%^7x2gg)EW-qPh<>lQtiV&xs9r%B$^+(GLa*3J0$>o7H4tF^Jtunb? zFDe>#Roy$}qowQ9{MoP@pVI zHj~`i(KA})ErDl2UZUNi7shsxyw>e&J-MZ{zA>^|i~AldDc}sGy}>M3|ua z>zl*?!2Z^)?S=UYhWS}p>;EaX(fb`<{*4#;ete!^P*CePSWI{9|KdEhhmXU5o{N-Y z*k)h3FO`E0?bct%k~kk$mX&K;uTI){JHO@CjoWP+UA*jfvoX0;&(sdn-RR1LK8}!G zDB?NEgeOa*(HZ9svAu9`82K(i2Ino#cnXh2-A?eBQFo- zQNfwL1PShYVv=9~=z;fo%H^-gffFGT_c6m&j@^4)M~78v@$+honR8EcIxfy1Q2h6c z+OF=B8`cy3Ds+DPo~E*+p9IhRmEx`bNFCZ+$Cqa*BChuPuiXgOOzIij;5$oVn2HDs-i z8+(R%f%076)$v>)E=rHrA7iImTZKIhvp5ImJcd;e$~)-X9wljMh$pK<6F>%(B!Cmp zD8Y|GlOsukU_qLe_9~!@F1R=#OOnpWL^XPk*4?U4C@F5ikLA!eaViRao&pwnvTn8$ zni4bUWz?40gUJg&c26z$`Fr90i>kXb3u^ecx&KhLbItMaS!+XE@OrPwDZztW!Uews zA0K5eab(f{6jAVPQqMU)#5+)r&bC=&Ia1#D&>w-AEY+i@+J5GgoH2TETr}Y=(P1FX zTwPZ;00#pZy;OTN>Df(Y5MM}`H1v*Q6a$Z|vyUG*iX}wcz1#Ek48DUw@f!U3pkq6) zT}TSI`a6|ByHMD7ss3a@-C&vE&eEfQ^Er6Md9|X>DJ34BV&C4inX5vjA-(C`>%T2i zPuzcQrMa`Hb5vgbp79HhcC|Tae}&ZNKxt78k}vvNHH>a@?K7#CnUf7$x9mNCIdfb8 zrym%l|eRw~Y|Ww%yrl8q%&@s`n6N z@jGU09iZWG+J9S1K=^G*hs;JF9g%*gTd#GnoDiDk*J9<@ZsYbXu)(5M^>AO?4%1!a zTxGoCiWYdERz}VZyz%h+*m3zY6~wtu z`pm9;Z{Twp@Mj}YTo`NxfKK53XI`(noMUoX*zXyK`^W1j9)80v(|#Ir=Zvii0d7%} z!euGPc@@8I1; zhAHc=L#-8Y|Nf`*qkP|8ZA#cNs(FQ}%|$#eVl_zd0VkuNZgdIk2d4(!xGt$%VPSPZ z3T{9oeZhZR?8nvW7qfsA%60mON+0TGLws?|(4jo7TJAYk$_!|j<`~}zT{Y3_ch?j5 z(D8qM_M-U8jSa%jP*nBqBQ;uxX3F!uIpRilZQYGBIltVo*^qTp_tC2nn;!LF^1f+H zqI*l$V10abyky81^jh*%q+hQ?B|W78iCT#gZdoUqS5VDf1pHEZ!ivM>zfK!s4T=i&3%ul zBY`fqHa1TLZUtqmR?pVnvLj2KK{H)VE~9Myag*<5l6*}c@r!#7uNN@=HN6J+^!<1% zPG@s0F*IYVC}%MpdMljw6EDde9lrh6yY)n~fnm^xPv_Lvk!avEdt(J(9Qr>6dv|!8!HJ_zQN8X#ZwWB$v2vX`=$%@K~qM7#r7~Ki8^Y z{dGCs@-5rCQ(ILS)P`Tbm+ zoH9;-$!A=*)3czxvk56+kfg$Fd3B7EKPXA&n8CbNdf%q3s`~H$0NX1miIWhlcPX@4 z4q@a{h^7(m0FWz{p0OM2-pw0e?5m-z?T4d-g_ZR=Q1P-)R|P3a6&38;#O$8on-dbt z%a`(r*Z%%0>V%z+BylK5Ig2tU_2ENmk*XQl)Jyk)#1eu$IR*hw6fb!U@0Fz?5t@Wg z2eGo5xjEU<#Qf~U=zjJv@`tfV&x$1gs`AAsoLfxyuQAsJn|D8}b8_ggJop6!ivAeG zUwAVr&vg_+RwKM%YwJB=?F2vz-0h|$;W9#p`LADM;&#}Yox|4;IUxXHhCk};=bN>h zoc2qt{C2@pekb;*xR^!y_sr@YSHE(VU8@fbdL8v+Bi)Ilj%}>Fmp3XbhZapT(O0t? z7_E{qxYO{KnLd1jY?haZ`#Dj0x5e1q5$iJgr2tC$iacGEb-MrjtPI#~Q8DwwI26{C zM~Oan2P}NH$kIedM}Lkux#Kw2+FzXVhsv-0!PQG_=>j%#gy3M6&2HyDc#v7oZP0NoeKt)85k7&!HkuNtP@rG%0TO zM=^Qw$FoSz%4!r|`?#CV_qh)q7pTsEiJ{v+Bp9X{#M~E0`T3(_@Sp`Ru~!Oqu%Esj z*>r4%;woXBT7CDlzmKw_JllLto%fS2r>FlrvYX>+*Cuzviz5=EMOQSPhOOIKJ}T zBoze2@VS-fAa-9Z##$tYDJx6h7%&*}1Eu~hnp4~w;ve0=x?a!J>kzE{)^bt*onHC7 ziCj$ZXAoNUI&eoNBR97WZ0>Nvl0gPhn69$^-pwEat;QwAsghpvbH>D}jy24CGmy@H zh5kd_+?pwo+9CGB*P`~&jOA-_HR?&-xjizqhRcgP>3fvvz;pBo4%Fo_m<>=pTfmIz zW6EfP%5KoPBNTS-j>_zAcD!tV;Ti@5hXn%w`{!dryE47)F}*v(ROnbgQwDbFPtkyE&#d{58 z*QS&%Govg_>y?t-x)%62TFDg7MZ}GXa9A3Ulzmjh|IbCF*EI!5_QOR^^ zXI(;`U0Hm_ob~1WMpkdmXt{W8=5U2&lcee1%3~svA zCr`S>(p#)%-W{C=8*IC&=j<9%fp)uK_pTg=&n1eBiwTFl_b zceRf!;{9AlrD%qt8U3SmRN(``ll?z&EBu)3WxFM{#E;n+6$NkqC91v2iigA%9c|H$ zH|GydRsS?0XIbW>`!+x3txF7uFC%4p={5V%2WwDCc__KDhsUv{)LPY~r8oxtUI>mF zKHqjXp-i?QRkKIx`8(z|6BG{L88BQZ?Xzgmsc(j5>)EqOFP7+)Kst3A&n>G3AH}`T zEpBpm!TqwbvfQ^LINU9o37wiMBYO_3qVF=)LR1tCE#x#bBFy#zPonr>!4Mb8QZaci zp@{F_omn<-ZoK~}H{{$m*9w>WaX`)S9(PbK!bP(8>B!^EcALOMCv0qNW&rQ5rVtOl zT;0EHIZI#O!rdx?@mIO^)X(a_wo+gs?C_Y_-+g5MS~D&i@Nt)cR7OWS3I(G>l-Qh> z%S^eL)b;f3@H6#aD;~M4#C2PX#Ns%@gjG=AOm016<7~X0o{<^rY8NKJgx;xMwsU2| z{W~rtOGBae?4WTexVatrjvKn!nD?kZHmksp z#q!o+mGrib4zY0~jt1nQ+xf49b6Cf>IZrI9(&=nXCl$&+1miP;963@JE#<&I&`>FE zTao-Z_MtvDL-Vedv2mXm6%(UIW$@4G8^R_}|J9hx^o4(IsK+MyCn!GAWxPtq5BScrW)3uL{dVZON?MbK^B2I>7}o!nB*}-`xSwj1nv*L@pWd;aV@N; z0A&v!JUV^B_VUKlnk&_}dBAO@&6R4#k#BcPq~^DCM*H^@1v$Ecup&*;&DH=ETE?0t zd1!R{Now(3UT*HrNFLf1=AI z3bcFO&mUx+40JCO?Bx>p_9oscX|uK3azp7zh_0vVSjJ&7?7nASKl?~6jf1>3)(TkE zI)z(1geonQ%l#NYE@#DL)DJf^p+J(5D}pQ#2h~p=({4{TdG{1sU;cc3-3)HILF_=1 z!%i64U}%!KCEz0B!uU#63q7`P!yB~XsyfRY>1k+u6h17)jZI9{Tx;lo9R^$po!=Ff z8@T)pmz*E<2@1L^b|5FgGv#>t9F~)ptZ>V169@Tr$(h%FZU-ud}Gko{Z;J-i90h&Ycf- zH*3@|4PwT$1tP}0if;n2i8~AHDxhsIK!GWQx^m;ZL&Yuvr}Oh$MY(i3vWmyOWbjc~ z!-Ff~-I&osSWG_B5Y*=8cIHTvpyv||)vzh(-zdIM+q?ZC8QH2cnAoMF=!DCg>LtF57SC_2AuC2(fYlooEJnD+g``fBlsH{M zQb}M4Gk_@rzlcaZnLA;i-Bq#rNhqLt^IzYGbG@IYPD+D*wT_~#tBcV?@e(_InK2w$ zN|%m(>54in6$}b-srweRUahayf4yU-%v8Qv2)2?wBwO{x@%l%vWj`^Mr)s`B4>sAV zhKHsmzY7mu%e@K9V~b(sQxc4xo&U7Rmam&>tuGZO;rl6Pana-2jlRdH=UO-*7Kalm zUS(=t?YNfU`gfLf$8}?WN2*auH{a3CX2pZIoj>GIKD@cN^u|)frto9mU++TuVKYB} zOyBS?0%$bG>z3AV)fzsvDlj_!x1JvgC!- zZQKNC$(~>6mp&(VN-3{m}{^yR;a-Na_aoRjF@JwuD<)j)4J!SxPevv%k! zJV$(*4NUE4z*N#^ORgo5{ImfI8%k8b3jn7yjzdiT9B^L18wn; zd954H>7kD0-QBWnMfU-_U$qp@zYpl{?r>Z-FlYXKKmfey)mMjDBbNMYt( z^C{LAw1GYVIo^~|e_tOY^WL5q|o*+lA>MjgKyVa8Y-0{z#Im}@~&*)W1 zCFS~tK|P<8*C~cDP)^KTf%~8i73*jgj!Jcm{VzR5f>eJ`UmpRa?;!#mmccj^sAVby zJ1zo`jXyFn0wf#&_hNuzXaKym={n7r@UyQZeH^!S3Sdth?Pz6ipn|5~vwM@}a?cXE zo&!`g7=U!_K=`7hr?y&$dRLk(X zxqb;chAmE76yrntV+kJO4Gu7e_3I<~u_!1g*r4Wn5nw4epzP=ESvkiF&?Tu|rRV{? zRxEJUV=ngL3mOiRu)h^AseTBV9{mLT7SFa@YzA+Un;AU~@t|BfdHAveHof$|_Ch_wR? z3lDs%^TkGXDJY0`3{MHnv0L0jUzV@&yhgXR*w*H~aT=#PJ9San4!7>jYnuvSHt9c} z{m6#EWd8+pP89*+jd2G^6am&cca=8fJ)#(VrBK@$?)U5pX?CXA#ztZ|9*9L&Mp0?Z z?Erqu2HIvGfKfq9HCshr>4?2+Xyif64wVnmE2M;a{oc~ApgV(f4sL$X!LX9Z?OnNE z{Dl7=!TUblZmoyd3O<~Ji1h@!5j&b#^cLHoh{PLKIyyuc8>lLL)m!Yvot8-u1P0S) zgiGcgeYd`w%+TU761cCFH#DD)NIl`=qZ0_6wYlA&R0&mB{dE#Wy^;A7MC#U$cg3#zd?J@0gTO>7(QPv~dmj?C0FVQ!h6IYN zU;w3nXaWWUxEY8~p(q5JI&uaGJ}BRs2Z`Bherb8|R=e|8B|L4VJLe}mU+%0(h|9+y znz)9jESh7HVOE9)z82fhTXa& z`Ds8(?~vbx*qOM4C_xikjHx4quD-p+LaA@5B(L*!G#-7%BW34mpW3aG$}~Ie!+EZ> z;gg2BjV9NITFb6-u(u!7SVW$Y(dQ4abLi8#6BhE(nm=CoQ^ZS;@@-AAoU1(l`@4GB z%DM9JV0S~H-Gx3@)^%bTcVLeA#+?)zc|&i%O#0wd77e8hxcDGacS(ZS0iwQXD#vDo z5lR~lIaBb^#2jrDv(r00G&mUv-gA6vQKq}8r?RC7K=R*TmWh6Upd@J00d~51*4+NM z^3erKl~ZC*jZb9sHc_QQB=f%?r!dr!sDp^!7dh-b445A)6sqhpM6)ow`EpXX<8sfO zpsfN)U2-Vx#A~i<1u!oyuf6i$Ec{%GAQKcV#P{Re z)y@{pF7aql{eh1$d=h86Zmi05*=Ur5&X(^=%A0K}Q4+CtIgX-%WPpCZ# z_<@C7TKsk<%Tz^K4unnBKr}^g9ooU6?u!*GRC=$;njC8&WjknvaNnLUfP7f}4v?H2{OS+_59%Sbcd+6MIF&Y04PT zqVe$$+&sTdxMM2ur+z;1VZDMQI;t2CBR;Bt^QCa`P#iXc-fY934=^!lWo17df0&nN z036xG#AJsM1eo_6o`OJQVB_OyDXs(U{g#&tS))w`rHu!3DPFQ%gKSi)XsF&gLBBq} z{J=6eZ)LAU*u_9{SShN>5~+HqEfv^@KUcB)8R*qPW&PZ&A<(QSA+PQ2Ma0F$0iq*k zqHdUk*1xSQd`B^7Xueo2-7U@iadR@7*k%T6G+2N9f+3MN!9o7=vRTT|ta%+I8E^uE zp*kP`$Eu5(m857ND47WZMWnE#G5B*~5&X zZDu;+-#NKbStrG_a&i|TT;aozmU|X>;MA|ppgWA<=MxFNUx(mLxng1zEvh-EzU7}g z=z+Ld$Id~Ege+&f-R`)Yy%gRM^9LBhoZJ&2B?DsAAvp| zKZ(|^?w3iqxsl|g1CkB$;!4mhw9?6@7E70h2Q-${KQj`M`7Ps)qLtl*f}tcljLdFL z4dd<GNt<21*B&!Nq3q?uSXKu91nkqjC}|SP36+yGO1jsI zRs}KSq}WW29yFDcK6iab%u1`HKOYpyadjFbBblT9_ZQ%PP*IiCQmHsT%RNGXB|UUn zQo{hi+u@7scS#Yz&q1HVr}gly*b6(4z?NsHhg6b8H5^vTF!TsK8l(y}0ed6g0qi{V zaiNuo#?#;gOFE#R4wRVj6Ax_4k#(JE(xPu_G{IMf{rgHy@FOSqCd~#>3S@v}>&&&C zlkoj~0Br7p2C#=IP(u9Yw>4#%Nze(N0Ch)K_yanU_d^-xl$cu_D5nqYWyo>=EoZ5} zeUN{nR6}{DaE{bmz& zP}b2CTK<%^_XD)vH+_w@M#)IFh|k@S|9YO`PdKf$;`z$0#^vK-Z~7HFB3aoTJB)sh z?2pOjJpQc<_miI%j*#UX3HN2ajS_dN)Dh5pCQ&+rBc_XRb)a9n)S`LUZX*@Qz&0<^ zI+y-)D!tN~ZJh&}+pIsnkxseOW1M0T0m>P0{Bx2azt5$n*vtD!?}@jI;peqUW{OX8 ztX90tA2Q&agpAtbK@s`pLfpS6@c@`(tM2D9x*ISUd`+iyDvy%6&%|a*FDqTxBX9>2 zjs7jkY@6;SP=>K>l-5#-J6eJ};}c2G{5EfTyI?>^o{(4cq>6n{W7Lc)`@b_gTh&Ri zKh#;QI3DStbK>lthBRv~1AxDv-=pwO>A-+A$ioj-|F`HVv0A=egC52mT+3u11dG&V z*7FBe4^2zE!1+yJU4#>%yKx|{_V7vazC9kBc&uSDb3zBwGOV^1-M|}HD3CF8HZx6E z%KLIX%av~}24uScgqT8~;RiY-Q~EaB41PPf@M0^t80D|t{kVHtI5eLH9BEuXABO$z z?Iq5TPp|bNL`MmZgq-Fe^Ha3K7Tuvz9PU}6dvyBP%0#jTtj`^7IF`-+`vY+^wbn<~ z3~dA)*6|AzvzxU{+UL;7`dA6%4z}4Xy3YoyR}O~B>1ifuCuk5HT#2+8~_mZf0C#} zhT(#98#?8v*o?0}mQL?AAv|vh+I^<%CQ9g%z8%NT-Sxk}mf}wOIw2k_|Cetb8D50C z+Wx~<_JbcxB1qAkn$7c|wf~>jUi(=DFf31XQ@e>d0FJ=CHNLqgBWXToTeWt2!?w)+ z-}(T{DG^^v;D)9!MUFL)i@lR=wN;`cKV*WUs%KbcBsFT5rvC3Z@+G6)cWcqO-zX~z z{%X&lUwec~hN*1_*Ix%nXB__f&JOL&w(pF7T(P`|LH>G}I2ckPZ)J6Mn&r}av#Nh# zX_})!?+^Fi`vdmECXEOAygUZ71TmHJc&drX1hM%WK;{BtOPSbidD^M+@1iG1XL7}o znoR2WUotX~*yin^J*`1|E+Q~|r{1^&9oV+QrdxC5AS(zjHppFa{)TmgN#;Q3^)$~Q zjL|8TZS@+CdfG`Fr5x+uBMd2PjqC$NTeD#FRVqVecRel!pC2E_r_G@f)f9WMvj1}p zE8|2tbL#&d;BeH`M(LwFwFHPqWXqUl+|_)=l99w`U!ml? zSz}O-{kI34Sv$CZJy)U{T2+=&&vKg!b$c*uhV73NCx=&uj~SF3tgf?lPr zeM>Ah9gqx#SJf*svb2+7Y5uo9=D>{&Kt8vCZi->rW9$9rgLka91>14&Kpcel-*zgL z_L}q^yaGoWXwR@);ti{ll#`K+t{qYA3PUofouH%!`Z&18wx4_u)U(WK-fNra<&!R# zNgJMTNCq9xvK6!MsKbXM*6NU=SF`;0(zT3v+;t-)6Q%mL{0hlPZ(4Yg2}o4u0`7ZqGIZS_Mg$}j># zsgv*hk7fMyZ58Ib(p9ht2>bzh3J4-6~ z2py5uvK#Hv8+cCgEjAB^wLleyHbC(OBo-hcf&;Z_?M4xT{(AMxZfhWN zgJQRsv4s6b7PGTu5zNPOiL*;yjFoV6*~|CYS&8~}eqyOy`qw^OV59pIVVPm5AxfY3 z90^ocF99|g8MeI3+)C*uRa^Z+ZMPm|WA=k8#<&A^uWG9@&(2I`rpto)N#9}-*uT{{QpzaI{eA!tl6G^Y#{i$ul7 zuDvgQ|7S4;QKo8M!Id{1^EME3^t_lfQsSj4!fBF#`GSD z2SKs-KF~yf+VxPzO+wqO{g(^SOD<#E^-D^2fX_F6DoQ-51L^(bA zKz>QbT|T%r12%(%GoKkDYD9jw)T`0rOzFM zkk0Wj=$Rum-q^TW7J5+uSk1b?Db5NR=05eSW*P$CruJZ6 zLj3u246s31Frp`~LKo|R7D@YEJR~%b90R!BcL1B%fQ?!NlAEaH%n@^&q37IpAcRJP z6Y`f)9Z#9_+J~J^=D$Q>QB{h~ZLcA^S`0jz#=>*Fb!iL8ald!jt&_hI{{E#L7GBZcpS&otJDZ1@y+3 zdDlEWQM`m4@6o{3X_3`N^W0$n!a(l`x_h~0-Tl0crCw@WXpbPRnHWgRQc5yJcW_ak zcN)aW?QD$`+j2Ko_D?$o22cA*7n?$Dgm!E||Af}+<0UYI!)L_&%?YP!Ui+L_)+j&7 z;VU}M&-?o8{#cjlpJ4oo&Bmo$VvKRzFh6<#WwQ6$BT8?fh3jA$B-qn!3ZK+nim;v2 zu;$ORhM4`@iYDK6^{?+NEH8$r;Hz_9MZ0ATmM`Mn6-zns2GaR9K8*G!iBu9td+|9( z&`z6g&dDW;iIJVUVqjn(Dpt;90I+LftZKWghYbw#f-DsfB}q1V{x)9Ye8$QV^Xu>8 z*U_NRTvv?A{UQWfvecQ!WQn`PVb@W2K>0~kO8V29Q#i}&Q@GHrK}nn0(+B6y zUV9q^$+Ztao?~ml^!D4;-rQDi0w!yb5r!`dA0B~a^n`nlhL~YTuGuipqXwd&t zy~M>&oCYKzBO3agyw*UWP|*>qV=MEuZ-xwTZH1mzfOw&yNvOmMhpt4@LaBQNj^m!*K;?ER9zACj-?X3;3$1t63tti9IQzTG`)+^z5Su z;i8eSPnbE-c}deS1pALgl@gg48AS{Yho(L)bJTGkgB6FWiA&YD&M2$pv%d-!<>b6& z`?>-tB>-Il2Lr4DyHnB8$rD|VwoT~G;rFs!1$%R=xc_0y?dan(6*79#6pb>gvh z?`PHY+%Z58#w+%=#`fub>!41S#0fDKD`RjM?iCr1cTTbYzm6q;Uiqg zL6&EU^R5sbx1Z2|Ku2TU4q`bCw=s`SPl=TZ zMRmLDp+k517YXLdYD>(B2PnkMsixi~O>bX)u<)g>To}}5AQ{y)Wf~lKJ3TkY>sAYV zu~prH6bJ}F2^*p_(1j%1&idchSXFLT>%90=2NLdH^$5+$-3BGxTnNe4V!y5MK3id< zg}Ij?PZ9DcWmm_SVVYX@5ViSFoXBt22T}K(1|~9irKIfx8r#v-UWw9!=YD7m2D^(;O+fM z?R(7qKZSl!-v&ZG=Q}|8b;g^jA`hyZ*x$}Kaq<4COmxtjQovs-dUW$P&Ul?-(bvH# z)civsj;tyZD&?#@1ybWLW?74!xn}||bbJx#vgYea{ZobkL&4!oiQkDYikXTfxH>f{H*Ztb5MF+DaiWZfelaP zw_kg7>Y$Z?@R|kWl+OU+T>`o=aLGOXyNP~Dhgv$7=E6TP%g}>tn#V5(oMY*UHytnz zoB7AEl*qii_RQSJBwmNE#^HDrIgkh#srmjqLA7|!`XdWOxhDdAg9AYEH?@>Rc9|uF zv9dOH+!_`X#Jg6A3+W>v#2@t8gY=O?*>=!Ty;mLGY}p)&b()zb>ms>-ES_0va!n+G zzmWj?BtHP>)d!jv1{zN|E-}a_HAxcc+ROiSOXkd2 z?unuG**$n2K*-81RBM9Z{w=(=rn)6j154}_8^jSA=JzRd65Zw3D6#Q^h~`F%$M-+> z;WFt`+21oV=|JZNmG6QP@=(tYz~9v5eY-sAa;Pn|`%`dL`Op#+TopFVf{{W{)eb~j z-0&Xw^Dy}3zDYzz5K#7#A!Xs* z(Z9Aq>Uzzj<>4t4-Isg$KHD-G1}iR#?WEu)*nU5+=3oDSpzLxw=g?zjZSH2{@;3kr(Iad2K=0v_w2^L_*r*n&^+f#u}4+`&(necu@nW+!yH5LCEC| zVu^|5`=BFKtga(5Pz=~in8c<78nlcOiXI_VxaaSS@?Ju@KS0V|7kt+rXK#g{5u7J3 z=D;4gyG%V@=O8~iS;!5!G*tZPzE;(bwL(>1k~gxJ;*QBoV*Ue;&ebA6buP+O%wJ@M zx$$x06vMhD`B6+u5D@D@`ULT4T8KA(DsNS%U;*0oboTdm0M+2Zk0<@(f;ZdhEUzoO zet>@mHB$vGP=T|A1`Qu9Eq8qY7eEg2yz8Wfs{`z@=Z#pZ!07~j+8bG|Sz@$66oe0EX?SmPXPI~mn}5I@7%+)gYZ zy)-BkYX{}%`vc-w3qVB#m3-|3TG$Xo)Sx`fr?T>Q$m{>9)0qFHZPg6^7m~0W;6uO| zGS#m}0JHYEOwmpxgZ7o?wac$dyzQqNR){z4Bfe}E(u9Ok!+c|y;Zip!=esufr?2mS z{rqKQ&8qJt$l%erHgi7!sE1b{Bd?a(G1tkYWU0`Sz#u^YXzYp9aD8Dh73>3QR)|3x zzcWxgj1BsYoK3H#xM2bw1QLF3tMdTGFsWGJD=&b-pPhATv;$ciP*G)JothX<^r5#M z@UA(v3KH5o>58n06h@c4EpsnK`l>dcRmh<2vAc@*KJ?&&^^NnSIMAOQzhPae4J+xT z=pBZAhs{I^Duc%;jvly4cLEBNTT--(EhDj}=N)#SA= z49V#N`Feo>0{Z0HF=ms+HdGQKeRWT7dFw^q5bq&WSAMvs=cGzfE?Wxk*KFCwT&OcL zpMBgChtk2!pYeOSQG-|Qm1aSTN}~wC&e^??3))93ap?M6{wDKE47MDNIE0P0$Sbbr zPLm@{sQS}2FtpXW|+2qF*=;psQq%kD0CKMVhj`cvnY)H7S%H zY3j|^>I~r_iUGIyfD(gEUKNRo`nITHjFL@Xj|TmG#;hT0Xm@oThxye~20$l9q|j!^ zQ)csy22jq`qV|G&tRt=E0c}o(gCw-fX-2Qf350ON zZt)VAIv-j1F9qXaq0w4xyhF%Ri@!Zc^2-eI`@!ns^vMI*IeUAETl*tPIK@s~xvS2)m&|2q!Rj`qC z&*42nsvE%{`4vqD2T3f5OvMJKt&bwfpBO(G6!CWN{#$!HtyS3NlP@$L0J)yE&~1YE zAQJE??t5a5MnN_QUwq|?qlR=@i1x@@FzDQ9QG2+>&RFM>X%Pk5*O3Mm(}ZfApm&FJ z((h`xVg-GdH8iX4?~ThDGL0KLO>36GtEhO{@YR{TG+-^wlhctMqb35vE{KOd8_5!CP`N>Il1(o2a;HTu0K!2G=Mm@4rcq!U=zL|1U>_}lp~ z{%vLewwOWl>4URngYd? zb)fzCt={;xkM~nk!W9MDUfg{pqLpCdHyO{|Qsr5UVFxFY-0 zJY{GkG4`_ILb4xh(PvH_9*=!(dg3tsPUDBFNOWV?@<~wNKcyg6(l@$rl4Tw4s3?^+!sC=U`t)>?-hb z>cq&tRbLH47vfG0${s_gK0hzo3rygL$>xyz`pEr z9z8+b8}C_0eoyQ_ovKTU?m%?Ayw&NM=P{tISA7l_=uPmj_7$5I+2{yZUdvbpi43>E zi0$#I+Q$Y~ukw3`%zc zIakaO@^&U~PD!@()lPm8e5}M%`w%}X!kJhKGq*|Xxz+}3=>J}@9(?Btl3{* z_(aZ<;QRYCTc&nC5pf8NpMi z&m&Z~A&{f`>@kmRqc00xkCRE#P_=?aYkD>S!%GRnLi`QOC8~$c!sB7tRaoF1*9Z zgu180jbPnNgkG4?I9mA;=1Tef^^H7JpK^GFm65Z8i76^QG7`lS zd!EQ(uaZEo9#s7F@2h{udf-BI_EWvCgtvF0j!l?6dbb+pq(3kt8RhcDjWsYpdFDrD zUpk|)=Nr1R{GK~7pd1Y~+%|zA`fILQE+TV{+iO_hR`dArH$_ zTqNA+>%tX;UxK?O(h?Zpo7n zA^PY|+hSNpI=6OW(#@}Lo@a}r_qHD{7(?i&$mhoG@me=|aclFLU|)Y`5*qiB^?Qsr zr>inSNFvp}S>^P|tI@*1(3cb5awt0M&-^IH3a&6>>l?8cLK5{7C|9#vD=Qr+oEjVP1VH60MN8 z{uOeiw|sS{Bv&@ULY;zyB_ zBfNn4=XvqM@=_;P-WRs7-LO_*uIPd&PROh082W~l{~y~n88^bTKc_Em(9K_~q-bJk zd!18duus-*5Gt6aqYr`>2aeF7s#r@QfbS`G~9$swlB;@&xwP}Pn6;t}mV1>4JS~ar< zMQr|{BrWEtu$Okt@0%!*hlkNJ6_`JLz?I%TZl8?lv``4BDr~l8%eQ6^hlT!q>wSKC ze53LFsr{oMv4A65)G7;mvT$Lcdro1yeOl-{1|r5V`cqUuL~JW!9y0v`(bq%}Qq~Tx z`kn35v>n`pv<5}wlPGed#Gbx)x2}l+S8RTTg~4WUsy0ex_YBEFb4+C0(|~NY-jlKA zDrSmGdCKi=l6$_~2g&&v!E9~!2KYAK63rXETx`l5(W;0mmbmOUsft=72Awk~hGwpp z*wx&(haxHGb9>+h<(0oz0Y6;G$bnuEa>r>?3UbH&Qn$d6jQi583V{;tgaAwcmaS<# zl@k|ocVtJAzs%QqCKQzK^kpORl! zz>z*SPb4<$$POXHk|CwyZ{NjDi6}PzVb!%{+jFE{r;%d|Ng`j?aC(ZiZ zLEK0OkG%Z*w9?Fc{)auxg9Yn};QlQ_B5Jp*Z9WVSv5%DsS4l5INItyA^ZPi==iK(} z1NqSF->^Yd6V?An(Q;*Z7Z$6_Wh$Jx@pm)vSva}T6y5Dy!zK|K?Rhh&Weu*C}#`l;<0_q2{K}^K5 zD%C;naP+QGz2R$T#6~%rmcY`CCxBAmB5(MPC$>P~QT_2tJ^UZ&-Ih=c#od#U@J7c8 z;e|=Bg;N~%Mnv(ei0|G{&wprR{QlYnY_=9MIDhE9>lZ@(qkx{7RP+BBUuODhm{~?Bb(* zXISo^$unp)Zf!yiv3cmL>BBBj_siFMUso+uads&QBVIq+z!H9RJ-K5=K{nPZG&qlo z!oFijt20d)l6`E!VO*v)UoQ>+`$aw>6bm_K0yaViXD@_Oezb{EC3+#?183ZDFDa9Z zC#N_6L2$ho*Py|VIn4ZYbdax%Axpjqzg4&XWve)k^_i8Im(@u2M;3Hy zm(~ItJ|sVi1^8Bv+nHEaiRnV^2TqE?cv0NP2%wL{VuG5N5SF3UECH?Uqg!|N;Hi+x zJ9aszMNQF|Ru^g^tvZ)us;h%_1f8Gy4ZYOWsnwZ_c-p!R)q*p-ampFg)f`ymuRhEi zpy+e9OSp9jt*KTMceS1L+i*wIHfMKWlo^dC=nN-0kG0*4`X{cXHM-1w8R}(0Xxkk# zXQP%+E5KHS{F6Yw1%Am*B!9JdEQNMlI)8lAc5mbHwxC5!Pbb@XHGyGUdNkQY=|=rW z?PO1{vYPlPM@vuC2pH4(d)b*hq<*sv8HY33KW^OqQ@K}4bKBmw=!?Qb{_axI*)xx3 z=Q@{OD*J9 zgEQxMO-tpRzy!O+8;ZP$;t7ig$#05radn3oQ6R92KFI)DAT@ z6HMjeeOI{0fi&wO)3x3KRArt|GMXfirfIj3r*|mHaA*GV!wC!9Ow`Rh1FXDqTk|;e z#+S{leN5(`P6ZBh!h0f|+5||f*3C4eIm8+9lBMg?bpo0>c5i`*pLs~Y@+Qy3hlT6@ zEKl8@UM>^3QhKQ`f&&9tQigSjyHm8_YxK_i3hVd{tKo*h{Vk{B?Krj6h)pBwS{@p6 zxxd@4l+EzI>Hb`{!9n{H=9+F4cF^qDIi_1JbTD!SZ3>FX5AgQl;=nR$6dPh_}n44wt=vbd#iGGH}XmUo7S z1rDd@H@XLe=zl$C9O@D7PtNh6Ss3$b0Pmq6m|$dG4c-H)8wAOMQa0WDrVpgy3oC^T zhw(LcbXSTKdM$dP`93gbeY5=_<)i%<&nW zOjTa?RUYaG{PD;I;$-40q~EyFQrBArvYz+URkA|vXH+z4$U<<|=C_ndXSjZbtOwz8 zI3>RlM4eB5UV}C(EBnK|2$!ZdJM)Zf2cL&&rj{&fvHXjrnE4gVE)ig%TbrPN-MRL+ z)F&27M#`*;o25 zs^&!9#5Z-Ugc}nV$A6M!62(zvM?lZn(9KieoYG}8yFb)joH7xumOoB2l$=x7I?q2ZI>BzpD0)1Y z#Tp*?PcgcwsyAzkb8~SJw^*e`w=ksbzm(8C$Ql|f(Cp>KYbb{Rb~=n`PGrI*e+an7 zGgH;LQQd|oP-O&YbkjIO2LpB;FPcllv4C&IL^Es!`tG2=vB@Tf-kjsz8%-w(8y&hk zl>KD>TUF8TvfJ zqyTNH?=@^phZ5R9gG-+PQ3V?#ElI2R3a&=}kf)QT^+JZG^~BN${X2L>e><#i@QN-D z@AO+*%Zyr7!+#czH7h5tOr~}I6VgSTxGOVJXyw;M-+|56TcKD{W=$)3=g^T9nJY5g zjaPs1UeGT-c#TK68%>Dh90N~V&=`7Lx`*DMF`~(zq{xUZOuozEJ!p`|Yu4eLNF1%L%?el=xHl%;FV(ZgQ3n(?zd%Yu*T zqlr>+KdFzz1#1+h$Z3an{pXsb@jCo+aaL+~#kwBFHYqzy`b7;^-@0jmaBR2;PcMXi zD_I8~>kUrdxBYR>V+fMT-CrAre{V~kAmC$tRmT#XYY6e-sYx?0($&J%JAhS zMS0zj_9?tzu}>rxr9xXdi@XIb{9>c+J7+U6YIYgP?zd&S#d zkY-CLjH_OSsqgixCuK%^k8oqP&JdQ+!e0D#XiZ}at2*{w6l5~~)L>3A za@RPQfS-SnPXZGmP4XV-ailT$eglhf_Xu`vQ4KnrIZ`}4YSWn+xC5$Cp-9$B!Me<# zJ@5C~VZ@VQI}Rq))HyyMmWN$gDVG*%t#9gAY8B%A@Kclda?Y-RgGcf=H|cO(UN@|8 z9p%4>mW97*zL6MLLr%w#v$SnE_(6|XNdA7)h`FjJ9sV|-oYu;k4Q0NzrW_^j(nwm$ zQZn30I^`CYho#tvb#B`g();FP#WuowakvpArCJE_Z*#5Er3FlHE!Ur`2uB?|snNmQps4S|rm?CfV8} z^6SB+(Ip~w;F9%|EQHf6dw>u2LESGS@-n#WZ9##^!E}(4-oCP2nUVHaL5oWX@n~6$ z8_^q)Gqr#;49b~h_oet=#tSR#yoh=XYJtq(*|q|?Q+WpKv*{taO`#aB6M0*!!i4uLtY zxbEipyE^2PQWR>>V6%VeI&ZII0q@6_7s0Z&>F;<8-&e=@POK1BS~AGTGR=LIJliU9 zxF$-XB;2lP${DIXs3ZD?dGvvNDoPL39huB?fnyCMvChktd-(my*m;s5=i8Yorl|8+ zv`k3zM5#9>h3oSwkIyIF74K^AV$(>mReFzb3*%TBPj$W2`E|mIr~ZJjX$w&MKnc9yuVTv}yW)C26?hG$}_8WuLF1#l^msX~9WTngYNf~o53)c8^ z879svWLB_sULvII70{~{f;SCkUD`w<{C5;v0JIZ#vP+@59%G$@L-V`z=w0bLE^DJk zN={)f$t?Z{*MP2YHR6ZPR{^R51N!HyXGO{S87+*BVn9iZFi@?|IXr}LEV)kCcwJu8 z+_9izSR~pui>!D!BoW6fU&Gka7jo;G_Jt->{Vas0vFcx(&vYsQVSwYDragwOd#mWM z7MKnKTBiAI2UI%g;)nqH)TtHwY;(A5?QBDn`ofUS6}gk)epz16{@L|$nURtw$uG3Q z?(jGLgRM*w%neMZue4{_eq)*5Z|CHli)+M?oWl}5j^eJaNym^8vu{b2;{Npi6pBu< zLlH|xMY+8jA7JIT-}WsF8J?Y-9Nn8|X{1f=9Dy7uT7z5^`PO27+s(`@{FtSi!oj)B z(5j(wsE1A0=b>`v(|*~BwJQr%>^`*EJ^4Xm6hq10K@-sQ9JMJ!r!^~u)mFf#-4piQ zz?x8E?VMyb-}Wz#>hM$yMd0Wt2uN!HTiSBLFU{U1Lf#F(hOop5T?{`Qg`H0UbC0c>UDr2) zA%A;69C+08|Awzp=Pl01yF~Z_kE}>hAB9~#cE~u%P?tGtB<=TAXXy&}I`1G3J)j8M zy{0Z(+EAl&K0L+vQ+*T~9Iaozubpxyo0(5R=_y@8)9ku!7Xbo&1FFo@mUCGa0e&Nk z$bmnQehDum!1(X{1sZb1*|iI*mO_O0FDmQ*Ofn{WM0@J1az|bCv7yJ!Xsk>@(+$jO{pLxK6{s z!8@l~g6lVjC8^e(kFD-`(}(}pwGA5*{UDe=8{9kFuY4GAq*vt*yLOUnoGBDG-4ccRFDzWCS;K{Qi>+u-8-E;LysW369<}(qU8RQdW8#_@ z{Zk{FU>+?h7H9%oOtoUgER%hFwrkv5jks$_D}&g0eM)0_kvbsx9C*syxBdG0q5(g1RhD`jM39y+Y+Nw|Og`YovHW)|~t?2*o;R7VQat!?=O*DCreRi== zEKqvQC{MueS;;xAACS5$`+a}hU<^Te*&8$+1~Y|>J3uQO3~TFiD{PFJqY=Zpuly=D zSF3}~XWusYC)i_X4Nq6F3{;(UGM50CfAw19LEiJjN=Fj>{pB13+V@P>~J)lH3_Wcn}mvE1jF6+2%_8E#PN`v&K@2GMOP z)`c)lUjlcJ3#a-ikXE?cK(=k`PZRX=>Ten5ko>Eib!wu3R($TQ@OG8g!w=}oHa_m(&bB`-?2j_e z1(QELkrIh<9~?4TLDaN=n>llEN7p`1m_zX(3557-r!fnv)iO5nujyrQ+%IRsO7cH| zs-4MYca=eF#tToPJj_OzAtyI)QvKECFjsL`z7=a}MHLnF?N!=^^Xx@)*NSrr}Jw8Vd>^}B!OInggb zl2i+lzp@zO=4{~OB+#EGn$=seQ*{}?YUj{2XAQqz!%xtMBmZtE8N%@77_$qD2|uWPog&u& z;Fo{^_QAX7gq~NN+7Z&8EbVNxJSE>q(#HB+77^A zoJK2@_{00axetVnV9=|QUvUSIM)>FcQW!%RZ@ztuLi+bjgaNiu`#;s)9T_XT&S!k; zOD|TBN^Ta=*mEP?)A=*{);G+4?>F(BkH*6`qcJ8>Mby2T4o^=qzID?)yqfVuLxi1K zs5x6oU=yHYNt9>|ReB=d4Ru}~d+F|3ch~ia26qx5iOx>qefRTK=0}cy(yt|kV5O}G z+{?LInvk!oxkXLPOF^vcO#J{qb9OwO6s(M&T6jpe49@=i83oT_e^3=rHsz410_j*N zkRxvmAupaB)$*ojQlNegvsA5I=*{Hcx0sb_I|>g!X=lc*F;K4jQppfs(8O)Vskv{# zUh#U%aK-U1zj>qP`)4mA(n^`B&33k4bG+nC-<kuZyUpu&p zp^yPk)f#hcVN1B5imte9qJIZ>H2}+sEZ9a+e2Pts<}_Pb#(D38I)@{UywaD`W$aBB ziZF(RF`V)YL2#>v@LjJ$_YMND!n;TQ2rqRstm{r+)AgzH&(bJmRKA>`#2=5#ZQg;0 zAK=$?W7SXS$OTC&f8EP38SbYuY{ob1ZyTzYse(O;?%br`yt|3?5><9NIsL%=rz^tK zPuOsm^0AAQ!epX*Yurn98Wjui`tlt7U1`zY9ju#v!W4;3wD3w#%!Zi?;yKYZXeGGV zRp9Q{!e{rvqYFJPW@_$j^b8gAh-rO|fj+X(cA)##;gNn$VrdCu`HxTrr%#K8;`oe% zUp-qVhCOxfJ$51YY4;fawTWaXHIm-OsKtHv%c3}IP;vcJpDf84Sulwc34_G=Qh=A2 z7|e3B?0}q6=g`Mtq61J91nE6#D-Bk}#Nj~zf7pH$IWG9UYw%uqDwxp*Y`?xVHRx9j zx)RIRerjU^l0j90@&kk)qx4o2v}o8KI4Hcniq`sd@y?u9yS(Vp%RC<1DI{{ zrl$+y>V|QOHg-ao-7dshcN82Sj_@+hd0?SWY$c>TGy__5nKP^xC^9ql&GJqI`+6}! zNZhS|GPH6;Y6MTg7on#oN$q1^Desys0fPzj{1FPT%**f=7fYhDt1&-JU0E26NFeQ>`0uUUHCUCc4xI#;%T zJv;Q&qAx5I1l;z`;IzM#s5DqZkRERSCJm~&^3Y#BJYz-N+Y_9rW5{_f5=(X_O|TTh z9y{OHkeL=uwwF-M_2R(6oYS*A$1jW6DX@VA)d>r=332c_Vcd4;L(bQm>fFX2bH9vb z;BTnW7QhNs>dg%NpYF~)8q2rs_ZLct%o0(CCMpqSP7+Z_k}`{5gk+W>B(o6GWTrvM zSY$}13{6TI3dvMtPNoL+e$VRJ@3Y=#ueJZ#YwfkRKU%H2-S>T6=Xo9Dd3-;gI9SjD z!Wj&r1GQ|G@;OjvP;Ri88hCtaw4i}-Z10!Q|4BHDbTB2?u=KXmgEYQ|rP;&EO!#X) z-^Cjj|50$-Imc$AAj{Xz9IcwSWyd=8eJ!8w8D^w+-$!}h)cnVpzN^QIwJvN_aZ*;F zG3H#du|T<_GSd82zk_T)1ih5$oXCS^A%RfZwm(}7bJtSY>F z6O-~7SNv!n4(Z(-*7Q~0AOm8x{UQ90zbWt@Z}bAe2a7)#Z^W6q&b(?uqXvkur&F8gQJ{-22+W&CSj8`Y`gm>Y!kY7Fi)&4`3LbpCB zgt;9|7HcNtjQ)zb?%JID-4Ou)Zs&v4Gr?d(Fp(gqARtvzYnCba+n*+%t#;U{Q!0oV zwz3#8x+(Ff^;vfFr8KyxENSVy^Tzg?99xQXWgQhI=nYxUsa>x0S(w^8uu(t=<50-G zP>DX}yU={GT|f5D{;!uTEj(F{v5ZA0eqW}RRO#D%2VZZ6HM;5Jy*46GpXTNL9Ke8~Y1T;Bohc!JpkQjqfP5O%;H$FX%#l&^Tbn zj$;g#KHidc+BqZBJ^Snug2Xw6o!f_G_l+#4kuiS5{?_fD+OCQ_uZ$j)iU>@MHYwic z*5RY;(GL$}JJb6v&`C2d_i~4l;KEs9YR~+(9D4JVEOq_u=au;wFFpF+Qz-b5!Mdgz z71wX)B(QUo8Fo3xf03!CW0xM^HB_Tswz{m%{#4#@L82{2ee(Slys7*g+4J$2FGKGO zT`0ilnlnTL#B(t_GJYMs`>ovci@fY#$}}cE)p!@iMr%O7RLkyMmXy){f3{?n^`_QW z?#MI0ZSt#Ke5d?~Yn5$5Mu+XrsKaiD&k%=+vT$98UCKD1&uQh~GI z>HF7rYyyoajE`S44r4VdlcM>R@@mP%m|WB)f9+j<|A-G4UaknxlHfW>yCa$2uj2@V zt?sUV!?S|DM&}}y?yP*dW#y*Np{;z(MWX%+N9=jXZP;<6-9jsgHFxM!+T`ugoMO|*T7I}!@MYFPP%pl9w&YIRxjsItcN#_Pbuu?9 ze@fT1B&9eyHoe~)<=6YueHHu9q2=SDXY^?HgfRz1WG@fvGQx;NjP__SIdNeVT3Fy@ zCFP=Zb@Rue^N*K&lv;J|BF(K^Jk-|!H~N>K(%Y`|j^zYa#%vGtU0@$>Uu^2D+MD?~ zMC*EBHSHbUyt?{lM*GgqR2x+IviCj>+ND&ayGV7dUvS4c3B3Xz^1Df8ZTFMXiK3=ka&e2oVn&RjW zloZ~^>nH!gyf}zj^vK-5t*&+QvcZq!ee1KN((*gPYHn8w8m`boHT%QPZa$ok6{>kZ zlDES>?8ivK+!0L%=eCT)cMaZjKgO!8Tk@>fb73T&9_wZIyiI-k{GicMm79m&a9QsuYB?R`3Vn>D(-e$Edu{c%4R**^QHFf z9wnOXx zDK;3;H}QHA<~k|Wc`JftQw$^dlsH)h42;*NT#_)42IT2m(u@9r@Q~r*%1a@)Tcejo zOPhSW);^-pB16VWPk$Y5nQXt+d-HYG`@Jmw$@JYu+@gDmudbjR5;g^8WxJ&7XZK_q z)EeFlN!2;wGn$>FaOu7I?iCVYtY=~_)-{J^E#QPiZ(-0LlZ$M}6)x(VMJBJPo0pW~ zFW82e-Flgs_C)Tx zXN8Q|ylt!h=^qPkV88a83#cx*G0e37oU!SDarQw`@c^YD$);!1BGb5JJ9AVW%Py-E z4NvT}We@E?WBT^%{K7u=XzoM8h> z?y<=mfyM2?kkC+tP0=9_WW*i?&)<7o8Xnehb&*Q;A&hrJcV%&ok=?Y-`TIP(j?(_p z+Pp~k+53m7?h{*fm~`dkE`u+<8DXD4=e7am!ruFLq{vm=QfK5CmN(dQ-hsPxB<9x7 z+fDBSM&ZdUpPW}>E1{_S;%#C@{t1F)b1d3U`>(@G)V;sEuhKyRR z!4)yhz*L6B3RbHwrOAu^)<1o;d_s4swOE3k zV`k|$#Qib!O089*U*K!GiC+SSFK-)!vCQst*b?7{=%PmVX6?24+4&vONgITPYc{aZ zDSE_fLu+o#SyMB-wiL*L;s&iTyN;1RlYsb@M=)y8cD}FF^!Tx}?DicyR#A{he4TNE z<@d%Ud3dbC=QnD#e?f9`8M6P*k@GCE|2+zY`AW{1oMxh~NJB^81KnJJ08{%O0H3kz zN9!d!3?>SU|M}1sNyy+@+t@sfuB)#vEMM7duIK^buxI~Ce4`*P3{YetzdtBY?2zVH z7%!>4xY22rJhFIb`=Qv1BC3-0jtd-YYRR!0>-dQ5V^5F8;f*|CmbEyVATNQ^$6`ux z`sJ>$hzL7rzrII|8;=w&GB7Y8faZLt-`+GwR6>3l<1yYT1RenyAw`V?!RI-MjjQ() z!Vnm=M0~?0#jAe&tIgcpMSDxH+&^=j&j`aTts(q1>| zlBTrU6gU?zGc{P>7CYt7uPlh;C4 zc^MNEQ$8RPor7Rn5a6qVx>`!a4*LPEA6_Dcy)XFKz4$y&n~q2uuTxxnU+2`ep9^u> zlQvN%;X6(ai2XQ{SzMpPIbb(FUDmecP|Ude-z!ne{g-wOJNv&*bl}Ygr2n)i$j*BG zw+x1V*7;KqARF%g_KS(4V%9%kXk@;4{pwZ61`fNWHos0!O<6%!dd zdpS9|2rJC&s$dF!DP;YslFi!r>en&~sVUT}Zkh%trI)yB`Le(;5O;ij9qh3U&kJ;y>el6nWaVFcNet zWAq zoq?k6#{e~i@T(v>%%T~$<>(^@f`6;16=emefoB?YjbEU2lNnV)E`o|Tw37voy-0}y z%cQ7cmniEj1ao=_R2UeUP6e(hHkdjx%R=aiK>rFu?vbE>!21cqV$3d!kzWs@2&CEx zbPK@1)kOLmBh0>&)k}~Z*FZ4&{DliG-Ij5oPT$)%>{N5K0j91GH4e68caM1dfU5WM zIMHx`F}mwwW7k2X`_km>ERSiq2lqPNlzaRTGM)&A;_~{RBU3R_`bFA;C_V>fCIG};-7VdP}FUCV2K;JGmKOpA!hLd zMa2zOWpF+WK}RYP$Pm%(W6aaX^Hh2TPJ*D&0yr_tn|7cV^6 z1WQ`itfx^7N>b+wbuF!k(Ikw0Gf_uTN!T16tr&jufes#p*u*2KT4B7I9SRXn-7@Va zXNQOFkhoXv#x3$5h}8f(FUUT(l>U;L_pNvHP{j!=Gz?E}$8~6n3gA&*yAPEfY z6!e|ksrYpueyH<)-YCRrB8gq2sz6#e2UJF>l;Us|*^!jW(WAlyrasu^_kD~Cz~nvI zO1Vr?is$g9h-UmT!sI%9I1E&)&@aBez7z#P=Uj$J#h2iP=OYoMsxX%>p)iOYqy}Ix zMAbzT!&ckn0C?G7I+#+69oRv36wqQsbDn@)2x6en^`6lt^2|^Hbw_(&tfHa*mHk)! z3+JsGCrXj@zc=np-!b{ z9exi+lN2T%aAMQ^nYq3%4n1qn|K@VL`Gl$pX8inB*U@1_@E0T>9Q~t$<7%*)rV8{j zOKCnD3i45UNy~Y8!%9kIsVdOTOgQ+xcyzs!aUQ4fxrtNtVk!WUF(Wj=t5f}d9^ZZw zDzDH$sx>e)4aPPokyo3dfR8_X-%)@{BXZexMPn=3-Pb~|Jpg+7pe_JS7pxej)jHqa z{mnDw1rIN;txr;F>iZj#u|Bq^?k?x%{@~=eF#jh%?Udd;rI<1;55Ewbcty!)TbbJ@ z+O*AQ0_f2~*eSGQ`LLgw&pr9>?EV?kRzr3#p)Tj}wCs34PqyScNAr zhTO!8T|%s`nBFH7>QHTO$c#~r!0i6xCj0rlKKk1eTI4{g=nxDI3X)CY=i_5ab1dJD zj#6U%?v#djvzw^;x@;8^5}JqNQhGC{a@WQ)MlP4A&(g~zn*%yhMB@4lKq9c+9dbr4 zhS2pXR9d!lDIG-w7NEW%gsT7vl)=Q~?LUMh)ww}+N==pFS+c@%z+^w=SIWkIe`PC8 z#?|+O5_!qo?}&3Zgw9LaqZN;zxRp149Z(X z=v_@+y(3yc-i@K%#Fgd8k01HoGj^S~mt?dd|96=FihXuw`+Hwb(1+B3Y9scHpj0rs zUx$l$;~bcD6fh5HxmTeMhz&h_4Y%~)glWdRJfg$o1Ho$O?7vaWG3+Ma*$?^nZIR*f z5}sbacZ{|+*qD1SZ7%A3T4dF*3}W8bf%eKEC&eGb})`$0~1+$jW+I@i|iW0lKO39mxSayJ{IwZARY*_qbVfIreA93n7 z{&bl^h)0`c{F#tjN;WD_ZS0cTDNqgg1qkUJR2AMzezZJjz?)_1RBQXA0|(wG)7mDv zt#+aJ{QHc6c+v;0`#NwP3P6-2a8N>;Lj=aRX?rfjB!FRkq^i~;=I7^E+yLhoF}8`5 zlk-H3x&OjU@v=z8mOrrWXPY=%9RE{Zrc*(5Smoa|Xeyr{&1h3Qh__5*lCx67xtn89L#i z^3laVkJumn)epY8zHdrQ3~OLuAc%6&P{BwqEaZTgvrc%pdptIKH+xzr>Qd8tr4ZJgMGov&3Y~}+I?x4Sp!hRB0`=g3=(YnyHE3U z1cR2Sg+FUjy z+`dFzpy@wTwX~9{3t4NrzPd-C;=lcXd3<_)e*Td!P|b@T8nPW{zs3`f$`aUs)M^ot zS|~7aZ$15Ox_8P`*kvgphayZX0Era4QPrafeiM0Ke_vykNJMyebpQ<=Rb{Dkg`|26 zG}L8qUH2XpdGTTV?{$Ng$3{)U$8NXx19Ql+e5|;bIb87#m?2b4h0p8!5`$eJR2D1u z&U`_+vJf-_ff&Up24EXNQ%aLP`TB--)Wv7|gWG_^psIjk+HYdAQDG3f{~}5Idy*w~$j1kX!z(J%9AI|qJ z?Q(7q@NgyCB9scm(1`Y4xvc6i^YD8C#qW}O_Sddo?=5_~85HrFe=eEckbU8>O+-Y5 z4xk%nOShI-#2l=752lz9@#njJI-oeyq90X1Q}SyVf97cq z9D=-~q;sDdV0HcQRW;W%UYW^VTt^cr9%!33|eudK&-7vss3 z6CUR-bS12-_#H=u5O)FeVjtRKHCXd4xCXaRuNITADBqHfaDG5=fOL9s#jZ81=VN2f z5Dq;!#C0(K=jP{6!43Ce%^pF(rU3Wp=bc!6B`|IX`WVQ?(Gn<2CVO^=bBiA;k(F|> z$v%`*gH}-YC=P+A1H+-LtbAfQSLtuY5LQwJImyRoSI%Z-truOhh9J}kZVVWqn4X@V z*=6xv7yf?ldZb&$j_)Es!XZMRNCe0O!yP5+azn{y)&h!IFGpqwWfL_EIEI+nWgrqX zUI((T*x_v;$Wvf(0!K)T-%`PgI~AlemYw}`Ton<43!kGC=o!C%ZvH)HgzPXWb}a?+2!cW+dY}lJm1|HLfgwSY0V!n4 zEy&KEy!&-G&F`X`q~TA(-O@V-*;1a!y53?&WahkNc`|e+AV7TIMx4{2mrWBqc5%n5Z5YZ-9U5;3>CQ)+}1IcyTX;Z>a!+P|*Q%}!cxq`xwuJ>dQ4V+u=$B*pc5O`Hy2lXLxm?X6uGy&qwuDr!|+;@2k4P2=@ z#A=Cj86vvf!&XRUv+mqcb98jHdAF85*1?Gg&UoJeRh{fBu>`GexiCXWlS)@;>{ipY zyXDXa-ldb9TTn%X5=Eeq`2_`Mz{2LzKX8E7$H!+q7n9d<#nPsA0Ho-u^jdXrnlMw z63Mz`$r7X^?H0^s3Cu|LK9%r`2*+*EA=^2|ZRn+tNtqiXV3PsYudfjn5xHIrj@?n@ zfyY(~uzxyeXxI-=;pFUm27#JcVrHg@iK!_KW7GunyUghWLbA#hkiJxkrO zYJ7bBz%!J9Hf>5+EBpl^=T1}8kd6zPRi~$8-F$!jJdK2{b!DwcM#GTVhFgiY z^T;8uZ?79#i5vn!_9+P8S{y&lm~$u+{pyO#=wyqa9*$dG3naXalK|;%&yLZ(lon#7 z+VjjCa*XeHcv`8cN!9=PSUiEBk^fnNZ|wbE;&8r-Q3wkKr8`)!?K6{MLy`z{C_!y$ zpuo~@-`0{ih9DVnSQW|}l=N8L`J|*f%QHJu(@VpH>gx$vya#};YGk6*9pl{RS zbhC4gb*ipwcx_&!>^3mqM%rp&X_?-BF(DzitW5s6%&sFxRse<>%r2s?=sv2ZrgRZI zWO(OVouu`UOEq@L%g*N9ym>Qi0JR!=&Dh>zM(_L)=7V&3WBrB=?3$XIv;o+f?2vy` z1)VM+fa)C?5yu7~1_U>LIkI=!0Ft|?d3lwxsfHovVO+Ov9SLVaKokYPvkt-HS~Rsb zjgF40p}gj!-+V%{;YPE;)B}rZ+Vq2ByRED;p&`wV^p0LqL?fEZb+CzBl>yO~DALYj zY+GSFX;e%q{obXGq1(Vs5uN9q#z^X^)qV>zhI;1a5~`}IY91aQ_6PQ;wOBd-HZA7} ze0u59rRX4ANN<*u)Vpd+tv)Dbko_(1&K)k)^SFY8gF&4GMew>ZkneSf>vuai+(8kB ze(;E~@m^^)We6mEo}hq%Q5i@BeTm^uZOg}HgDR*jpXhqx-Y__qH2o1 z^DkGg-M-!M+^QXBgnqp{k|!J`y0e#8Y&{l+VEb4e1jWr6JUu=2jEp)QeB9jbO-@d- z;hywC5^;;XnXoWN4ZhL7B5xEt8k0zlDJw4z^5A1z*aU&DuC8m(yKxFJXrw(a6WNeD z0spQdc^WvkG?dofy^_|AY?OAQ_U(gW745dlt0+4O>#m-c=`)rR9K0CNKI3ywpFgjIi!^GzY4TX90WiTm+S+52e#yzn z&JeZaF%(wR94Cv^^xHJY6`>0tjDx1&?VV7*?>W(Z`0ggujfc*4`~_w%a_MVu2N{?}KH&&$YtJk_3Snq0W59+`-d(&I@{xsO+H zv}pM{9L?R+22)0Q1w^aym%Kla;N-*tEDdD=r-q$E0{N(vxl`KZ1)+BlRcI9r*Y{y+ z15qi3F=gdf{FJwp+{Y5}vCwpp2D0vheS(0hh#F&m?$2&L(UI7zi3GVCfzSFa8b zs;92f#OJFXo}P0&{ce>MUHz&iaQ?2hp9l#F(R#mB=o*W-58uZ((!Uo~oEYs`hg%25 zo?Vq$isx%=81+Tk+1c4w&JGS6k!l&8%gf3dn!GxTN(>E!l3K9Wmye%L{~9l!&}xW^ ziaLx<2Vzw(uvxIh3_|(nlfcwhJ$grd{sKXF6l_w6gR=Nw$ZkqKP>yX*t_~A*yrut+hpF(d+IG?O9kk(bIyc)lYl9D|5$XUhq?brwTcH zmd@eC36zreA2<*Qx7LHw<06WAr7YXY2cPLj$HuT^@2_@_7LrdkOgVFdBLQEx4`Sf( z!}Dkx^$rb@di_c{mqmzq(e2oc8{2sjvqkdUb3|bAt=_GJYfE+Z?PDGu9-e-fefzd5 z@+!#tBj?FsIOvD0&od%C-mke{OPpb#&MrKCY*Z1@mF(P;2PsTjc@=rdVDOy6`J zqI1-OLazTaw;(~mKzw|*buvqB4Zw4TxhB=5gefSvOhG{bF$rNazX5#K5B1mCuC+M3 z5;(pfv6`K|nG?zov2k%nU6NHxI=tC}Orve+Yf4HAE^_~^gPYp! zjjU8W#YP(I&~;aj;#-WU3(*`Jkb5IOPfn^>Sga1vV6E28&Yp<=vqm&M4Xgas5VBKg z#l<|x0?w9~E0975zBxHCikmevGc#7MhXBHfN0q^Hd?&I*y@sjD$ts|%o#)0)rzhUO z@2ZVm^ReU$jI{`!IK&SyJa9QxVeBGKy)}yu8yja96tJJHnBl=%6~NOwR(c18?Qty8 zKw1?0%vPH32P!l$rc$c{6c}B*N{x&&p#EmcNlZ_ewfdaJ$H76H?lXCHk|K~j7CRisas}m=p*6h7FNmIg!S5%3X7#o{;cx%Hcnqc~g$P2gAb3*8NrM#Dwdz+TZVux5q&f*}oJ? iqAvXVjPrl|^GAR2L{DeVjk8e{el&OMsO73!1pXIpxNqSA literal 0 HcmV?d00001 diff --git a/docs/source/_static/lsst_dc2/LSST_errors.png b/docs/source/_static/lsst_dc2/LSST_errors.png new file mode 100644 index 0000000000000000000000000000000000000000..591e2a25a395ec03f9a084dcc7e9e8cd50a397a7 GIT binary patch literal 61881 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
    xz-LT94Ot_j9rtMWn(mOcCkZN zKr43b+!+wPlZ)^PO_s?7hJx|x?4`{g5 ze?;dZq3(HZB+=O)l#`CD#+PNaJtEqjq)H_Sy*s(|7OqM_O;tad$3oo0PAVu2H*=yZ zvU^M*vpEv0l~}t{I)8|Wc3ic<{ZOM}zw5f4k1WAUznauTY81l{R$%pJwHM9)uTMLneW(Fx%)2#j@yn3yKS@XnytJ@#G9 z!h<+{&I}thH8tp`T=-`iSe{S9&x6p9b|~DS*@OMG-0@LL!PsarB1aBDt+?%Bb`jeq z%gmps;#FhW6M>iVe_FnP`?bwcRNYN#2MeacbDb&Lw+H$RzDbEJp)?-yBdL4o!Tywj zKN$C^3=eqT#>B&=V2mjN*M+Mj1M##ot@KhlK!xr=a}Ej|5IQI2uk&_uo?~7Eo3CIh zSV+~+A9vPJ_R!Uh%A=v7iWb7*Ednxlnj+Y~JsZg)mh(tOFJZw8M~!yJ-I4tiPc0IA zc=Fk-&3kJ&y_5yd{MMCNNzWn-E=`A^TiGnylS~l>q9n${RXO81U@jFKOYcy|ohzuK zV1fxV$pp(n_ZBr8QSDi;^F3%DX0*!M^LC7B)&KSBN<^&cC;$T>KfQeUa)hjz!l=#> zd2=#x<2r}Xk5soCH(uBzb3{|AbU6ITEL literal 0 HcmV?d00001 diff --git a/docs/source/_static/lsst_dc2/depth_maps_yr1.png b/docs/source/_static/lsst_dc2/depth_maps_yr1.png new file mode 100644 index 0000000000000000000000000000000000000000..c71b8feccb2dd0d0259e3053f36eb867d5a22c69 GIT binary patch literal 127410 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

    ZVQ6*fL38*7x@S_T{;$473_x` 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

    O~YqU-<1e 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 JC21P;zW|rEb4~yN literal 0 HcmV?d00001 diff --git a/docs/source/_static/lsst_dc2/depth_maps_yr4.png b/docs/source/_static/lsst_dc2/depth_maps_yr4.png new file mode 100644 index 0000000000000000000000000000000000000000..7b9da23037b9899734d31904b04bde953dbebaa6 GIT binary patch literal 121020 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 Date: Thu, 18 Jun 2026 16:25:19 +0200 Subject: [PATCH 21/29] complete documentation about lsst --- docs/source/surveys/LSST.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/surveys/LSST.md b/docs/source/surveys/LSST.md index 210430c..bf6a27e 100644 --- a/docs/source/surveys/LSST.md +++ b/docs/source/surveys/LSST.md @@ -74,7 +74,7 @@ Magnitude limits are obtained from [RubinSim](https://rubin-sim.lsst.io/) and pr ### Extinction coefficients -Dust extinction is modeled using the Schlegel, Finkbeiner & Davis (1998) reddening maps. +Dust extinction is modeled using the Schlegel et. all (1998) reddening maps. The adopted extinction coefficients are From a21a695949ed3c689ad6a71e6b2ad1e4f8a16319 Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Thu, 18 Jun 2026 16:26:11 +0200 Subject: [PATCH 22/29] complete documentation about lsst --- docs/source/surveys/LSST.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/surveys/LSST.md b/docs/source/surveys/LSST.md index bf6a27e..9f40007 100644 --- a/docs/source/surveys/LSST.md +++ b/docs/source/surveys/LSST.md @@ -7,6 +7,7 @@ Current estimation of LSST performances are done using DC2 simulations (expected performances for LSST year 5), and extrapolated for year 1 to 5. ## LSST DC2 Survey Files +More information about the LSST simulations can be found in Pélissier et. all (2026). This page is the **data sheet** for the `lsst / dc2` release: the survey-specific numbers, products, and figures. For **how** these products are derived (matched truth catalogs, completeness estimation, photometric-error calibration, depth-map construction, and analysis selections), see the survey-agnostic :doc:`selection_function_methodology`. From dd1b3ce7cbb918516a1760883ee21ff1a5b31692 Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Thu, 18 Jun 2026 16:29:03 +0200 Subject: [PATCH 23/29] fix paths --- docs/source/surveys/LSST.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/source/surveys/LSST.md b/docs/source/surveys/LSST.md index 9f40007..74c2f01 100644 --- a/docs/source/surveys/LSST.md +++ b/docs/source/surveys/LSST.md @@ -39,7 +39,7 @@ $$ for which morphological star-galaxy separation becomes challenging near the survey magnitude limit. -![Detection, classification and galaxy misclassification efficiencies](_static/lsst_dc2/LSST_efficiencies.png) +![Detection, classification and galaxy misclassification efficiencies](../_static/lsst_dc2/LSST_efficiencies.png) *Detection efficiency, stellar classification efficiency, combined stellar efficiency, and galaxy contamination efficiency as a function of distance to the local magnitude limit.* @@ -55,7 +55,7 @@ $$ The photometric scatter increases rapidly near the magnitude limit and approaches a systematic floor of approximately 0.005 mag for bright sources. -![LSST photometric error model](_static/lsst_dc2/LSST_errors.png) +![LSST photometric error model](../_static/lsst_dc2/LSST_errors.png) *Photometric uncertainty as a function of distance to the local magnitude limit. An analytic approximation not used in StreamObs is overlaid on the DC2-derived @@ -68,8 +68,8 @@ Depth maps describe the spatial variation of the LSST 5σ limiting magnitude acr Magnitude limits are obtained from [RubinSim](https://rubin-sim.lsst.io/) and propagated to `StreamObs` as `HEALPix` maps. Survey systematics are modeled through spatial variations in these limiting magnitudes, which drive both photometric uncertainties and selection functions. -![LSST depth maps after 1 year of observation](_static/lsst_dc2/depth_maps_yr1.png) -![LSST depth maps after 4 years of observation](_static/lsst_dc2/depth_maps_yr4.png) +![LSST depth maps after 1 year of observation](../_static/lsst_dc2/depth_maps_yr1.png) +![LSST depth maps after 4 years of observation](../_static/lsst_dc2/depth_maps_yr4.png) *LSST 5σ limiting magnitude maps in the g and r bands for Year 1 and Year 4 survey configurations.* @@ -95,7 +95,7 @@ and are applied consistently when generating observed magnitudes. ### Using the survey in streamobs -Configured by `config/surveys/lsst_dc2.yaml`, data in `data/surveys/lsst_dc2/`: +Configured by `config/surveys/lsst_{releases}.yaml`, data in `data/surveys/lsst_{releases}/`: ```python from streamobs.surveys import SurveyFactory From 641c1fd6c9661afc211b1840b6f10e45cdec2924 Mon Sep 17 00:00:00 2001 From: MatthieuPe Date: Thu, 18 Jun 2026 16:31:47 +0200 Subject: [PATCH 24/29] fix typos --- docs/source/surveys/LSST.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/docs/source/surveys/LSST.md b/docs/source/surveys/LSST.md index 74c2f01..8994557 100644 --- a/docs/source/surveys/LSST.md +++ b/docs/source/surveys/LSST.md @@ -9,8 +9,6 @@ performances for LSST year 5), and extrapolated for year 1 to 5. ## LSST DC2 Survey Files More information about the LSST simulations can be found in Pélissier et. all (2026). -This page is the **data sheet** for the `lsst / dc2` release: the survey-specific numbers, products, and figures. For **how** these products are derived (matched truth catalogs, completeness estimation, photometric-error calibration, depth-map construction, and analysis selections), see the survey-agnostic :doc:`selection_function_methodology`. - ### The simulated survey All quantities are measured from the LSST Dark Energy Science Collaboration Data Challenge 2 (DC2) simulations, a realistic realization of the expected Rubin LSST survey performance based on five years of observations. DC2 contains both truth and measured catalogs, enabling direct characterization of survey selection effects and photometric performance. @@ -33,7 +31,7 @@ Compact galaxies can be incorrectly classified as stars, producing an important The galaxy contamination model is derived from true galaxies with $$ -{\rm size_true} < 0.3\ {\rm arcsec}, +{\rm size\_true} < 0.3\ {\rm arcsec}, $$ for which morphological star-galaxy separation becomes challenging near the survey magnitude limit. From 7a56a3c562461e0e4986d9a7be6c7763ab64ca1e Mon Sep 17 00:00:00 2001 From: psferguson Date: Thu, 18 Jun 2026 11:15:41 -0700 Subject: [PATCH 25/29] Docs: true-mag columns key on survey name (release-independent), not full namespace --- docs/source/column_convention.md | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/docs/source/column_convention.md b/docs/source/column_convention.md index 068b9c9..98865fc 100644 --- a/docs/source/column_convention.md +++ b/docs/source/column_convention.md @@ -9,17 +9,23 @@ survey. Every column is prefixed with the survey's **namespace**, which is `{name}_{release}` (e.g. `lsst_yr5`, `roman_dc2`), or just `{name}` when the survey was loaded without a release. The namespace is always derived from the -`Survey` itself ({attr}`streamobs.surveys.Survey.namespace`) and includes the -release on **every** column kind, so the same survey at two releases produces -distinct, non-colliding columns. When you construct a multi-survey injector from +`Survey` itself ({attr}`streamobs.surveys.Survey.namespace`). **Observed**, +**error**, and **flag** columns carry the full namespace (release included), so +the same survey at two releases produces distinct, non-colliding observations. +**True-magnitude columns are the exception**: because a star's intrinsic +(noiseless) magnitude does not depend on which survey/release observed it, they +are keyed on the survey **name only** — the release is dropped (e.g. +`roman_F158_true`, shared across `roman_dc2` and `roman_hlwas_*`). When you +construct a multi-survey injector from a `{key: spec}` dict the keys are containers only — they do **not** become the namespace (it is re-derived from each loaded `Survey`). -For a survey with namespace `` and a photometric band ``: +For a survey with namespace `` (= `{name}_{release}`), survey name +``, and a photometric band ``: | Column | Meaning | |---|---| -| `__true` | True (noiseless) apparent magnitude | +| `__true` | True (noiseless) apparent magnitude — keyed on the survey **name only** (release-independent) | | `__obs` | Observed (noisy) magnitude; `"BAD_MAG"` where the noisy flux went negative | | `__err` | Reported photometric error (the *catalog* error; see below) | | `_flag_observed` | Detection flag — `True` if detected **and** classified as a star | @@ -28,7 +34,7 @@ For a survey with namespace `` and a photometric band ``: Plus the shared, un-namespaced sky coordinates `ra`, `dec`. Examples (LSST loaded with `release="yr5"`, Roman with `release="dc2"`): -`lsst_yr5_r_obs`, `lsst_yr5_g_err`, `roman_dc2_F158_true`, `lsst_yr5_flag_observed`. +`lsst_yr5_r_obs`, `lsst_yr5_g_err`, `roman_F158_true` (true mag — name only), `lsst_yr5_flag_observed`. These names are produced by the helpers in `streamobs.columns` (`true_col`, `obs_col`, `err_col`, `flag_col`, `perfect_flag_col`), which take a From 11581541086b41c1095e93ce3a647172ba4f4802 Mon Sep 17 00:00:00 2001 From: psferguson Date: Thu, 18 Jun 2026 11:22:06 -0700 Subject: [PATCH 26/29] small docs updates --- docs/source/conf.py | 2 +- docs/source/index.rst | 2 +- docs/source/surveys/{roman.md => Roman.md} | 0 3 files changed, 2 insertions(+), 2 deletions(-) rename docs/source/surveys/{roman.md => Roman.md} (100%) diff --git a/docs/source/conf.py b/docs/source/conf.py index dfa7e7b..5403409 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -25,7 +25,7 @@ "sphinx.ext.napoleon", "sphinx.ext.viewcode", "numpydoc", - "myst_parser", + "myst_nb", ] templates_path = ["_templates"] diff --git a/docs/source/index.rst b/docs/source/index.rst index e95d6f5..f865213 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -86,7 +86,7 @@ Documentation Contents multisurvey citation - .. toctree:: +.. toctree:: :maxdepth: 1 :caption: Examples diff --git a/docs/source/surveys/roman.md b/docs/source/surveys/Roman.md similarity index 100% rename from docs/source/surveys/roman.md rename to docs/source/surveys/Roman.md From fcc0905d88cf1b230642d134cb36b94ca0b9d347 Mon Sep 17 00:00:00 2001 From: psferguson Date: Thu, 18 Jun 2026 11:33:52 -0700 Subject: [PATCH 27/29] Consolidate IsochroneModel.sample/sample_multisurvey into one sample() and fix test_surveys collection error (pytest >=9) --- docs/source/multisurvey.md | 2 +- docs/source/roman_multisurvey_plan.md | 17 ++++-------- streamobs/model.py | 40 ++------------------------- tests/test_model.py | 14 +++++----- tests/test_surveys.py | 1 - 5 files changed, 17 insertions(+), 57 deletions(-) diff --git a/docs/source/multisurvey.md b/docs/source/multisurvey.md index faaae22..e083c0c 100644 --- a/docs/source/multisurvey.md +++ b/docs/source/multisurvey.md @@ -193,7 +193,7 @@ all surveys — the same physical star). You can also go the other way and suppl your own masses: pass a fully-populated `mass` column in the input catalog and the isochrone uses *those* masses instead of drawing fresh ones, so the sampled magnitudes reproduce your simulation's exact stars. At the model level -{meth}`streamobs.model.IsochroneModel.sample_multisurvey` accepts a `masses=` +{meth}`streamobs.model.IsochroneModel.sample` accepts a `masses=` array and returns the masses it used. The mass grid resolution is controlled by `IsochroneModel._MASS_STEPS` (default 4000) and a per-call `mass_steps=` override. diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md index 2d6f4dd..471ea5f 100644 --- a/docs/source/roman_multisurvey_plan.md +++ b/docs/source/roman_multisurvey_plan.md @@ -303,26 +303,21 @@ namespaced); `tests/test_observed.py` + `tests/test_model.py` green. plus shared `name`/`age`/`z`/... at top level), building one `ugali` isochrone per survey (`self.isos`, `self.survey_bands`). - ✅ New `sample_masses(...)` draws the initial masses *once* from the primary - isochrone's IMF (exactly `nstars`), and `sample_multisurvey(...)` interpolates + isochrone's IMF (exactly `nstars`), and `sample(...)` interpolates those shared masses into every survey's bands → `{(survey, band): - apparent_mag}` (same physical star, consistent across surveys). The legacy - `sample(nstars, dm)` still returns the `(mag_band_1, mag_band_2)` tuple (the - primary survey's two bands) so existing callers are unchanged. + apparent_mag}` (same physical star, consistent across surveys). - ✅ `_to_ab(band, mag)` converts Roman bands Vega→AB **unconditionally** using the `ROMAN_VEGA_TO_AB` table (no config flag; non-Roman bands pass through). - Applied in the shared `sample_multisurvey` path. See the Vega→AB section above. + Applied in the shared `sample` path. See the Vega→AB section above. - ✅ `StreamModel.sample`/`complete_catalog` derive their magnitude columns from the isochrone via `_iso_mag_columns()` / `_sample_iso_mags()`, which **always** emit `__true` (a single-survey isochrone simply has one survey; `IsochroneModel` tracks `surveys`/`survey_bands` in both config forms). Naming routes through `columns.true_col`. -**Note on the chosen API:** the plan originally named the dict-returning method -`sample` and a tuple `sample_legacy`; to avoid `sample()` changing return *type* -by config (a foot-gun for existing callers), the implementation keeps -`IsochroneModel.sample()` as the `(mag_1, mag_2)` tuple and adds -`sample_multisurvey()` for the dict. `StreamModel` always goes through -`sample_multisurvey()` (a single-survey isochrone is just the one-survey case), +**Note on the API:** `IsochroneModel.sample()` returns +`{(survey, band): apparent_mag}` and the masses used. `StreamModel` always goes +through `sample()` (a single-survey isochrone is just the one-survey case), so the emitted columns are uniformly `__true`. **Validated:** model tests green; a two-isochrone multi-survey config produces diff --git a/streamobs/model.py b/streamobs/model.py index 0ae3884..bf15712 100644 --- a/streamobs/model.py +++ b/streamobs/model.py @@ -203,7 +203,7 @@ def _sample_iso_mags(self, n, dist, masses=None): is given it is used directly instead of an IMF draw, so the sampled magnitudes reproduce those exact stars. """ - mags, masses = self.isochrone.sample_multisurvey(n, dist, masses=masses) + mags, masses = self.isochrone.sample(n, dist, masses=masses) cols = {true_col(band, name): vals for (name, band), vals in mags.items()} cols["mass"] = masses return cols @@ -671,7 +671,7 @@ class IsochroneModel(ConfigurableModel): is built per survey from the *same* stellar population, so a single shared draw of initial masses (:meth:`sample_masses`) is interpolated into every survey's bands — giving the same physical star consistent magnitudes - across surveys. :meth:`sample_multisurvey` returns + across surveys. :meth:`sample` returns ``{(survey, band): apparent_mag}``. Roman bands are always converted from Vega to AB (see @@ -830,7 +830,7 @@ def _add_distance_modulus(abs_mag, distance_modulus): return abs_mag return abs_mag + np.asarray(distance_modulus, dtype=float) - def sample_multisurvey( + def sample( self, nstars, distance_modulus, rng=None, masses=None, **kwargs ): """Sample apparent magnitudes for every ``(survey, band)``. @@ -882,40 +882,6 @@ def sample_multisurvey( out[(name, band_2)] = self._add_distance_modulus(abs_2, distance_modulus) return out, masses - def sample(self, nstars, distance_modulus, rng=None, masses=None, **kwargs): - """Simulate magnitudes in the two bands of the (primary) isochrone. - - Draws *exactly* ``nstars`` stars: a fixed set of initial masses is drawn - once from the isochrone IMF (:meth:`sample_masses`) and interpolated into - the two bands. This differs from the historical behaviour, where - ``nstars`` was converted to a total stellar mass and ``ugali``'s - ``simulate`` returned a random-length IMF realization (count generally - ``!= nstars``). The fixed-count semantics are required so the *same - physical star* can be shared across surveys (see - :meth:`sample_multisurvey`). - - Parameters - ---------- - nstars : int - Number of stars to simulate (returns exactly this many). - distance_modulus : float or array-like - Distance modulus per star (broadcast if scalar). - - Returns - ------- - tuple of numpy.ndarray - ``(mag_band_1, mag_band_2)`` arrays. For a multi-survey isochrone - this returns the primary survey's two bands; use - :meth:`sample_multisurvey` to get every survey's bands. - """ - mags, _ = self.sample_multisurvey( - nstars, distance_modulus, rng=rng, masses=masses, **kwargs - ) - return ( - mags[(self.survey_name, self.band_1)], - mags[(self.survey_name, self.band_2)], - ) - def _dist_to_modulus(self, distance): """ Convert physical distances in pc into distance modulus diff --git a/tests/test_model.py b/tests/test_model.py index 3a95214..3bae578 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -332,25 +332,25 @@ class TestIsochroneMasses: G = "lsst_g_true" R = "lsst_r_true" - def test_sample_multisurvey_returns_and_reuses_masses( + def test_sample_returns_and_reuses_masses( self, stream_config_with_distance ): """Replaying the returned masses reproduces identical magnitudes.""" iso = StreamModel(stream_config_with_distance).isochrone - mags1, masses = iso.sample_multisurvey(50, 16.8, rng=np.random.default_rng(0)) + mags1, masses = iso.sample(50, 16.8, rng=np.random.default_rng(0)) assert masses.shape == (50,) # Supplying those masses (no rng) is deterministic and reproduces mags1. - mags2, masses2 = iso.sample_multisurvey(50, 16.8, masses=masses) + mags2, masses2 = iso.sample(50, 16.8, masses=masses) assert np.allclose(masses, masses2) for key in mags1: assert np.allclose(mags1[key], mags2[key]), f"{key} not reproduced" - def test_sample_multisurvey_masses_length_validated( + def test_sample_masses_length_validated( self, stream_config_with_distance ): iso = StreamModel(stream_config_with_distance).isochrone with pytest.raises(ValueError): - iso.sample_multisurvey(50, 16.8, masses=np.ones(49)) + iso.sample(50, 16.8, masses=np.ones(49)) def test_complete_catalog_exposes_mass_column(self, stream_config_with_distance): """A completed catalog carries the shared `mass` column.""" @@ -364,11 +364,11 @@ def test_input_mass_column_drives_magnitudes(self, stream_config_with_distance): """Providing a `mass` column makes the sampled mags match those masses.""" model = StreamModel(stream_config_with_distance) iso = model.isochrone - _, masses = iso.sample_multisurvey(15, 16.8, rng=np.random.default_rng(3)) + _, masses = iso.sample(15, 16.8, rng=np.random.default_rng(3)) df = pd.DataFrame({"dist": [16.8] * 15, "mass": masses}) out = model.complete_catalog( catalog=df, columns_to_add=[self.G, self.R], verbose=False ) - direct, _ = iso.sample_multisurvey(15, 16.8, masses=masses) + direct, _ = iso.sample(15, 16.8, masses=masses) assert np.allclose(out[self.G].to_numpy(), direct[("lsst_yr4", "g")]) assert np.allclose(out[self.R].to_numpy(), direct[("lsst_yr4", "r")]) diff --git a/tests/test_surveys.py b/tests/test_surveys.py index 682fcbf..9d52126 100644 --- a/tests/test_surveys.py +++ b/tests/test_surveys.py @@ -80,7 +80,6 @@ def _survey_id(entry): # --------------------------------------------------------------------------- -@pytest.mark.surveys @pytest.fixture( scope="module", params=SURVEY_REGISTRY, ids=[_survey_id(e) for e in SURVEY_REGISTRY] ) From 6a2724622c2b871b4a5a575ec65175df54067edd Mon Sep 17 00:00:00 2001 From: psferguson Date: Thu, 18 Jun 2026 11:38:25 -0700 Subject: [PATCH 28/29] remove plan.md file from the branch --- .gitignore | 2 + docs/source/index.rst | 6 - docs/source/roman_multisurvey_plan.md | 394 -------------------------- 3 files changed, 2 insertions(+), 400 deletions(-) delete mode 100644 docs/source/roman_multisurvey_plan.md diff --git a/.gitignore b/.gitignore index 9e4f7a0..97d6cdd 100644 --- a/.gitignore +++ b/.gitignore @@ -137,3 +137,5 @@ data/others/* /survey_systematics_in_LSST_streams/ /rubin_roman_object_classification/ /lsst_dc2_scratch/ +/artifacts/ +docs/source/roman_multisurvey_plan.md diff --git a/docs/source/index.rst b/docs/source/index.rst index f865213..08f77a9 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -118,12 +118,6 @@ Documentation Contents data modules -.. toctree:: - :maxdepth: 2 - :caption: Design Notes - - roman_multisurvey_plan - Indices and Tables ================== diff --git a/docs/source/roman_multisurvey_plan.md b/docs/source/roman_multisurvey_plan.md deleted file mode 100644 index 471ea5f..0000000 --- a/docs/source/roman_multisurvey_plan.md +++ /dev/null @@ -1,394 +0,0 @@ -# Multi-survey (Roman + Rubin) injection — design & roadmap - -```{warning} -This is a **living design document** for in-progress work, not a description of -shipped behaviour. It records the agreed design, the phased rollout, and — most -importantly — the **behaviour changes that need discussion** before we rely on -them. Sections marked *(future)* are designed but not yet implemented. -``` - -```{important} -**Remove this file before merging the `roman_multisurvey` branch.** It is a -working design/roadmap doc, not user documentation. Before merge, migrate the -durable content — the column convention, the sample/catalog error split, the -multi-survey `StreamInjector` usage, and the Vega→AB handling — into the proper -docs pages (and the API docstrings), then delete `roman_multisurvey_plan.md`. - -**Also remove before merge — useful for now, but not part of the merged package:** - -- `notebooks/multisurvey_phases_demo.ipynb` — the Phases 1–4 walkthrough. It is - kept tracked (with outputs stripped) during the branch's life, but should be - removed before merge and migrated into the rendered docs as an Examples page - (see the separate notebooks→docs migration). Its generator, - `scripts/build_multisurvey_demo_nb.py`, is a local-only helper and is **not** - tracked. -``` - -## Motivation - -`streamobs` was built for **single-survey** stream injection (LSST). We want to -inject mock streams that carry **both Roman and Rubin/LSST photometric columns** -in one catalog, where each band draws its photometric errors and detection -probability from its **own** survey magnitude-limit (maglim) HEALPix maps. - -A working prototype of this idea exists outside the package (the -`rubin_roman_object_classification` proposal code: survey-indexed dictionaries, -`{survey}_{band}` columns, and a "sample masses once, interpolate per survey" -photometry step). The goal here is to bring that capability **into** `streamobs` -properly, reusing the package's existing {class}`~streamobs.surveys.Survey` / -maglim-map machinery (which the prototype lacked), rather than maintaining a -parallel codebase. - -Two science realities drive specific features: - -- The Roman DC2 characterization (see *Roman DC2 Survey Files*) found the **true - photometric scatter is ~2× the reported catalog error**. So the error model - needs a *sample* model (true scatter, used to draw observed magnitudes) - distinct from a *catalog* model (the reported `magerr`). -- We need a **realistic background** (field stars + galaxies, with star/galaxy - misclassification) **without** loading the heavy DC2 mock catalogs at runtime - — using lightweight binned colour–magnitude distributions vs. maglim, and - optionally TRILEGAL for the stellar component. *(Designed below; future work.)* - -## Locked design decisions - -1. **One `StreamInjector` for one *or* many surveys.** A single injector holds - `{survey_name: Survey}` (size 1 for the single-survey case) and delegates - per-survey work to the existing, unchanged `Survey` per-band API via a shared - `_inject_one_survey` helper. Not a composite `Survey`; not manual re-runs; - and **no separate multi-survey class** — `StreamInjector` accepts a survey - name/`Survey`, a `{name: spec}` dict, or a list of specs. -2. **Column convention (always survey-namespaced `{survey}_{band}_true/_obs/_err`).** - A single naming scheme is used everywhere — `{survey}_{band}_true` / - `{survey}_{band}_obs` / `{survey}_{band}_err` / `{survey}_flag_observed` - (e.g. `roman_f158_obs`, `lsst_r_err`) — and it is **always namespaced by - survey, even for a single survey** (a one-survey injection of LSST emits - `lsst_r_obs`, not `r_obs`). There is no longer an un-namespaced single-survey - form. **This intentionally drops the historical `mag_{band}` / - `mag_{band}_obs` / `magerr_{band}` names — it is *not* backward compatible** - with catalogs or downstream readers expecting those columns (decision made - deliberately to keep one convention; see decision 5). -3. **Sample-vs-catalog error split, backward-compatible by default.** `Survey` - holds two error curves, both functions of `delta_mag = mag − maglim`: - - `log_photo_error_catalog` — the survey's **reported** error curve (the - existing `photoerror_*.csv`). Written as `magerr` and drives the S/N cut. - Always present; loaded from the `log_photo_error_catalog` key or the legacy - `log_photo_error` key. - - `log_photo_error_sample` — an **optional second** curve giving the **true - scatter** of observed−true magnitudes; drives the noise draw. Config key - `log_photo_error_sample`. - - If no sample curve is supplied, the noise draw falls back to the catalog - curve ⇒ existing outputs unchanged. Separating them is opt-in: supply the - second CSV. (Earlier drafts proposed a scalar `report_error_factor` / - inflation curve to *derive* one from the other; superseded by two independent - curves, which is more general and matches the Roman DC2 products that measure - the true scatter directly.) -4. **Sample stellar masses once, interpolate per survey.** This is a correctness - requirement (see below) and the engine of the whole feature. -5. **Public API preserved; column schema deliberately changed.** The - `StreamInjector(survey).inject(df, bands=[...])` single-survey call still - works (the same `StreamInjector` also takes a dict/list for several surveys). - The **column names are not** preserved — we adopt the always-namespaced - `{survey}_{band}_true/_obs/_err` scheme (decision 2) *instead of* the - historical `mag_g_obs`/`mag_r_obs`/`magerr_g` names. Downstream consumers that - read those columns must be updated. This is an accepted break in exchange for - one convention across single- and multi-survey output. - -## Behaviour changes for discussion - -```{important} -These are deliberate changes from current behaviour. They are flagged here for -review **before** we depend on them — they are not silently adopted. -``` - -### S/N detection cut now applies to *all* injected bands *(Phase 2, adopted)* - -Previously the injector applied its SNR ≥ 5 cut to a single hard-coded band -(`detection_mag_cut=["g"]`). Now the default is **every band passed to -`inject()`** — a star must have SNR ≥ 5 in *all* injected bands to be flagged -observed. For the default LSST `bands=["r", "g"]` this is stricter than before -(it adds the r-band SNR requirement on top of g), so detection counts drop -relative to the old default. Rationale: it generalizes cleanly to any band set -and makes "observed" mean "detected in everything you asked for". Callers can -restore any prior behaviour by passing `detection_mag_cut=[...]` explicitly -(e.g. `["g"]` for the old LSST default). **Adopted, but flagged for review.** - -### S/N cut ownership: who applies the reference-band cut *(adopted — option (b))* - -The reference band (`survey.completeness_band`, e.g. LSST `r`) is special: the -survey's **selection functions are estimated with the SNR ≥ 5 cut already -applied** in that band. So the reference-band cut is conceptually *owned by the -selection functions*, not by the injector's per-band loop. - -**The problem (pre-(b)).** The old code applied the per-band SNR loop to *every* -injected band, including the reference band — so the reference band's cut was -applied **twice** (once inside `get_completeness`, once in the loop). That is -idempotent today (`A & A == A`), so `flag_observed` was numerically correct, but -it is conceptually double-counted and fragile: it silently breaks if `SNR_min` -ever differs from the threshold the curve was estimated at. Worse, the two -selection curves disagreed about ownership — `get_completeness` bakes the cut -in, but `get_detection_efficiency` (used for the perfect-galstarsep flag) does -**not** — which forced a special-cased "force SNR cut on the completeness band" -block just for `flag_perfect`. - -**Option (b) — implemented now (injector-only, no data regeneration).** Treat the -reference-band cut as owned by the selection functions and apply it **exactly -once**, to both flags: - -- The reference band's SNR cut is applied once in `_inject_one_survey`, to - `flag_observed` (idempotent with the baked-in completeness cut) and to - `flag_perfect` (which supplies it, since the efficiency curve lacks it). -- `detection_mag_cut` defaults to *every injected band except the reference - band*; the reference band is skipped inside the loop. -- The old special-cased "force" block is removed. - -This is **behaviour-preserving** (the same set of bands gets an SNR cut, the -reference band counted once instead of twice) but removes the double-count and -the asymmetry between the two flags. `survey.completeness_band` is the single -attribute identifying the reference band for both completeness and detection -efficiency (default `"r"`). - -**Option (a) — the eventual "correct home" (deferred; requires new data).** Fold -the SNR cut into the **detection-efficiency curve itself**, so that -`get_completeness` *and* `get_detection_efficiency` both own it consistently. -Then the injector needs no reference-band special-casing at all — it simply -**skips** `survey.completeness_band` in the SNR loop (the curves handle it), and -the once-applied reference-band block from (b) can be deleted. - -*Why (a) is better:* the "a star's reference-band detectability already includes -SNR ≥ 5" fact lives in **one place** — the survey product — rather than being -re-asserted in the injector. Any consumer of `get_detection_efficiency` (not -just this injector) then gets a self-consistent curve, and there is no implicit -contract that "the caller must remember to also apply the SNR cut". - -*How to get from (b) to (a):* - -1. **Regenerate the detection-efficiency product with the SNR cut applied.** In - the build script that emits the efficiency tables - (`scripts/roman/create_streamobs_files_hlwas.py` for Roman DC2; the analogous - LSST/DES builders for the others), the *denominator* of the detection - efficiency is all true stars and the *numerator* is true stars detected — add - the requirement that the numerator detection also passes SNR ≥ 5 in the - reference band (the completeness/`classification_detection_eff` curve is - already built this way; mirror that selection for the detection-only curve). - Concretely: the column the loader reads for `type="detection_efficiency"` - (`detection_eff`, via `selection="detected"` in `set_completeness`) must be - recomputed with the SNR cut, so it matches how `classifiction_eff` / - `classification_detection_eff` are produced. -2. **Re-emit the per-survey efficiency CSVs** (e.g. Roman - `roman_stellar_efficiency_cutf158.csv` in `data/surveys/roman_hlwas/`, and the - LSST/DES equivalents in `data/others/`) and re-run the notebook/build so the - committed products carry the cut. Keep the `classifiction_eff` header spelling - the loader greps for. -3. **Flip the injector to (a):** drop the once-applied reference-band block and - change the `detection_mag_cut` default to skip the reference band *without* - re-adding its cut (the curve now carries it). `flag_observed` and - `flag_perfect` then both inherit the reference-band cut purely from the - selection functions. -4. **Validate** that detection counts are unchanged within noise versus (b) on a - fixed seed (they should be, since (b) already applies the same cut once) — this - confirms the regenerated curve encodes exactly the SNR ≥ 5 selection rather - than a different threshold. - -Until those products are regenerated, (b) is the correct, behaviour-preserving -state. - -### `nstars` becomes "exactly N stars" (was an emergent IMF count) *(adopted — agreed)* - -```{important} -**Adopted (Phase 4) and agreed.** {meth}`~streamobs.model.IsochroneModel.sample` -now draws *exactly* `nstars` (the shared-mass path described below), for **both** -single-survey and multi-survey isochrones. The single-survey -`ugali.simulate()` emergent-count path has been removed. This was reviewed and -**accepted as the intended semantics** (you control N, and it is shared across -surveys); it is no longer open for discussion. -``` - -Previously {meth}`~streamobs.model.IsochroneModel.sample` converted `nstars` -into a total stellar mass and let `ugali`'s `iso.simulate()` return a -*random-length* IMF realization — so the number of stars returned was stochastic -and generally **≠ `nstars`**. - -The multi-survey requirement (the *same physical star* must get consistent Roman -**and** Rubin magnitudes) forces us instead to draw a fixed set of initial -masses once and interpolate each survey's magnitudes from them: - -```python -init_mass, mass_pdf, *_ = base_iso.sample(mass_min=mass_min, mass_steps=mass_steps) -sampled_masses = rng.choice(init_mass[sel], size=nstars, p=imf_pdf) # exactly nstars -# then, per survey: mag_band = np.interp(sampled_masses, init_mass, mag_band) + dist_mod -``` - -This returns *exactly* `nstars` stars. It is the right semantics for injection -(you control N, and it is shared across surveys). It changes what -`StreamModel.sample(size)` returns relative to the old emergent count, but this -was reviewed and **agreed** — no further discussion needed. - -### Roman Vega→AB conversion is automatic and unconditional - -`ugali` delivers Roman isochrone magnitudes in **Vega**, while our catalogs are -**AB**. `IsochroneModel` corrects this **unconditionally** for every Roman band -using the module-level table `streamobs.model.ROMAN_VEGA_TO_AB` (AB = Vega + -offset). The per-band offsets are the mode of the by-chip Roman zeropoints -(`Roman_zeropoints_20240301.ecsv`), the same values the -`rubin_roman_object_classification` prototype used: - -| band | F062 | F087 | F106 | F129 | F146 | F158 | F184 | F213 | -|---|---|---|---|---|---|---|---|---| -| AB − Vega | 0.153 | 0.481 | 0.660 | 1.051 | 1.164 | 1.315 | 1.556 | 1.837 | - -There is **no config flag** — Roman bands are always converted, non-Roman bands -pass through unchanged. The code carries a `TODO` flagging that this conversion -ideally belongs in `ugali` itself (so isochrones are returned natively in AB); -when that lands the table can be removed. - -## Phased rollout - -Phases 1–4 are the current branch; Phases 5–6 are designed here but deferred. - -### Phase 1 — Sample vs. catalog error models on `Survey` ✅ *(implemented)* - -Two independent error curves, both vs `delta_mag = mag − maglim`: - -- ✅ `Survey`: replaced the single `log_photo_error` field with - `log_photo_error_catalog` (reported error, the base curve) and - `log_photo_error_sample` (optional true-scatter curve). Kept a read/write - `log_photo_error` property aliasing the **catalog** model (the legacy field's - meaning — back-compat for existing tests and any code that sets it). -- ✅ `Survey.get_photo_error(band, mag, maglim, kind="catalog")`: `kind` selects - the curve via `_resolve_log_photo_error`. `kind="catalog"` returns the reported - error; `kind="sample"` returns the true-scatter curve, falling back to the - catalog curve when no sample curve is loaded. Default `kind="catalog"` - reproduces today's numbers exactly. -- ✅ `SurveyFactory._load_survey_data`: loads the catalog curve from - `log_photo_error_catalog` (or the legacy `log_photo_error`) key, and an - optional sample curve from the `log_photo_error_sample` key. No factor / - inflation logic — both curves are read directly via `set_photo_error`. -- ✅ `StreamInjector.inject`: draws noise with the **sample** error - (`kind="sample"`); writes the **catalog** error as `magerr` and runs the S/N - cut on it (`kind="catalog"`). - -**Backward compatibility verified (94 passing tests from the test branch):** with -only the legacy `log_photo_error` curve and no `log_photo_error_sample`, the -sample draw falls back to the catalog curve, so the noise draw, `magerr`, and the -S/N cut are bit-for-bit identical to the previous single-curve behaviour. To opt -in, add `log_photo_error_sample: ` (the measured true-scatter curve) to a -survey's `survey_files`. - -### Phase 2 — De-hardcode the injector to arbitrary bands ✅ *(implemented)* - -- ✅ New `streamobs/columns.py` with `true_col` / `obs_col` / `err_col` helpers - `(band, survey=None)` and `flag_col(survey=None)`. Injected catalogs are - **always** survey-namespaced (`__…` / `_flag_observed`); - `survey=None` is retained only as a low-level fallback that the injector itself - never uses. -- ✅ `observed.py`: removed the `bands in {"r","g"}` hard block; the true-mag - read, the observed/err columns, the valid-flux check (now ANDs over every - injected band), the S/N cut, the per-survey detection flag, and the stored - flag all route through the `columns.py` helpers and the survey's - `completeness_band`. Existing per-band nside handling already supports Roman - nside=1024 vs. LSST nside=128. -- ⚠️ The S/N-cut default changed from the hard-coded `["g"]` to **all injected - bands** — see *Behaviour changes for discussion* above. - -**Validated:** single-band (`bands=["r"]`) and arbitrary band sets inject without -the old hard block; the `inject(df, bands=[...])` API is unchanged (output now -namespaced); `tests/test_observed.py` + `tests/test_model.py` green. - -### Phase 3 — Multi-band / multi-survey `IsochroneModel` ✅ *(implemented)* - -- ✅ `IsochroneModel.create_isochrone` accepts either today's single-survey - config or a multi-survey form (`surveys: {name: {survey, band_1, band_2}}` - plus shared `name`/`age`/`z`/... at top level), building one `ugali` isochrone - per survey (`self.isos`, `self.survey_bands`). -- ✅ New `sample_masses(...)` draws the initial masses *once* from the primary - isochrone's IMF (exactly `nstars`), and `sample(...)` interpolates - those shared masses into every survey's bands → `{(survey, band): - apparent_mag}` (same physical star, consistent across surveys). -- ✅ `_to_ab(band, mag)` converts Roman bands Vega→AB **unconditionally** using - the `ROMAN_VEGA_TO_AB` table (no config flag; non-Roman bands pass through). - Applied in the shared `sample` path. See the Vega→AB section above. -- ✅ `StreamModel.sample`/`complete_catalog` derive their magnitude columns from - the isochrone via `_iso_mag_columns()` / `_sample_iso_mags()`, which **always** - emit `__true` (a single-survey isochrone simply has one survey; - `IsochroneModel` tracks `surveys`/`survey_bands` in both config forms). Naming - routes through `columns.true_col`. - -**Note on the API:** `IsochroneModel.sample()` returns -`{(survey, band): apparent_mag}` and the masses used. `StreamModel` always goes -through `sample()` (a single-survey isochrone is just the one-survey case), -so the emitted columns are uniformly `__true`. - -**Validated:** model tests green; a two-isochrone multi-survey config produces -consistent shared-mass magnitudes, Roman bands are converted Vega→AB by the -fixed `ROMAN_VEGA_TO_AB` offsets, and `StreamModel.sample` emits the -`__true` columns. - -### Phase 4 — one `StreamInjector` for one *or* many surveys ✅ *(implemented)* - -- ✅ The per-band body of injection lives in a shared - `StreamInjector._inject_one_survey(data, bands, survey, survey_namespace, ...)` - helper. It assumes positions and true magnitudes are already present and only - does the observed/err draw, detection flags, and S/N cut, routing every column - name through `columns.py`. `survey`/`survey_namespace` are passed explicitly so - the same method serves every survey. -- ✅ `StreamInjector` accepts **one survey or several** (a name/`Survey`, a - `{namespace: spec}` dict, or a list); `__init__` normalizes to - `self.surveys = {namespace: Survey}` with a `survey` property pointing at the - `primary`. `inject(data, survey_bands=None, bands=None, stream_config=...)`: - (1) one shared sky placement; (2) one shared true-magnitude fill via the - isochrone (masses sampled once → every survey's `__true`); - (3) a per-survey loop calling `_inject_one_survey` with `survey_namespace=`, - writing `__obs/_err` and `_flag_observed` from that - survey's own `completeness_band` and maglim maps. Per-survey RNG via - `rng.spawn(...)` for order-independent reproducibility. `columns.perfect_flag_col` - namespaces the optional `perfect_galstarsep` flag. The separate - `MultiSurveyInjector` class has been **removed**. -- ✅ A *scene* config (`config/scenes/roman_rubin_demo.yaml`) lists the surveys, - per-survey bands, the multi-survey isochrone, and shared stream geometry. -- ✅ `notebooks/multisurvey_phases_demo.ipynb` walks through Phases 1–4 end to - end (executes against `StubSurvey` + real `ugali` isochrones). - -### Phase 5 *(future)* — Lightweight background + galaxy misclassification - -- New `streamobs/background.py`: a `CMDDistribution` (binned colour–magnitude - distribution vs. maglim, stored raw so one file serves any isochrone) and a - `BackgroundGenerator` that, per HEALPix pixel, looks up the local maglim, - selects the nearest-maglim CMD slice, scales counts linearly by pixel area, - Poisson-draws the count, samples multi-band magnitudes, places objects - uniformly within the pixel, and optionally applies a matched filter. -- Independent, pluggable `StellarBackground` / `GalaxyBackground` models. -- Galaxy misclassification: a new `Survey.get_galaxy_misclassification` curve and - an `is_galaxy`-aware `detect_flag`, so misclassified galaxies leak into the - stellar sample (and `perfect_galstarsep=True` ⇒ no leakage). A build script - reads DC2 truth+det **once, offline** to emit the lightweight files; the - runtime never loads DC2. - -### Phase 6 *(future)* — TRILEGAL + docs - -- `TrilegalStellarBackground` implementing the same interface, **lazy** (reads a - user-provided TRILEGAL table or a `fetch` callable; never imported at module - import). Documentation polish for the `{survey}_{band}` outputs, the error - split, and scenes. - -## Development fixtures (this branch) - -Survey data files (maglim maps, efficiency / photo-error CSVs) are **not** -committed — they are downloaded into the git-ignored `data/surveys//`. -To keep this branch self-contained and testable without the real Roman/Rubin -data, we add **dummy surveys**: small committed configs -(`config/surveys/*_dummy.yaml`) plus a generator that synthesizes tiny HEALPix -maglim maps and CSV tables at test time. The real `roman_dc2.yaml` is **not** -recreated here, so it can land cleanly when the `roman_hlwas` work merges. - -## Key files - -| File | Phase | Role | -|---|---|---| -| `streamobs/surveys.py` | 1 | sample/catalog error fields, `get_photo_error(kind=)`, loader | -| `streamobs/columns.py` | 2 | NEW — column-name helpers (always namespaced) | -| `streamobs/observed.py` | 1,2,4 | error wiring; de-hardcode bands; unified one-or-many-survey `StreamInjector` (`_inject_one_survey` + `_complete_shared`) | -| `streamobs/model.py` | 3 | multi-band `IsochroneModel`; always-namespaced `StreamModel` | -| `config/scenes/roman_rubin_demo.yaml` | 4 | NEW — multi-survey scene | -| `streamobs/background.py` | 5 *(future)* | NEW — lightweight background | From 8467c9af4316748f0e915d9d583b8689890ba373 Mon Sep 17 00:00:00 2001 From: psferguson Date: Thu, 18 Jun 2026 11:49:44 -0700 Subject: [PATCH 29/29] isort and black --- bin/generate_spline_stream.py | 1 + bin/generate_stream.py | 1 + streamobs/model.py | 4 +--- streamobs/utils.py | 2 +- tests/test_functions.py | 10 ++++++---- tests/test_model.py | 8 ++------ 6 files changed, 12 insertions(+), 14 deletions(-) diff --git a/bin/generate_spline_stream.py b/bin/generate_spline_stream.py index 883467a..f75e537 100755 --- a/bin/generate_spline_stream.py +++ b/bin/generate_spline_stream.py @@ -2,6 +2,7 @@ """ More modular stream generation example. """ + import matplotlib.pyplot as plt import numpy as np import pandas as pd diff --git a/bin/generate_stream.py b/bin/generate_stream.py index 017bfeb..66c8a41 100755 --- a/bin/generate_stream.py +++ b/bin/generate_stream.py @@ -2,6 +2,7 @@ """ More modular stream generation example. """ + import copy import os from importlib import reload diff --git a/streamobs/model.py b/streamobs/model.py index bf15712..e3eca90 100644 --- a/streamobs/model.py +++ b/streamobs/model.py @@ -830,9 +830,7 @@ def _add_distance_modulus(abs_mag, distance_modulus): return abs_mag return abs_mag + np.asarray(distance_modulus, dtype=float) - def sample( - self, nstars, distance_modulus, rng=None, masses=None, **kwargs - ): + def sample(self, nstars, distance_modulus, rng=None, masses=None, **kwargs): """Sample apparent magnitudes for every ``(survey, band)``. A single shared set of initial masses is interpolated into each survey's diff --git a/streamobs/utils.py b/streamobs/utils.py index c226c0f..3f19ccd 100644 --- a/streamobs/utils.py +++ b/streamobs/utils.py @@ -20,6 +20,6 @@ def parse_config(config): try: # If `config` is a file return yaml.safe_load(open(config, "r")) - except (OSError, FileNotFoundError): + except OSError, FileNotFoundError: # Otherwise assume it is a string return yaml.safe_load(config) diff --git a/tests/test_functions.py b/tests/test_functions.py index 0133baf..179c110 100644 --- a/tests/test_functions.py +++ b/tests/test_functions.py @@ -1,9 +1,11 @@ import numpy as np -from streamobs.functions import (CubicSplineInterpolation, - FileCubicSplineInterpolation, - FileLinearDensityCubicSplineInterpolation, - LinearDensityCubicSplineInterpolation) +from streamobs.functions import ( + CubicSplineInterpolation, + FileCubicSplineInterpolation, + FileLinearDensityCubicSplineInterpolation, + LinearDensityCubicSplineInterpolation, +) SPREAD_NODES = np.array([-13.0, -7.875, -2.75, 2.375, 7.5]) diff --git a/tests/test_model.py b/tests/test_model.py index 3bae578..6b9f9ad 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -332,9 +332,7 @@ class TestIsochroneMasses: G = "lsst_g_true" R = "lsst_r_true" - def test_sample_returns_and_reuses_masses( - self, stream_config_with_distance - ): + def test_sample_returns_and_reuses_masses(self, stream_config_with_distance): """Replaying the returned masses reproduces identical magnitudes.""" iso = StreamModel(stream_config_with_distance).isochrone mags1, masses = iso.sample(50, 16.8, rng=np.random.default_rng(0)) @@ -345,9 +343,7 @@ def test_sample_returns_and_reuses_masses( for key in mags1: assert np.allclose(mags1[key], mags2[key]), f"{key} not reproduced" - def test_sample_masses_length_validated( - self, stream_config_with_distance - ): + def test_sample_masses_length_validated(self, stream_config_with_distance): iso = StreamModel(stream_config_with_distance).isochrone with pytest.raises(ValueError): iso.sample(50, 16.8, masses=np.ones(49))