workspace_index.json

[
  {
    "contents": [
      "Imports & Output Path",
      "Point Dataset CSV",
      "Galaxy Model CSV API",
      "Scaling Galaxies CSV",
      "af.Model[Galaxy] from CSVs",
      "Wrap Up"
    ],
    "cross_refs": [
      "modeling.py",
      "simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/cluster/csv_api.ipynb",
    "path": "scripts/cluster/csv_api.py",
    "summary": "Cluster lens modelling uses a small family of CSV files as its canonical input format. Rather than composing a tracer and a model inline in Python, the cluster workflow stores every component \u2014 main galaxies, dark-matter halo, source light, source point components, scaling-tier members \u2014 in spreadsheet-editable CSVs that are then loaded into PyAutoLens objects.",
    "title": "CSV API: Cluster"
  },
  {
    "contents": [
      "Paths + URLs",
      "Downloads",
      "Coordinate Convention",
      "Parse arcs.dat",
      "Parse galcat.cat",
      "Parse best.par",
      "Image Cutout",
      "Write CSVs"
    ],
    "cross_refs": [
      "modeling.py"
    ],
    "notebook": "notebooks/cluster/lenstool/data.ipynb",
    "path": "scripts/cluster/lenstool/data.py",
    "summary": "This script prepares everything needed to repeat a *published Lenstool cluster analysis* in **PyAutoLens**: the strong-lensing model of the first JWST cluster, SMACS J0723.3-7327, by Mahler et al. 2023 (ApJ 945, 49; arXiv:2207.07101).",
    "title": "Lenstool Users: Data Preparation (SMACS J0723)"
  },
  {
    "contents": [
      "Load Data",
      "The Published Model, Reconstructed",
      "Verification I \u2014 source-plane compactness",
      "Verification II \u2014 image-plane RMS (optional)",
      "Critical Curves (optional)",
      "The Refit"
    ],
    "cross_refs": [
      "data.py",
      "scripts/cluster/modeling.py"
    ],
    "notebook": "notebooks/cluster/lenstool/modeling.ipynb",
    "path": "scripts/cluster/lenstool/modeling.py",
    "summary": "**If you model galaxy clusters with Lenstool, this script is for you.** It repeats a published Lenstool analysis \u2014 Mahler et al. 2023's model of SMACS J0723, the first JWST cluster \u2014 in **PyAutoLens**, in three steps:",
    "title": "Lenstool Users: Cluster Modeling (SMACS J0723)"
  },
  {
    "contents": [],
    "cross_refs": [
      "autolens_workspace_test/scripts/cluster/lenstool_parity.py",
      "cluster/mass_parameterizations.py",
      "cluster/modeling.py",
      "cluster/simulator.py",
      "cluster/start_here.py",
      "group/slam.py"
    ],
    "notebook": "notebooks/cluster/lenstool/parameterization_mapping.ipynb",
    "path": "scripts/cluster/lenstool/parameterization_mapping.py",
    "summary": "**If you want to fit cluster member (scaling) galaxies without knowing the source or lens redshift, this script shows you how \u2014 and proves it recovers the standard Lenstool model exactly once the redshifts become known.**",
    "title": "Lenstool Users: dPIE Parameterization Mapping (Scaling Galaxies)"
  },
  {
    "contents": [
      "JAX",
      "Dataset",
      "Truth Model",
      "Tracer",
      "Source-Plane Chi Squared: Concept",
      "Multi-Plane Ray Tracing",
      "Back-Traced Source-Plane Positions",
      "Source-Plane Centroid",
      "Residual Map",
      "Magnifications at Positions",
      "Chi Squared Map (Source)",
      "Per-Source Chi Squared",
      "Total Chi Squared (Source)",
      "Noise Normalization (Source)",
      "Source-Plane Log Likelihood",
      "Source-Plane Validation",
      "Image-Plane Chi Squared: Concept",
      "Point Solver Setup",
      "Forward Solving Model Positions",
      "Pairing Model to Observed",
      "Image-Plane Residual Map",
      "Chi Squared Map (Image)",
      "Per-Source / Total Chi Squared",
      "Noise Normalization (Image)",
      "Image-Plane Log Likelihood",
      "Image-Plane Validation",
      "Source-Plane vs Image-Plane: When to Use Which",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens/point/fit/positions/source/separations.py",
      "autolens_workspace/scripts/guides/advanced/multi_plane.py",
      "autolens_workspace/scripts/guides/lens_calc.py",
      "autolens_workspace/scripts/guides/point_source_pairing.py",
      "autolens_workspace_test/scripts/cluster/likelihood_sanity.py",
      "csv_api.py",
      "guides/point_source_pairing.py",
      "modeling.py",
      "scripts/cluster/csv_api.py",
      "scripts/cluster/modeling.py",
      "scripts/cluster/simulator.py",
      "scripts/cluster/start_here.py",
      "scripts/group/likelihood_function.py",
      "scripts/guides/using_jax.py",
      "scripts/imaging/likelihood_function.py"
    ],
    "notebook": "notebooks/cluster/likelihood_function.ipynb",
    "path": "scripts/cluster/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the cluster point-source ``log_likelihood_function``, the figure-of-merit Nautilus optimises when fitting a cluster lens model to ``point_datasets.csv``.",
    "title": "Log Likelihood Function: Cluster Point Source"
  },
  {
    "contents": [
      "Model 1 \u2014 The Standard Lenstool Model",
      "Model 2 \u2014 The Angular (b0) Parameterization",
      "Model 3 \u2014 Mass Anchoring",
      "Model 4 \u2014 The Two-Parameter Relation"
    ],
    "cross_refs": [
      "mass_parameterizations_pyautolens.py"
    ],
    "notebook": "notebooks/cluster/mass_parameterizations.ipynb",
    "path": "scripts/cluster/mass_parameterizations.py",
    "summary": "**A plain-language tour of the ways to parameterize and couple the masses in a Lenstool-style cluster model \u2014 the cluster-scale halo, the BCG and other individually-freed galaxies, and the member (\"scaling\") population.**",
    "title": "Cluster & Group Mass Parameterizations"
  },
  {
    "contents": [],
    "cross_refs": [
      "cluster/mass_parameterizations.py"
    ],
    "notebook": "notebooks/cluster/mass_parameterizations_pyautolens.ipynb",
    "path": "scripts/cluster/mass_parameterizations_pyautolens.py",
    "summary": "**For Lenstool users: how and why PyAutoLens re-expresses the standard Lenstool cluster / group model in its native parameterization for multi-galaxy lenses (MGLs), with the scaling galaxies keeping the dPIE's truncation throughout.**",
    "title": "Mass Parameterizations II \u2014 Mapping Lenstool onto PyAutoLens"
  },
  {
    "contents": [
      "Example",
      "Simulation",
      "Dataset",
      "Model CSVs",
      "Scaling Galaxies Table",
      "Point Solver",
      "Chi Squared",
      "Cluster Components",
      "Redshifts",
      "Model",
      "Scaling Relation",
      "Name Pairing",
      "Search",
      "Live Visual Update",
      "Analysis",
      "Factor Graph",
      "Run Times",
      "Output Folder Layout",
      "Result"
    ],
    "cross_refs": [
      "/cluster/simulator.py",
      "autolens_workspace_test/scripts/cluster/visualization.py",
      "cluster/likelihood_function.py",
      "cluster/simulator.py",
      "guides/point_source_pairing.py",
      "point_source/modeling.py",
      "point_source/start_here.py",
      "scripts/cluster/csv_api.py",
      "scripts/group/features/scaling_relation/modeling.py",
      "scripts/group/features/scaling_relation/modeling_for_luminosities.py",
      "start_here.py"
    ],
    "notebook": "notebooks/cluster/modeling.ipynb",
    "path": "scripts/cluster/modeling.py",
    "summary": "This script models the small multi-plane cluster lens simulated by ``cluster/simulator.py``: a Brightest Cluster Galaxy (BCG) plus one satellite member at the lens redshift ``z = 0.5``, 10 lower-mass cluster members modelled collectively via a luminosity-mass scaling relation, a standalone NFW host dark matter halo *not* tied to any individual galaxy, and 2 background sources at *different* redshifts (``z = 1.0`` and ``z = 2.0``) which the cluster lenses into multiple images.",
    "title": "Modeling: Cluster"
  },
  {
    "contents": [
      "Dataset",
      "Dataset Figures",
      "Positions Overlay",
      "Image Group Zooms",
      "Cluster Subplot",
      "Tracer",
      "Critical Curves",
      "Caustics",
      "Visualizer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "scripts/cluster/start_here.py",
      "scripts/imaging/plot.py",
      "scripts/point_source/plot.py"
    ],
    "notebook": "notebooks/cluster/plot.ipynb",
    "path": "scripts/cluster/plot.py",
    "summary": "This example shows how to plot a cluster-scale strong lens dataset \u2014 the multiple-image positions of its lensed sources, individually and overlaid together on an image of the cluster.",
    "title": "Plots: Cluster"
  },
  {
    "contents": [
      "Multi-Plane Setup",
      "Main Lens vs Scaling Members vs Host Halo vs Source Galaxies",
      "Dataset Paths",
      "Imaging and Visualization Grids",
      "Galaxy Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Scaling Member Galaxies",
      "Host Dark Matter Halo",
      "Source Galaxies",
      "Ray Tracing",
      "JAX JIT",
      "Point Solver",
      "Point Datasets",
      "Combined CSV",
      "Manual CSV Editing",
      "Scaling Galaxies CSV",
      "Model CSVs",
      "Tracer JSON",
      "Imaging",
      "Visualize"
    ],
    "cross_refs": [
      "group/modeling.py",
      "modeling.py",
      "scripts/cluster/csv_api.py",
      "scripts/point_source/simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/cluster/simulator.ipynb",
    "path": "scripts/cluster/simulator.py",
    "summary": "This script simulates an example strong lens on the 'cluster' scale: a small cluster consisting of 2 main lens galaxies (a brightest cluster galaxy + a single satellite), 10 lower-mass cluster member galaxies on a luminosity-mass scaling relation, a single host dark matter halo not tied to any individual galaxy, and 2 multiply-imaged background source galaxies sitting at *different* redshifts (``z = 1.0`` and ``z = 2.0``) \u2014 making this a genuine multi-plane lens.",
    "title": "Simulator: Cluster"
  },
  {
    "contents": [
      "JAX",
      "Capabilities",
      "Google Colab Setup",
      "Imports",
      "Dataset",
      "Model CSVs",
      "Scaling Galaxies Table",
      "Point Solver",
      "Cluster Components",
      "Model",
      "Analysis + Factor Graph",
      "Search",
      "Model Fit",
      "Live Visual Update",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/cluster/modeling.py",
      "autolens_workspace/scripts/cluster/simulator.py",
      "autolens_workspace/scripts/group/features/scaling_relation/modeling.py",
      "autolens_workspace/start_here.py",
      "cluster/modeling.py",
      "csv_api.py",
      "group/start_here.ipynb",
      "guides/point_source_pairing.py",
      "imaging/start_here.ipynb",
      "multi_galaxy/start_here.ipynb",
      "prep.py",
      "scripts/cluster/csv_api.py",
      "scripts/cluster/modeling.py",
      "scripts/cluster/simulator.py",
      "scripts/group/features/scaling_relation/modeling_for_luminosities.py"
    ],
    "notebook": "notebooks/cluster/start_here.ipynb",
    "path": "scripts/cluster/start_here.py",
    "summary": "Cluster-scale strong lenses are made of:",
    "title": "Start Here: Cluster"
  },
  {
    "contents": [
      "Dataset & Paths",
      "Main Lens Centres",
      "Masking (Search 1)",
      "Model (Search 1)",
      "Search + Result (Search 1)",
      "Masking (Search 2)",
      "Model (Search 2)",
      "Search + Result (Search 2)",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/start_here.py",
      "autolens_workspace/scripts/imaging/features/advanced/double_source_plane_lens/chaining.py",
      "modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/group/features/advanced/double_source_plane_lens/chaining.ipynb",
    "path": "scripts/group/features/advanced/double_source_plane_lens/chaining.py",
    "summary": "This script chains two non-linear searches to fit `Imaging` data of a group-scale double source-plane lens (DSPL) \u2014 two source galaxies at different redshifts lensed by multiple main lens galaxies at the lens-plane redshift.",
    "title": "Chaining: Group DSPL"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset, Mask, Over Sampling",
      "Main Lens Centres",
      "MGE Bases",
      "Galaxies",
      "Tracer",
      "Fit",
      "Multi-Plane Ray-Tracing",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/fit.py",
      "autolens_workspace/scripts/imaging/features/advanced/double_source_plane_lens/fit.py",
      "chaining.py",
      "modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/group/features/advanced/double_source_plane_lens/fit.ipynb",
    "path": "scripts/group/features/advanced/double_source_plane_lens/fit.py",
    "summary": "A group-scale double source-plane lens (DSPL), where two source galaxies at different redshifts are lensed by multiple main lens galaxies at the lens-plane redshift.",
    "title": "Features: Group DSPL Fit"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask",
      "Main Lens Centres",
      "Galaxies",
      "Multi-Plane Ray-Tracing",
      "Source-Plane Images",
      "Likelihood",
      "Fit Check",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/advanced/double_source_plane_lens/likelihood_function.py",
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "autolens_workspace/scripts/imaging/likelihood_function.py",
      "imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "imaging/likelihood_function.py"
    ],
    "notebook": "notebooks/group/features/advanced/double_source_plane_lens/likelihood_function.ipynb",
    "path": "scripts/group/features/advanced/double_source_plane_lens/likelihood_function.py",
    "summary": "This script describes the additional steps required to compute the `log_likelihood` for a group-scale double source-plane lens (DSPL) \u2014 two source galaxies at different redshifts lensed by multiple main lens galaxies at the lens-plane redshift.",
    "title": "__Log Likelihood Function: Group DSPL__"
  },
  {
    "contents": [
      "Model",
      "Dataset, Mask, Over Sampling",
      "Main Lens Centres",
      "Model Composition",
      "Cheating",
      "Cosmology",
      "Search, Analysis, Run-Time, Result, Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/features/advanced/double_source_plane_lens/chaining.py",
      "chaining.py",
      "slam.py"
    ],
    "notebook": "notebooks/group/features/advanced/double_source_plane_lens/modeling.ipynb",
    "path": "scripts/group/features/advanced/double_source_plane_lens/modeling.py",
    "summary": "A group-scale double source-plane lens (DSPL), where two source galaxies at different redshifts are lensed by multiple main lens galaxies at the lens-plane redshift.",
    "title": "Modeling Features: Group DSPL"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Source Galaxies",
      "Ray Tracing",
      "Dataset",
      "Tracer JSON",
      "Centres JSON"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/simulator.py",
      "autolens_workspace/scripts/imaging/features/advanced/double_source_plane_lens/simulator.py",
      "group/simulator.py"
    ],
    "notebook": "notebooks/group/features/advanced/double_source_plane_lens/simulator.ipynb",
    "path": "scripts/group/features/advanced/double_source_plane_lens/simulator.py",
    "summary": "A double source-plane lens (DSPL) in a group-scale context, where two source galaxies at different redshifts are lensed by multiple main lens galaxies at the lens-plane redshift.",
    "title": "Simulator: Group DSPL"
  },
  {
    "contents": [],
    "cross_refs": [
      "guides/modeling/slam_start_here.py",
      "scripts/imaging/features/advanced/double_source_plane_lens/slam.py"
    ],
    "notebook": "notebooks/group/features/advanced/double_source_plane_lens/slam.ipynb",
    "path": "scripts/group/features/advanced/double_source_plane_lens/slam.py",
    "summary": "This script adapts the SLaM (Source, Light and Mass) pipelines to a group-scale Double Source Plane Lens (DSPL) system, where two source galaxies at different redshifts behind multiple main lens galaxies form a double Einstein ring.",
    "title": "SLaM (Source, Light and Mass): Group DSPL"
  },
  {
    "contents": [
      "Dataset + Masking",
      "Main Lens Centres",
      "Paths",
      "Model (Search 1)",
      "Search 1",
      "Model (Search 2)",
      "Search 2",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/start_here.py",
      "autolens_workspace/scripts/imaging/features/advanced/mass_stellar_dark/chaining.py",
      "slam.py"
    ],
    "notebook": "notebooks/group/features/advanced/mass_stellar_dark/chaining.ipynb",
    "path": "scripts/group/features/advanced/mass_stellar_dark/chaining.py",
    "summary": "This script chains two searches to fit `Imaging` data of a 'group-scale' strong lens where each main lens galaxy is decomposed into stellar + dark matter components.",
    "title": "Chaining: Group Mass Stellar Dark"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask",
      "Over Sampling",
      "MGE Basis",
      "Main Lens Centres",
      "Galaxies",
      "Tracer",
      "Fit",
      "Decomposed Deflection (Multi-Galaxy)",
      "Intensities",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/start_here.py",
      "autolens_workspace/scripts/imaging/features/advanced/mass_stellar_dark/fit.py",
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/fit.py",
      "chaining.py",
      "modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/group/features/advanced/mass_stellar_dark/fit.ipynb",
    "path": "scripts/group/features/advanced/mass_stellar_dark/fit.py",
    "summary": "A group-scale strong lens where each main lens galaxy carries a decomposed mass model \u2014 a stellar component tied to its observed light via a mass-to-light ratio, plus a separately-parameterized dark matter halo. The total deflection at every image-plane coordinate is the sum over all main lens galaxies of the per-galaxy stellar + dark contributions, plus a single external shear.",
    "title": "Features: Group Mass Stellar Dark Fit"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask",
      "Main Lens Centres",
      "Galaxies",
      "Decomposed Deflection (Multi-Galaxy)",
      "Manual Ray-Tracing",
      "Source-Plane Image",
      "Model Image",
      "Fit Check",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/start_here.py",
      "autolens_workspace/scripts/imaging/features/advanced/mass_stellar_dark/likelihood_function.py",
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "autolens_workspace/scripts/imaging/likelihood_function.py",
      "imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "imaging/likelihood_function.py"
    ],
    "notebook": "notebooks/group/features/advanced/mass_stellar_dark/likelihood_function.ipynb",
    "path": "scripts/group/features/advanced/mass_stellar_dark/likelihood_function.py",
    "summary": "This script describes the additional steps required to compute the `log_likelihood` for a group-scale strong lens whose mass model decomposes each main lens galaxy's mass into a stellar component (tied to its light via a mass-to-light ratio) and a separately-parameterized dark matter halo.",
    "title": "__Log Likelihood Function: Group Mass Stellar Dark__"
  },
  {
    "contents": [
      "Model",
      "Dataset & Mask",
      "Main Lens Centres",
      "Over Sampling",
      "Model Cookbook",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/features/advanced/mass_stellar_dark/chaining.py",
      "autolens_workspace/scripts/group/start_here.py",
      "autolens_workspace/scripts/imaging/features/advanced/mass_stellar_dark/modeling.py",
      "chaining.py",
      "group/start_here.py",
      "slam.py",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/group/features/advanced/mass_stellar_dark/modeling.ipynb",
    "path": "scripts/group/features/advanced/mass_stellar_dark/modeling.py",
    "summary": "A group-scale strong lens where each main lens galaxy carries a decomposed mass model: a stellar component tied to the galaxy's own light via a mass-to-light ratio, plus a separately-parameterized dark matter halo. The total lens-plane deflection is the sum, over every main lens galaxy, of stellar + dark contributions, plus a single external shear attached to `lens_0` representing the group-wide shear field.",
    "title": "Modeling Features: Group Mass Stellar Dark"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Tracer JSON",
      "Centres JSON"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/simulator.py",
      "autolens_workspace/scripts/imaging/features/advanced/mass_stellar_dark/simulator.py",
      "group/features/advanced/double_source_plane_lens/simulator.py",
      "group/simulator.py",
      "scripts/group/features/advanced/double_source_plane_lens/slam.py"
    ],
    "notebook": "notebooks/group/features/advanced/mass_stellar_dark/simulator.ipynb",
    "path": "scripts/group/features/advanced/mass_stellar_dark/simulator.py",
    "summary": "A group-scale strong lens where each main lens galaxy carries a decomposed mass model: a stellar component tied to the galaxy's own light via a mass-to-light ratio, plus a separately-parameterized dark matter halo.",
    "title": "Simulator: Group Mass Stellar Dark"
  },
  {
    "contents": [],
    "cross_refs": [
      "guides/modeling/slam_start_here.py",
      "scripts/group/features/advanced/double_source_plane_lens/slam.py",
      "scripts/imaging/features/advanced/mass_stellar_dark/slam.py"
    ],
    "notebook": "notebooks/group/features/advanced/mass_stellar_dark/slam.ipynb",
    "path": "scripts/group/features/advanced/mass_stellar_dark/slam.py",
    "summary": "This script adapts the SLaM (Source, Light and Mass) pipelines to a group-scale strong lens where each main lens galaxy is decomposed into a stellar component (tied to its light via a mass-to-light ratio) and a dark matter halo.",
    "title": "SLaM (Source, Light and Mass): Group Mass Stellar Dark"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Model",
      "Search",
      "Analysis",
      "Result"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/advanced/operated_light_profile/modeling.ipynb",
    "path": "scripts/group/features/advanced/operated_light_profile/modeling.py",
    "summary": "Operated light profiles are light profiles which are assumed to have already been convolved with the PSF. This means that during the model-fitting process, these profiles are NOT convolved again with the PSF, unlike standard light profiles.",
    "title": "Modeling Features: Operated Light Profiles (Group)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Extra Galaxies",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Centre JSON Files"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/advanced/operated_light_profile/simulator.ipynb",
    "path": "scripts/group/features/advanced/operated_light_profile/simulator.py",
    "summary": "This script simulates a group-scale strong lens where the galaxy light uses operated light profiles. Operated light profiles represent emission that has already been convolved with the PSF, meaning they are NOT convolved again during the simulation.",
    "title": "Simulator: Operated Light Profiles (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Basis",
      "Fit",
      "Intensities"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/advanced/shapelets/fit.ipynb",
    "path": "scripts/group/features/advanced/shapelets/fit.py",
    "summary": "A shapelet is a basis function that is appropriate for capturing the exponential / disk-like features of a galaxy. This script demonstrates how to create a fit using shapelet light profiles for a group-scale strong lens, without performing a non-linear search.",
    "title": "Fit Features: Shapelets (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Model",
      "Search",
      "Analysis",
      "Result"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/advanced/shapelets/modeling.ipynb",
    "path": "scripts/group/features/advanced/shapelets/modeling.py",
    "summary": "A shapelet is a basis function that is appropriate for capturing the exponential / disk-like features of a galaxy. It has been employed in many strong lensing studies to model the light of lensed source galaxies, because it can represent features of disky star forming galaxies that a single Sersic function cannot.",
    "title": "Modeling Features: Shapelets (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Fit"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/advanced/sky_background/fit.ipynb",
    "path": "scripts/group/features/advanced/sky_background/fit.py",
    "summary": "The background of an image is the light that is not associated with the strong lens we are interested in. This script demonstrates how to include the sky background in a fit for a group-scale strong lens, without performing a non-linear search.",
    "title": "Fit Features: Sky Background (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Model",
      "Search",
      "Analysis",
      "Result"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/advanced/sky_background/modeling.ipynb",
    "path": "scripts/group/features/advanced/sky_background/modeling.py",
    "summary": "The background of an image is the light that is not associated with the strong lens we are interested in. This is due to light from the sky, zodiacal light, and light from other galaxies in the field of view.",
    "title": "Modeling Features: Sky Background (Group)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Extra Galaxies",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Centre JSON Files"
    ],
    "cross_refs": [
      "group/features/advanced/sky_background/modeling.py"
    ],
    "notebook": "notebooks/group/features/advanced/sky_background/simulator.ipynb",
    "path": "scripts/group/features/advanced/sky_background/simulator.py",
    "summary": "This script simulates a group-scale strong lens dataset where the sky background is NOT subtracted from the image. The sky background is therefore present in the data and must be accounted for during model-fitting.",
    "title": "Simulator: Sky Background (Group)"
  },
  {
    "contents": [
      "SLaM Pipelines",
      "Grid Search",
      "Group Adaptation",
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "SLaM Pipeline Functions",
      "Bayesian Evidence",
      "Grid Search Result"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/advanced/subhalo/detect/start_here.ipynb",
    "path": "scripts/group/features/advanced/subhalo/detect/start_here.py",
    "summary": "Strong gravitational lenses can be used to detect the presence of small-scale dark matter (DM) subhalos. This occurs when the DM subhalo overlaps the lensed source emission, and therefore gravitationally perturbs the observed image of the lensed source galaxy.",
    "title": "Subhalo Detection: Group"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Extra Galaxies",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Centre JSON Files",
      "Subhalo Difference Image"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/advanced/subhalo/simulator.ipynb",
    "path": "scripts/group/features/advanced/subhalo/simulator.py",
    "summary": "If a low mass dark matter halo overlaps the lensed source emission, it perturbs it in a unique and observable way.",
    "title": "Simulator: Subhalo (Group)"
  },
  {
    "contents": [
      "Dataset",
      "Model A",
      "Model B",
      "Fits",
      "Model Comparison",
      "Wrap Up"
    ],
    "cross_refs": [
      "cluster/mass_parameterizations.py",
      "cluster/start_here.py",
      "group/modeling.py",
      "simulator.py"
    ],
    "notebook": "notebooks/group/features/group_halo/modeling.ipynb",
    "path": "scripts/group/features/group_halo/modeling.py",
    "summary": "**Whether a group-scale lens model includes a separate dark-matter halo for the group is a modelling choice, not an assumption.** Some groups genuinely require one; others are adequately described by their member galaxies alone. This tutorial \u2014 the signature example of the group regime \u2014 fits the SAME dataset with both compositions and walks through how to decide between them:",
    "title": "Modeling Features (Group): The Group Halo \u2014 An Explicit Choice"
  },
  {
    "contents": [
      "Dataset Paths",
      "Simulation Switch",
      "Grid / PSF / Simulator",
      "Group Halo",
      "BGG + Members",
      "Source Galaxy / Ray Tracing / Dataset",
      "Tracer json + Centres"
    ],
    "cross_refs": [
      "cluster/mass_parameterizations.py",
      "group/modeling.py",
      "group/start_here.py",
      "modeling.py"
    ],
    "notebook": "notebooks/group/features/group_halo/simulator.ipynb",
    "path": "scripts/group/features/group_halo/simulator.py",
    "summary": "This script simulates the `Imaging` dataset fitted by the `group_halo` feature tutorial: a group-scale lens with a genuine **group-scale dark matter halo**, a brightest group galaxy (BGG) and two tidally truncated member galaxies, lensing a single extended background source.",
    "title": "Simulator: Group Halo"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Galaxy Centres",
      "Over Sampling",
      "Fitting",
      "Intensities",
      "Visualization"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/linear_light_profiles/fit.ipynb",
    "path": "scripts/group/features/linear_light_profiles/fit.py",
    "summary": "This script shows how to fit data using the ``FitImaging`` object for group-scale strong lenses when using **linear light profiles**, where the ``intensity`` of every light profile is solved via linear algebra rather than being specified as a parameter.",
    "title": "Fit Features: Linear Light Profiles (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Over Sampling",
      "Linear Light Profiles",
      "Lens Galaxy Mass",
      "Ray Tracing",
      "Linear Inversion",
      "Fit",
      "Likelihood Function"
    ],
    "cross_refs": [
      "group/likelihood_function.py",
      "imaging/features/linear_light_profiles/likelihood_function.py"
    ],
    "notebook": "notebooks/group/features/linear_light_profiles/likelihood_function.ipynb",
    "path": "scripts/group/features/linear_light_profiles/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the ``log_likelihood_function`` which is used to fit ``Imaging`` data of a group-scale strong lens using **linear light profiles**.",
    "title": "__Log Likelihood Function: Linear Light Profiles (Group)__"
  },
  {
    "contents": [
      "Advantages",
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Model",
      "Search",
      "Analysis",
      "Result",
      "Intensities"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/linear_light_profiles/modeling.ipynb",
    "path": "scripts/group/features/linear_light_profiles/modeling.py",
    "summary": "This script fits a group-scale strong lens using **linear light profiles**, where the ``intensity`` of every light profile is solved analytically via linear algebra rather than being a free parameter in the non-linear search.",
    "title": "Modeling Features: Linear Light Profiles (Group)"
  },
  {
    "contents": [
      "Prerequisites",
      "SOURCE LP PIPELINE 0",
      "SOURCE LP PIPELINE 1",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Galaxy Centres",
      "Mask",
      "Settings AutoFit",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "group/slam.py"
    ],
    "notebook": "notebooks/group/features/linear_light_profiles/slam.ipynb",
    "path": "scripts/group/features/linear_light_profiles/slam.py",
    "summary": "This script uses the SLaM pipelines to fit a group-scale strong lens using **linear Sersic light profiles** instead of Multi-Gaussian Expansion (MGE) profiles for the galaxy light.",
    "title": "Linear Light Profiles: Group SLaM"
  },
  {
    "contents": [
      "Loading Data",
      "Mask",
      "Galaxy Centres",
      "Over Sampling",
      "Fitting",
      "Bad Fit",
      "Fit Quantities",
      "Figures of Merit",
      "MGE In Practice"
    ],
    "cross_refs": [
      "modeling.py"
    ],
    "notebook": "notebooks/group/features/multi_gaussian_expansion/fit.ipynb",
    "path": "scripts/group/features/multi_gaussian_expansion/fit.py",
    "summary": "This guide shows how to fit data using the `FitImaging` object for group-scale strong lenses, including visualizing and interpreting its results.",
    "title": "Fit Features: Multi Gaussian Expansion (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Over Sampling",
      "Main Lens Galaxy",
      "Extra Galaxies",
      "Source Galaxy",
      "Lens Light",
      "Lens Galaxy Mass",
      "Ray Tracing",
      "Source Image",
      "Convolution",
      "Likelihood Function",
      "MGE Likelihood",
      "Fit"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/multi_gaussian_expansion/likelihood_function.ipynb",
    "path": "scripts/group/features/multi_gaussian_expansion/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Imaging` data of a group-scale strong lens, with a focus on how Multi Gaussian Expansion (MGE) light profiles fit into the likelihood calculation.",
    "title": "__Log Likelihood Function: Multi Gaussian Expansion (Group)__"
  },
  {
    "contents": [
      "MGE Advantages for Group Lenses",
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Search",
      "Analysis",
      "Run Times",
      "Result"
    ],
    "cross_refs": [
      "/group/simulator.py"
    ],
    "notebook": "notebooks/group/features/multi_gaussian_expansion/modeling.ipynb",
    "path": "scripts/group/features/multi_gaussian_expansion/modeling.py",
    "summary": "A Multi Gaussian Expansion (MGE) decomposes the light of each galaxy into ~10-30+ Gaussians, where the `intensity` of every Gaussian is solved for via linear algebra using a process called an \"inversion\" (see the `linear_light_profiles` feature for a full description of this).",
    "title": "Modeling Features: Multi Gaussian Expansion (Group)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Extra Galaxies",
      "Source Galaxy",
      "Ray Tracing",
      "Output"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/multi_gaussian_expansion/simulator.ipynb",
    "path": "scripts/group/features/multi_gaussian_expansion/simulator.py",
    "summary": "This script simulates an example strong lens on the 'group' scale, where there is a single primary lens galaxy and two smaller extra galaxies nearby, whose mass contributes significantly to the ray-tracing and is therefore included in the strong lens model.",
    "title": "Simulator: Multi Gaussian Expansion (Group)"
  },
  {
    "contents": [
      "Prerequisites",
      "This Script",
      "SOURCE LP PIPELINE",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Settings AutoFit",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "group/slam.py"
    ],
    "notebook": "notebooks/group/features/multi_gaussian_expansion/slam.ipynb",
    "path": "scripts/group/features/multi_gaussian_expansion/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines for fitting a group-scale strong lens where all light profiles use Multi Gaussian Expansion (MGE) models.",
    "title": "Multi Gaussian Expansion: Group SLaM"
  },
  {
    "contents": [
      "Simulated Dataset",
      "Mask",
      "Source Values",
      "MGE Source",
      "Source Flux",
      "Source Magnification",
      "Impact of Extra Galaxies",
      "Tracer"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/multi_gaussian_expansion/source_science.ipynb",
    "path": "scripts/group/features/multi_gaussian_expansion/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy.",
    "title": "Source Science: Multi Gaussian Expansion (Group)"
  },
  {
    "contents": [
      "Advantages",
      "Dataset & Mask",
      "Centres",
      "Model",
      "Over Sampling",
      "Search",
      "Analysis",
      "Result"
    ],
    "cross_refs": [
      "group/modeling.py",
      "imaging/features/no_lens_light/modeling.py"
    ],
    "notebook": "notebooks/group/features/no_lens_light/modeling.ipynb",
    "path": "scripts/group/features/no_lens_light/modeling.py",
    "summary": "This script models a group-scale strong lens where none of the lens galaxies have visible light emission. In the group context, \"no lens light\" means that **all** main lens galaxies **and** all extra galaxies are modeled with mass profiles only \u2014 no light profiles at all. Only the source galaxy has light.",
    "title": "Modeling Features: No Lens Light (Group)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Extra Galaxies",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files",
      "Positions"
    ],
    "cross_refs": [
      "imaging/features/no_lens_light/simulator.py"
    ],
    "notebook": "notebooks/group/features/no_lens_light/simulator.ipynb",
    "path": "scripts/group/features/no_lens_light/simulator.py",
    "summary": "This script simulates `Imaging` of a 'group-scale' strong lens where none of the lens galaxies have visible light emission \u2014 only their mass profiles contribute to the ray-tracing. The source galaxy still has light.",
    "title": "Simulator: No Lens Light (Group)"
  },
  {
    "contents": [
      "Prerequisites",
      "This Script",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Galaxy Centres",
      "Mask",
      "Settings AutoFit",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "group/slam.py",
      "guides/modeling/slam_start_here.ipynb",
      "imaging/features/no_lens_light/slam.py"
    ],
    "notebook": "notebooks/group/features/no_lens_light/slam.ipynb",
    "path": "scripts/group/features/no_lens_light/slam.py",
    "summary": "This script uses the SLaM pipelines to fit a group-scale strong lens where none of the lens galaxies have visible light emission. In the group context, \"no lens light\" means that **all** main lens galaxies **and** all extra galaxies are modeled with mass profiles only.",
    "title": "No Lens Light: Group SLaM"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Galaxy Centres",
      "Search 1",
      "Search 2",
      "Search 3",
      "Adapt Images"
    ],
    "cross_refs": [
      "group/features/pixelization/slam.py"
    ],
    "notebook": "notebooks/group/features/pixelization/adaptive.ipynb",
    "path": "scripts/group/features/pixelization/adaptive.py",
    "summary": "This script demonstrates how adaptive pixelization features work for group-scale strong lenses.",
    "title": "Adaptive Pixelization (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Galaxy Centres",
      "Sparse Operators",
      "Fit",
      "Model"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/pixelization/cpu_fast_modeling.ipynb",
    "path": "scripts/group/features/pixelization/cpu_fast_modeling.py",
    "summary": "This script demonstrates how to achieve fast pixelization performance on a CPU without JAX for group-scale strong lenses, by combining:",
    "title": "CPU Fast Modeling: Pixelization (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Galaxy Centres",
      "Fit",
      "Model",
      "Advantages for Group Lenses"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/pixelization/delaunay.ipynb",
    "path": "scripts/group/features/pixelization/delaunay.py",
    "summary": "This script demonstrates using a Delaunay triangulation mesh for source reconstruction in a group-scale strong lens, as an alternative to the rectangular mesh used in other examples.",
    "title": "Delaunay Pixelization (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Galaxy Centres",
      "Fitting",
      "Inversion",
      "Over Sampling"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/pixelization/fit.ipynb",
    "path": "scripts/group/features/pixelization/fit.py",
    "summary": "This script demonstrates how to create a `FitImaging` object for a group-scale strong lens where the source galaxy is reconstructed using a pixelized mesh, rather than parametric light profiles.",
    "title": "Fit Features: Pixelization (Group)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Galaxy Centres",
      "Lens Galaxies",
      "Source Galaxy Pixelization",
      "Lens Light",
      "Deflection Angles",
      "Ray Tracing",
      "Pixelized Source Reconstruction",
      "Likelihood Function",
      "Fit"
    ],
    "cross_refs": [
      "group/likelihood_function.py",
      "imaging/features/pixelization/likelihood_function.py"
    ],
    "notebook": "notebooks/group/features/pixelization/likelihood_function.ipynb",
    "path": "scripts/group/features/pixelization/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Imaging` data of a group-scale strong lens where the source galaxy is reconstructed using a pixelized mesh.",
    "title": "__Log Likelihood Function: Pixelization (Group)__"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Galaxy Centres",
      "Model",
      "Over Sampling",
      "Search",
      "Analysis",
      "Result"
    ],
    "cross_refs": [
      "group/features/pixelization/slam.py",
      "scripts/group/slam.py"
    ],
    "notebook": "notebooks/group/features/pixelization/modeling.ipynb",
    "path": "scripts/group/features/pixelization/modeling.py",
    "summary": "This script fits a group-scale strong lens where the source galaxy is reconstructed using a pixelized mesh (Delaunay triangulation) with adaptive regularization, rather than parametric light profiles.",
    "title": "Modeling Features: Pixelization (Group)"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset",
      "Galaxy Centres",
      "Mask",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "group/slam.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/group/features/pixelization/slam.ipynb",
    "path": "scripts/group/features/pixelization/slam.py",
    "summary": "This script uses the SLaM (Source, Light and Mass) pipelines to fit a group-scale strong lens where the source galaxy is reconstructed using a pixelized mesh with adaptive regularization.",
    "title": "Pixelization: Group SLaM"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Galaxy Centres",
      "Model Fit",
      "Source Flux",
      "Source Magnification",
      "Impact of Extra Galaxies",
      "Interpolated Source",
      "Parametric Comparison"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/features/pixelization/source_science.ipynb",
    "path": "scripts/group/features/pixelization/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy.",
    "title": "Source Science: Pixelization (Group)"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask",
      "Centres + Luminosities",
      "Over Sampling",
      "MGE Basis",
      "Galaxies",
      "Tracer",
      "Three-Tier Deflection Tour",
      "Intensities",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/group/slam.py",
      "autolens_workspace/scripts/group/start_here.py",
      "autolens_workspace/scripts/imaging/features/scaling_relation/fit.py",
      "modeling.py",
      "modeling_for_luminosities.py"
    ],
    "notebook": "notebooks/group/features/scaling_relation/fit.ipynb",
    "path": "scripts/group/features/scaling_relation/fit.py",
    "summary": "A group-scale strong lens often has many foreground galaxies near the line of sight to the source, on top of one or more primary lens galaxies. The **three-tier API** splits these galaxies into populations that the lens model treats differently:",
    "title": "Features: Group Scaling Relation Fit"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask.",
      "Centres + Luminosities",
      "Galaxies",
      "Three-Tier Deflection",
      "Manual Ray-Tracing",
      "Source-Plane Image",
      "Fit Check.",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/group/start_here.py",
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "autolens_workspace/scripts/imaging/features/scaling_relation/likelihood_function.py",
      "autolens_workspace/scripts/imaging/likelihood_function.py"
    ],
    "notebook": "notebooks/group/features/scaling_relation/likelihood_function.ipynb",
    "path": "scripts/group/features/scaling_relation/likelihood_function.py",
    "summary": "This script describes the additional steps required to compute the `log_likelihood` for a group-scale strong lens whose foreground galaxy population is split across three tiers \u2014 main lens galaxies (modelled via the group `lens_dict` API), individually-modelled extras (tidally truncated `dPIEMassSph` profiles, each with its own free `sigma`), and scaling-tier extras (whose truncated `dPIEMassSph` masses are derived from a shared reference-anchored relation `sigma = sigma_ref * (luminosity / reference_luminosity) ** 0.25` with tied truncation `r_cut = r_cut_ref * (luminosity / reference_luminosity) ** 0.7`, the Lenstool convention).",
    "title": "__Log Likelihood Function: Group Scaling Relation__"
  },
  {
    "contents": [
      "Three-Tier API",
      "Centres",
      "Luminosities",
      "Dataset & Mask",
      "Main Lens Galaxies",
      "Extra Galaxies",
      "Scaling Galaxies",
      "Model",
      "Over Sampling",
      "Search and Analysis",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/group/features/scaling_relation/modeling_for_luminosities.py",
      "autolens_workspace/scripts/group/slam.py",
      "autolens_workspace/scripts/imaging/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/multi_galaxy/features/scaling_relation/modeling.py",
      "group/modeling.py",
      "scripts/cluster/modeling.py",
      "scripts/group/features/pixelization/slam.py",
      "scripts/group/features/scaling_relation/modeling_for_luminosities.py",
      "scripts/group/features/scaling_relation/simulator.py",
      "scripts/group/slam.py"
    ],
    "notebook": "notebooks/group/features/scaling_relation/modeling.ipynb",
    "path": "scripts/group/features/scaling_relation/modeling.py",
    "summary": "Group-scale strong lenses can have many galaxies in the foreground beyond the primary lens. As the number grows, modelling each galaxy individually becomes impractical: a system with 10 companions would gain 10 extra mass free parameters, and the data is rarely informative enough to constrain them all.",
    "title": "Modeling Features (Group): Scaling Relations"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres",
      "Light-only Model",
      "Search and Analysis",
      "Compute Luminosities",
      "Output",
      "Wrap Up"
    ],
    "cross_refs": [
      "modeling.py",
      "scripts/group/features/pixelization/slam.py",
      "scripts/group/slam.py",
      "scripts/imaging/features/scaling_relation/modeling.py"
    ],
    "notebook": "notebooks/group/features/scaling_relation/modeling_for_luminosities.ipynb",
    "path": "scripts/group/features/scaling_relation/modeling_for_luminosities.py",
    "summary": "The scaling-relation modeling examples (`modeling.py` in this directory and `scripts/imaging/features/scaling_relation/modeling.py`) need a measured **luminosity** for every galaxy that sits on the relation:",
    "title": "Modeling Features (Group): Fit Galaxy Luminosities for a Scaling Relation"
  },
  {
    "contents": [],
    "cross_refs": [
      "autogalaxy/galaxy/galaxy_table.py",
      "group/features/scaling_relation/modeling.py"
    ],
    "notebook": "notebooks/group/features/scaling_relation/simulator.ipynb",
    "path": "scripts/group/features/scaling_relation/simulator.py",
    "summary": "This script simulates a group-scale strong lens with three populations of galaxies in the foreground, designed to exercise the three-tier modeling API used by `group/features/scaling_relation/modeling.py`:",
    "title": "Simulator: Group Scaling Relation"
  },
  {
    "contents": [
      "Loading Data",
      "Mask",
      "Galaxy Centres",
      "Fitting",
      "Bad Fit",
      "Fit Quantities",
      "Figures of Merit",
      "Plane Quantities",
      "Unmasked Quantities",
      "Pixel Counting",
      "Outputting Results",
      "Over Sampling"
    ],
    "cross_refs": [
      "modeling.py",
      "scripts/guides/using_jax.py",
      "scripts/imaging/fit.py",
      "start_here.py"
    ],
    "notebook": "notebooks/group/fit.ipynb",
    "path": "scripts/group/fit.py",
    "summary": "This guide shows how to fit data using the `FitImaging` object for group-scale strong lenses, including visualizing and interpreting its results.",
    "title": "Fits: Group"
  },
  {
    "contents": [
      "JAX",
      "Dataset & Mask",
      "Over Sampling",
      "Masked Image Grid",
      "Main Lens Galaxy",
      "Extra Galaxies",
      "Source Galaxy Light Profile",
      "Lens Light",
      "Lens Galaxy Mass",
      "Ray Tracing",
      "Source Image",
      "Convolution",
      "Likelihood Function",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.py",
      "scripts/guides/using_jax.py"
    ],
    "notebook": "notebooks/group/likelihood_function.ipynb",
    "path": "scripts/group/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Imaging` data of a group-scale strong lens, where there are multiple lens galaxies whose mass profiles all contribute to the ray-tracing of the source galaxy.",
    "title": "__Log Likelihood Function: Group__"
  },
  {
    "contents": [
      "Scaling Relations",
      "Group Halo",
      "Example",
      "Simulation",
      "Data Preparation",
      "Dataset & Mask",
      "Main Galaxies and Extra Galaxies",
      "Centres",
      "Redshifts",
      "Model",
      "Coordinates",
      "Improved Lens Model",
      "Linear Light Profiles",
      "Over Sampling",
      "Search",
      "Unique Identifier",
      "Iterations Per Update",
      "Live Visual Update",
      "Analysis",
      "JAX",
      "VRAM Use",
      "Run Times",
      "Output Folder Layout",
      "Result",
      "Features",
      "HowToLens",
      "Modeling Customization"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "/imaging/data_preparation/start_here.ipynb",
      "/imaging/simulator.py",
      "features/scaling_relation/modeling.ipynb",
      "imaging/data_preparation/gui/extra_galaxies_centres.py",
      "over_sampling.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/group/modeling.ipynb",
    "path": "scripts/group/modeling.py",
    "summary": "This script models an example strong lens on the 'group' scale, which typically have one or more \"main\" lens galaxies and smaller extra galaxies nearby, whose light may blur with the source light and whose mass contributes significantly to the ray-tracing, meaning both are therefore included in the strong lens model.",
    "title": "Group: Modeling"
  },
  {
    "contents": [
      "Dataset",
      "Dataset Figures",
      "Dataset Subplot",
      "Fit",
      "Fit Figures",
      "Plane Images",
      "Fit Subplot",
      "Visualizer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "scripts/imaging/plot.py"
    ],
    "notebook": "notebooks/group/plot.ipynb",
    "path": "scripts/group/plot.py",
    "summary": "This example shows how to plot a group-scale `Imaging` dataset and a `FitImaging` fit, figure by figure and via multi-panel subplots.",
    "title": "Plots: Group"
  },
  {
    "contents": [
      "Main Lens Galaxies vs Extra Galaxies",
      "No Group Halo",
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "PSF Convolution",
      "Main Lens Galaxies",
      "Extra Galaxies",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "scripts/guides/using_jax.py",
      "scripts/imaging/simulator.py"
    ],
    "notebook": "notebooks/group/simulator.ipynb",
    "path": "scripts/group/simulator.py",
    "summary": "This script simulates an example strong lens on the 'group' scale, where there is a single primary lens galaxy and two smaller extra galaxies nearby, whose mass contributes significantly to the ray-tracing and is therefore included in the strong lens model.",
    "title": "Simulator: Group"
  },
  {
    "contents": [
      "Prerequisites",
      "Extra Galaxies and Scaling Galaxies",
      "This Script",
      "SOURCE LP PIPELINE 0",
      "SOURCE LP PIPELINE 1",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Galaxy Centres",
      "Mask",
      "Settings AutoFit",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "guides/modeling/slam_start_here.ipynb",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/group/slam.ipynb",
    "path": "scripts/group/slam.py",
    "summary": "This script uses the SLaM pipelines to fit a group-scale strong lens, including extra galaxies and scaling galaxies surrounding the main lens whose light and mass are both modeled.",
    "title": "SLaM (Source, Light and Mass): Group Scale"
  },
  {
    "contents": [
      "Simulated Dataset",
      "Mask",
      "Source Values",
      "Source Flux",
      "Source Magnification",
      "Impact of Extra Galaxies",
      "Tracer",
      "Parametric Source Models"
    ],
    "cross_refs": [],
    "notebook": "notebooks/group/source_science.ipynb",
    "path": "scripts/group/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy (or galaxies).",
    "title": "Source Science: Group"
  },
  {
    "contents": [
      "JAX",
      "Google Colab Setup",
      "Imports",
      "Dataset",
      "Main Lens Galaxies",
      "Masking",
      "Model",
      "Model Fit",
      "Live Visual Update",
      "Result",
      "Centre Input GUI",
      "Model Your Own Lens",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/start_here.py",
      "cluster/start_here.ipynb",
      "imaging/start_here.ipynb",
      "imaging/start_here.py",
      "modeling.py",
      "multi_galaxy/start_here.ipynb",
      "scripts/imaging/start_here.py"
    ],
    "notebook": "notebooks/group/start_here.ipynb",
    "path": "scripts/group/start_here.py",
    "summary": "Group scale lenses typically have multiple lens galaxies whose light and mass all contribute significantly to the lensing of the source galaxy. Groups typically also have just one lensed source.",
    "title": "Start Here: Group"
  },
  {
    "contents": [
      "Source Code",
      "Example Mass Profile",
      "Inheritance Structure",
      "Data Structure Decorators",
      "Transform Decorator",
      "Lens Modeling",
      "Lens Modeling Configs",
      "Deflections",
      "Spherical Template",
      "Physical Profiles",
      "Light Profiles"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoGalaxy/blob/main/autogalaxy/operate/deflections.py",
      "//github.com/PyAutoLabs/PyAutoGalaxy/blob/main/autogalaxy/profiles/geometry_profiles.py",
      "//github.com/PyAutoLabs/PyAutoGalaxy/blob/main/autogalaxy/profiles/mass/abstract/abstract.py",
      "//github.com/PyAutoLabs/PyAutoGalaxy/blob/main/autogalaxy/profiles/mass/total/isothermal.py"
    ],
    "notebook": "notebooks/guides/advanced/add_a_profile.ipynb",
    "path": "scripts/guides/advanced/add_a_profile.py",
    "summary": "**PyAutoLens** supports a wide range of mass and light profiles for modelling the lens and source galaxies in strong gravitational lensing systems.",
    "title": "Misc: Add A Profile"
  },
  {
    "contents": [
      "PyAutoFit",
      "Source Code",
      "Example Analysis Class",
      "Lens Model",
      "Instances",
      "Simple Analysis Example",
      "Analysis Class Considerations",
      "Model Fit",
      "Weak Lensing Example",
      "Result",
      "To Do List"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoGalaxy/blob/main/autogalaxy/imaging/model/analysis.py",
      "//github.com/PyAutoLabs/PyAutoLens/blob/main/autolens/imaging/model/analysis.py"
    ],
    "notebook": "notebooks/guides/advanced/custom_analysis.ipynb",
    "path": "scripts/guides/advanced/custom_analysis.py",
    "summary": "Users familiar with **PyAutoLens** will have seen that `Analysis` classes are used to performed lens modeling of different datasets. For example, the `AnalysisImaging` class fits imaging datasets, the `AnalysisInterferometer` class fits interferometer datasets.",
    "title": "Misc: Custom Analysis"
  },
  {
    "contents": [
      "Example",
      "Ray Tracing",
      "Trace",
      "Lensing Units vs Physical Units",
      "The PyAutoLens Convention",
      "Profiles With Physical Units",
      "Science Corollaries",
      "Attribution"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoLens/blob/main/autolens/lens/tracer_util.py",
      "tracer_util.py"
    ],
    "notebook": "notebooks/guides/advanced/multi_plane.ipynb",
    "path": "scripts/guides/advanced/multi_plane.py",
    "summary": "Multi-plane ray-tracing is used when a lens system has more planes than just an image-plane and source-plane. When tracing from one plane to the next, the redshifts of the planes are used to compute scaling factors that are applied to the deflection angles, so that every plane's lensing effect is combined consistently.",
    "title": "Misc: Multi-Plane"
  },
  {
    "contents": [
      "Illustration",
      "Numerics",
      "Images",
      "Adaptive Over Sampling",
      "Multiple Lens Galaxies",
      "Ray Tracing",
      "Default Ray Tracing",
      "Dataset & Modeling",
      "Pixelization"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling_chaining.ipynb",
      "autolens_workspace_test/scripts/imaging/convolution_over_sampled.py",
      "scripts/imaging/simulator.py"
    ],
    "notebook": "notebooks/guides/advanced/over_sampling.ipynb",
    "path": "scripts/guides/advanced/over_sampling.py",
    "summary": "Throughout the workspace, we have created 2D grids of (y,x) coordinates and input them into light profiles to compute their image.",
    "title": "Over Sampling"
  },
  {
    "contents": [
      "Start Here Notebook",
      "Dataset + Masking",
      "Paths",
      "Redshifts",
      "Model (Search 1)",
      "Search + Analysis + Model-Fit (Search 1)",
      "Result (Search 1)",
      "Over Sampling (Search 2)"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.py",
      "guides/modeling/chaining.ipynb"
    ],
    "notebook": "notebooks/guides/advanced/over_sampling_chaining.ipynb",
    "path": "scripts/guides/advanced/over_sampling_chaining.py",
    "summary": "Over sampling is a numerical technique where the images of light profiles and galaxies are evaluated on a higher resolution grid than the image data to ensure the calculation is accurate.",
    "title": "Chaining: Over Sample"
  },
  {
    "contents": [
      "Conventions",
      "Lens Model",
      "Export",
      "Import",
      "Round Trip",
      "NFW Profiles"
    ],
    "cross_refs": [],
    "notebook": "notebooks/guides/coolest_interop.ipynb",
    "path": "scripts/guides/coolest_interop.py",
    "summary": "COOLEST (COde-independent Organized LEns STandard, https://github.com/aymgal/COOLEST) is a standard for storing and exchanging strong lens models between different lens modeling software, for example lenstronomy, herculens and GLEE.",
    "title": "COOLEST"
  },
  {
    "contents": [
      "JAX",
      "Units",
      "API",
      "Grids",
      "Native",
      "Slim",
      "Masked Data Structures",
      "Data",
      "Tracer",
      "Irregular Structures",
      "Vector Quantities"
    ],
    "cross_refs": [
      "guides/units/cosmology.ipynb",
      "scripts/guides/using_jax.py"
    ],
    "notebook": "notebooks/guides/data_structures.ipynb",
    "path": "scripts/guides/data_structures.py",
    "summary": "This tutorial illustrates the data structure objects which data and results quantities are stored using, which are extensions of NumPy arrays.",
    "title": "Data Structures"
  },
  {
    "contents": [
      "JAX",
      "Units",
      "Data Structures",
      "Grids",
      "Tracer",
      "Individual Lens Galaxy Components",
      "Log10"
    ],
    "cross_refs": [
      "/guides/data_structures.ipynb",
      "guides/units/cosmology.ipynb",
      "results/start_here.ipynb",
      "scripts/guides/using_jax.py",
      "tracer.py"
    ],
    "notebook": "notebooks/guides/galaxies.ipynb",
    "path": "scripts/guides/galaxies.py",
    "summary": "In the guide `tracer.py`, we inspected the results of a `Tracer` and computed the overall properties of the lens model's image, convergence and other quantities.",
    "title": "Galaxies"
  },
  {
    "contents": [
      "HPC Output Path",
      "HPC Dataset Path",
      "HPC Home Path",
      "Batch Script: Many Datasets (Array Job)",
      "Dataset",
      "Batch Script: Single Dataset with Multiple CPUs",
      "Nautilus CPUs",
      "Lens Modeling",
      "GPU Jobs"
    ],
    "cross_refs": [
      "PROJECT_PATH/scripts/guides/hpc/example_cpu_and_gpu.py"
    ],
    "notebook": "notebooks/guides/hpc/example_cpu_and_gpu.ipynb",
    "path": "scripts/guides/hpc/example_cpu_and_gpu.py",
    "summary": "This example illustrates how to set up lens modeling on a High Performance Computing (HPC) system, using either multiple CPUs or a GPU.",
    "title": "HPC: Example CPU and GPU"
  },
  {
    "contents": [
      "JAX",
      "Units",
      "Data Structures",
      "Grids",
      "Mass Profile and Galaxy",
      "Tracer",
      "LensCalc",
      "The Lens Equation",
      "Deflection Angles",
      "Hessian",
      "Convergence",
      "Shear",
      "Magnification",
      "Critical Curves and Caustics",
      "Einstein Radius",
      "Fermat Potential",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/data_structures.ipynb",
      "guides/units/cosmology.ipynb",
      "scripts/guides/using_jax.py"
    ],
    "notebook": "notebooks/guides/lens_calc.ipynb",
    "path": "scripts/guides/lens_calc.py",
    "summary": "This guide explains the ``LensCalc`` class, which computes a comprehensive set of lensing quantities from the deflection angles of a mass distribution.",
    "title": "Lens Calc"
  },
  {
    "contents": [
      "Sample Simulation",
      "Dataset & Mask",
      "Model Individual Factors",
      "Analysis",
      "Model",
      "Paths",
      "Analysis Factors",
      "Factor Graph",
      "Expectation Propagation",
      "Cyclic Fitting",
      "Result",
      "Output",
      "Results"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/simulator_sample.py"
    ],
    "notebook": "notebooks/guides/modeling/advanced/expectation_propagation.ipynb",
    "path": "scripts/guides/modeling/advanced/expectation_propagation.py",
    "summary": "In the `hierarchical` example, we fitted graphical models to a dataset comprising 3 images of strong lenses, which had a hierarchical parameter, the power-law `slope`. This provides the basis of composing and fitting complex graphical models to large datasets.",
    "title": "Modeling: Expectation Propagation"
  },
  {
    "contents": [
      "Initialization",
      "Point Solver",
      "Model",
      "Analysis",
      "Analysis Factors",
      "Factor Graph",
      "Search",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/start_here.ipynb"
    ],
    "notebook": "notebooks/guides/modeling/advanced/graphical.ipynb",
    "path": "scripts/guides/modeling/advanced/graphical.py",
    "summary": "The example scripts throughout the workspace have focused on modeling **individual strong lens datasets**. From each fit, you may have inspected lens properties (e.g., Einstein radius) and source properties (e.g., magnification). You may even have analyzed many lenses one-by-one and combined their results to study global trends in galaxy formation or cosmology.",
    "title": "Modeling: Graphical"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Analysis",
      "Model Individual Factors",
      "Analysis Factors",
      "Model",
      "Factor Graph",
      "Search",
      "Result",
      "Concept",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/simulator_sample.py"
    ],
    "notebook": "notebooks/guides/modeling/advanced/hierarchical.ipynb",
    "path": "scripts/guides/modeling/advanced/hierarchical.py",
    "summary": "A hierarchical model assumes that certain model parameters are drawn from a **shared parent distribution** (e.g. a Gaussian). When we fit such a model, the parameters of this parent distribution (such as its `mean` and `sigma`) become explicit free parameters in the inference. Scientifically, these parent-distribution parameters are often of greatest interest because they describe **population-level trends**, rather than the properties of individual lenses.",
    "title": "Modeling: Hierarchical"
  },
  {
    "contents": [
      "The Fix",
      "Trouble Shooting"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/modeling.py"
    ],
    "notebook": "notebooks/guides/modeling/bug_fix.ipynb",
    "path": "scripts/guides/modeling/bug_fix.py",
    "summary": "Depending on the operating system (e.g. Linux, Mac, Windows) and Python version, running a Python script or Jupyter notebook may lead to a error being raised when the search begins.",
    "title": "Modeling: Parallel Bug Fix"
  },
  {
    "contents": [
      "Concise Model Composition API",
      "This Example",
      "Dataset + Masking",
      "Paths",
      "Model (Search 1)",
      "Search + Analysis + Model-Fit (Search 1)",
      "Result (Search 1)",
      "Model Chaining",
      "Model Centred Chaining",
      "Search + Analysis + Model-Fit (Search 2)",
      "Result (Search 2)",
      "How is Search Chaining Used?",
      "Detailed Explanation Of Prior Passing",
      "EXAMPLE"
    ],
    "cross_refs": [],
    "notebook": "notebooks/guides/modeling/chaining.ipynb",
    "path": "scripts/guides/modeling/chaining.py",
    "summary": "Non-linear search chaining is an advanced model-fitting approach which breaks the model-fitting procedure down into multiple non-linear searches, using the results of the initial searches to initialization parameter sampling in subsequent searches. This contrasts the `modeling` examples which each compose and fit a single lens model-fit using one non-linear search.",
    "title": "Modeling: Chaining"
  },
  {
    "contents": [
      "Simple Lens Model",
      "More Complex Lens Models",
      "Concise API",
      "Prior Customization",
      "Model Customization",
      "Redshift Free",
      "Available Model Components"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/autolens_workspace/blob/main/notebooks/imaging/advanced/guides/modeling/chaining.ipynb",
      "//github.com/PyAutoLabs/autolens_workspace/blob/main/notebooks/modeling/features/multi_gaussian_expansion.ipynb",
      "//github.com/PyAutoLabs/autolens_workspace/blob/main/notebooks/modeling/features/shapelets.ipynb",
      "//github.com/PyAutoLabs/autolens_workspace/blob/main/notebooks/multi_dataset/features/wavelength_dependence/modeling.ipynb",
      "//github.com/PyAutoLabs/autolens_workspace/blob/main/notebooks/multi_dataset/start_here.ipynb",
      "imaging/start_here.ipynb"
    ],
    "notebook": "notebooks/guides/modeling/cookbook.ipynb",
    "path": "scripts/guides/modeling/cookbook.py",
    "summary": "The model cookbook provides a concise reference to lens model composition tools, specifically the `Model` and `Collection` objects.",
    "title": "Model Cookbook"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Over Sampling",
      "Positions"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "/guides/advanced/over_sampling_chaining.ipynb",
      "/imaging/data_preparation/gui/mask.py",
      "/imaging/data_preparation/gui/positions.py",
      "imaging/start_here.ipynb"
    ],
    "notebook": "notebooks/guides/modeling/customize.ipynb",
    "path": "scripts/guides/modeling/customize.py",
    "summary": "This script gives a run through of all the different ways the analysis can be customized for lens modeling, with reasons explaining why each customization is useful.",
    "title": "Modeling: Customize"
  },
  {
    "contents": [
      "Nautilus",
      "MultiStartProdigy",
      "Dynesty",
      "Emcee",
      "Zeus",
      "LBFGS",
      "Start Point",
      "Search Cookbook"
    ],
    "cross_refs": [
      "imaging/start_here.ipynb",
      "modeling.py",
      "start_here.py"
    ],
    "notebook": "notebooks/guides/modeling/searches.ipynb",
    "path": "scripts/guides/modeling/searches.py",
    "summary": "This script gives a run through of all non-linear searches that are available for modeling.",
    "title": "Modeling: Searches"
  },
  {
    "contents": [
      "Preqrequisites",
      "Overview",
      "Design Choices",
      "This Script",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "Positions",
      "Adapt Images",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [],
    "notebook": "notebooks/guides/modeling/slam_start_here.ipynb",
    "path": "scripts/guides/modeling/slam_start_here.py",
    "summary": "This scripts gives an introduce to the Source, (lens) Light and Mass (SLaM) pipelines. These are advanced modeling pipelines which use many aspects of core PyAutoLens functionality to automate the modeling of strong lenses.",
    "title": "SLaM (Source, Light and Mass): Start Here"
  },
  {
    "contents": [
      "Setup",
      "Light Profile",
      "Mass Profile",
      "Galaxy",
      "Tracer",
      "Lensed Grids",
      "1D Profiles"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "plot.py",
      "scripts/imaging/plot.py"
    ],
    "notebook": "notebooks/guides/plot/plotters.ipynb",
    "path": "scripts/guides/plot/plotters.py",
    "summary": "This example illustrates how to plot each key PyAutoLens object \u2014 light profiles, mass profiles, galaxies and tracers \u2014 figure by figure.",
    "title": "Plots: Objects"
  },
  {
    "contents": [
      "Setup",
      "Notation",
      "Dynesty",
      "Plots",
      "Emcee",
      "Search Specific Visualization",
      "Zeus",
      "GetDist",
      "Parameter Names",
      "GetDist Plotter",
      "GetDist Subplots",
      "GetDist Single Plots",
      "Output",
      "GetDist Other Plots",
      "Plotting Multiple Samples"
    ],
    "cross_refs": [
      "corner.py",
      "guides/plot/start_here.ipynb"
    ],
    "notebook": "notebooks/guides/plot/searches.ipynb",
    "path": "scripts/guides/plot/searches.py",
    "summary": "This example illustrates the API for plotting the results of different non-linear searches.",
    "title": "Plots: Searches"
  },
  {
    "contents": [
      "Dataset",
      "plot_array",
      "plot_grid",
      "Customization",
      "Output",
      "Config Defaults",
      "Overlays",
      "subplot_* Functions",
      "Where To Next"
    ],
    "cross_refs": [
      "plot.py",
      "scripts/guides/plot/plotters.py",
      "scripts/guides/plot/searches.py",
      "scripts/guides/plot/visuals.py",
      "scripts/imaging/plot.py",
      "scripts/interferometer/plot.py",
      "scripts/point_source/plot.py"
    ],
    "notebook": "notebooks/guides/plot/start_here.ipynb",
    "path": "scripts/guides/plot/start_here.py",
    "summary": "This example introduces the PyAutoLens plotting API.",
    "title": "Plots: Start Here"
  },
  {
    "contents": [
      "Setup",
      "Critical Curves",
      "Multiple Critical Curves",
      "Caustics",
      "Image Positions",
      "Light Profile Centres",
      "Mass Profile Centres",
      "Combined Overlays"
    ],
    "cross_refs": [
      "guides/plot/start_here.ipynb"
    ],
    "notebook": "notebooks/guides/plot/visuals.ipynb",
    "path": "scripts/guides/plot/visuals.py",
    "summary": "This example illustrates how to add overlays to plots.",
    "title": "Plots: Visuals (Overlays)"
  },
  {
    "contents": [],
    "cross_refs": [
      "autolens_profiling/scripts/cluster/likelihood_breakdown/image_plane.py",
      "likelihood_sanity.py",
      "scripts/cluster/likelihood_function.py"
    ],
    "notebook": "notebooks/guides/point_source_pairing.ipynb",
    "path": "scripts/guides/point_source_pairing.py",
    "summary": "When fitting multiple-image positions \u2014 the bread and butter of group- and cluster-scale lens modeling \u2014 the model tracer will not, in general, predict exactly the images you observed. A wrong (or merely uncertain) mass model predicts *extra* images that were never detected, or fails to produce an observed image at all. What the likelihood does in those two situations decides which models a sampler rewards, and historically lensing codes have handled it with quiet conventions rather than explicit choices.",
    "title": "Guide: Point-Source Pairing, Over-Prediction and Under-Prediction"
  },
  {
    "contents": [
      "Overview & Docs URL",
      "All Light Profiles (Survey)",
      "Detailed Example: Sersic Image",
      "Linear Light Profiles",
      "Operated Light Profiles",
      "Basis",
      "Light Profile in a Model",
      "Model Instance from Light Profile",
      "Multipole Light Profiles",
      "Remaining Profiles Walkthrough"
    ],
    "cross_refs": [
      "fit.py",
      "guides/data_structures.py",
      "guides/units/cosmology.ipynb",
      "likelihood_function.py",
      "modeling.py",
      "scripts/guides/profiles/mass.py",
      "scripts/guides/results/start_here.py",
      "scripts/guides/tracer.py",
      "scripts/imaging/start_here.py",
      "simulator.py",
      "tracer.py"
    ],
    "notebook": "notebooks/guides/profiles/light.ipynb",
    "path": "scripts/guides/profiles/light.py",
    "summary": "This guide is the single-page tour of every light profile available in **PyAutoLens** (all of which are re-exported from **PyAutoGalaxy**): how to construct each one, how to evaluate its image on a grid, how to compose it into a model, and how to pull an instance back out of that model.",
    "title": "Light Profiles"
  },
  {
    "contents": [
      "Overview & Docs URL",
      "All Profiles (Survey)",
      "Stellar Mass Detailed Example",
      "Dark Mass Detailed Example",
      "NFW Variants",
      "Combined Light + Mass Profiles (`al.lmp`)",
      "Linear Combined Light + Mass (`al.lmp_linear`)",
      "Composing a Decomposed Bulge+Halo Model",
      "Model Instance from Decomposed Model",
      "Remaining Profiles Walkthrough",
      "Back-References"
    ],
    "cross_refs": [
      "autogalaxy/profiles/light_and_mass_profiles.py",
      "guides/units/cosmology.ipynb",
      "light.py",
      "mass.py",
      "scripts/guides/modeling/slam_start_here.py",
      "scripts/guides/profiles/light.py",
      "scripts/guides/profiles/light_and_mass_profiles.py",
      "scripts/guides/profiles/mass.py",
      "scripts/guides/results/start_here.py",
      "scripts/imaging/start_here.py"
    ],
    "notebook": "notebooks/guides/profiles/light_and_mass_profiles.ipynb",
    "path": "scripts/guides/profiles/light_and_mass_profiles.py",
    "summary": "This guide is the third and final entry in the `scripts/guides/profiles/` trilogy.  It covers the *stellar*, *dark-matter*, and *combined light-and-mass* profiles \u2014 the ones used to decompose a lens galaxy into its constituent matter components rather than to model the total mass with a single parametric profile.",
    "title": "Light-and-Mass Profiles"
  },
  {
    "contents": [
      "Overview & Docs URL",
      "All Mass Profiles (Survey)",
      "Detailed Example: Isothermal",
      "Mass Sheets",
      "Point Mass",
      "Mass Profile in a Model",
      "Model Instance from Mass Profile",
      "Multipole Mass Profile",
      "Remaining Profiles Walkthrough",
      "Follow-Up"
    ],
    "cross_refs": [
      "guides/units/cosmology.ipynb",
      "light.py",
      "light_and_mass_profiles.py",
      "scripts/guides/profiles/light.py",
      "scripts/guides/profiles/light_and_mass_profiles.py",
      "scripts/guides/results/start_here.py",
      "scripts/guides/tracer.py",
      "scripts/imaging/start_here.py"
    ],
    "notebook": "notebooks/guides/profiles/mass.ipynb",
    "path": "scripts/guides/profiles/mass.py",
    "summary": "This guide is the single-page tour of every lensing mass profile available in **PyAutoLens** (re-exported from **PyAutoGalaxy**): how to construct each one, how to evaluate its convergence and deflections on a grid, how to compose it into a model, and how to pull an instance back out of that model.",
    "title": "Mass Profiles"
  },
  {
    "contents": [],
    "cross_refs": [
      "start_here.py"
    ],
    "notebook": "notebooks/guides/results/_quick_fit.ipynb",
    "path": "scripts/guides/results/_quick_fit.py",
    "summary": "Internal helper invoked via subprocess from the tutorials in this folder. Produces two fast, capped Nautilus fits at ``output/results_folder/`` so the aggregator and workflow examples have a populated results directory to read from.",
    "title": "Results: Quick Fit Helper"
  },
  {
    "contents": [
      "Interferometer",
      "Aggregator",
      "Fits via Aggregator",
      "Modification",
      "Visualization Customization"
    ],
    "cross_refs": [
      "aggregator/models.py",
      "start_here.py"
    ],
    "notebook": "notebooks/guides/results/aggregator/data_fitting.ipynb",
    "path": "scripts/guides/results/aggregator/data_fitting.py",
    "summary": "In this tutorial, we use the aggregator to load models and data from a non-linear search and use them to perform fits to the data.",
    "title": "Results: Data Fitting"
  },
  {
    "contents": [
      "Units",
      "Data Structures",
      "Model Fit",
      "Max Likelihood Tracer",
      "Refitting",
      "Samples API",
      "Max Likelihood Fit",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/data_structures.ipynb",
      "/guides/galaxies.ipynb",
      "/guides/tracer.ipynb",
      "/imaging/fit.ipynb",
      "_quick_fit.py",
      "guides/units/cosmology.ipynb",
      "imaging/start_here.py",
      "results/start_here.ipynb"
    ],
    "notebook": "notebooks/guides/results/aggregator/galaxies_fits.ipynb",
    "path": "scripts/guides/results/aggregator/galaxies_fits.py",
    "summary": "This tutorial inspects an inferred model using galaxies inferred by the non-linear search. This allows us to visualize and interpret its results.",
    "title": "Results: Galaxies and Fits"
  },
  {
    "contents": [],
    "cross_refs": [],
    "notebook": "notebooks/guides/results/aggregator/interferometer.ipynb",
    "path": "scripts/guides/results/aggregator/interferometer.py",
    "summary": "> For interferometric data, which units PyAutoLens uses for brightness? I think they are in Jy/arcsec^2 (?) since I have computed the magnification from from my original image in Jy/beam I just wanted to be sure that the conversions I have assumed are fine.",
    "title": "This script still needs writing, I have kept some notes on questions asked by users which may help you..."
  },
  {
    "contents": [
      "Aggregator",
      "Tracer via Aggregator",
      "Einstein Mass Example"
    ],
    "cross_refs": [
      "start_here.py"
    ],
    "notebook": "notebooks/guides/results/aggregator/models.ipynb",
    "path": "scripts/guides/results/aggregator/models.py",
    "summary": "In this tutorial, we use the aggregator to load models and `Tracer`'s from a non-linear search. This allows us to visualize and interpret its results.",
    "title": "Results: Models"
  },
  {
    "contents": [
      "Aggregator",
      "Unique Tag",
      "Search Name",
      "Model Queries",
      "Logic"
    ],
    "cross_refs": [
      "start_here.py"
    ],
    "notebook": "notebooks/guides/results/aggregator/queries.ipynb",
    "path": "scripts/guides/results/aggregator/queries.py",
    "summary": "Suppose we have the results of many fits in the database and we only wanted to load and inspect a specific set of model-fits (e.g. the results of `tutorial_1_introduction`). We can use the database's querying tools to only load the results we are interested in.",
    "title": "Results: Queries"
  },
  {
    "contents": [
      "Units",
      "Model Fit",
      "Info",
      "Plot",
      "Samples",
      "Parameters",
      "Figures of Merit",
      "Instances",
      "Errors",
      "Sample Instance",
      "Search Plots",
      "Maximum Likelihood",
      "Bayesian Evidence",
      "Lists",
      "Latex"
    ],
    "cross_refs": [
      "GetDist.py",
      "_quick_fit.py",
      "fit.py",
      "guides/units/cosmology.ipynb",
      "imaging/start_here.py",
      "results/start_here.ipynb",
      "tracer.py"
    ],
    "notebook": "notebooks/guides/results/aggregator/samples.ipynb",
    "path": "scripts/guides/results/aggregator/samples.py",
    "summary": "After a non-linear search has completed, it returns a `Result` object that contains information on samples of the non-linear search, such as the maximum likelihood model instance, the errors on each parameter and the Bayesian evidence.",
    "title": "Results: Samples"
  },
  {
    "contents": [
      "Samples via Result",
      "Files",
      "Aggregator",
      "Generators",
      "Samples",
      "Parameters",
      "Samples Info",
      "Figures of Merit",
      "Samples Summary",
      "Maximum Likelihood Model",
      "Parameter Names",
      "Instances",
      "Errors",
      "Sample Instance",
      "Search Plots",
      "Maximum Likelihood",
      "Bayesian Evidence",
      "Lists",
      "Latex",
      "Ordering",
      "Samples Filtering"
    ],
    "cross_refs": [
      "/guides/results/aggregator/samples.py",
      "GetDist.py",
      "samples.py",
      "start_here.py"
    ],
    "notebook": "notebooks/guides/results/aggregator/samples_via_aggregator.ipynb",
    "path": "scripts/guides/results/aggregator/samples_via_aggregator.py",
    "summary": "In the script `autogalaxy_workspace/*/guides/results/aggregator/samples.py` we show how to inspect the non-linear search samples from a result.",
    "title": "Results: Samples via Aggregator"
  },
  {
    "contents": [
      "Model",
      "Unique Identifiers",
      "Dataset",
      "Results From Hard Disk",
      "Sample Retention",
      "Building a Database File From an Output Folder",
      "Writing Directly To Database",
      "Files",
      "Generators",
      "Search",
      "Samples",
      "Wrap Up"
    ],
    "cross_refs": [
      "//docs.py"
    ],
    "notebook": "notebooks/guides/results/database/start_here.ipynb",
    "path": "scripts/guides/results/database/start_here.py",
    "summary": "The default behaviour of model-fitting results output is to be written to hard-disc in folders. These are simple to navigate and manually check.",
    "title": "Database: Introduction"
  },
  {
    "contents": [
      "Lensing Latents in PyAutoLens: The eight library-shipped latents and what each one means physically.",
      "Toggling Latents: The workspace ``config/latent.yaml`` override.",
      "Model Fit: Reuse the shared quick fit (``_quick_fit.py``) that produces real latent output.",
      "Loading Latent Results: ``analysis.compute_latent_samples`` over a subset of PDF draws, and the two",
      "Extending with a Custom Latent: Subclass ``al.AnalysisImaging`` to add lens-mass derived quantities.",
      "Contributing Upstream: When your custom latent is general enough, promote it to the library."
    ],
    "cross_refs": [
      "../../../autofit_workspace/scripts/cookbooks/latent_variables.py",
      "_quick_fit.py",
      "aggregator/models.py",
      "autolens/analysis/latent.py",
      "euclid_strong_lens_modeling_pipeline/util.py",
      "scripts/guides/units/flux.py",
      "start_here.py",
      "test_autolens/analysis/test_latent.py"
    ],
    "notebook": "notebooks/guides/results/latent_variables.ipynb",
    "path": "scripts/guides/results/latent_variables.py",
    "summary": "PyAutoLens ships a curated catalogue of lensing-specific latent variables \u2014 quantities derived from the lens model that aren't sampled directly but are computed from each posterior draw to give you Bayesian uncertainties on the science quantities you actually care about. This tutorial shows the catalogue, how to toggle individual latents via the workspace config, how to load latent results from a completed fit, and how to extend ``al.AnalysisImaging`` with your own derived quantities.",
    "title": "Results: Latent Variables"
  },
  {
    "contents": [
      "Model Fit",
      "Info"
    ],
    "cross_refs": [
      "/guides/results/aggregator/galaxies_fits.py",
      "/guides/results/aggregator/samples.py",
      "/guides/tracer.py",
      "/guides/units/cosmology.py",
      "/imaging/features/linear_light_profiles/fit.py",
      "/imaging/features/pixelization/fit.py",
      "/imaging/fit.py",
      "/imaging/start_here.ipynb",
      "_quick_fit.py",
      "aggregator/samples.py",
      "csv_maker.py",
      "fits_maker.py",
      "png_maker.py"
    ],
    "notebook": "notebooks/guides/results/start_here.ipynb",
    "path": "scripts/guides/results/start_here.py",
    "summary": "After a lens model-fit completes, nearly everything a user could need is written to the `output/` folder. Most of it can be loaded back into full Python objects with a single line of code, via either `.json` files (for model objects like the `Tracer`, `Model` and samples) or `.fits` files (for imaging products like the model image, residuals and source-plane images).",
    "title": "Results: Start Here"
  },
  {
    "contents": [
      "Interferometer",
      "Database File",
      "Model Fit",
      "Workflow Paths",
      "Aggregator",
      "Model Paths",
      "Adding CSV Columns",
      "Saving the CSV",
      "Customizing CSV Headers",
      "Maximum Likelihood Values",
      "Errors",
      "Column Label List",
      "Latent Variables",
      "Computed Columns"
    ],
    "cross_refs": [
      "_quick_fit.py",
      "fits_make.py",
      "png_make.py",
      "start_here.py"
    ],
    "notebook": "notebooks/guides/results/workflow/csv_make.ipynb",
    "path": "scripts/guides/results/workflow/csv_make.py",
    "summary": "This example is a results workflow example, which means it provides tool to set up an effective workflow inspecting and interpreting the large libraries of modeling results.",
    "title": "Results: CSV"
  },
  {
    "contents": [
      "Interferometer",
      "Database File",
      "Model Fit",
      "Workflow Paths",
      "Aggregator",
      "Extract Images",
      "Output Single Fits",
      "Output to Folder",
      "Naming Convention",
      "CSV Files",
      "Add Extra Fits",
      "Custom Fits Files in Analysis",
      "Path Navigation"
    ],
    "cross_refs": [
      "_quick_fit.py",
      "png_make.py",
      "start_here.py"
    ],
    "notebook": "notebooks/guides/results/workflow/fits_make.ipynb",
    "path": "scripts/guides/results/workflow/fits_make.py",
    "summary": "This example is a results workflow example, which means it provides tool to set up an effective workflow inspecting and interpreting the large libraries of modeling results.",
    "title": "Results: Fits Make"
  },
  {
    "contents": [
      "Interferometer",
      "Database File",
      "Model Fit",
      "Workflow Paths",
      "Aggregator",
      "Extract Images",
      "Output Single Png",
      "Output to Folder",
      "Naming Convention",
      "Combine Images From Subplots",
      "Custom Subplots in Analysis",
      "Path Navigation"
    ],
    "cross_refs": [
      "_quick_fit.py",
      "fits_make.py",
      "start_here.py"
    ],
    "notebook": "notebooks/guides/results/workflow/png_make.ipynb",
    "path": "scripts/guides/results/workflow/png_make.py",
    "summary": "This example is a results workflow example, which means it provides tool to set up an effective workflow inspecting and interpreting the large libraries of modeling results.",
    "title": "Results: PNG Make"
  },
  {
    "contents": [
      "JAX",
      "Units",
      "Data Structures",
      "Other Models",
      "Grids",
      "Light Profiles",
      "Mass Profiles",
      "Galaxies",
      "Ray Tracing",
      "Log10",
      "Extending Objects",
      "Attributes",
      "Lensing Quantities",
      "Grid Choices",
      "Sub Gridding",
      "Positions Grid",
      "Scalar Lensing Quantities",
      "Vector Quantities",
      "Other Vector Lensing Quantities",
      "Other Quantities"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoGalaxy/blob/main/autogalaxy/operate/deflections.py",
      "/guides/data_structures.ipynb",
      "galaxies.py",
      "guides/advanced/over_sampling.py",
      "guides/data_structures.py",
      "guides/units/cosmology.ipynb",
      "imaging/features/linear_light_profiles/fit.py",
      "imaging/features/pixelization/fit.py",
      "results/start_here.ipynb",
      "scripts/guides/using_jax.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/guides/tracer.ipynb",
    "path": "scripts/guides/tracer.py",
    "summary": "This tutorial inspects an inferred model using the `Tracer` object inferred by the non-linear search. This allows us to visualize and interpret its results.",
    "title": "Tracer"
  },
  {
    "contents": [
      "Errors",
      "Tracer",
      "Arcsec to Kiloparsec",
      "Einstein Radius",
      "Einstein Mass",
      "Convergence"
    ],
    "cross_refs": [
      "results/aggregator/samples.ipynb"
    ],
    "notebook": "notebooks/guides/units/cosmology.ipynb",
    "path": "scripts/guides/units/cosmology.py",
    "summary": "This tutorial illustrates how to perform unit conversions from **PyAutoLens**'s internal units (e.g. arc-seconds, electrons per second, dimensionless mass units) to physical units (e.g. kiloparsecs, magnitudes, solar masses).",
    "title": "Units and Cosmology"
  },
  {
    "contents": [
      "Zero Point",
      "Total Flux",
      "Latent Variables"
    ],
    "cross_refs": [],
    "notebook": "notebooks/guides/units/flux.ipynb",
    "path": "scripts/guides/units/flux.py",
    "summary": "Absolute flux calibration in Astronomy is the process of converting the number of photons detected by a telescope into a physical unit of luminosity or a magnitude. For example, a luminosity might be given in units of solar luminosities or the brightness of a galaxy quoted as a magnitude in units of AB magnitudes.",
    "title": "Flux"
  },
  {
    "contents": [],
    "cross_refs": [],
    "notebook": "notebooks/guides/units/mass_to_light_ratio_units.ipynb",
    "path": "scripts/guides/units/mass_to_light_ratio_units.py",
    "summary": "This guide is in development and not written with extensive text and descrptions (yet!).",
    "title": "Author: Kaihao Wang"
  },
  {
    "contents": [
      "Auto-Enabled Modeling",
      "Disabling JAX",
      "Writing @jax.jit Yourself",
      "Custom Likelihood Functions",
      "JIT-ing Library Methods",
      "Pytree Registration",
      "The Pairing Rule",
      "Grids Stay Outside the Boundary",
      "Bound Methods and the JIT Cache",
      "Return-Type Contract"
    ],
    "cross_refs": [
      "autofit.jax.py",
      "likelihood_function.py",
      "scripts/imaging/likelihood_function.py",
      "scripts/imaging/simulator.py",
      "scripts/interferometer/likelihood_function.py",
      "scripts/point_source/simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/guides/using_jax.ipynb",
    "path": "scripts/guides/using_jax.py",
    "summary": "**PyAutoLens** runs on either **NumPy** (the default) or **JAX** (Google's array library with GPU support and just-in-time compilation). JAX makes lens modeling 10-100x faster on large grids \u2014 sometimes more on GPU \u2014 so the library is built to use it automatically wherever it helps.",
    "title": "Using JAX"
  },
  {
    "contents": [
      "Pixel Scale",
      "Loading Data From Individual Fits Files",
      "Converting Data To Electrons Per Second",
      "Resizing Data",
      "Background Subtraction"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoArray/blob/main/autoarray/dataset/preprocess.py",
      "/imaging/data_preparation/examples/noise_map.py",
      "data_preparation/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/data.ipynb",
    "path": "scripts/imaging/data_preparation/examples/data.py",
    "summary": "The image is the image of your galaxy, which comes from a telescope like the Hubble Space telescope (HST).",
    "title": "Data Preparation: Image"
  },
  {
    "contents": [
      "Pixel Scale",
      "Loading Data From Individual Fits Files",
      "1) Tools Illustrated In Image",
      "Noise Conversions"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoArray/blob/main/autoarray/dataset/preprocess.py",
      "data_preparation/examples/data.ipynb",
      "data_preparation/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/noise_map.ipynb",
    "path": "scripts/imaging/data_preparation/examples/noise_map.py",
    "summary": "The noise-map defines the uncertainty in every pixel of your lens image, where values are defined as the RMS standard deviation in every pixel (not the variances, HST WHT-map values, etc.).",
    "title": "Data Preparation: Noise-map"
  },
  {
    "contents": [
      "Masking Extra Galaxies",
      "Output"
    ],
    "cross_refs": [
      "/imaging/data_preparation/gui/extra_galaxies_centres.py",
      "data_preparation/gui/extra_galaxies_centres.ipynb",
      "data_preparation/start_here.ipynb",
      "mask_extra_galaxies.py"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/optional/extra_galaxies_centres.ipynb",
    "path": "scripts/imaging/data_preparation/examples/optional/extra_galaxies_centres.py",
    "summary": "There may be extra galaxies nearby the lens and source galaxies, whose emission blends with the lens and source and whose mass may contribute to the ray-tracing and lens model.",
    "title": "Data Preparation: Extra Galaxies (Optional)"
  },
  {
    "contents": [],
    "cross_refs": [
      "data_preparation/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/optional/info.ipynb",
    "path": "scripts/imaging/data_preparation/examples/optional/info.py",
    "summary": "Auxiliary information about a strong lens dataset may used during an analysis or afterwards when interpreting the modeling results. For example, the redshifts of the source and lens galaxy.",
    "title": "Data Preparation: Info (Optional)"
  },
  {
    "contents": [],
    "cross_refs": [
      "/imaging/data_preparation/gui/lens_light_centre.py",
      "data_preparation/gui/lens_light_centre.ipynb",
      "data_preparation/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/optional/lens_light_centre.ipynb",
    "path": "scripts/imaging/data_preparation/examples/optional/lens_light_centre.py",
    "summary": "This script marks the (y,x) arcsecond locations of the lens galaxy light centre(s) of the strong lens you are analysing. These can be used as fixed values for the lens light and mass models in a model-fit.",
    "title": "Data Preparation: Lens Light Centre (Optional)"
  },
  {
    "contents": [],
    "cross_refs": [
      "/imaging/data_preparation/gui/mask.py",
      "data_preparation/examples/optional/mask.ipynb",
      "data_preparation/gui/mask.ipynb",
      "data_preparation/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/optional/mask.ipynb",
    "path": "scripts/imaging/data_preparation/examples/optional/mask.py",
    "summary": "The mask removes the regions of the image where the lens and source galaxy are not present, typically the edges of the image.",
    "title": "Data Preparation: Mask (Optional)"
  },
  {
    "contents": [
      "Output"
    ],
    "cross_refs": [
      "/imaging/data_preparation/gui/mask_extra_galaxies.py",
      "data_preparation/gui/mask_extra_galaxies.ipynb",
      "data_preparation/start_here.ipynb",
      "scripts/imaging/features/extra_galaxies/simulator.py"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/optional/mask_extra_galaxies.ipynb",
    "path": "scripts/imaging/data_preparation/examples/optional/mask_extra_galaxies.py",
    "summary": "There may be regions of an image that have signal near the lens and source that is from other galaxies not associated with the strong lens we are studying. The emission from these images will impact our model fitting and needs to be removed from the analysis.",
    "title": "Data Preparation: Extra Galaxies Mask (Optional)"
  },
  {
    "contents": [],
    "cross_refs": [
      "data_preparation/gui/positions.ipynb",
      "data_preparation/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/optional/positions.ipynb",
    "path": "scripts/imaging/data_preparation/examples/optional/positions.py",
    "summary": "The script manually marks the (y,x) arc-second positions of the multiply imaged lensed source galaxy in the image-plane, under the assumption that they originate from the same location in the source-plane.",
    "title": "Data Preparation: Positions (Optional)"
  },
  {
    "contents": [
      "Pixel Scale",
      "Loading Data From Individual Fits Files",
      "PSF Dimensions",
      "PSF Normalization"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoArray/blob/main/autoarray/dataset/preprocess.py",
      "data_preparation/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/data_preparation/examples/psf.ipynb",
    "path": "scripts/imaging/data_preparation/examples/psf.py",
    "summary": "The Point Spread Function (PSF) describes blurring due the optics of your dataset`s telescope. It is used by PyAutoLens when fitting a dataset to include these effects, such that does not bias the model.",
    "title": "Data Preparation: PSF"
  },
  {
    "contents": [
      "Dataset",
      "Search Box",
      "Clicker",
      "Output"
    ],
    "cross_refs": [
      "clicker.py",
      "imaging/data_preparation/examples/optional/extra_galaxies_centres.py"
    ],
    "notebook": "notebooks/imaging/data_preparation/gui/extra_galaxies_centres.ipynb",
    "path": "scripts/imaging/data_preparation/gui/extra_galaxies_centres.py",
    "summary": "There may be extra galaxies nearby the lens and source galaxies, whose emission blends with the lens and source and whose mass may contribute to the ray-tracing and lens model.",
    "title": "GUI Preprocessing: Extra Galaxies Centres"
  },
  {
    "contents": [
      "Dataset",
      "Search Box",
      "Clicker",
      "Output"
    ],
    "cross_refs": [
      "clicker.py"
    ],
    "notebook": "notebooks/imaging/data_preparation/gui/lens_light_centre.ipynb",
    "path": "scripts/imaging/data_preparation/gui/lens_light_centre.py",
    "summary": "This tool allows one to input the lens light centre(s) of a strong lens(es) via a GUI, which can be used as a fixed value in pipelines.",
    "title": "GUI Preprocessing: Lens Light Centre"
  },
  {
    "contents": [
      "Dataset",
      "Scribbler",
      "Output"
    ],
    "cross_refs": [],
    "notebook": "notebooks/imaging/data_preparation/gui/mask.ipynb",
    "path": "scripts/imaging/data_preparation/gui/mask.py",
    "summary": "This tool allows one to mask a bespoke mask for a given image of a strong lens using an interactive GUI. This mask can then be loaded before a pipeline is run and passed to that pipeline so as to become the default masked used by a search (if a mask function is not passed to that search).",
    "title": "GUI Preprocessing: Mask"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Scribbler",
      "Output"
    ],
    "cross_refs": [
      "imaging/data_preparation/examples/optional/mask_extra_galaxies.py"
    ],
    "notebook": "notebooks/imaging/data_preparation/gui/mask_extra_galaxies.ipynb",
    "path": "scripts/imaging/data_preparation/gui/mask_extra_galaxies.py",
    "summary": "There may be regions of an image that have signal near the lens and source that is from other galaxies not associated with the strong lenswe are studying. The emission from these images will impact our model fitting and needs to be removed from the analysis.",
    "title": "GUI Preprocessing: Extra Galaxies Mask (Optional)"
  },
  {
    "contents": [
      "Dataset",
      "Search Box",
      "Clicker",
      "Output"
    ],
    "cross_refs": [
      "clicker.py"
    ],
    "notebook": "notebooks/imaging/data_preparation/gui/positions.ipynb",
    "path": "scripts/imaging/data_preparation/gui/positions.py",
    "summary": "This tool allows one to input the positions of strong lenses via a GUI, which can be used to penalize inaccurate mass models during lensing modeling.",
    "title": "GUI Preprocessing: Positions"
  },
  {
    "contents": [],
    "cross_refs": [],
    "notebook": "notebooks/imaging/data_preparation/manual/mask_irregular.ipynb",
    "path": "scripts/imaging/data_preparation/manual/mask_irregular.py",
    "summary": "(no summary in script docstring)",
    "title": "Manual Preprocessing: Mask Irregular"
  },
  {
    "contents": [
      "Pixel Scale",
      "Image",
      "Noise Map",
      "PSF",
      "Data Processing Complete"
    ],
    "cross_refs": [
      "data_preparation/examples/optional/extra_galaxies_centres.py",
      "data_preparation/examples/optional/info.py",
      "data_preparation/examples/optional/lens_light_centre.py",
      "data_preparation/examples/optional/mask.ipynb",
      "data_preparation/examples/optional/mask_extra_galaxies.py",
      "data_preparation/examples/optional/positions.ipynb",
      "data_preparation/gui/extra_galaxies_centres.ipynb",
      "data_preparation/gui/lens_light_centre.ipynb",
      "data_preparation/gui/mask.ipynb",
      "data_preparation/gui/mask_extra_galaxies.ipynb",
      "data_preparation/gui/positions.ipynb",
      "extra_galaxies_centres.py",
      "features/extra_galaxies/modeling.py",
      "imaging/data_preparation/examples/data.ipynb",
      "imaging/data_preparation/examples/noise_map.ipynb",
      "imaging/data_preparation/examples/psf.ipynb",
      "mask_extra_galaxies.py"
    ],
    "notebook": "notebooks/imaging/data_preparation/start_here.ipynb",
    "path": "scripts/imaging/data_preparation/start_here.py",
    "summary": "When a CCD imaging dataset is analysed, it must conform to certain standards in order for the analysis to be performed correctly. This tutorial describes these standards and links to more detailed scripts which will help you prepare your dataset to adhere to them if it does not already.",
    "title": "Imaging: Data Preparation"
  },
  {
    "contents": [
      "Dataset",
      "Paths",
      "Masking (Search 1)",
      "Model (Search 1)",
      "Search + Analysis + Model-Fit (Search 1)",
      "Result (Search 1)",
      "Masking (Search 2)",
      "Model (Search 2)",
      "Search + Analysis + Model-Fit (Search 2)",
      "Result (Search 2)",
      "Wrap Up",
      "Pipelines"
    ],
    "cross_refs": [
      "guides/modeling/chaining.ipynb",
      "notebooks/imaging/features/advanced/double_source_plane_lens/chaining.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/double_source_plane_lens/chaining.ipynb",
    "path": "scripts/imaging/features/advanced/double_source_plane_lens/chaining.py",
    "summary": "This script chains two searches to fit `Imaging` data of a 'galaxy-scale' strong lens which has two source galaxies at two different redshifts, forming a double source-plane lens (DSPL). This fits a model where:",
    "title": "Chaining: DSPL"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask",
      "Over Sampling",
      "MGE Basis",
      "Galaxies",
      "Tracer",
      "Fit",
      "Multi-Plane Ray-Tracing",
      "Intensities",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/fit.py",
      "autolens_workspace/scripts/imaging/fit.py",
      "chaining.py",
      "modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/double_source_plane_lens/fit.ipynb",
    "path": "scripts/imaging/features/advanced/double_source_plane_lens/fit.py",
    "summary": "A double source-plane lens (DSPL) is a strong lens system where two source galaxies at different redshifts are lensed by the foreground lens galaxy. They appear as two distinct Einstein rings in the image-plane.",
    "title": "Features: DSPL Fit"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask",
      "Galaxies",
      "Multi-Plane Ray-Tracing",
      "Source-Plane Images",
      "Model Image",
      "Likelihood",
      "Fit Check",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "autolens_workspace/scripts/imaging/likelihood_function.py",
      "imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "imaging/likelihood_function.py",
      "modeling.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/double_source_plane_lens/likelihood_function.ipynb",
    "path": "scripts/imaging/features/advanced/double_source_plane_lens/likelihood_function.py",
    "summary": "This script describes the additional steps required to compute the `log_likelihood` for a double source-plane lens (DSPL) \u2014 a strong lens system with two source galaxies at different redshifts behind the foreground lens.",
    "title": "__Log Likelihood Function: DSPL__"
  },
  {
    "contents": [
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Model Cookbook",
      "Cheating",
      "Cosmology",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "autolens_workspace/scripts/imaging/features/advanced/double_source_plane_lens/chaining.py",
      "chaining.py",
      "features/advanced/shapelets/modeling.ipynb",
      "features/multi_gaussian_expansion/modeling.ipynb",
      "features/pixelization/modeling.ipynb",
      "imaging/features/advanced/double_source_plane_lens/chaining.py",
      "imaging/start_here.ipynb",
      "slam.py",
      "start.here.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/double_source_plane_lens/modeling.ipynb",
    "path": "scripts/imaging/features/advanced/double_source_plane_lens/modeling.py",
    "summary": "A double source-plane lens (DSPL) is a strong lens system where there are two source galaxies at different redshifts behind the lens galaxy. They appear as two distinct Einstein rings in the image-plane, and can constrain Cosmological parameters in a way single Einstein ring lenses cannot.",
    "title": "Modeling Features: DSPL"
  },
  {
    "contents": [
      "Setup",
      "Fit Imaging",
      "Per-Plane Images",
      "Full Subplot",
      "Pixelized Source Reconstruction",
      "Inversion"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "scripts/imaging/plot.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/double_source_plane_lens/plot.ipynb",
    "path": "scripts/imaging/features/advanced/double_source_plane_lens/plot.py",
    "summary": "This example illustrates the plotting API for double source-plane lenses (DSPLs), which have more than two planes at different redshifts.",
    "title": "Plots: DSPL"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "imaging/features/advanced/double_source_plane_lens/modeling.py",
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/double_source_plane_lens/simulator.ipynb",
    "path": "scripts/imaging/features/advanced/double_source_plane_lens/simulator.py",
    "summary": "A double source-plane lens (DSPL) is a strong lens system where there are two source galaxies at different redshifts behind the lens galaxy. They appear as two distinct Einstein rings in the image-plane, and can constrain Cosmological parameters in a way single Einstein ring lenses cannot.",
    "title": "Simulator: DSPL"
  },
  {
    "contents": [],
    "cross_refs": [
      "guides/modeling/slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/double_source_plane_lens/slam.ipynb",
    "path": "scripts/imaging/features/advanced/double_source_plane_lens/slam.py",
    "summary": "This script adapts the SLaM (Source, Light and Mass) pipelines to a Double Source Plane Lens (DSPL) system, where there are two source galaxies at different redshifts behind the lens galaxy. Both source galaxies must be modeled simultaneously because the first source (at the intermediate redshift) acts as both a background source of the lens galaxy and as an additional deflector for the second (higher-redshift) source.",
    "title": "SLaM (Source, Light and Mass): DSPL"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Grid",
      "Over Sampling",
      "PSF",
      "Simulator",
      "LOS Configuration",
      "Sample LOS Halos",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json",
      "LOS Diagnostics"
    ],
    "cross_refs": [],
    "notebook": "notebooks/imaging/features/advanced/los_halos/simulator.ipynb",
    "path": "scripts/imaging/features/advanced/los_halos/simulator.py",
    "summary": "This script simulates a strong gravitational lens including line-of-sight (LOS) dark matter halos that perturb the lensed images via multi-plane ray tracing.",
    "title": "Simulator: Line-of-Sight Halos"
  },
  {
    "contents": [
      "LOS Configuration",
      "Sample LOS Halos",
      "Grid",
      "PSF",
      "Lens Galaxy and Source Galaxy",
      "Convert to Padded Arrays",
      "Scaling Matrix",
      "Parameterized Functions",
      "Single Realisation",
      "Batched Realisations"
    ],
    "cross_refs": [
      "simulator.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/los_halos/simulator_jax.ipynb",
    "path": "scripts/imaging/features/advanced/los_halos/simulator_jax.py",
    "summary": "This script simulates the same strong lens configuration as ``simulator.py`` \u2014 a galaxy-scale lens with line-of-sight (LOS) dark matter halos \u2014 but uses a JAX-accelerated path that compiles the full simulation pipeline under ``jax.jit``.",
    "title": "Simulator: Line-of-Sight Halos (JAX)"
  },
  {
    "contents": [
      "Dataset + Masking",
      "Paths",
      "Model (Search 1)",
      "Search + Analysis + Model-Fit (Search 1)",
      "Result (Search 1)",
      "Model (Search 2)",
      "Search + Analysis + Model-Fit (Search 2)",
      "Result (Search 2)",
      "Wrap Up",
      "SLaM (Source, Light and Mass)"
    ],
    "cross_refs": [
      "guides/modeling/chaining.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/mass_stellar_dark/chaining.ipynb",
    "path": "scripts/imaging/features/advanced/mass_stellar_dark/chaining.py",
    "summary": "This script chains two searches to fit `Imaging` data of a 'galaxy-scale' strong lens with a model where:",
    "title": "Chaining: Chaining Lens Light To Mass"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask",
      "Over Sampling",
      "MGE Basis",
      "Galaxies",
      "Tracer",
      "Fit",
      "Decomposed Deflection",
      "Intensities",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/fit.py",
      "autolens_workspace/scripts/imaging/fit.py",
      "chaining.py",
      "modeling.py",
      "simulator.py",
      "slam.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/mass_stellar_dark/fit.ipynb",
    "path": "scripts/imaging/features/advanced/mass_stellar_dark/fit.py",
    "summary": "A decomposed mass model splits the lens galaxy's total mass into a stellar component (tied to its observed light via a mass-to-light ratio) and a dark matter component (typically an NFW halo). The total deflection at every image-plane coordinate is the sum of the deflections produced by each component, plus any external shear.",
    "title": "Features: Mass Stellar Dark Fit"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset & Mask",
      "Galaxies",
      "Decomposed Deflection",
      "Source-Plane Image",
      "Model Image",
      "Fit Check",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "autolens_workspace/scripts/imaging/likelihood_function.py",
      "imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "imaging/likelihood_function.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/mass_stellar_dark/likelihood_function.ipynb",
    "path": "scripts/imaging/features/advanced/mass_stellar_dark/likelihood_function.py",
    "summary": "This script describes the additional steps required to compute the `log_likelihood` for a strong lens whose mass model decomposes the lens galaxy's mass into a stellar component (tied to its light via a mass-to-light ratio) and a separately-parameterized dark matter halo.",
    "title": "__Log Likelihood Function: Mass Stellar Dark__"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Model Cookbook",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "autolens_workspace/scripts/imaging/features/advanced/mass_stellar_dark/chaining.py",
      "chaining.py",
      "imaging/start_here.ipynb",
      "slam.py",
      "start.here.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/mass_stellar_dark/modeling.ipynb",
    "path": "scripts/imaging/features/advanced/mass_stellar_dark/modeling.py",
    "summary": "The majority of example scripts fit a mass profile which represents the _total_ mass of the lens galaxy (its stars, dark matter and other components combined). This typically uses an `Isothermal` or `PowerLaw` mass profile.",
    "title": "Modeling Features: Mass Stellar Dark"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/advanced/mass_stellar_dark/modeling.py",
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/mass_stellar_dark/simulator.ipynb",
    "path": "scripts/imaging/features/advanced/mass_stellar_dark/simulator.py",
    "summary": "The majority of example scripts simulate a mass profile which represents the _total_ mass of the lens galaxy (its stars, dark matter and other components combined). This typically uses an `Isothermal` or `PowerLaw` mass profile.",
    "title": "Simulator: Mass Stellar Dark"
  },
  {
    "contents": [
      "Model",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS LIGHT DARK PIPELINE",
      "Dataset",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/mass_stellar_dark/slam.ipynb",
    "path": "scripts/imaging/features/advanced/mass_stellar_dark/slam.py",
    "summary": "This example shows how to use the SLaM pipelines to end with a mass model which decomposes the lens into its stars and dark matter, using a light plus dark matter mass model.",
    "title": "SLaM (Source, Light and Mass): Mass Light Dark"
  },
  {
    "contents": [
      "Model",
      "Fit",
      "Dataset & Mask",
      "Over Sampling",
      "Model Cookbook",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "fit.py",
      "imaging/fit.py",
      "imaging/start_here.ipynb",
      "linear_light_profiles.py",
      "start.here.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/operated_light_profile/modeling.ipynb",
    "path": "scripts/imaging/features/advanced/operated_light_profile/modeling.py",
    "summary": "It is common for galaxies to have point-source emission, for example bright emission right at their centre due to an active galactic nuclei or a compact knot of star formation.",
    "title": "Modeling Features: Operated Light Profiles"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "imaging/features/advanced/operated_light_profile/modeling.py",
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/operated_light_profile/simulator.ipynb",
    "path": "scripts/imaging/features/advanced/operated_light_profile/simulator.py",
    "summary": "It is common for galaxies to have point-source emission, for example bright emission right at their centre due to an active galactic nuclei or a compact knot of star formation.",
    "title": "Simulator: Light Operated"
  },
  {
    "contents": [
      "Simplifications",
      "Prerequisites",
      "Dataset",
      "Arc Mask",
      "Smooth Starting Model",
      "Dpsi Mesh",
      "Dpsi Gradient Operator",
      "Source Gradients",
      "PSF Blur Matrix",
      "Dpsi Mapping Matrix",
      "Source Inversion Blocks",
      "Joint System",
      "Solve",
      "Dkappa Map",
      "Evidence Terms",
      "Verification",
      "JAX / xp",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace_test/scripts/imaging/jax_likelihood/potential_correction.py",
      "features/pixelization/likelihood_function.py",
      "imaging/features/advanced/potential_correction/start_here.ipynb",
      "imaging/features/pixelization/likelihood_function.ipynb",
      "imaging/likelihood_function.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/potential_correction/likelihood_function.ipynb",
    "path": "scripts/imaging/features/advanced/potential_correction/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the **PyAutoLens** potential-correction `log_likelihood_function` (the Bayesian evidence of `al.pc.FitDpsiSrcImaging`), which jointly inverts `Imaging` data for a pixelized source and pixelized corrections $\\delta\\psi$ to the lensing potential.",
    "title": "__Log Likelihood Function: Potential Correction (Gravitational Imaging)__"
  },
  {
    "contents": [
      "Simulate",
      "Smooth Model Fit",
      "Joint Fit",
      "Dkappa Map",
      "Iterative Fit",
      "Evidence Sampling"
    ],
    "cross_refs": [
      "imaging/features/advanced/potential_correction/likelihood_function.ipynb",
      "interferometer/features/advanced/potential_correction/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/potential_correction/start_here.ipynb",
    "path": "scripts/imaging/features/advanced/potential_correction/start_here.py",
    "summary": "Parametric lens mass models (e.g. the `PowerLaw` used throughout the workspace) are smooth: their convergence and deflection angles vary gradually across the image plane. Real lens galaxies are not perfectly smooth. They contain substructure \u2014 dark matter subhaloes, globular clusters, satellite galaxies \u2014 and their large-scale mass distributions can depart from ellipsoidal symmetry in ways no simple parametric profile captures.",
    "title": "Potential Correction: Start Here"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Basis",
      "Coefficients",
      "Linear Light Profiles",
      "Fit",
      "Positive Negative Solver",
      "Intensities",
      "Shapelet Cartesian",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "imaging/features/multi_gaussian_expansion/modeling.py",
      "imaging/start_here.ipynb",
      "linear_light_profiles.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/shapelets/fit.ipynb",
    "path": "scripts/imaging/features/advanced/shapelets/fit.py",
    "summary": "A shapelet is a basis function that is appropriate for capturing the exponential / disk-like features of a galaxy. It has been employed in many strong lensing studies to model the light of the lensed source galaxy, because it can represent features of disky star forming galaxies that a single Sersic function cannot.",
    "title": "Modeling Features: Shapelets"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Positive Negative Solver",
      "Model Cookbook",
      "Search",
      "Position Likelihood",
      "Brief Description",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Shapelet Cartesian",
      "Cartesian Shapelets",
      "Fit",
      "Lens Shapelets",
      "Regularization",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "/imaging/data_preparation/gui/positions.py",
      "autolens_workspace_developer/basis_regularization/shapelets_lens.py",
      "imaging/start_here.ipynb",
      "linear_light_profiles.py",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/shapelets/modeling.ipynb",
    "path": "scripts/imaging/features/advanced/shapelets/modeling.py",
    "summary": "A shapelet is a basis function that is appropriate for capturing the exponential / disk-like features of a galaxy. It has been employed in many strong lensing studies to model the light of the lensed source galaxy, because it can represent features of disky star forming galaxies that a single Sersic function cannot.",
    "title": "Modeling Features: Shapelets"
  },
  {
    "contents": [
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Fit",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/sky_background/fit.ipynb",
    "path": "scripts/imaging/features/advanced/sky_background/fit.py",
    "summary": "The background of an image is the light that is not associated with the strong lens we are interested in. This is due to light from the sky, zodiacal light, and light from other galaxies in the field of view.",
    "title": "Modeling Features: Sky Background"
  },
  {
    "contents": [
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "imaging/start_here.ipynb",
      "start.here.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/sky_background/modeling.ipynb",
    "path": "scripts/imaging/features/advanced/sky_background/modeling.py",
    "summary": "The background of an image is the light that is not associated with the strong lens we are interested in. This is due to light from the sky, zodiacal light, and light from other galaxies in the field of view.",
    "title": "Modeling Features: Sky Background"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "/imaging/features/advanced/sky_background/modeling.py",
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/sky_background/simulator.ipynb",
    "path": "scripts/imaging/features/advanced/sky_background/simulator.py",
    "summary": "This script simulates `Imaging` of a strong lens where the sky background is not subtracted from the image and therefore appears in the dataset.",
    "title": "Simulator: Start Here"
  },
  {
    "contents": [
      "Model",
      "Start Here Notebooks",
      "Grid Searches",
      "Grid Search Visualization",
      "Best Fit"
    ],
    "cross_refs": [
      "guides/results/database/start_here.ipynb",
      "start_here.ipynb",
      "subhalo/detect/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/subhalo/detect/database.ipynb",
    "path": "scripts/imaging/features/advanced/subhalo/detect/database.py",
    "summary": "The example `subhalo/detect/start_here.ipynb` shows how to perform dark matter subhalo detection in strong lens with **PyAutoLens**, including using results to inspect and visualize the fit.",
    "title": "Subhalo Detection: Database"
  },
  {
    "contents": [
      "SLaM Pipelines",
      "Grid Search",
      "Pixelized Source",
      "Model",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline",
      "Bayesian Evidence",
      "Log Likelihood",
      "Grid Search Result"
    ],
    "cross_refs": [
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/advanced/subhalo/detect/start_here.ipynb",
    "path": "scripts/imaging/features/advanced/subhalo/detect/start_here.py",
    "summary": "Strong gravitational lenses can be used to detect the presence of small-scale dark matter (DM) subhalos. This occurs when the DM subhalo overlaps the lensed source emission, and therefore gravitationally perturbs the observed image of the lensed source galaxy.",
    "title": "Subhalo Detection: Start Here"
  },
  {
    "contents": [
      "Model",
      "SOURCE LP PIPELINE",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Simulate Function Class",
      "Base Fit",
      "Perturb Fit",
      "Settings AutoFit",
      "Redshifts",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "imaging/features/advanced/subhalo/sensitivity/start_here.py",
      "slam_start_here.py",
      "subhalo/detect/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/subhalo/sensitivity/slam_source_parametric.ipynb",
    "path": "scripts/imaging/features/advanced/subhalo/sensitivity/slam_source_parametric.py",
    "summary": "This example illustrates how to perform DM subhalo sensitivity mapping using a SLaM pipeline for a source modeling using light profiles.",
    "title": "SLaM (Source, Light and Mass): Subhalo Source Parametric Sensitivity Mapping"
  },
  {
    "contents": [
      "Model",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Simulate Function Class",
      "Base Fit",
      "Perturb Fit",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "imaging/features/advanced/subhalo/sensitivity/start_here.py",
      "slam_start_here.py",
      "subhalo/detect/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/subhalo/sensitivity/slam_source_pixelized.ipynb",
    "path": "scripts/imaging/features/advanced/subhalo/sensitivity/slam_source_pixelized.py",
    "summary": "This example illustrates how to perform DM subhalo sensitivity mapping using a SLaM pipeline for a dataset where the source is modeled using a pixelization.",
    "title": "SLaM (Source, Light and Mass): Subhalo Source Pixelized Sensitivity Mapping"
  },
  {
    "contents": [
      "Subhalo Detection Discussion",
      "Subhalo Sensitivity Mapping",
      "SLaM Pipelines",
      "Pixelized Source",
      "Base Model",
      "Perturb Model",
      "Mapping Grid",
      "Perturb Model Prior Func",
      "Simulation Instance",
      "Simulate Function Class",
      "Base Fit",
      "Perturb Fit",
      "Results"
    ],
    "cross_refs": [
      "subhalo/sensitivity/slam_source_pixelized.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/subhalo/sensitivity/start_here.ipynb",
    "path": "scripts/imaging/features/advanced/subhalo/sensitivity/start_here.py",
    "summary": "Bayesian model comparison allows us to take a dataset, fit it with multiple models and use the Bayesian evidence to quantify which model objectively gives the best-fit following the principles of Occam's Razor.",
    "title": "Sensitivity Mapping: Start Here"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json",
      "Subhalo Difference Image",
      "No Lens Light"
    ],
    "cross_refs": [
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/features/advanced/subhalo/simulator.ipynb",
    "path": "scripts/imaging/features/advanced/subhalo/simulator.py",
    "summary": "If a low mass dark matter halo overlaps the lensed source emission, it perturbs it in a unique and observable way.",
    "title": "Simulator: Dark Matter Subhalo"
  },
  {
    "contents": [
      "Data Preparation",
      "Dataset & Mask",
      "Extra Galaxies Over Sampling",
      "Extra Galaxies Noise Scaling",
      "Extra Galaxies Dataset",
      "Extra Galaxies Centres",
      "Model",
      "Extra Galaxies Model",
      "VRAM",
      "Run Time",
      "Result",
      "Approaches to Extra Galaxies",
      "Scaling Relations",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "/imaging/data_preparation/examples/optional/extra_galaxies_centres.py",
      "/imaging/data_preparation/examples/optional/mask_extra_galaxies.py",
      "cluster/modeling.py",
      "group/modeling.py",
      "imaging/start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/extra_galaxies/modeling.ipynb",
    "path": "scripts/imaging/features/extra_galaxies/modeling.py",
    "summary": "There may be extra galaxies nearby the lens and source galaxies, whose emission blends with the lens and source and whose mass may contribute to the ray-tracing and lens model.",
    "title": "Modeling Features: Extra Galaxies"
  },
  {
    "contents": [
      "Model",
      "Other Scripts",
      "Dataset Paths",
      "Simulate",
      "Galaxies",
      "Extra Galaxies",
      "Output",
      "Mask Extra Galaxies",
      "Visualize",
      "Tracer json",
      "Multiple Images"
    ],
    "cross_refs": [
      "/imaging/data_preparation/examples/optional/extra_galaxies_centres.ipynb",
      "/imaging/data_preparation/examples/optional/mask_extra_galaxies.ipynb",
      "/imaging/features/extra_galaxies/modeling.ipynb",
      "imaging/features/extra_galaxies/modeling.py",
      "imaging/features/pixelization/modeling.py",
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/features/extra_galaxies/simulator.ipynb",
    "path": "scripts/imaging/features/extra_galaxies/simulator.py",
    "summary": "Certain lenses have small galaxies within their Einstein radius, or nearby the lensed source emission.",
    "title": "Simulator: Extra Galaxies"
  },
  {
    "contents": [
      "Prerequisites",
      "Group SLaM",
      "This Script",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Extra Galaxies Centres",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "features/extra_galaxies/modeling.ipynb",
      "guides/modeling/slam_start_here.ipynb",
      "scripts/group/slam.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/extra_galaxies/slam.ipynb",
    "path": "scripts/imaging/features/extra_galaxies/slam.py",
    "summary": "This script uses the SLaM pipelines to fit a lens dataset that includes extra galaxies surrounding the main lens, whose light and mass are both included in the model.",
    "title": "Extra Galaxies: SLaM"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "Model",
      "Notes",
      "Dataset & Mask",
      "Over Sampling",
      "Fit",
      "Intensities",
      "Visualization",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "imaging/start_here.ipynb",
      "imaging/start_here.py"
    ],
    "notebook": "notebooks/imaging/features/linear_light_profiles/fit.ipynb",
    "path": "scripts/imaging/features/linear_light_profiles/fit.py",
    "summary": "A \"linear light profile\" is a variant of a standard light profile where the `intensity` parameter is solved for via linear algebra every time the model is fitted to the data. This uses a process called an \"inversion\" and it always computes the `intensity` values that give the best fit to the data (e.g. maximize the likelihood) given the light profile's other parameters.",
    "title": "Modeling Features: Linear Light Profiles Fit"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset",
      "Masked Image Grid",
      "Linear Light Profiles",
      "LightProfileLinearObjFuncList",
      "Mapping Matrix",
      "Combining Matrices",
      "Image Reconstruction",
      "Likelihood Function",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "contributor_guide.py",
      "imaging/likelihood_function.ipynb",
      "imaging/likelihood_function.py"
    ],
    "notebook": "notebooks/imaging/features/linear_light_profiles/likelihood_function.ipynb",
    "path": "scripts/imaging/features/linear_light_profiles/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Imaging` data with linear light profiles (e.g. a Sersic bulge and Exponential disk).",
    "title": "__Log Likelihood Function: Linear Light Profile__"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "Model",
      "Notes",
      "Dataset & Mask",
      "Over Sampling",
      "Model Cookbook",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Intensities",
      "Visualization",
      "Wrap Up",
      "Max Likelihood Inversion"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "imaging/start_here.ipynb",
      "imaging/start_here.py",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/imaging/features/linear_light_profiles/modeling.ipynb",
    "path": "scripts/imaging/features/linear_light_profiles/modeling.py",
    "summary": "A \"linear light profile\" is a variant of a standard light profile where the `intensity` parameter is solved for via linear algebra every time the model is fitted to the data. This uses a process called an \"inversion\" and it always computes the `intensity` values that give the best fit to the data (e.g. maximize the likelihood) given the light profile's other parameters.",
    "title": "Modeling Features: Linear Light Profiles"
  },
  {
    "contents": [
      "Prerequisites",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/linear_light_profiles/slam.ipynb",
    "path": "scripts/imaging/features/linear_light_profiles/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines using linear light profiles for the lens galaxy's light.",
    "title": "Linear Light Profiles: SLaM"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "MGE Source Galaxy",
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Basis",
      "Gaussians",
      "Linear Light Profiles",
      "Fit",
      "Intensities",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "autolens_workspace/scripts/imaging/features/pixelization/modeling.py",
      "imaging/start_here.ipynb",
      "linear_light_profiles.py"
    ],
    "notebook": "notebooks/imaging/features/multi_gaussian_expansion/fit.ipynb",
    "path": "scripts/imaging/features/multi_gaussian_expansion/fit.py",
    "summary": "A multi Gaussian expansion (MGE) decomposes the lens light into ~15-100 Gaussians, where the `intensity` of every Gaussian is solved for via a linear algebra using a process called an \"inversion\" (see the `linear_light_profiles.py` feature for a full description of this).",
    "title": "Modeling Features: Multi Gaussian Expansion"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset",
      "Masked Image Grid",
      "Multiple Gaussians & Linear Light Profiles",
      "Basis",
      "Comparison To Linear Light Profiles Example",
      "LightProfileLinearObjFuncList",
      "Combining Matrices",
      "Mapping Matrix",
      "Image Reconstruction",
      "Likelihood Function",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Galaxy Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "contributor_guide.py",
      "imaging/features/linear_light_profiles/likelihood_function.ipynb",
      "imaging/features/linear_light_profiles/likelihood_function.py",
      "imaging/likelihood_function.ipynb",
      "imaging/likelihood_function.py"
    ],
    "notebook": "notebooks/imaging/features/multi_gaussian_expansion/likelihood_function.ipynb",
    "path": "scripts/imaging/features/multi_gaussian_expansion/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Imaging` data with a multi-Gaussian expansion (MGE), which is a superposition of multiple 2D Gaussian linear light profiles.",
    "title": "__Log Likelihood Function: Multi Gaussian Expansion__"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "MGE Source Galaxy",
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Model Cookbook",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Source MGE",
      "Lens Point Source",
      "Wrap Up",
      "Description"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "autolens_workspace/scripts/imaging/features/pixelization/modeling.py",
      "autolens_workspace_developer/basis_regularization/mge_lens.py",
      "imaging/start_here.ipynb",
      "linear.py",
      "linear_light_profiles.py",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/imaging/features/multi_gaussian_expansion/modeling.ipynb",
    "path": "scripts/imaging/features/multi_gaussian_expansion/modeling.py",
    "summary": "A multi Gaussian expansion (MGE) decomposes the lens light into ~15-100 Gaussians, where the `intensity` of every Gaussian is solved for via a linear algebra using a process called an \"inversion\" (see the `linear_light_profiles.py` feature for a full description of this).",
    "title": "Modeling Features: Multi Gaussian Expansion"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "imaging/features/multi_gaussian_expansion/modeling.py",
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/features/multi_gaussian_expansion/simulator.ipynb",
    "path": "scripts/imaging/features/multi_gaussian_expansion/simulator.py",
    "summary": "The morphological of massive elliptical galaxies which act as strong lens are often asymmetric and irregular, with features such as isophotal twists or radially varying elliptical components.",
    "title": "Simulator: Lens Light Asymmetric"
  },
  {
    "contents": [
      "Prerequisites",
      "Model",
      "SOURCE LP PIPELINE",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Settings AutoFit",
      "Redshifts",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/multi_gaussian_expansion/slam.ipynb",
    "path": "scripts/imaging/features/multi_gaussian_expansion/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines for fitting a lens model where the source is modeled using a Multi Gaussian Expansion (MGE).",
    "title": "Multi Gaussian Expansion: SLaM"
  },
  {
    "contents": [
      "Simulated Dataset",
      "Mask",
      "Lens",
      "Multi Gaussian Expansion Source",
      "Source Flux",
      "Source Magnification",
      "Tracer",
      "Parametric Source Models",
      "Wrap Up"
    ],
    "cross_refs": [
      "/imaging/source_science.py"
    ],
    "notebook": "notebooks/imaging/features/multi_gaussian_expansion/source_science.ipynb",
    "path": "scripts/imaging/features/multi_gaussian_expansion/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy (or galaxies).",
    "title": "Source Science"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Fit",
      "Model Cookbook",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/start_here.ipynb",
      "start.here.py",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/imaging/features/no_lens_light/modeling.ipynb",
    "path": "scripts/imaging/features/no_lens_light/modeling.py",
    "summary": "CCD imaging data of a strong lens may not have lens galaxy light emission present, for example if the lens galaxy light has already been subtracted from the image.",
    "title": "Modeling Features: No Lens Light"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Mask Extra Galaxies",
      "Tracer json"
    ],
    "cross_refs": [
      "autolens_workspace/notebooks/imaging/features/no_lens_light/modeling.ipynb",
      "imaging/features/pixelization/fit.py",
      "imaging/features/pixelization/modeling.py",
      "imaging/fit.py",
      "imaging/simulator.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/imaging/features/no_lens_light/simulator.ipynb",
    "path": "scripts/imaging/features/no_lens_light/simulator.py",
    "summary": "This script simulates `Imaging` of a 'galaxy-scale' which is identical to the `simple` simulated in the `start_here.py` script, but where the lens galaxy's light is omitted.",
    "title": "Simulator: No Lens Light"
  },
  {
    "contents": [
      "Prerequisites",
      "Model",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "MASS TOTAL PIPELINE",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/no_lens_light/slam.ipynb",
    "path": "scripts/imaging/features/no_lens_light/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines for fitting a lens model where there is no lens light observed in the imaging data.",
    "title": "No Lens Light: SLaM"
  },
  {
    "contents": [
      "Model",
      "Dataset + Masking + Positions",
      "Paths",
      "Model (Search 1)",
      "Mesh Shape",
      "Analysis + Position Likelihood",
      "Brief Description",
      "Adaptive Pixelization",
      "Adapt Images",
      "SLaM Pipelines"
    ],
    "cross_refs": [
      "guides/modeling/chaining.ipynb"
    ],
    "notebook": "notebooks/imaging/features/pixelization/adaptive.ipynb",
    "path": "scripts/imaging/features/pixelization/adaptive.py",
    "summary": "Non-linear search chaining is an advanced model-fitting approach which breaks the model-fitting procedure down into multiple non-linear searches, using the results of the initial searches to initialization parameter sampling in subsequent searches. This contrasts the `modeling` example which fits a single lens model-fit using one non-linear search.",
    "title": "Pixelization: Adaptive"
  },
  {
    "contents": [
      "Sparse Operators",
      "Mesh Shape",
      "Fit",
      "Model",
      "SLaM Pipeline",
      "SLaM Pipeline Functions",
      "CPU Fast SLaM Pipelines",
      "Wrap Up"
    ],
    "cross_refs": [
      "guides/modeling//slam_start_here.ipynb",
      "imaging/features/pixelization/fit.py"
    ],
    "notebook": "notebooks/imaging/features/pixelization/cpu_fast_modeling.ipynb",
    "path": "scripts/imaging/features/pixelization/cpu_fast_modeling.py",
    "summary": "This example demonstrates how to achieve **fast pixelization performance on a CPU without JAX**, by combining:",
    "title": "Pixelization: CPU Fast Modeling"
  },
  {
    "contents": [
      "Image Mesh",
      "Edge Zeroing",
      "Fit",
      "Source Science",
      "Model",
      "JAX CPU",
      "VRAM",
      "Adaptive Delaunay",
      "SLaM Pipelines",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Settings AutoFit",
      "Redshifts",
      "SLaM Pipeline",
      "Likelihood Function",
      "Source Galaxy Pixelization and Regularization",
      "Lens Light",
      "Source Pixel Centre Calculation",
      "Ray Tracing",
      "Border Relocation",
      "Delaunay Mesh",
      "Interpolation",
      "Lens Modeling",
      "Sub Gridding",
      "Sourrce Plane Interpolation",
      "Wrap Up"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoArray/blob/main/autoarray/inversion/mappers/voronoi.py",
      "//github.com/PyAutoLabs/PyAutoArray/blob/main/autoarray/structures/grids/two_d/grid_iterate.py",
      "//github.com/PyAutoLabs/PyAutoArray/blob/main/autoarray/util/mapper_util.py",
      "imaging/features/pixelization/adaptive.py",
      "imaging/features/pixelization/fit.py",
      "imaging/features/pixelization/likelihood_function.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/pixelization/delaunay.ipynb",
    "path": "scripts/imaging/features/pixelization/delaunay.py",
    "summary": "The majority of pixelized source reconstructions in the workspace use a rectangular mesh to reconstruct the source's surface brightness.",
    "title": "Pixelization: Delaunay"
  },
  {
    "contents": [
      "CPU Users",
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "Dataset & Mask",
      "Over Sampling",
      "Mesh Shape",
      "Edge Zeroing",
      "Pixelization",
      "Fit",
      "Mask Extra Galaxies",
      "Wrap Up",
      "Linear Objects",
      "Grids",
      "Reconstruction",
      "Mapped Reconstructed Images",
      "Simulated Imaging"
    ],
    "cross_refs": [],
    "notebook": "notebooks/imaging/features/pixelization/fit.ipynb",
    "path": "scripts/imaging/features/pixelization/fit.py",
    "summary": "A pixelization reconstructs the source's light using a pixel-grid, which is regularized using a prior that forces the solution to have a degree of smoothness.",
    "title": "Features: Pixelization Fit"
  },
  {
    "contents": [
      "Simplifications",
      "Prerequisites",
      "Dataset & Mask",
      "Over Sampling",
      "Masked Image Grid",
      "Mesh Shape",
      "Edge Zeroing",
      "Lens Galaxy",
      "Source Galaxy Pixelization and Regularization",
      "Lens Light",
      "Ray Tracing",
      "Border Relocation",
      "Source Pixel Centre Calculation",
      "Interpolation",
      "Mapper",
      "Alternative Meshes",
      "Mapping Matrix",
      "Image Reconstruction",
      "Likelihood Function",
      "Chi Squared",
      "Regularization Term",
      "Complexity Terms",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.py",
      "imaging/features/linear_light_profiles/likelihood_function.ipynb",
      "imaging/likelihood_function.ipynb"
    ],
    "notebook": "notebooks/imaging/features/pixelization/likelihood_function.ipynb",
    "path": "scripts/imaging/features/pixelization/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the **PyAutoLens** `log_likelihood_function` which is used to fit `Imaging` data with a pixelization (`RectangularUniform` mesh and `Constant` regularization scheme`).",
    "title": "__Log Likelihood Function: Pixelization__"
  },
  {
    "contents": [
      "GPU Run Times",
      "CPU Users",
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "Model",
      "Dataset & Mask",
      "Over Sampling",
      "Mesh Shape",
      "Edge Zeroing",
      "Search",
      "Position Likelihood",
      "Brief Description",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Mask Extra Galaxies",
      "Wrap Up",
      "Chaining",
      "HowToGalaxy"
    ],
    "cross_refs": [
      "/imaging/data_preparation/gui/positions.py",
      "imaging/start_here.ipynb",
      "pixelization/fit.py",
      "start.here.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/imaging/features/pixelization/modeling.ipynb",
    "path": "scripts/imaging/features/pixelization/modeling.py",
    "summary": "A pixelization reconstructs the source's light using a pixel-grid, which is regularized using a prior that forces the solution to have a degree of smoothness.",
    "title": "Features: Pixelization Modeling"
  },
  {
    "contents": [
      "Setup",
      "Fit Imaging",
      "Inversion",
      "Mapper Grids",
      "Mapper Galaxy Dict",
      "Fit Interferometer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "scripts/imaging/plot.py"
    ],
    "notebook": "notebooks/imaging/features/pixelization/plot.ipynb",
    "path": "scripts/imaging/features/pixelization/plot.py",
    "summary": "This example illustrates how to plot fits which reconstruct the source galaxy using a pixelization.",
    "title": "Plots: Pixelization"
  },
  {
    "contents": [
      "Prerequisites",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "features/pixelization/delaunay.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/pixelization/slam.ipynb",
    "path": "scripts/imaging/features/pixelization/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines for pixelized source modeling.",
    "title": "Pixelization: SLaM"
  },
  {
    "contents": [
      "Model Fit",
      "Interpolated Source",
      "Source Flux",
      "Zoom",
      "Errors",
      "Magnification",
      "Masking",
      "Magnification via Mesh",
      "Reconstruction CSV"
    ],
    "cross_refs": [],
    "notebook": "notebooks/imaging/features/pixelization/source_science.ipynb",
    "path": "scripts/imaging/features/pixelization/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy (or galaxies).",
    "title": "Pixelization: Source Science"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres + Luminosities",
      "Over Sampling",
      "The Relation",
      "Galaxies",
      "Tracer & Fit",
      "The Relation, Evaluated",
      "Deflection Sum",
      "Intensities",
      "CSV Interface",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/fit.py",
      "autolens_workspace/scripts/imaging/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/imaging/fit.py",
      "modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/imaging/features/scaling_relation/fit.ipynb",
    "path": "scripts/imaging/features/scaling_relation/fit.py",
    "summary": "Fits the `scaling_relation` dataset with every parameter set to the simulator's truth, so the two-tier foreground population can be inspected without a non-linear search in the way.",
    "title": "Features: Scaling Relation Fit"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres + Luminosities",
      "The Relation",
      "Galaxies",
      "Per-Galaxy Deflection",
      "Manual Ray-Tracing",
      "Source-Plane Image",
      "Likelihood",
      "CSV Interface",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "autolens_workspace/scripts/imaging/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/imaging/likelihood_function.py",
      "fit.py",
      "slam.py"
    ],
    "notebook": "notebooks/imaging/features/scaling_relation/likelihood_function.ipynb",
    "path": "scripts/imaging/features/scaling_relation/likelihood_function.py",
    "summary": "Describes the one step of the `log_likelihood` computation that a scaling relation changes: how the lens plane's deflection field is composed when most of the foreground galaxies' Einstein radii are not free parameters but derived from the main lens's.",
    "title": "__Log Likelihood Function: Scaling Relation__"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres",
      "Luminosities",
      "Over Sampling",
      "Main Lens & Source",
      "Bounded Tier",
      "Scaling Tier",
      "Model",
      "Zero Free Parameters",
      "Search / Analysis / Fit / Result.",
      "CSV Interface",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/extra_galaxies/modeling.py",
      "autolens_workspace/scripts/imaging/features/multi_gaussian_expansion/modeling.py",
      "autolens_workspace/scripts/imaging/modeling.py",
      "cluster/modeling.py",
      "fit.py",
      "group/start_here.py",
      "imaging/features/extra_galaxies/modeling.py",
      "imaging/modeling.py",
      "likelihood_function.py",
      "scripts/group/features/scaling_relation/modeling_for_luminosities.py",
      "scripts/imaging/features/scaling_relation/slam.py",
      "simulator.py",
      "slam.py"
    ],
    "notebook": "notebooks/imaging/features/scaling_relation/modeling.ipynb",
    "path": "scripts/imaging/features/scaling_relation/modeling.py",
    "summary": "A strong lens often has many foreground galaxies near the line of sight, and freeing an `einstein_radius` for each one quickly stops working: with 30 companions the parameter space is too large to sample and the data does not contain enough information to constrain them individually anyway.",
    "title": "Modeling Features: Scaling Relation"
  },
  {
    "contents": [
      "Dataset Paths / Grid / PSF / Simulator",
      "Luminosity Convention",
      "Main Lens Galaxy",
      "Faber-Jackson Relation",
      "Bounded Companions",
      "Scaling Companions",
      "Source / Dataset / Records"
    ],
    "cross_refs": [
      "cluster/modeling.py",
      "fit.py",
      "likelihood_function.py",
      "modeling.py"
    ],
    "notebook": "notebooks/imaging/features/scaling_relation/simulator.ipynb",
    "path": "scripts/imaging/features/scaling_relation/simulator.py",
    "summary": "Simulates the dataset for the `imaging/features/scaling_relation` feature: a galaxy-scale lens plus two tiers of foreground companions.",
    "title": "Simulator: Scaling Relation"
  },
  {
    "contents": [
      "Luminosity Measurement",
      "LENS LIGHT PIPELINE",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1 / 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset / Centres / Settings / Redshifts / Mesh Shape.",
      "SLaM Pipeline",
      "Measured Luminosities"
    ],
    "cross_refs": [
      "fit.py",
      "likelihood_function.py",
      "modeling.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/imaging/features/scaling_relation/slam.ipynb",
    "path": "scripts/imaging/features/scaling_relation/slam.py",
    "summary": "Uses the SLaM pipelines to fit a lens with two tiers of foreground companions, where the scaling tier's Einstein radii are tied to the main lens's own Einstein radius by a Faber-Jackson relation.",
    "title": "Scaling Relation: SLaM"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/features/simulator_manual_signal_to_noise_ratio.ipynb",
    "path": "scripts/imaging/features/simulator_manual_signal_to_noise_ratio.py",
    "summary": "When simulating `Imaging` of a strong lens, one is often not concerned with the actual units of the light (e.g. electrons per second, counts, etc.) but instead simple wants the data to correspond to a certain signal to noise value.",
    "title": "Simulator: Manual Signal to Noise Ratio"
  },
  {
    "contents": [
      "Loading Data",
      "Mask",
      "Fitting",
      "Bad Fit",
      "Fit Quantities",
      "Figures of Merit",
      "Plane Quantities",
      "Unmasked Quantities",
      "Pixel Counting",
      "Outputting Results"
    ],
    "cross_refs": [
      "/imaging/data_preparation/examples/optional/mask_extra_galaxies.py",
      "/imaging/data_preparation/gui/mask_extra_galaxies.py",
      "likelihood_function.py",
      "modeling.py",
      "scripts/guides/using_jax.py",
      "start_here.py"
    ],
    "notebook": "notebooks/imaging/fit.ipynb",
    "path": "scripts/imaging/fit.py",
    "summary": "This guide shows how to fit data using the `FitImaging` object, including visualizing and interpreting its results.",
    "title": "Fits"
  },
  {
    "contents": [
      "JAX",
      "Dataset & Mask",
      "Over Sampling",
      "Masked Image Grid",
      "Lens Galaxy Mass",
      "Lens Galaxy",
      "Source Galaxy Light Profile",
      "Lens Light",
      "Ray Tracing",
      "Source Image",
      "Convolution",
      "Likelihood Function",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.py",
      "/imaging/data_preparation/gui/mask_extra_galaxies.py",
      "contributor_guide.py",
      "data_preparation/examples/optional/mask_extra_galaxies.py",
      "scripts/guides/using_jax.py"
    ],
    "notebook": "notebooks/imaging/likelihood_function.ipynb",
    "path": "scripts/imaging/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Imaging` data with a lens light profile and source light profile (e.g. an elliptical Sersic lens and source).",
    "title": "__Log Likelihood Function: Inversion (Parametric)__"
  },
  {
    "contents": [
      "Model",
      "Plotters",
      "Simulation",
      "Data Preparation",
      "Dataset & Mask",
      "Extra Galaxies Noise Scaling",
      "Over Sampling",
      "Model Composition",
      "Coordinates",
      "Improved Lens Model",
      "Linear Light Profiles",
      "Concise API",
      "Search",
      "Unique Identifier",
      "Iterations Per Update",
      "Live Visual Update",
      "Analysis",
      "JAX",
      "VRAM Use",
      "Run Times",
      "Output Folder Layout",
      "Result",
      "Features",
      "HowToLens",
      "Modeling Customization"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "/guides/results/start_here.py",
      "/imaging/data_preparation/examples/optional/mask_extra_galaxies.py",
      "/imaging/data_preparation/gui/mask_extra_galaxies.py",
      "/imaging/data_preparation/start_here.ipynb",
      "/imaging/simulator.py",
      "over_sampling.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/imaging/modeling.ipynb",
    "path": "scripts/imaging/modeling.py",
    "summary": "This script is the starting point for lens modeling of CCD imaging data (E.g. Hubble Space Telescope, Euclid) with **PyAutoLens** and it provides an overview of the lens modeling API.",
    "title": "Imaging: Modeling"
  },
  {
    "contents": [
      "Dataset",
      "Dataset Figures",
      "Dataset Subplot",
      "Fit",
      "Fit Figures",
      "Plane Images",
      "Plane Subplots",
      "Fit Subplot",
      "Fit Subplot (Log10)",
      "Tracer Subplot",
      "Outputting to FITS",
      "Visualizer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "modeling.py",
      "scripts/multi_dataset/plot.py"
    ],
    "notebook": "notebooks/imaging/plot.ipynb",
    "path": "scripts/imaging/plot.py",
    "summary": "This example shows how to plot an `Imaging` dataset and a `FitImaging` fit, figure by figure and via multi-panel subplots.",
    "title": "Plots: Imaging"
  },
  {
    "contents": [
      "Model",
      "Plotters",
      "Dataset Paths",
      "Grid",
      "Over Sampling",
      "PSF Convolution",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json",
      "Multiple Images",
      "JAX Variant (Advanced)",
      "Oversampled PSF (Advanced)"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "autolens_workspace_test/scripts/imaging/convolution_over_sampled.py",
      "imaging/fit.py",
      "imaging/likelihood_function.py",
      "imaging/modeling.py",
      "scripts/cluster/simulator.py",
      "scripts/guides/using_jax.py",
      "scripts/interferometer/simulator.py",
      "scripts/point_source/simulator.py"
    ],
    "notebook": "notebooks/imaging/simulator.ipynb",
    "path": "scripts/imaging/simulator.py",
    "summary": "This script is the starting point for simulating galaxy-galaxy strong lenses as CCD imaging data (E.g. Hubble Space Telescope, Euclid) and it provides an overview of the lens simulation API.",
    "title": "Simulator: Start Here"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Simulate",
      "Sample Model Distributions",
      "Sample Instances"
    ],
    "cross_refs": [
      "imaging/features/simulator_manual_signal_to_noise_ratio.ipynb",
      "imaging/simulator.ipynb"
    ],
    "notebook": "notebooks/imaging/simulator_sample.ipynb",
    "path": "scripts/imaging/simulator_sample.py",
    "summary": "This script illustrates how to simulate a sample of `Imaging` datasets of 'galaxy-scale' strong lenses, which can easily be used to simulate hundreds or thousands of strong lenses.",
    "title": "Simulator: Sample"
  },
  {
    "contents": [
      "Simulated Dataset",
      "Mask",
      "Source Values",
      "Source Flux",
      "Source Magnification",
      "Tracer",
      "Parametric Source Models"
    ],
    "cross_refs": [],
    "notebook": "notebooks/imaging/source_science.ipynb",
    "path": "scripts/imaging/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy (or galaxies).",
    "title": "Source Science"
  },
  {
    "contents": [
      "JAX",
      "Google Colab Setup",
      "Imports",
      "Dataset",
      "Extra Galaxy Removal",
      "Masking",
      "Model",
      "Model Fit",
      "Iterations Per Update",
      "Live Visual Update",
      "Result",
      "Extra Galaxy Removal GUI",
      "Model Your Own Lens",
      "Simulator",
      "Sample",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/modeling.py",
      "autolens_workspace/start_here.py",
      "cluster/start_here.ipynb",
      "group/start_here.ipynb",
      "modeling.py",
      "scripts/imaging/simulator.py"
    ],
    "notebook": "notebooks/imaging/start_here.ipynb",
    "path": "scripts/imaging/start_here.py",
    "summary": "Strong gravitational lenses are often observed with CCD imaging, for example using HST, JWST, or ground-based telescopes.",
    "title": "Start Here: Imaging"
  },
  {
    "contents": [
      "PyAutoLens Requirements",
      "CASA in Five Steps",
      "Step 1 \u2014 Split by Field / SPW",
      "Step 2 \u2014 Channel Averaging",
      "Step 3 \u2014 Continuum Subtraction",
      "Step 4 \u2014 Rescale Sigmas",
      "Step 5 \u2014 Export to FITS",
      "Combining Spectral Windows",
      "Polarisations",
      "Building the Interferometer Object",
      "Troubleshooting",
      "SLACK"
    ],
    "cross_refs": [
      "export_to_fits.py",
      "my_script.py",
      "scripts/interferometer/casa_reduction.py",
      "scripts/interferometer/data_preparation.py",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/casa_reduction.ipynb",
    "path": "scripts/interferometer/casa_reduction.py",
    "summary": "This script is a practical walkthrough of how to reduce an ALMA / JVLA interferometer observation with **CASA** and export it into the three FITS files that **PyAutoLens** expects for lens modeling:",
    "title": "Interferometer: CASA Reduction"
  },
  {
    "contents": [
      "SLACK",
      "Pixel Scale",
      "Visibilities",
      "Noise-Map",
      "UV Wavelengths",
      "Real Space Mask",
      "Data Processing Complete",
      "Positions (Optional)",
      "Lens Light Centre (Optional)",
      "Extra Galaxies (Optional)",
      "Mask Extra Galaxies (Optional)",
      "Info (Optional)"
    ],
    "cross_refs": [
      "data_preparation/examples/optional/extra_galaxies_centres.py",
      "data_preparation/examples/optional/info.py",
      "data_preparation/examples/optional/lens_light_centre.py",
      "data_preparation/examples/optional/mask_extra_galaxies.py",
      "data_preparation/examples/optional/positions.ipynb",
      "data_preparation/gui/extra_galaxies_centres.ipynb",
      "data_preparation/gui/lens_light_centre.ipynb",
      "data_preparation/gui/mask_extra_galaxies.ipynb",
      "data_preparation/gui/positions.ipynb",
      "extra_galaxies_centres.py",
      "features/extra_galaxies/modeling.py",
      "interferometer/casa_reduction.ipynb",
      "mask_extra_galaxies.py"
    ],
    "notebook": "notebooks/interferometer/data_preparation.ipynb",
    "path": "scripts/interferometer/data_preparation.py",
    "summary": "When an interferometer dataset is analysed, it must conform to certain standards in order for the analysis to be performed correctly. This tutorial describes these standards and links to more detailed scripts which will help you prepare your dataset to adhere to them if it does not already.",
    "title": "Interferometer: Data Preparation"
  },
  {
    "contents": [
      "Mask",
      "Dataset",
      "Dataset Auto-Simulation",
      "Model",
      "Search",
      "Analysis",
      "Run Time",
      "Model-Fit",
      "Result"
    ],
    "cross_refs": [
      "/imaging/features/advanced/operated_light_profile/modeling.py",
      "fit.py",
      "interferometer/fit.py",
      "interferometer/start_here.ipynb"
    ],
    "notebook": "notebooks/interferometer/features/advanced/operated_light_profile/modeling.ipynb",
    "path": "scripts/interferometer/features/advanced/operated_light_profile/modeling.py",
    "summary": "It is common for galaxies to have point-source emission, for example bright emission right at their centre due to an active galactic nuclei or a compact knot of star formation.",
    "title": "Modeling Features: Operated Light Profiles (Interferometer)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "uv-wavelengths",
      "Simulator",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "interferometer/features/advanced/operated_light_profile/modeling.py",
      "interferometer/simulator.ipynb"
    ],
    "notebook": "notebooks/interferometer/features/advanced/operated_light_profile/simulator.ipynb",
    "path": "scripts/interferometer/features/advanced/operated_light_profile/simulator.py",
    "summary": "It is common for galaxies to have point-source emission, for example bright emission right at their centre due to an active galactic nuclei or a compact knot of star formation.",
    "title": "Simulator: Light Operated (Interferometer)"
  },
  {
    "contents": [
      "Simplifications",
      "Prerequisites",
      "Dataset",
      "Source Inversion Blocks",
      "Dpsi Mesh",
      "Correction Response",
      "Joint Response",
      "Dense Route",
      "Sparse (w-tilde) Route",
      "Solve",
      "Dkappa Map",
      "Evidence Terms",
      "Verification",
      "JAX / xp",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace_test/scripts/interferometer/jax_likelihood/potential_correction.py",
      "imaging/features/advanced/potential_correction/likelihood_function.ipynb",
      "interferometer/features/advanced/potential_correction/start_here.ipynb",
      "interferometer/features/pixelization/likelihood_function.ipynb",
      "interferometer/features/pixelization/likelihood_function.py",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/advanced/potential_correction/likelihood_function.ipynb",
    "path": "scripts/interferometer/features/advanced/potential_correction/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the **PyAutoLens** visibility-space potential-correction `log_likelihood_function` (the Bayesian evidence of `al.pc.FitDpsiSrcInterferometer`), which jointly inverts `Interferometer` data for a pixelized source and pixelized corrections $\\delta\\psi$ to the lensing potential.",
    "title": "__Log Likelihood Function: Potential Correction (Interferometer)__"
  },
  {
    "contents": [],
    "cross_refs": [
      "imaging/features/advanced/potential_correction/start_here.ipynb",
      "interferometer/start_here.ipynb",
      "interferometer/start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/advanced/potential_correction/start_here.ipynb",
    "path": "scripts/interferometer/features/advanced/potential_correction/start_here.py",
    "summary": "This example performs gravitational imaging on interferometer data: pixelized corrections $\\delta\\psi$ to the lensing potential are reconstructed jointly with the pixelized source, revealing mass structure (e.g. dark subhaloes) the smooth lens model omits, as a convergence-correction map $\\delta\\kappa = \\frac{1}{2}\\nabla^2\\delta\\psi$.",
    "title": "Feature: Potential Correction (Gravitational Imaging)"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Positive Negative Solver",
      "Model",
      "Mask",
      "Dataset",
      "Basis",
      "Fit",
      "Intensities",
      "Visualization",
      "Wrap Up"
    ],
    "cross_refs": [
      "interferometer/start_here.ipynb",
      "linear_light_profiles.py",
      "modeling.py"
    ],
    "notebook": "notebooks/interferometer/features/advanced/shapelets/fit.ipynb",
    "path": "scripts/interferometer/features/advanced/shapelets/fit.py",
    "summary": "A shapelet is a basis function appropriate for capturing the exponential / disk-like features of a galaxy. The `intensity` of every shapelet is solved for via linear algebra (\"inversion\") rather than being a free parameter of the non-linear search.",
    "title": "Modeling Features: Shapelets Fit (Interferometer)"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "NUFFT (nufftax)",
      "Positive Negative Solver",
      "Model",
      "Mask",
      "Dataset",
      "Over Sampling",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "/imaging/features/advanced/shapelets/modeling.py",
      "interferometer/features/multi_gaussian_expansion/modeling.py",
      "interferometer/modeling.py",
      "interferometer/start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/advanced/shapelets/modeling.ipynb",
    "path": "scripts/interferometer/features/advanced/shapelets/modeling.py",
    "summary": "A shapelet is a basis function appropriate for capturing the exponential / disk-like features of a galaxy. It has been employed in many strong lensing studies to model the light of the lensed source galaxy, because it can represent features of disky star-forming galaxies that a single Sersic function cannot.",
    "title": "Modeling Features: Shapelets (Interferometer)"
  },
  {
    "contents": [
      "SLaM Pipelines",
      "Grid Search",
      "Pixelized Source",
      "Model",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "MASS TOTAL PIPELINE",
      "Two Datasets",
      "Sparse Operators",
      "Settings",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "slam_start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/advanced/subhalo/detect/start_here.ipynb",
    "path": "scripts/interferometer/features/advanced/subhalo/detect/start_here.py",
    "summary": "Strong gravitational lenses can be used to detect the presence of small-scale dark matter (DM) subhalos. This occurs when the DM subhalo overlaps the lensed source emission, and therefore gravitationally perturbs the observed image of the lensed source galaxy.",
    "title": "Subhalo Detection: Start Here"
  },
  {
    "contents": [],
    "cross_refs": [],
    "notebook": "notebooks/interferometer/features/advanced/subhalo/sensitivity/start_here.ipynb",
    "path": "scripts/interferometer/features/advanced/subhalo/sensitivity/start_here.py",
    "summary": "(no summary in script docstring)",
    "title": "start_here"
  },
  {
    "contents": [
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "interferometer/simulator.ipynb"
    ],
    "notebook": "notebooks/interferometer/features/advanced/subhalo/simulator.ipynb",
    "path": "scripts/interferometer/features/advanced/subhalo/simulator.py",
    "summary": "This script simulates `Interferometer` data of a 'galaxy-scale' strong lens where:",
    "title": "Simulator: Subhalo"
  },
  {
    "contents": [
      "What ALMA Gives You",
      "Polarisation Handling",
      "Canonical 3D Shape",
      "Shared vs Per-Channel uv_wavelengths / noise_map",
      "3D-FITS Loader",
      "Worked Example"
    ],
    "cross_refs": [
      "simulator.py"
    ],
    "notebook": "notebooks/interferometer/features/datacube/data_preparation.ipynb",
    "path": "scripts/interferometer/features/datacube/data_preparation.py",
    "summary": "Most users come to datacube modeling with a single 4D FITS file from CASA, with shape ``(n_pol, n_chan, n_vis, 2)`` \u2014 for example, an ALMA observation of a CO emission line might be ``(2, 34, 16984, 2)``: two polarisations, 34 spectral channels, ~17k visibilities per channel, real/imag.",
    "title": "Data Preparation: Datacube"
  },
  {
    "contents": [
      "Mask",
      "Dataset",
      "Dataset Auto-Simulation",
      "Dataset Loading",
      "Sparse Operators",
      "Positions",
      "Settings",
      "Image Mesh",
      "Edge Zeroing",
      "Adapt Images",
      "Model",
      "Per-Channel Analyses",
      "FactorGraph",
      "Search",
      "Model Fit",
      "Wrap Up"
    ],
    "cross_refs": [
      "likelihood_function.py",
      "modeling.py",
      "modeling_parametric.py",
      "simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/datacube/delaunay.ipynb",
    "path": "scripts/interferometer/features/datacube/delaunay.py",
    "summary": "This script fits a datacube \u2014 a list of `Interferometer` channels \u2014 with a single shared lens model and a per-channel **Delaunay-pixelized** source reconstruction. It is the Delaunay sibling of `modeling.py`, which fits the same cube with a `RectangularBilinearAdaptDensity` mesh.",
    "title": "Modeling: Datacube \u2014 Delaunay Source"
  },
  {
    "contents": [
      "Comparison",
      "Simplifications",
      "Prerequisites",
      "Mesh Shape",
      "Mask",
      "Dataset",
      "Lens Galaxy",
      "Source Galaxy Pixelization and Regularization",
      "One Channel Walkthrough",
      "Across All Channels",
      "Fit",
      "Lens Modeling",
      "Log Likelihood Function: Source Code Speed Up",
      "Wrap Up"
    ],
    "cross_refs": [
      "data_preparation.py",
      "datacube/modeling.py",
      "delaunay.py",
      "interferometer/features/pixelization/likelihood_function.py",
      "interferometer/likelihood_function.py",
      "modeling.py",
      "modeling_parametric.py",
      "pixelization/likelihood_function.py",
      "simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/datacube/likelihood_function.ipynb",
    "path": "scripts/interferometer/features/datacube/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the **PyAutoLens** `log_likelihood_function` used to fit a **datacube** \u2014 a list of N per-channel `Interferometer` objects sharing a single lens model \u2014 with a per-channel pixelized source reconstruction (specifically a `RectangularBilinearAdaptDensity` mesh and `Constant` regularization scheme).",
    "title": "__Log Likelihood Function: Datacube__"
  },
  {
    "contents": [
      "Mask",
      "Dataset",
      "Dataset Auto-Simulation",
      "Dataset Loading",
      "Sparse Operators",
      "Settings",
      "Mesh Shape",
      "Model",
      "Per-Channel Analyses",
      "FactorGraph",
      "Search",
      "Model Fit",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace_test/scripts/interferometer/datacube/shared_preloads.py",
      "likelihood_function.py",
      "pixelization/many_visibilities_preparation.py",
      "simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/datacube/modeling.ipynb",
    "path": "scripts/interferometer/features/datacube/modeling.py",
    "summary": "This script fits a list of `Interferometer` channels \u2014 a \"datacube\" \u2014 with a single shared lens model and a per-channel pixelized source reconstruction. Each channel is an independent `Interferometer` dataset; the `af.FactorGraphModel` ties them together by feeding the same lens parameters into every channel's `AnalysisInterferometer.log_likelihood_function` and summing the per-channel log-evidences.",
    "title": "Modeling: Datacube"
  },
  {
    "contents": [
      "Mask",
      "Dataset",
      "Dataset Auto-Simulation",
      "Dataset Loading",
      "Positions",
      "Settings",
      "Model",
      "Per-Channel Analyses",
      "FactorGraph",
      "Search",
      "Model Fit",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/multi_dataset/modeling.py",
      "likelihood_function.py",
      "modeling.py",
      "simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/datacube/modeling_parametric.ipynb",
    "path": "scripts/interferometer/features/datacube/modeling_parametric.py",
    "summary": "This script fits a datacube \u2014 a list of `Interferometer` channels \u2014 with a single shared lens model and a **parametric** source (`al.lp.Sersic`) whose morphology is shared across channels and whose `intensity` varies channel-to-channel. It is the parametric-fit sibling of `modeling.py`, which fits the same cube with a pixelized source instead.",
    "title": "Modeling: Datacube \u2014 Parametric Source"
  },
  {
    "contents": [
      "Cube Configuration",
      "Dataset Paths",
      "uv_wavelengths",
      "Real-Space Grid",
      "Lens Galaxy",
      "Per-Channel Source",
      "Per-Channel Simulate",
      "3D-FITS Cube",
      "4D CASA-like Cube",
      "Multiple Images",
      "Cube Summary",
      "Cube Overview Plot",
      "Spectrum Plot"
    ],
    "cross_refs": [
      "data_preparation.py"
    ],
    "notebook": "notebooks/interferometer/features/datacube/simulator.ipynb",
    "path": "scripts/interferometer/features/datacube/simulator.py",
    "summary": "This script simulates an ALMA-style spectral-line `Interferometer` datacube of a 'galaxy-scale' strong lens where:",
    "title": "Simulator: Datacube"
  },
  {
    "contents": [
      "JAX",
      "Imports",
      "Mask",
      "Dataset",
      "Dataset Auto-Simulation",
      "Dataset Loading",
      "Sparse Operators",
      "Positions",
      "Settings",
      "Mesh Shape",
      "Model",
      "Per-Channel Analyses",
      "FactorGraph",
      "Search",
      "Model Fit",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/multi_dataset/modeling.py",
      "interferometer/start_here.py",
      "likelihood_function.py",
      "modeling.py",
      "pixelization/many_visibilities_preparation.py",
      "simulator.py"
    ],
    "notebook": "notebooks/interferometer/features/datacube/start_here.ipynb",
    "path": "scripts/interferometer/features/datacube/start_here.py",
    "summary": "A datacube is a stack of interferometer observations of the same lens taken across many spectral channels \u2014 for example, an ALMA observation of a CO emission line in a high-redshift lensed galaxy, where each channel records visibilities at a slightly different frequency. The lens galaxy is the same in every channel, but the source's emission-line morphology varies across the cube: bright in channels close to the line peak, faint in channels at the line wings, and shifting in shape if the source has internal velocity structure.",
    "title": "Start Here: Datacube"
  },
  {
    "contents": [
      "Data Preparation",
      "Mask",
      "Dataset",
      "Extra Galaxies Dataset",
      "Extra Galaxies Centres",
      "Model",
      "Extra Galaxies Model",
      "VRAM",
      "Run Time",
      "Result",
      "Scaling Relations",
      "Wrap Up"
    ],
    "cross_refs": [
      "/imaging/data_preparation/examples/optional/extra_galaxies_centres.py",
      "cluster/modeling.py",
      "group/modeling.py",
      "interferometer/start_here.ipynb"
    ],
    "notebook": "notebooks/interferometer/features/extra_galaxies/modeling.ipynb",
    "path": "scripts/interferometer/features/extra_galaxies/modeling.py",
    "summary": "There may be extra galaxies nearby the lens and source galaxies, whose mass may contribute to the ray-tracing and lens model.",
    "title": "Modeling Features: Extra Galaxies"
  },
  {
    "contents": [
      "Model",
      "Other Scripts",
      "Dataset Paths",
      "Simulate",
      "Galaxies",
      "Extra Galaxies",
      "Output",
      "Visualize",
      "Tracer json",
      "Multiple Images"
    ],
    "cross_refs": [
      "interferometer/simulator.ipynb"
    ],
    "notebook": "notebooks/interferometer/features/extra_galaxies/simulator.ipynb",
    "path": "scripts/interferometer/features/extra_galaxies/simulator.py",
    "summary": "There may be extra galaxies nearby the lens and source galaxies, whose mass may contribute to the ray-tracing and lens model.",
    "title": "Simulator: Extra Galaxies"
  },
  {
    "contents": [
      "Prerequisites",
      "Group SLaM",
      "This Script",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "MASS TOTAL PIPELINE",
      "Extra Galaxies Centres",
      "Two Datasets",
      "Sparse Operators",
      "Settings",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "Extra Galaxies",
      "SLaM Pipeline",
      "Output"
    ],
    "cross_refs": [
      "features/extra_galaxies/modeling.ipynb",
      "guides/modeling/slam_start_here.ipynb",
      "slam_start_here.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/interferometer/features/extra_galaxies/slam.ipynb",
    "path": "scripts/interferometer/features/extra_galaxies/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines for fitting a lens model where extra galaxies surrounding the lens are included in the lens model.",
    "title": "Extra Galaxies: SLaM"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "Model",
      "Mask",
      "Dataset",
      "Fit",
      "Intensities",
      "Visualization",
      "Wrap Up"
    ],
    "cross_refs": [
      "interferometer/start_here.ipynb",
      "modeling.py"
    ],
    "notebook": "notebooks/interferometer/features/linear_light_profiles/fit.ipynb",
    "path": "scripts/interferometer/features/linear_light_profiles/fit.py",
    "summary": "A \"linear light profile\" is a variant of a standard light profile where the `intensity` parameter is solved for via linear algebra every time the model is fitted to the data. This uses a process called an \"inversion\" and it always computes the `intensity` values that give the best fit to the data (e.g. maximize the likelihood) given the light profile's other parameters.",
    "title": "Modeling Features: Linear Light Profiles Fit (Interferometer)"
  },
  {
    "contents": [
      "Prerequisites",
      "Mask",
      "Dataset",
      "Lens Galaxy",
      "Source Galaxy Linear Light Profile",
      "Internal Intensity",
      "Ray Tracing",
      "Source Image (Internal)",
      "Mapping Matrix",
      "Transformed Mapping Matrix ($f$)",
      "Data Vector (D)",
      "Curvature Matrix (F)",
      "Reconstruction (Positive-Negative)",
      "Reconstruction (Positive Only)",
      "Visibilities Reconstruction",
      "Likelihood Function",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/linear_light_profiles/likelihood_function.ipynb",
      "imaging/features/linear_light_profiles/likelihood_function.py",
      "interferometer/likelihood_function.ipynb"
    ],
    "notebook": "notebooks/interferometer/features/linear_light_profiles/likelihood_function.ipynb",
    "path": "scripts/interferometer/features/linear_light_profiles/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Interferometer` data with a linear light profile (e.g. a linear `SersicCore` source).",
    "title": "__Log Likelihood Function: Linear Light Profile (Interferometer)__"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "NUFFT (nufftax)",
      "Positive Only Solver",
      "Model",
      "Mask",
      "Dataset",
      "Over Sampling",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Intensities",
      "Visualization",
      "Max Likelihood Inversion",
      "Linear Objects (Internal Source Code)",
      "Wrap Up"
    ],
    "cross_refs": [
      "/imaging/features/linear_light_profiles/modeling.py",
      "interferometer/modeling.py",
      "interferometer/start_here.ipynb",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/linear_light_profiles/modeling.ipynb",
    "path": "scripts/interferometer/features/linear_light_profiles/modeling.py",
    "summary": "A \"linear light profile\" is a variant of a standard light profile where the `intensity` parameter is solved for via linear algebra every time the model is fitted to the data. This uses a process called an \"inversion\" and it always computes the `intensity` values that give the best fit to the data (e.g. maximize the likelihood) given the light profile's other parameters.",
    "title": "Modeling Features: Linear Light Profiles (Interferometer)"
  },
  {
    "contents": [
      "Prerequisites",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "MASS TOTAL PIPELINE",
      "Two Datasets",
      "Sparse Operators",
      "Settings",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "interferometer/features/pixelization/slam.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/linear_light_profiles/slam.ipynb",
    "path": "scripts/interferometer/features/linear_light_profiles/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines for `Interferometer` data, using a **linear light profile** in the SOURCE LP stage instead of a Multi-Gaussian Expansion (MGE).",
    "title": "Linear Light Profiles: SLaM (Interferometer)"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "Model",
      "Mask",
      "Dataset",
      "Basis",
      "Fit",
      "Intensities",
      "Visualization",
      "Wrap Up"
    ],
    "cross_refs": [
      "interferometer/start_here.ipynb",
      "linear_light_profiles.py",
      "modeling.py"
    ],
    "notebook": "notebooks/interferometer/features/multi_gaussian_expansion/fit.ipynb",
    "path": "scripts/interferometer/features/multi_gaussian_expansion/fit.py",
    "summary": "A multi-Gaussian expansion (MGE) decomposes a galaxy's light into ~15-100 Gaussians, where the `intensity` of every Gaussian is solved for via linear algebra using a process called an \"inversion\".",
    "title": "Modeling Features: Multi Gaussian Expansion Fit (Interferometer)"
  },
  {
    "contents": [
      "Prerequisites",
      "Mask",
      "Dataset",
      "Lens Galaxy",
      "Source Galaxy MGE Basis",
      "Ray Tracing",
      "Mapping Matrix",
      "Transformed Mapping Matrix ($f$)",
      "Data Vector (D)",
      "Curvature Matrix (F)",
      "Reconstruction (Positive-Negative)",
      "Reconstruction (Positive Only)",
      "Visibilities Reconstruction",
      "Likelihood Function",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "features/linear_light_profiles/likelihood_function.py",
      "fit.py",
      "interferometer/features/linear_light_profiles/likelihood_function.ipynb",
      "interferometer/features/linear_light_profiles/likelihood_function.py",
      "interferometer/likelihood_function.ipynb",
      "modeling.py"
    ],
    "notebook": "notebooks/interferometer/features/multi_gaussian_expansion/likelihood_function.ipynb",
    "path": "scripts/interferometer/features/multi_gaussian_expansion/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Interferometer` data with a multi-Gaussian expansion (MGE) source: a `Basis` of many linear `Gaussian` profiles whose `intensity` values are solved for analytically via a linear inversion.",
    "title": "__Log Likelihood Function: Multi Gaussian Expansion (Interferometer)__"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "NUFFT (nufftax)",
      "Positive Only Solver",
      "Model",
      "Mask",
      "Dataset",
      "Over Sampling",
      "Search",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "/imaging/features/multi_gaussian_expansion/modeling.py",
      "autolens_workspace/scripts/interferometer/features/multi_gaussian_expansion/slam.py",
      "interferometer/modeling.py",
      "interferometer/start_here.ipynb",
      "linear.py",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/multi_gaussian_expansion/modeling.ipynb",
    "path": "scripts/interferometer/features/multi_gaussian_expansion/modeling.py",
    "summary": "A multi-Gaussian expansion (MGE) decomposes a galaxy's light into ~15-100 Gaussians, where the `intensity` of every Gaussian is solved for via linear algebra using a process called an \"inversion\" (see the `linear_light_profiles` feature for a full description of this).",
    "title": "Modeling Features: Multi Gaussian Expansion (Interferometer)"
  },
  {
    "contents": [
      "Prerequisites",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "MASS TOTAL PIPELINE",
      "Two Datasets",
      "Sparse Operators",
      "Settings",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "interferometer/features/pixelization/slam.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/multi_gaussian_expansion/slam.ipynb",
    "path": "scripts/interferometer/features/multi_gaussian_expansion/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines for `Interferometer` data, using a **multi-Gaussian expansion (MGE)** for the source galaxy in the SOURCE LP stage.",
    "title": "Multi Gaussian Expansion: SLaM (Interferometer)"
  },
  {
    "contents": [
      "Image Mesh",
      "Edge Zeroing",
      "Fit",
      "Model",
      "VRAM",
      "Adaptive Delaunay",
      "SLaM Pipelines",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "MASS TOTAL PIPELINE",
      "Settings AutoFit",
      "Redshifts",
      "SLaM Pipeline",
      "Prerequisites",
      "Likelihood Function",
      "Mask",
      "Dataset",
      "Source Galaxy Pixelization and Regularization",
      "Source Pixel Centre Calculation",
      "Ray Tracing",
      "Border Relocation",
      "Delaunay Mesh",
      "Interpolation",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "contributor_guide.py",
      "imaging/features/pixelization/adaptive.py",
      "interferometer/features/linear_light_profiles/likelihood_function.py",
      "interferometer/features/pixelization/fit.py",
      "interferometer/features/pixelization/likelihood_function.py",
      "interferometer/likelihood_function.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/pixelization/delaunay.ipynb",
    "path": "scripts/interferometer/features/pixelization/delaunay.py",
    "summary": "The majority of pixelized source reconstructions in the workspace use a rectangular mesh to reconstruct the source's surface brightness.",
    "title": "Pixelization: Delaunay"
  },
  {
    "contents": [
      "CPU Users",
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "Mask",
      "Dataset",
      "Sparse Operators",
      "Settings",
      "Over Sampling",
      "Mesh Shape",
      "Edge Zeroing",
      "Pixelization",
      "Fit",
      "Wrap Up",
      "Linear Objects",
      "Grids",
      "Reconstruction",
      "Mapped Reconstructed Images",
      "Simulated Interferometer"
    ],
    "cross_refs": [
      "pixelization/many_visibilities_preparation.py"
    ],
    "notebook": "notebooks/interferometer/features/pixelization/fit.ipynb",
    "path": "scripts/interferometer/features/pixelization/fit.py",
    "summary": "A pixelization reconstructs the source's light using a pixel-grid, which is regularized using a prior that forces the solution to have a degree of smoothness.",
    "title": "Features: Pixelization"
  },
  {
    "contents": [
      "Simplifications",
      "Prerequisites",
      "Mesh Shape",
      "Edge Zeroing",
      "Mask",
      "Dataset",
      "Over Sampling",
      "Masked Image Grid",
      "Lens Galaxy",
      "Source Galaxy Pixelization and Regularization",
      "Ray Tracing",
      "Border Relocation",
      "Source Pixel Centre Calculation",
      "Interpolation",
      "Mapper",
      "Alternative Meshes",
      "Mapping Matrix",
      "Visibilities Reconstruction",
      "Likelihood Function",
      "Chi Squared",
      "Regularization Term",
      "Complexity Terms",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/linear_light_profiles/likelihood_function.py",
      "interferometer/likelihood_function.py"
    ],
    "notebook": "notebooks/interferometer/features/pixelization/likelihood_function.ipynb",
    "path": "scripts/interferometer/features/pixelization/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the **PyAutoLens** `log_likelihood_function` which is used to fit `Interferometer` data with an inversion (specifically a `RectangularUniform` mesh and `Constant` regularization scheme`).",
    "title": "__Log Likelihood Function: Pixelization__"
  },
  {
    "contents": [
      "High Resolution Dataset",
      "Profiling Dataset",
      "Curvature Preload",
      "Curvature Preload Output",
      "Wrap Up"
    ],
    "cross_refs": [],
    "notebook": "notebooks/interferometer/features/pixelization/many_visibilities_preparation.ipynb",
    "path": "scripts/interferometer/features/pixelization/many_visibilities_preparation.py",
    "summary": "To perform many visibility modeling, a matrix called `nufft_precision_operator` is created and used, which encodes information and symmetries into the Fourier transform operation performed when modeling interferometer datasets, in a way that exploits the sparsity of the pixelized source reconstructions and means a very small amount of memory or VRAM is used.",
    "title": "Pixelization: Many Visibilities Preparation"
  },
  {
    "contents": [
      "CPU Users",
      "Advantages & Disadvantages",
      "Positive Only Solver",
      "Model",
      "High Resolution Dataset",
      "Mask",
      "Dataset",
      "Sparse Operators",
      "Settings",
      "Over Sampling",
      "Mesh Shape",
      "Edge Zeroing",
      "Search",
      "Position Likelihood",
      "Brief Description",
      "Analysis",
      "VRAM",
      "Run Time",
      "Result",
      "Result Use",
      "Wrap Up",
      "Chaining",
      "HowToLens"
    ],
    "cross_refs": [
      "/imaging/data_preparation/gui/positions.py",
      "fit.py",
      "interferometer/start_here.ipynb",
      "pixelization/fit.py",
      "pixelization/many_visibilities_preparation.py",
      "start.here.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/interferometer/features/pixelization/modeling.ipynb",
    "path": "scripts/interferometer/features/pixelization/modeling.py",
    "summary": "A pixelization reconstructs the source galaxy\u2019s light on a grid of pixels, which is regularized using a prior that enforces a degree of smoothness in the solution.",
    "title": "Features: Pixelization"
  },
  {
    "contents": [
      "Prerequisites",
      "Interferometer SLaM Description",
      "High Resolution Dataset",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1",
      "SOURCE PIX PIPELINE 2",
      "MASS TOTAL PIPELINE",
      "Two Datasets",
      "Sparse Operators",
      "Settings",
      "Settings AutoFit",
      "Redshifts",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "slam_start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/pixelization/slam.ipynb",
    "path": "scripts/interferometer/features/pixelization/slam.py",
    "summary": "This script provides an example of the Source, (Lens) Light, and Mass (SLaM) pipelines for pixelized source modeling.",
    "title": "Pixelization: SLaM"
  },
  {
    "contents": [
      "Model Fit",
      "Interpolated Source",
      "Source Flux",
      "Zoom",
      "Errors",
      "Magnification",
      "Masking",
      "Magnification via Mesh",
      "Reconstruction CSV"
    ],
    "cross_refs": [],
    "notebook": "notebooks/interferometer/features/pixelization/source_science.ipynb",
    "path": "scripts/interferometer/features/pixelization/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy (or galaxies).",
    "title": "Pixelization: Source Reconstruction"
  },
  {
    "contents": [
      "Real Space Mask / Dataset",
      "Centres + Luminosities",
      "The Relation",
      "Galaxies",
      "Tracer & Fit",
      "The Relation, Evaluated",
      "Deflection Sum",
      "CSV Interface.",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/scaling_relation/fit.py",
      "autolens_workspace/scripts/interferometer/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/interferometer/fit.py",
      "modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/interferometer/features/scaling_relation/fit.ipynb",
    "path": "scripts/interferometer/features/scaling_relation/fit.py",
    "summary": "Fits the interferometer `scaling_relation` dataset at the simulator's truth values, so the tied tier can be inspected without a non-linear search in the way.",
    "title": "Features (Interferometer): Scaling Relation Fit"
  },
  {
    "contents": [
      "Real Space Mask / Dataset",
      "Centres + Luminosities",
      "The Relation",
      "Galaxies",
      "Deflection Field",
      "Manual Ray-Tracing",
      "Real-Space Image",
      "Likelihood",
      "CSV Interface.",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/interferometer/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/interferometer/likelihood_function.py",
      "slam.py"
    ],
    "notebook": "notebooks/interferometer/features/scaling_relation/likelihood_function.ipynb",
    "path": "scripts/interferometer/features/scaling_relation/likelihood_function.py",
    "summary": "Describes the one step of the interferometer `log_likelihood` computation that a scaling relation changes: how the real-space deflection field is composed when most of the foreground galaxies' Einstein radii are derived from the main lens's rather than sampled.",
    "title": "__Log Likelihood Function: Scaling Relation (Interferometer)__"
  },
  {
    "contents": [
      "Real Space Mask / Dataset",
      "Centres",
      "Luminosities",
      "Main Lens & Source",
      "Scaling Tier",
      "Model",
      "Zero Free Parameters",
      "Search / Analysis / Fit / Result.",
      "CSV Interface",
      "Wrap Up."
    ],
    "cross_refs": [
      "/imaging/data_preparation/examples/optional/extra_galaxies_centres.py",
      "autolens_workspace/scripts/imaging/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/interferometer/features/extra_galaxies/modeling.py",
      "autolens_workspace/scripts/interferometer/modeling.py",
      "cluster/modeling.py",
      "fit.py",
      "interferometer/features/extra_galaxies/modeling.py",
      "interferometer/features/extra_galaxies/slam.py",
      "likelihood_function.py",
      "slam.py"
    ],
    "notebook": "notebooks/interferometer/features/scaling_relation/modeling.ipynb",
    "path": "scripts/interferometer/features/scaling_relation/modeling.py",
    "summary": "Ties a population of foreground companions to the main lens's own Einstein radius by a Faber-Jackson relation, so the whole tier costs **zero free parameters**:",
    "title": "Modeling Features (Interferometer): Scaling Relation"
  },
  {
    "contents": [
      "Dataset Paths / Grid / uv-Wavelengths / Simulator",
      "Luminosity Convention",
      "Main Lens Galaxy",
      "Scaling Companions",
      "Source / Dataset / Records"
    ],
    "cross_refs": [
      "slam.py"
    ],
    "notebook": "notebooks/interferometer/features/scaling_relation/simulator.ipynb",
    "path": "scripts/interferometer/features/scaling_relation/simulator.py",
    "summary": "Simulates the dataset for the `interferometer/features/scaling_relation` feature: a lens plus a tier of foreground companions whose Einstein radii are tied to the main lens's own by a Faber-Jackson relation.",
    "title": "Simulator: Scaling Relation (Interferometer)"
  },
  {
    "contents": [
      "The Tie",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1 / 2",
      "MASS TOTAL PIPELINE",
      "Dataset / Centres / External Luminosities / Settings / Mesh Shape.",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "imaging/features/scaling_relation/slam.py",
      "interferometer/features/extra_galaxies/slam.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/interferometer/features/scaling_relation/slam.ipynb",
    "path": "scripts/interferometer/features/scaling_relation/slam.py",
    "summary": "Runs the SLaM pipelines on an interferometer dataset whose foreground companions are tied to the main lens's own Einstein radius by a Faber-Jackson relation.",
    "title": "Scaling Relation: SLaM (Interferometer)"
  },
  {
    "contents": [
      "Mask",
      "Loading Data",
      "Fitting",
      "Bad Fit",
      "Fit Quantities",
      "Figures of Merit",
      "Plane Quantities",
      "Outputting Results"
    ],
    "cross_refs": [
      "modeling.py",
      "scripts/guides/using_jax.py",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/fit.ipynb",
    "path": "scripts/interferometer/fit.py",
    "summary": "This guide shows how to fit data using the `FitInterferometer` object, including visualizing and interpreting its results.",
    "title": "Fits"
  },
  {
    "contents": [
      "JAX",
      "Mask",
      "Dataset",
      "Over Sampling",
      "Masked Image Grid",
      "Lens Galaxy Mass",
      "Lens Galaxy",
      "Source Galaxy Light Profile",
      "Lens Light",
      "Ray Tracing",
      "Source Image",
      "Fourier Transform",
      "Likelihood Function",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "contributor_guide.py",
      "scripts/guides/using_jax.py"
    ],
    "notebook": "notebooks/interferometer/likelihood_function.ipynb",
    "path": "scripts/interferometer/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Interferometer` data with a lens light profile and source light profile (e.g. an elliptical Sersic lens and source).",
    "title": "__Log Likelihood Function: Parametric__"
  },
  {
    "contents": [
      "Number of Visibilities",
      "Model",
      "Mask",
      "Dataset",
      "Over Sampling",
      "Coordinates",
      "Improved Lens Model",
      "Linear Light Profiles",
      "Concise API",
      "Search",
      "Unique Identifier",
      "Iterations Per Update",
      "Live Visual Update",
      "Analysis",
      "JAX",
      "VRAM Use",
      "Run Times",
      "Output Folder Layout",
      "Result",
      "Features",
      "Data Preparation",
      "HowToLens",
      "Modeling Customization"
    ],
    "cross_refs": [
      "/interferometer/data_preparation.ipynb",
      "interferometer/start_here.py",
      "start_here.py"
    ],
    "notebook": "notebooks/interferometer/modeling.ipynb",
    "path": "scripts/interferometer/modeling.py",
    "summary": "This script is the starting point for lens modeling of interferometer datasets (e.g. SMA, ALMA) and it provides an overview of the lens modeling API. The same workflow scales from a few hundred visibilities to many millions, thanks to the JAX-native `TransformerNUFFT` (backed by `nufftax`).",
    "title": "Modeling: Start Here"
  },
  {
    "contents": [
      "Dataset",
      "Dataset Subplot",
      "Dirty Images Subplot",
      "Fit",
      "Fit Figures",
      "Fit Subplot",
      "Fit Dirty Images Subplot",
      "Real Space Subplot",
      "Tracer Subplot",
      "Outputting to FITS",
      "Visualizer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "modeling.py"
    ],
    "notebook": "notebooks/interferometer/plot.ipynb",
    "path": "scripts/interferometer/plot.py",
    "summary": "This example shows how to plot an `Interferometer` dataset and a `FitInterferometer` fit, figure by figure and via multi-panel subplots.",
    "title": "Plots: Interferometer"
  },
  {
    "contents": [
      "Grid",
      "Over Sampling",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json",
      "Multiple Images",
      "Many Visibilities",
      "High Resolution Dataset",
      "JAX Variant (Advanced)"
    ],
    "cross_refs": [
      "autolens_workspace_test/scripts/interferometer/nufft.py",
      "scripts/cluster/simulator.py",
      "scripts/guides/using_jax.py",
      "scripts/point_source/simulator.py"
    ],
    "notebook": "notebooks/interferometer/simulator.ipynb",
    "path": "scripts/interferometer/simulator.py",
    "summary": "This script simulates `Interferometer` data of a 'galaxy-scale' strong lens where:",
    "title": "Simulator: SIE"
  },
  {
    "contents": [
      "Mask",
      "Loading Data",
      "Source Values",
      "Source Flux",
      "Source Magnification",
      "Tracer",
      "Parametric Source Models"
    ],
    "cross_refs": [],
    "notebook": "notebooks/interferometer/source_science.ipynb",
    "path": "scripts/interferometer/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy (or galaxies).",
    "title": "Source Science"
  },
  {
    "contents": [
      "JAX",
      "NUFFT (nufftax)",
      "Number of Visibilities",
      "Google Colab Setup",
      "Imports",
      "Dataset",
      "Model",
      "Model Fit",
      "Live Visual Update",
      "Result",
      "Model Your Own Lens",
      "Simulator",
      "Sample",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/scripts/interferometer/modeling.py",
      "autolens_workspace/start_here.py",
      "cluster/start_here.ipynb",
      "group/start_here.ipynb",
      "modeling.py",
      "scripts/interferometer/casa_reduction.py",
      "scripts/interferometer/simulator.py"
    ],
    "notebook": "notebooks/interferometer/start_here.ipynb",
    "path": "scripts/interferometer/start_here.py",
    "summary": "Strong lenses are observed with radio/mm interferometers (e.g. ALMA), which measure complex visibilities in the uv-plane instead of CCD images.",
    "title": "Start Here: Interferometer"
  },
  {
    "contents": [
      "Advantages & Disadvantages",
      "Model",
      "Colors",
      "Pixel Scales",
      "Dataset & Mask",
      "Analysis",
      "Search",
      "Result"
    ],
    "cross_refs": [
      "features/same_wavelength/modeling.py",
      "multi_dataset/start_here.ipynb"
    ],
    "notebook": "notebooks/multi_dataset/features/dataset_offsets/modeling.ipynb",
    "path": "scripts/multi_dataset/features/dataset_offsets/modeling.py",
    "summary": "Multi-wavelength datasets often have offsets between their images, which are due to the different telescope pointings during the observations.",
    "title": "Modeling Features: Dataset Offsets"
  },
  {
    "contents": [
      "Model",
      "Colors",
      "Dataset Paths",
      "Simulate",
      "Offset",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [],
    "notebook": "notebooks/multi_dataset/features/dataset_offsets/simulator.ipynb",
    "path": "scripts/multi_dataset/features/dataset_offsets/simulator.py",
    "summary": "Multi-wavelength datasets often have offsets between their images, which are due to the different telescope pointings during the observations.",
    "title": "Simulator: Dataset Offsets"
  },
  {
    "contents": [
      "Benefits",
      "Interferometer Masking",
      "Interferometer Dataset",
      "Imaging Dataset",
      "Imaging Masking",
      "Analysis",
      "Model",
      "Shared Source Mesh (Pixelization)",
      "Search",
      "Result"
    ],
    "cross_refs": [
      "features/same_wavelength/modeling.py",
      "start.here.py"
    ],
    "notebook": "notebooks/multi_dataset/features/imaging_and_interferometer/modeling.ipynb",
    "path": "scripts/multi_dataset/features/imaging_and_interferometer/modeling.py",
    "summary": "This script fits an `Interferometer` and `Imaging` dataset of a 'galaxy-scale' strong lens with a model where:",
    "title": "Modeling: Mass Total + Source Parametric"
  },
  {
    "contents": [
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "multi_dataset/simulator.py"
    ],
    "notebook": "notebooks/multi_dataset/features/imaging_and_interferometer/simulator.ipynb",
    "path": "scripts/multi_dataset/features/imaging_and_interferometer/simulator.py",
    "summary": "This script simulates `Interferometer` data of a 'galaxy-scale' strong lens where:",
    "title": "Simulator: Mutli Interferometer"
  },
  {
    "contents": [
      "Dataset",
      "Quasar Image Masking",
      "Model",
      "Analysis Factor & Factor Graph",
      "Search & Model-Fit",
      "Result"
    ],
    "cross_refs": [
      "point_source/features/deblending/modeling.py",
      "point_source/start_here.py"
    ],
    "notebook": "notebooks/multi_dataset/features/imaging_and_point_source/modeling.ipynb",
    "path": "scripts/multi_dataset/features/imaging_and_point_source/modeling.py",
    "summary": "This script jointly fits CCD imaging of a lensed quasar's **extended arcs** and its **point-source observables** (image positions and time delays) with a **single lens mass model**, using PyAutoFit's factor-graph API to sample the joint likelihood with one non-linear search.",
    "title": "Modeling: Combined Imaging + Point Source"
  },
  {
    "contents": [
      "Model",
      "Colors",
      "Pixel Scales",
      "Dataset & Mask",
      "Analysis",
      "Search",
      "Result",
      "Second Dataset Mass Model Fixed",
      "Second Dataset Offset"
    ],
    "cross_refs": [
      "multi_dataset/start_here.ipynb"
    ],
    "notebook": "notebooks/multi_dataset/features/one_by_one/modeling.ipynb",
    "path": "scripts/multi_dataset/features/one_by_one/modeling.py",
    "summary": "Multi-wavelength analysis does not necessarily require us to fit all datasets simultaneously. Instead, we can fit one dataset first in order to infer a robust lens and source model, and then fit the next dataset, using the inferred model as the starting point.",
    "title": "Modeling Features: One By One"
  },
  {
    "contents": [
      "Colors",
      "Pixel Scales",
      "Dataset & Mask",
      "Positions",
      "Mesh Shape",
      "Analysis",
      "Model",
      "Search",
      "Result"
    ],
    "cross_refs": [
      "/imaging/data_preparation/gui/positions.py",
      "start.here.py"
    ],
    "notebook": "notebooks/multi_dataset/features/pixelization/modeling.ipynb",
    "path": "scripts/multi_dataset/features/pixelization/modeling.py",
    "summary": "This script fits a multi-wavelength `Imaging` dataset of a 'galaxy-scale' strong lens with a model where:",
    "title": "Modeling: Pixelized"
  },
  {
    "contents": [
      "Colors",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [],
    "notebook": "notebooks/multi_dataset/features/pixelization/simulator.ipynb",
    "path": "scripts/multi_dataset/features/pixelization/simulator.py",
    "summary": "This script simulates multi-wavelength `Imaging` of a 'galaxy-scale' strong lens where:",
    "title": "Simulator: SIE"
  },
  {
    "contents": [
      "Pixel Scales",
      "Dataset & Mask",
      "Analysis",
      "Model",
      "Shared Source Mesh (Pixelization)",
      "Search",
      "Result"
    ],
    "cross_refs": [
      "start.here.py"
    ],
    "notebook": "notebooks/multi_dataset/features/same_wavelength/modeling.ipynb",
    "path": "scripts/multi_dataset/features/same_wavelength/modeling.py",
    "summary": "This script fits a multiple `Imaging` datasets observed at the same wavelength of a 'galaxy-scale' strong lens with a model where:",
    "title": "Modeling: Same Wavelength"
  },
  {
    "contents": [
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [],
    "notebook": "notebooks/multi_dataset/features/same_wavelength/simulator.ipynb",
    "path": "scripts/multi_dataset/features/same_wavelength/simulator.py",
    "summary": "This script simulates multiple `Imaging` datasets of a 'galaxy-scale' strong lens where:",
    "title": "Simulator: Wavelength Dependent"
  },
  {
    "contents": [
      "Preqrequisites",
      "This Script",
      "Dataset",
      "Settings AutoFit",
      "Redshifts",
      "SLaM Pipeline Functions",
      "SLaM Pipeline",
      "Second Dataset Fits",
      "Dataset Wavebands",
      "Result Dict"
    ],
    "cross_refs": [
      "guides/modeling/slam_start_here.ipynb",
      "multi_dataset/features/one_by_one/modeling.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/multi_dataset/features/slam/independent.ipynb",
    "path": "scripts/multi_dataset/features/slam/independent.py",
    "summary": "This example shows how to use the SLaM pipeline to fit a lens dataset at one wavelength, and then fit other data of the same lens at different wavelengths with the same mass model fitted to the original dataset.",
    "title": "SLaM: Multi Wavelength Independent"
  },
  {
    "contents": [
      "Preqrequisites",
      "This Script",
      "Dataset",
      "Settings AutoFit",
      "Redshifts",
      "SLaM Pipeline Functions",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "guides/modeling/slam_start_here.ipynb"
    ],
    "notebook": "notebooks/multi_dataset/features/slam/simultaneous.ipynb",
    "path": "scripts/multi_dataset/features/slam/simultaneous.py",
    "summary": "This example shows how to use the SLaM pipeline to fit a lens dataset at multiple wavelengths simultaneously.",
    "title": "SLaM: Multi Wavelength Simultaneous"
  },
  {
    "contents": [
      "Effective Radius vs Wavelength",
      "Colors",
      "Wavelengths",
      "Pixel Scales",
      "Dataset & Mask",
      "Analysis",
      "Model",
      "Shared Source Mesh (Pixelization)",
      "Search",
      "Result"
    ],
    "cross_refs": [
      "features/same_wavelength/modeling.py",
      "start.here.py"
    ],
    "notebook": "notebooks/multi_dataset/features/wavelength_dependence/modeling.ipynb",
    "path": "scripts/multi_dataset/features/wavelength_dependence/modeling.py",
    "summary": "This script fits a multi-wavelength `Imaging` dataset of a 'galaxy-scale' strong lens with a model where:",
    "title": "Modeling: Mass Total + Source Parametric"
  },
  {
    "contents": [
      "Colors",
      "Wavelengths",
      "Dataset Paths",
      "Simulate",
      "Intensity vs Wavelength",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [],
    "notebook": "notebooks/multi_dataset/features/wavelength_dependence/simulator.ipynb",
    "path": "scripts/multi_dataset/features/wavelength_dependence/simulator.py",
    "summary": "This script simulates multi-wavelength `Imaging` of a 'galaxy-scale' strong lens where:",
    "title": "Simulator: Wavelength Dependent"
  },
  {
    "contents": [
      "Colors",
      "Pixel Scales",
      "Dataset & Mask",
      "Model",
      "Model Extension",
      "Linear Light Profiles",
      "Analysis List",
      "JAX",
      "Analysis Factor",
      "Factor Graph",
      "Search",
      "Live Visual Update",
      "VRAM Use",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "start_here.py"
    ],
    "notebook": "notebooks/multi_dataset/modeling.ipynb",
    "path": "scripts/multi_dataset/modeling.py",
    "summary": "This script fits a multi-wavelength `Imaging` dataset of a 'galaxy-scale' strong lens with a model where:",
    "title": "Modeling: Multi Modeling"
  },
  {
    "contents": [
      "Dataset",
      "Single Dataset Subplots",
      "Combined Dataset Subplot",
      "Fits",
      "Combined Fit Subplot",
      "Multi Fits",
      "Visualizer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "scripts/imaging/plot.py",
      "scripts/multi_dataset/modeling.py",
      "scripts/multi_dataset/simulator.py"
    ],
    "notebook": "notebooks/multi_dataset/plot.ipynb",
    "path": "scripts/multi_dataset/plot.py",
    "summary": "This example shows how to plot multiple datasets \u2014 and fits to multiple datasets \u2014 together, with every dataset appearing in one combined subplot.",
    "title": "Plots: Multi"
  },
  {
    "contents": [
      "Colors",
      "Dataset Paths",
      "Simulate",
      "Ray Tracing",
      "Output",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "multi_dataset/modeling.py"
    ],
    "notebook": "notebooks/multi_dataset/simulator.ipynb",
    "path": "scripts/multi_dataset/simulator.py",
    "summary": "This script simulates multi-wavelength `Imaging` of a 'galaxy-scale' strong lens where:",
    "title": "Simulator: SIE"
  },
  {
    "contents": [
      "JAX",
      "Google Colab Setup",
      "Imports",
      "Dataset",
      "Extra Galaxy Removal",
      "Masking",
      "Model",
      "Analysis",
      "Model Fit",
      "Live Visual Update",
      "Result",
      "Model Your Own Lens",
      "Simulator",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/start_here.py",
      "cluster/start_here.ipynb",
      "group/start_here.ipynb",
      "imaging/start_here.ipynb",
      "imaging/start_here.py",
      "modeling.py",
      "scripts/imaging/simulator.py"
    ],
    "notebook": "notebooks/multi_dataset/start_here.ipynb",
    "path": "scripts/multi_dataset/start_here.py",
    "summary": "Strong gravitational lenses are often observed with CCD imaging, for example using HST, JWST, or ground-based telescopes.",
    "title": "Start Here: Multi Wavelength"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset",
      "Centres",
      "Paths",
      "Masking (Search 1)",
      "Model (Search 1)",
      "Search + Analysis + Model-Fit (Search 1)",
      "Masking (Search 2)",
      "Model (Search 2)",
      "Search + Analysis + Model-Fit (Search 2)",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/double_source_plane_lens/chaining.py",
      "modeling.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/modeling.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/slam.py",
      "multi_galaxy/modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/double_source_plane_lens/chaining.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/double_source_plane_lens/chaining.py",
    "summary": "This script fits a multi-galaxy double source-plane lens with **two chained searches**, which is how you would fit one on real data. `modeling.py` in this folder does it in one search, but only by initialising priors at their true values.",
    "title": "Chaining: DSPL (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Mask",
      "Centres",
      "Over Sampling",
      "MGE Bases",
      "Galaxies",
      "Tracer",
      "Fit",
      "Multi-Plane Ray-Tracing",
      "Basis Images",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/double_source_plane_lens/fit.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/likelihood_function.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/modeling.py",
      "multi_galaxy/fit.py",
      "simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/double_source_plane_lens/fit.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/double_source_plane_lens/fit.py",
    "summary": "This script fits a multi-galaxy double source-plane lens without a non-linear search, so the multi-plane tracer and the objects it produces can be inspected directly.",
    "title": "Fits: DSPL (Multi Galaxy)"
  },
  {
    "contents": [
      "What Changes",
      "Dataset, Mask & Over Sampling",
      "Galaxies",
      "Multi-Plane Ray-Tracing",
      "Source-Plane Images",
      "Image Assembly",
      "Likelihood",
      "Fit",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/double_source_plane_lens/likelihood_function.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/fit.py",
      "multi_galaxy/likelihood_function.py",
      "simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/double_source_plane_lens/likelihood_function.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/double_source_plane_lens/likelihood_function.py",
    "summary": "This script walks through the log likelihood function of a multi-galaxy double source-plane lens, step by step, so the calculation can be followed without reading the source code.",
    "title": "__Log Likelihood Function: DSPL (Multi Galaxy)__"
  },
  {
    "contents": [
      "Why Two Source Planes Help Here",
      "Model",
      "Dataset, Mask & Over Sampling",
      "Model Composition",
      "Model Cookbook",
      "Cheating",
      "Cosmology",
      "Search & Analysis",
      "Run Time",
      "VRAM",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "chaining.py",
      "imaging/features/advanced/double_source_plane_lens/modeling.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/chaining.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/fit.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/slam.py",
      "multi_galaxy/modeling.py",
      "simulator.py",
      "slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/double_source_plane_lens/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/double_source_plane_lens/modeling.py",
    "summary": "A double source-plane lens (DSPL) is a strong lens with two source galaxies at different redshifts behind the same deflector. They appear as two distinct Einstein rings in the image plane, and can constrain cosmological parameters in a way single-ring lenses cannot.",
    "title": "Modeling Features: DSPL (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "PSF Convolution",
      "Main Lens Galaxies",
      "External Shear",
      "Source Galaxies",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files"
    ],
    "cross_refs": [
      "imaging/features/advanced/double_source_plane_lens/simulator.py",
      "modeling.py",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/double_source_plane_lens/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/double_source_plane_lens/simulator.py",
    "summary": "A double source-plane lens (DSPL) is a strong lens with **two source galaxies at different redshifts** behind the same deflector. They appear as two distinct Einstein rings in the image plane.",
    "title": "Simulator: DSPL (Multi Galaxy)"
  },
  {
    "contents": [
      "Helpers",
      "Source LP Pipeline 1 & 2",
      "Source Pix Pipeline 1 & 2",
      "Light LP Pipeline",
      "Mass Total Pipeline",
      "Dataset, Centres, Masks",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "chaining.py",
      "modeling.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/chaining.py",
      "multi_galaxy/features/advanced/double_source_plane_lens/modeling.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/double_source_plane_lens/slam.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/double_source_plane_lens/slam.py",
    "summary": "The SLaM pipeline for a multi-galaxy double source-plane lens.",
    "title": "SLaM (Source, Light and Mass): DSPL (Multi Galaxy)"
  },
  {
    "contents": [
      "Prerequisites",
      "Dataset, Mask & Over Sampling",
      "Centres",
      "Paths",
      "Model (Search 1)",
      "Search + Analysis + Model-Fit (Search 1)",
      "Model (Search 2)",
      "Search + Analysis + Model-Fit (Search 2)",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/mass_stellar_dark/chaining.py",
      "modeling.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/modeling.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/slam.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/mass_stellar_dark/chaining.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/mass_stellar_dark/chaining.py",
    "summary": "This script fits a multi-galaxy lens with decomposed stellar and dark mass using **two chained searches**: a total mass model first, the decomposition second.",
    "title": "Chaining: Stellar and Dark Mass (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Mask",
      "Centres",
      "Over Sampling",
      "Galaxies",
      "Tracer",
      "Fit",
      "Decomposed Deflection",
      "Component Fractions",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/mass_stellar_dark/fit.py",
      "modeling.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/likelihood_function.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/modeling.py",
      "multi_galaxy/fit.py",
      "simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/mass_stellar_dark/fit.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/mass_stellar_dark/fit.py",
    "summary": "This script fits a multi-galaxy strong lens with decomposed stellar and dark mass, without a non-linear search, so the individual mass components and the deflection field each contributes can be inspected directly.",
    "title": "Fits: Stellar and Dark Mass (Multi Galaxy)"
  },
  {
    "contents": [
      "What Changes",
      "Dataset, Mask & Over Sampling",
      "Galaxies",
      "Lens Light",
      "Decomposed Deflection",
      "Ray Tracing",
      "Source-Plane Image",
      "Likelihood",
      "Fit",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/mass_stellar_dark/likelihood_function.py",
      "modeling.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/fit.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/modeling.py",
      "multi_galaxy/likelihood_function.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/mass_stellar_dark/likelihood_function.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/mass_stellar_dark/likelihood_function.py",
    "summary": "This script walks through the log likelihood function of a multi-galaxy lens whose deflectors have **decomposed stellar and dark mass**, step by step.",
    "title": "__Log Likelihood Function: Stellar and Dark Mass (Multi Galaxy)__"
  },
  {
    "contents": [
      "Advantages",
      "Disadvantages",
      "The Choice This Folder Is About",
      "Model",
      "Dataset, Mask & Over Sampling",
      "Model Composition",
      "Tying The Mass-To-Light Ratio",
      "Model Cookbook",
      "Search & Analysis",
      "Run Time",
      "VRAM",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/mass_stellar_dark/modeling.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/chaining.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/fit.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/slam.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/mass_stellar_dark/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/mass_stellar_dark/modeling.py",
    "summary": "This script fits a multi-galaxy strong lens where **each co-dominant deflector's mass is decomposed into a stellar component and a dark matter halo**, rather than described by a single total mass profile.",
    "title": "Modeling Features: Stellar and Dark Mass (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "PSF Convolution",
      "Main Lens Galaxies",
      "External Shear",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files"
    ],
    "cross_refs": [
      "imaging/features/advanced/mass_stellar_dark/simulator.py",
      "modeling.py",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/mass_stellar_dark/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/mass_stellar_dark/simulator.py",
    "summary": "This script simulates a multi-galaxy strong lens where **each co-dominant deflector's mass is decomposed into a stellar component and a dark matter halo**, rather than described by a single total mass profile.",
    "title": "Simulator: Stellar and Dark Mass (Multi Galaxy)"
  },
  {
    "contents": [
      "Helpers",
      "Source LP Pipeline",
      "Source Pix Pipeline 1 & 2",
      "Light LP Pipeline",
      "Mass Light Dark Pipeline",
      "Dataset, Centres, Mask",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "multi_galaxy/features/advanced/mass_stellar_dark/chaining.py",
      "multi_galaxy/features/advanced/mass_stellar_dark/modeling.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/mass_stellar_dark/slam.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/mass_stellar_dark/slam.py",
    "summary": "The SLaM pipeline for a multi-galaxy lens whose deflectors' mass is decomposed into stellar and dark components.",
    "title": "SLaM (Source, Light and Mass): Stellar and Dark Mass (Multi Galaxy)"
  },
  {
    "contents": [
      "Advantages",
      "Disadvantages",
      "Positive Only Solver",
      "Model",
      "Dataset, Mask & Over Sampling",
      "Positions",
      "Model Composition",
      "Model Cookbook",
      "Search & Analysis",
      "Run Time",
      "VRAM",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/operated_light_profile/modeling.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/operated_light_profile/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/operated_light_profile/modeling.py",
    "summary": "This script fits a multi-galaxy strong lens where **each co-dominant deflector hosts a compact nuclear point source** \u2014 an AGN \u2014 modelled with an operated light profile.",
    "title": "Modeling Features: Operated Light Profiles (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "PSF Convolution",
      "Main Lens Galaxies",
      "External Shear",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files",
      "Positions"
    ],
    "cross_refs": [
      "modeling.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/operated_light_profile/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/operated_light_profile/simulator.py",
    "summary": "This script simulates a multi-galaxy strong lens where **each co-dominant deflector hosts a compact nuclear point source** \u2014 an AGN \u2014 on top of its extended stellar light.",
    "title": "Simulator: Operated Light Profiles (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Extra Galaxies Noise Scaling",
      "Mask",
      "Centres",
      "Over Sampling",
      "Basis",
      "Main Lens Galaxies",
      "Fit",
      "Intensities",
      "Basis Image",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/shapelets/fit.py",
      "modeling.py",
      "multi_galaxy/features/advanced/shapelets/modeling.py",
      "multi_galaxy/features/pixelization/fit.py",
      "multi_galaxy/fit.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/shapelets/fit.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/shapelets/fit.py",
    "summary": "This script fits a multi-galaxy strong lens with a shapelet source, without a non-linear search, so the `Basis` API and the solved shapelet intensities can be inspected directly.",
    "title": "Fits: Shapelets (Multi Galaxy)"
  },
  {
    "contents": [
      "Advantages",
      "Disadvantages",
      "Positive Negative Solver",
      "Why The Deflectors Stay MGE",
      "Model",
      "Dataset, Mask & Over Sampling",
      "Positions",
      "Model Composition",
      "Model Cookbook",
      "Search & Analysis",
      "Run Time",
      "VRAM",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/shapelets/modeling.py",
      "multi_galaxy/features/advanced/shapelets/fit.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/shapelets/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/shapelets/modeling.py",
    "summary": "This script fits a multi-galaxy strong lens where the **source** is reconstructed with a basis of shapelets \u2014 a set of orthogonal basis functions well suited to describing irregular, asymmetric morphology with relatively few non-linear parameters.",
    "title": "Modeling Features: Shapelets (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Mask",
      "Centres",
      "Over Sampling",
      "Main Lens Galaxies",
      "Fit",
      "Sky Omitted",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/sky_background/fit.py",
      "modeling.py",
      "multi_galaxy/features/advanced/sky_background/modeling.py",
      "multi_galaxy/fit.py",
      "simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/sky_background/fit.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/sky_background/fit.py",
    "summary": "This script fits a multi-galaxy strong lens whose data still contains the sky background, without a non-linear search, so the `DatasetModel` API can be seen directly.",
    "title": "Fits: Sky Background (Multi Galaxy)"
  },
  {
    "contents": [
      "Advantages",
      "Disadvantages",
      "Model",
      "Dataset, Mask & Over Sampling",
      "Positions",
      "Model Composition",
      "Model Cookbook",
      "Search & Analysis",
      "Run Time",
      "VRAM",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/advanced/sky_background/modeling.py",
      "multi_galaxy/features/advanced/sky_background/fit.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/sky_background/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/sky_background/modeling.py",
    "summary": "This script fits a multi-galaxy strong lens whose data still contains the **sky background** \u2014 the diffuse emission from the atmosphere, zodiacal light and unresolved sources in the field.",
    "title": "Modeling Features: Sky Background (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "PSF Convolution",
      "Sky Background",
      "Main Lens Galaxies",
      "External Shear",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files",
      "Positions"
    ],
    "cross_refs": [
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/sky_background/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/sky_background/simulator.py",
    "summary": "This script simulates a multi-galaxy strong lens dataset where the **sky background is not subtracted**, so it is present in the data and has to be accounted for when the lens model is fitted.",
    "title": "Simulator: Sky Background (Multi Galaxy)"
  },
  {
    "contents": [
      "What Changes",
      "The False Positive This Regime Invites",
      "Helpers",
      "Source LP / Source Pix 1 & 2 / Light LP / Mass Total",
      "Subhalo Pipeline (no subhalo)",
      "Subhalo Pipeline (grid search)",
      "Subhalo Pipeline (refine)",
      "Dataset, Centres, Mask",
      "Mesh Shape",
      "Pipeline",
      "Bayesian Evidence",
      "Grid Search Result"
    ],
    "cross_refs": [
      "multi_galaxy/modeling.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/subhalo/detect/start_here.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/subhalo/detect/start_here.py",
    "summary": "This script runs the full SLaM pipeline followed by the three SUBHALO stages, to detect a dark matter subhalo in a multi-galaxy strong lens.",
    "title": "Subhalo Detection: Multi Galaxy"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "PSF Convolution",
      "Main Lens Galaxies",
      "External Shear",
      "Subhalo",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files"
    ],
    "cross_refs": [
      "detect/start_here.py",
      "imaging/features/advanced/subhalo/simulator.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/advanced/subhalo/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/advanced/subhalo/simulator.py",
    "summary": "This script simulates a multi-galaxy strong lens containing a **dark matter subhalo** \u2014 a compact, dark perturber that distorts the lensed source's arcs without producing any light of its own.",
    "title": "Simulator: Subhalo (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Mask & Over Sampling",
      "Centres",
      "Why Not Noise Scaling",
      "Model",
      "Extra Galaxies Model",
      "Getting The Tier Wrong",
      "Search + Analysis / Run Time / Model-Fit / Result.",
      "Wrap Up"
    ],
    "cross_refs": [
      "cluster/modeling.py",
      "group/modeling.py",
      "imaging/features/extra_galaxies/modeling.ipynb",
      "multi_galaxy/modeling.ipynb",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py",
      "multi_galaxy/start_here.ipynb"
    ],
    "notebook": "notebooks/multi_galaxy/features/extra_galaxies/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/extra_galaxies/modeling.py",
    "summary": "Extends the multi-galaxy lens model with an **extra galaxies tier**: perturbers near the co-dominant pair which are carried in the model with their own light and mass, their centres fixed to the observed light.",
    "title": "Modeling Features (Multi Galaxy): Extra Galaxies"
  },
  {
    "contents": [
      "Dataset Paths / Grid / PSF / Simulator",
      "Main Lens Galaxies",
      "Extra Galaxies",
      "Shear / Source",
      "Dataset",
      "Mask Extra Galaxies",
      "Records"
    ],
    "cross_refs": [
      "modeling.py",
      "multi_galaxy/simulator.ipynb",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/extra_galaxies/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/extra_galaxies/simulator.py",
    "summary": "Simulates the dataset for the `multi_galaxy/features/extra_galaxies` feature: the co-dominant pair of `multi_galaxy/simulator.py`, plus two extra galaxies near the lens which have **mass as well as light**.",
    "title": "Simulator: Multi Galaxy Extra Galaxies"
  },
  {
    "contents": [
      "What Changes",
      "The Tier Through The Stages",
      "Source LP Pipeline",
      "Source Pix Pipeline 1 & 2",
      "Light LP Pipeline",
      "Mass Total Pipeline",
      "Dataset, Centres, Mask",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "imaging/features/extra_galaxies/slam.py",
      "modeling.py",
      "multi_galaxy/features/extra_galaxies/modeling.py",
      "multi_galaxy/features/linear_light_profiles/likelihood_function.py",
      "multi_galaxy/slam.py",
      "simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/extra_galaxies/slam.ipynb",
    "path": "scripts/multi_galaxy/features/extra_galaxies/slam.py",
    "summary": "The SLaM pipeline for a multi-galaxy lens with a tier of perturbing extra galaxies alongside the co-dominant deflectors.",
    "title": "SLaM (Source, Light and Mass): Extra Galaxies (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Tracer",
      "Fit",
      "Intensities",
      "Comparison To Truth",
      "The Flux Ratio",
      "Negative Intensities",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/linear_light_profiles/fit.py",
      "modeling.py",
      "multi_galaxy/features/linear_light_profiles/likelihood_function.py",
      "multi_galaxy/features/linear_light_profiles/modeling.py",
      "multi_galaxy/features/scaling_relation/slam.py",
      "multi_galaxy/fit.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/linear_light_profiles/fit.ipynb",
    "path": "scripts/multi_galaxy/features/linear_light_profiles/fit.py",
    "summary": "This script fits a multi-galaxy strong lens with linear light profiles **without a non-linear search** \u2014 the model is composed at known values and fitted once, so the linear solve can be inspected directly.",
    "title": "Fits: Linear Light Profiles (Multi Galaxy)"
  },
  {
    "contents": [
      "What Changes",
      "Dataset, Mask & Over Sampling",
      "Tracer",
      "Linear Object Lists",
      "Blurred Mapping Matrix (f)",
      "Data Vector (D)",
      "Curvature Matrix (F)",
      "Reconstruction",
      "Log Likelihood",
      "Wrap Up"
    ],
    "cross_refs": [
      "fit.py",
      "imaging/features/linear_light_profiles/likelihood_function.py",
      "multi_galaxy/features/linear_light_profiles/fit.py",
      "multi_galaxy/likelihood_function.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/linear_light_profiles/likelihood_function.ipynb",
    "path": "scripts/multi_galaxy/features/linear_light_profiles/likelihood_function.py",
    "summary": "This script walks through the log likelihood function of a multi-galaxy lens fitted with **linear light profiles**, step by step, with an emphasis on the one step that behaves differently when there are two co-dominant deflectors.",
    "title": "__Log Likelihood Function: Linear Light Profiles (Multi Galaxy)__"
  },
  {
    "contents": [
      "Advantages",
      "Disadvantages",
      "Model",
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Model Composition",
      "Search",
      "Analysis",
      "Result",
      "Intensities",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/linear_light_profiles/modeling.py",
      "multi_galaxy/features/linear_light_profiles/fit.py",
      "multi_galaxy/features/linear_light_profiles/likelihood_function.py",
      "multi_galaxy/features/linear_light_profiles/slam.py",
      "multi_galaxy/features/scaling_relation/slam.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/linear_light_profiles/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/linear_light_profiles/modeling.py",
    "summary": "A \"linear light profile\" is a variant of a standard light profile where the `intensity` parameter is solved for via linear algebra every time the model is fitted, rather than being sampled by the non-linear search. The solver always computes the `intensity` values that maximize the likelihood for the other parameters' current values.",
    "title": "Modeling Features: Linear Light Profiles (Multi Galaxy)"
  },
  {
    "contents": [
      "What Changes",
      "Source LP Pipeline",
      "Source Pix Pipeline 1 & 2",
      "Light LP Pipeline",
      "Mass Total Pipeline",
      "Dataset, Centres, Mask",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "fit.py",
      "imaging/features/linear_light_profiles/slam.py",
      "multi_galaxy/features/linear_light_profiles/likelihood_function.py",
      "multi_galaxy/simulator.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/linear_light_profiles/slam.ipynb",
    "path": "scripts/multi_galaxy/features/linear_light_profiles/slam.py",
    "summary": "The SLaM pipeline for a multi-galaxy lens using a single linear `Sersic` per deflector, instead of the MGE bases used by `multi_galaxy/slam.py`.",
    "title": "SLaM (Source, Light and Mass): Linear Light Profiles (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Basis",
      "Two Bases",
      "Fit",
      "Comparison To A Sersic",
      "How Many Gaussians",
      "Solved Intensities",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/multi_gaussian_expansion/fit.py",
      "likelihood_function.py",
      "modeling.py",
      "multi_galaxy/features/linear_light_profiles/fit.py",
      "multi_galaxy/features/multi_gaussian_expansion/likelihood_function.py",
      "multi_galaxy/features/multi_gaussian_expansion/modeling.py",
      "multi_galaxy/modeling.py",
      "simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/multi_gaussian_expansion/fit.ipynb",
    "path": "scripts/multi_galaxy/features/multi_gaussian_expansion/fit.py",
    "summary": "This script fits a multi-galaxy strong lens with an MGE per co-dominant deflector **without a non-linear search**, so the basis can be built by hand and the MGE-versus-Sersic comparison run directly.",
    "title": "Fits: Multi Gaussian Expansion (Multi Galaxy)"
  },
  {
    "contents": [
      "What Changes",
      "Dataset, Mask & Over Sampling",
      "Tracer",
      "Linear Object Lists",
      "Blurred Mapping Matrix",
      "Curvature Matrix (F)",
      "Condition Number",
      "Reconstruction",
      "Wrap Up"
    ],
    "cross_refs": [
      "fit.py",
      "imaging/features/multi_gaussian_expansion/likelihood_function.py",
      "multi_galaxy/features/linear_light_profiles/likelihood_function.py",
      "multi_galaxy/features/multi_gaussian_expansion/fit.py",
      "multi_galaxy/features/multi_gaussian_expansion/source_science.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/multi_gaussian_expansion/likelihood_function.ipynb",
    "path": "scripts/multi_galaxy/features/multi_gaussian_expansion/likelihood_function.py",
    "summary": "This script walks through the log likelihood function of a multi-galaxy lens fitted with **an MGE per co-dominant deflector**, focusing on the one structure that has no galaxy-scale equivalent: the block structure of the curvature matrix when two nearby galaxies each carry their own basis.",
    "title": "__Log Likelihood Function: Multi Gaussian Expansion (Multi Galaxy)__"
  },
  {
    "contents": [
      "Why This Folder Exists",
      "Advantages",
      "Disadvantages",
      "Model",
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Model Composition",
      "How Many Gaussians",
      "Search",
      "Analysis",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/multi_gaussian_expansion/modeling.py",
      "multi_galaxy/features/linear_light_profiles/likelihood_function.py",
      "multi_galaxy/features/multi_gaussian_expansion/fit.py",
      "multi_galaxy/features/multi_gaussian_expansion/likelihood_function.py",
      "multi_galaxy/features/multi_gaussian_expansion/slam.py",
      "multi_galaxy/features/multi_gaussian_expansion/source_science.py",
      "multi_galaxy/modeling.py",
      "simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/multi_gaussian_expansion/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/multi_gaussian_expansion/modeling.py",
    "summary": "A Multi Gaussian Expansion (MGE) decomposes a galaxy's light into ~10-30 Gaussians whose `intensity` values are solved by linear algebra. This script fits a multi-galaxy strong lens giving **each co-dominant deflector its own MGE**.",
    "title": "Modeling Features: Multi Gaussian Expansion (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "PSF Convolution",
      "Main Lens Galaxies",
      "External Shear",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files",
      "Positions"
    ],
    "cross_refs": [
      "multi_galaxy/simulator.ipynb",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/multi_gaussian_expansion/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/multi_gaussian_expansion/simulator.py",
    "summary": "This script simulates `Imaging` of a 'multi-galaxy' strong lens whose co-dominant deflectors have **disturbed, asymmetric light** that a single symmetric `Sersic` cannot represent.",
    "title": "Simulator: Multi Gaussian Expansion (Multi Galaxy)"
  },
  {
    "contents": [
      "Source LP Pipeline",
      "Source Pix Pipeline 1 & 2",
      "Light LP Pipeline",
      "Mass Total Pipeline",
      "Dataset, Centres, Mask",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "fit.py",
      "likelihood_function.py",
      "multi_galaxy/features/multi_gaussian_expansion/fit.py",
      "multi_galaxy/features/multi_gaussian_expansion/source_science.py",
      "multi_galaxy/slam.py",
      "simulator.py",
      "source_science.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/multi_gaussian_expansion/slam.ipynb",
    "path": "scripts/multi_galaxy/features/multi_gaussian_expansion/slam.py",
    "summary": "The SLaM pipeline for a multi-galaxy lens whose deflectors have disturbed, twisted light \u2014 the `mge` dataset of this folder's `simulator.py`.",
    "title": "SLaM (Source, Light and Mass): Multi Gaussian Expansion (Multi Galaxy)"
  },
  {
    "contents": [
      "Why Integrate A Basis",
      "Dataset & Fit",
      "Deflector Luminosities",
      "The Flux Ratio",
      "Source Magnification",
      "Source Flux",
      "Wrap Up"
    ],
    "cross_refs": [
      "fit.py",
      "imaging/features/multi_gaussian_expansion/source_science.py",
      "likelihood_function.py",
      "modeling.py",
      "multi_galaxy/features/multi_gaussian_expansion/likelihood_function.py",
      "multi_galaxy/features/scaling_relation/slam.py",
      "multi_galaxy/fit.py",
      "multi_galaxy/slam.py",
      "multi_galaxy/source_science.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/multi_gaussian_expansion/source_science.ipynb",
    "path": "scripts/multi_galaxy/features/multi_gaussian_expansion/source_science.py",
    "summary": "Science calculations on a multi-galaxy lens fitted with an MGE per co-dominant deflector: the **luminosity of each deflector**, the **flux ratio** between them, and the source's magnification and flux.",
    "title": "Source Science: Multi Gaussian Expansion (Multi Galaxy)"
  },
  {
    "contents": [
      "Advantages",
      "Disadvantages",
      "Model",
      "Dataset & Mask",
      "Centres",
      "Over Sampling",
      "Model Composition",
      "Search",
      "Analysis",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/no_lens_light/modeling.py",
      "multi_galaxy/features/no_lens_light/slam.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/start_here.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/no_lens_light/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/no_lens_light/modeling.py",
    "summary": "CCD imaging data of a multi-galaxy strong lens may not have lens galaxy light emission present \u2014 for example if the deflectors' light has already been subtracted from the image, or if they are undetected at the observed wavelength.",
    "title": "Modeling Features: No Lens Light (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Over Sampling",
      "PSF Convolution",
      "Main Lens Galaxies",
      "External Shear",
      "Source Galaxy",
      "Ray Tracing",
      "Dataset",
      "Visualize",
      "Tracer json",
      "Centre JSON Files",
      "Positions"
    ],
    "cross_refs": [
      "imaging/features/no_lens_light/simulator.py",
      "modeling.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.ipynb",
      "multi_galaxy/simulator.py",
      "slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/no_lens_light/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/no_lens_light/simulator.py",
    "summary": "This script simulates `Imaging` of a 'multi-galaxy' strong lens where neither co-dominant deflector has visible light emission \u2014 only their mass profiles contribute to the ray-tracing. The source galaxy still has light.",
    "title": "Simulator: No Lens Light (Multi Galaxy)"
  },
  {
    "contents": [
      "What Changes",
      "Source LP Pipeline",
      "Source Pix Pipeline 1",
      "Source Pix Pipeline 2",
      "Mass Total Pipeline",
      "Dataset, Centres, Mask",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "imaging/features/no_lens_light/slam.py",
      "modeling.py",
      "multi_galaxy/features/no_lens_light/modeling.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/no_lens_light/slam.ipynb",
    "path": "scripts/multi_galaxy/features/no_lens_light/slam.py",
    "summary": "The SLaM pipeline for a multi-galaxy lens whose co-dominant deflectors have no visible light.",
    "title": "SLaM (Source, Light and Mass): No Lens Light (Multi Galaxy)"
  },
  {
    "contents": [
      "Adaptive Features",
      "Dataset",
      "Extra Galaxies Noise Scaling",
      "Mask, Centres & Over Sampling",
      "Paths",
      "Model (Search 1)",
      "Mesh Shape",
      "Model (Search 2)",
      "Adapt Images",
      "Model (Search 3)",
      "Model (Search 4)",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/pixelization/adaptive.py",
      "multi_galaxy/features/pixelization/delaunay.py",
      "multi_galaxy/features/pixelization/modeling.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/adaptive.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/adaptive.py",
    "summary": "This script fits a multi-galaxy strong lens with an **adaptive** pixelized source, where both the mesh and the regularization adapt to the source's own reconstructed morphology rather than being applied uniformly.",
    "title": "Adaptive Pixelization (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Extra Galaxies Noise Scaling",
      "Mask, Centres & Over Sampling",
      "Sparse Operators",
      "Mesh Shape",
      "Fit",
      "Model",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/pixelization/cpu_fast_modeling.py",
      "multi_galaxy/features/pixelization/delaunay.py",
      "multi_galaxy/features/pixelization/fit.py",
      "multi_galaxy/features/pixelization/modeling.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/cpu_fast_modeling.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/cpu_fast_modeling.py",
    "summary": "This script fits a multi-galaxy strong lens with a pixelized source **on the CPU, without JAX**, using:",
    "title": "CPU Fast Modeling: Pixelization (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Extra Galaxies Noise Scaling",
      "Mask, Centres & Over Sampling",
      "Image-Plane Mesh Grid",
      "Edge Zeroing",
      "Fit",
      "Inversion Visualization",
      "Reconstructed Source",
      "Model",
      "Search & Analysis",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/pixelization/delaunay.py",
      "multi_galaxy/features/pixelization/adaptive.py",
      "multi_galaxy/features/pixelization/fit.py",
      "multi_galaxy/features/pixelization/modeling.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/delaunay.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/delaunay.py",
    "summary": "This script fits a multi-galaxy strong lens with a source reconstructed on a **Delaunay** mesh, the alternative to the rectangular meshes used elsewhere in this package.",
    "title": "Delaunay Pixelization (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Extra Galaxies Noise Scaling",
      "Mask",
      "Over Sampling",
      "Mesh Shape",
      "Pixelization",
      "Main Lens Galaxies",
      "Fit",
      "Inversion",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/pixelization/fit.py",
      "multi_galaxy/features/pixelization/modeling.py",
      "multi_galaxy/fit.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/fit.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/fit.py",
    "summary": "This script fits a multi-galaxy strong lens with a pixelized source reconstruction, without a non-linear search, so the pixelization API and the objects it produces can be inspected directly.",
    "title": "Fits: Pixelization (Multi Galaxy)"
  },
  {
    "contents": [
      "What Changes",
      "Dataset, Mask & Over Sampling",
      "Main Lens Galaxies",
      "Source Galaxy Pixelization",
      "Lens Light",
      "Deflection Angles",
      "Ray Tracing",
      "Pixelized Source Reconstruction",
      "Likelihood Function",
      "Fit",
      "Inversion Details",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/pixelization/likelihood_function.py",
      "multi_galaxy/features/pixelization/delaunay.py",
      "multi_galaxy/features/pixelization/fit.py",
      "multi_galaxy/features/pixelization/modeling.py",
      "multi_galaxy/likelihood_function.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/likelihood_function.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/likelihood_function.py",
    "summary": "This script walks through the log likelihood function of a multi-galaxy lens fitted with a **pixelized source**, step by step, so the calculation can be followed without reading the source code.",
    "title": "__Log Likelihood Function: Pixelization (Multi Galaxy)__"
  },
  {
    "contents": [
      "Advantages",
      "Disadvantages",
      "Positive Only Solver",
      "Model",
      "Dataset, Mask & Over Sampling",
      "Positions",
      "Model Composition",
      "Search & Analysis",
      "Run Time",
      "VRAM",
      "Result",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/pixelization/modeling.py",
      "multi_galaxy/features/pixelization/adaptive.py",
      "multi_galaxy/features/pixelization/delaunay.py",
      "multi_galaxy/features/pixelization/fit.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/modeling.py",
    "summary": "This script fits a multi-galaxy strong lens with a **pixelized source reconstruction**: the source is reconstructed on a mesh of pixels whose fluxes are solved by linear algebra, rather than assumed to follow an analytic profile.",
    "title": "Modeling Features: Pixelization (Multi Galaxy)"
  },
  {
    "contents": [
      "Setup",
      "Fit Imaging",
      "Inversion",
      "Mapper Grids",
      "Mapper Galaxy Dict",
      "Wrap Up"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "imaging/features/pixelization/plot.py",
      "multi_galaxy/features/pixelization/fit.py",
      "multi_galaxy/features/pixelization/source_science.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/plot.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/plot.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/plot.py",
    "summary": "This script plots a multi-galaxy fit whose source is reconstructed on a pixelized mesh.",
    "title": "Plots: Pixelization (Multi Galaxy)"
  },
  {
    "contents": [
      "Source LP Pipeline",
      "Source Pix Pipeline 1 & 2",
      "Light LP Pipeline",
      "Mass Total Pipeline",
      "Dataset, Centres, Mask",
      "Mesh Shape",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "multi_galaxy/features/pixelization/adaptive.py",
      "multi_galaxy/features/pixelization/delaunay.py",
      "multi_galaxy/features/pixelization/source_science.py",
      "multi_galaxy/slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/slam.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/slam.py",
    "summary": "The SLaM pipeline for a multi-galaxy lens, with every pixelization choice its SOURCE PIX stages make written out.",
    "title": "SLaM (Source, Light and Mass): Pixelization (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset",
      "Extra Galaxies Noise Scaling",
      "Mask, Centres & Over Sampling",
      "Model Fit",
      "Inversion",
      "Source Flux",
      "Source Magnification",
      "Omitting A Deflector",
      "Interpolated Source",
      "Zoom",
      "Errors",
      "Parametric Comparison",
      "Magnification via Mesh",
      "Wrap Up"
    ],
    "cross_refs": [
      "imaging/features/pixelization/source_science.py",
      "multi_galaxy/features/pixelization/modeling.py",
      "multi_galaxy/features/pixelization/plot.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py",
      "multi_galaxy/source_science.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/pixelization/source_science.ipynb",
    "path": "scripts/multi_galaxy/features/pixelization/source_science.py",
    "summary": "Source science studies the highly magnified background source rather than the deflectors. This script computes the quantities a pixelized reconstruction gives access to for a multi-galaxy lens:",
    "title": "Source Science: Pixelization (Multi Galaxy)"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres + Luminosities",
      "The Relation",
      "Galaxies",
      "Tracer & Fit",
      "Deflection Sum",
      "How Much Does The Tier Matter?",
      "CSV Interface.",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/scaling_relation/fit.py",
      "autolens_workspace/scripts/multi_galaxy/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/multi_galaxy/fit.py",
      "modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/scaling_relation/fit.ipynb",
    "path": "scripts/multi_galaxy/features/scaling_relation/fit.py",
    "summary": "Fits the multi-galaxy `scaling_relation` dataset at the simulator's truth values, so the tied tier can be inspected without a non-linear search in the way.",
    "title": "Features (Multi Galaxy): Scaling Relation Fit"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres + Luminosities",
      "The Relation",
      "Galaxies",
      "Summed Deflection Field",
      "Manual Ray-Tracing",
      "Likelihood",
      "CSV Interface.",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/scaling_relation/likelihood_function.py",
      "autolens_workspace/scripts/multi_galaxy/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/multi_galaxy/likelihood_function.py",
      "fit.py",
      "slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/scaling_relation/likelihood_function.ipynb",
    "path": "scripts/multi_galaxy/features/scaling_relation/likelihood_function.py",
    "summary": "Describes the one step of the `log_likelihood` computation that a brightest-galaxy-anchored scaling tier changes: how the summed deflection field is composed when most of the deflectors' Einstein radii are not free parameters but derived from the brightest co-dominant galaxy's.",
    "title": "__Log Likelihood Function: Multi Galaxy Scaling Relation__"
  },
  {
    "contents": [
      "Dataset & Mask",
      "Centres",
      "Luminosities",
      "Over Sampling / Main Lens Galaxies / Source.",
      "Scaling Tier",
      "Model",
      "Zero Free Parameters",
      "Search / Analysis / Fit / Result.",
      "CSV Interface",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/multi_galaxy/modeling.py",
      "multi_galaxy/modeling.py",
      "simulator.py",
      "slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/scaling_relation/modeling.ipynb",
    "path": "scripts/multi_galaxy/features/scaling_relation/modeling.py",
    "summary": "Extends the multi-galaxy model with a **scaling tier**: faint galaxies far from the co-dominant pair whose Einstein radii are tied to the brightest of the pair by a Faber-Jackson relation:",
    "title": "Modeling Features (Multi Galaxy): Scaling Relation"
  },
  {
    "contents": [
      "Dataset Paths / Grid / PSF / Simulator",
      "Luminosity Convention",
      "Main Lens Galaxies",
      "Scaling Galaxies",
      "Source / Dataset / Records"
    ],
    "cross_refs": [
      "modeling.py",
      "multi_galaxy/simulator.py",
      "slam.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/scaling_relation/simulator.ipynb",
    "path": "scripts/multi_galaxy/features/scaling_relation/simulator.py",
    "summary": "Simulates the dataset for the `multi_galaxy/features/scaling_relation` feature: the co-dominant pair of `multi_galaxy/simulator.py`, plus five faint galaxies scattered FAR from the lens whose masses are tied to the **brightest** of the pair by a Faber-Jackson relation.",
    "title": "Simulator: Multi Galaxy Scaling Relation"
  },
  {
    "contents": [
      "Luminosity Measurement",
      "LENS LIGHT PIPELINE 1",
      "LENS LIGHT PIPELINE 2",
      "SOURCE LP PIPELINE",
      "SOURCE PIX PIPELINE 1 / 2",
      "LIGHT LP PIPELINE",
      "MASS TOTAL PIPELINE",
      "Dataset / Two Masks / Centres / Settings.",
      "SLaM Pipeline",
      "Measured Luminosities"
    ],
    "cross_refs": [
      "fit.py",
      "imaging/features/scaling_relation/slam.py",
      "likelihood_function.py",
      "modeling.py",
      "multi_galaxy/slam.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/multi_galaxy/features/scaling_relation/slam.ipynb",
    "path": "scripts/multi_galaxy/features/scaling_relation/slam.py",
    "summary": "Uses the SLaM pipelines to fit a multi-galaxy lens with a scaling tier whose Einstein radii are tied to the brightest co-dominant deflector.",
    "title": "Multi Galaxy Scaling Relation: SLaM"
  },
  {
    "contents": [
      "Loading Data",
      "Extra Galaxies Noise Scaling",
      "Mask",
      "Galaxies",
      "Per-Galaxy Deflections",
      "Fitting",
      "Bad Fit",
      "Fit Quantities",
      "Figures of Merit",
      "Plane Quantities",
      "Per-Galaxy Quantities",
      "Unmasked Quantities",
      "Pixel Counting",
      "Outputting Results"
    ],
    "cross_refs": [
      "/imaging/data_preparation/examples/optional/mask_extra_galaxies.py",
      "/imaging/data_preparation/gui/mask_extra_galaxies.py",
      "imaging/fit.py",
      "lens_calc.py",
      "likelihood_function.py",
      "modeling.py",
      "multi_galaxy/likelihood_function.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py",
      "multi_galaxy/start_here.py",
      "start_here.py"
    ],
    "notebook": "notebooks/multi_galaxy/fit.ipynb",
    "path": "scripts/multi_galaxy/fit.py",
    "summary": "This guide shows how to fit multi-galaxy strong lens data using the `FitImaging` object, including visualizing and interpreting its results.",
    "title": "Fits: Multi Galaxy"
  },
  {
    "contents": [
      "JAX",
      "Dataset",
      "Extra Galaxies Noise Scaling",
      "Mask",
      "Over Sampling",
      "Masked Image Grid",
      "Main Lens Galaxy Light (Setup)",
      "Main Lens Galaxy Mass",
      "Summed Deflection Field",
      "Main Lens Galaxies",
      "Source Galaxy Light Profile",
      "Lens Light",
      "Ray Tracing",
      "Source Image",
      "Convolution",
      "Likelihood Function",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Lens Modeling",
      "Wrap Up"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.py",
      "contributor_guide.py",
      "imaging/data_preparation/gui/mask_extra_galaxies.py",
      "imaging/likelihood_function.py",
      "multi_galaxy/simulator.py",
      "multi_galaxy/start_here.py",
      "scripts/guides/using_jax.py"
    ],
    "notebook": "notebooks/multi_galaxy/likelihood_function.ipynb",
    "path": "scripts/multi_galaxy/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the `log_likelihood_function` which is used to fit `Imaging` data of a **multi-galaxy** strong lens, where two (or more) galaxies of comparable mass both contribute significantly to the lensing of a single background source.",
    "title": "__Log Likelihood Function: Multi Galaxy (Parametric)__"
  },
  {
    "contents": [
      "Example",
      "Plotters",
      "Simulation",
      "Data Preparation",
      "Dataset",
      "Extra Galaxies Noise Scaling",
      "Main Lens Galaxies",
      "Mask",
      "Over Sampling",
      "Redshifts",
      "Model",
      "External Shear",
      "Model Composition",
      "Coordinates",
      "Improved Lens Model",
      "Linear Light Profiles",
      "Concise API",
      "Search",
      "Unique Identifier",
      "Iterations Per Update",
      "Live Visual Update",
      "Analysis",
      "JAX",
      "VRAM Use",
      "Run Times",
      "Output Folder Layout",
      "Result",
      "Loading From Output Folder",
      "Source Science (Magnification, Flux and More)",
      "Features",
      "HowToLens",
      "Modeling Customization"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "/guides/results/start_here.py",
      "/imaging/data_preparation/examples/optional/mask_extra_galaxies.py",
      "/imaging/data_preparation/gui/mask_extra_galaxies.py",
      "/imaging/data_preparation/start_here.ipynb",
      "/multi_galaxy/likelihood_function.py",
      "/multi_galaxy/simulator.py",
      "/multi_galaxy/source_science.py",
      "group/start_here.ipynb",
      "multi_galaxy/start_here.py",
      "start_here.py"
    ],
    "notebook": "notebooks/multi_galaxy/modeling.ipynb",
    "path": "scripts/multi_galaxy/modeling.py",
    "summary": "This script models an example strong lens on the 'multi galaxy' scale, where two (or more) galaxies of comparable mass both contribute significantly to the lensing of a single background source.",
    "title": "Multi Galaxy: Modeling"
  },
  {
    "contents": [
      "Dataset",
      "Dataset Figures",
      "Dataset Subplot",
      "Fit",
      "Fit Figures",
      "Plane Images",
      "Fit Subplot",
      "Visualizer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "imaging/plot.py",
      "scripts/imaging/plot.py"
    ],
    "notebook": "notebooks/multi_galaxy/plot.ipynb",
    "path": "scripts/multi_galaxy/plot.py",
    "summary": "This example shows how to plot a multi-galaxy `Imaging` dataset and a `FitImaging` fit, figure by figure and via multi-panel subplots.",
    "title": "Plots: Multi Galaxy"
  },
  {
    "contents": [
      "Dataset Paths",
      "Grid",
      "Galaxy Centres",
      "Extra Galaxy Centre",
      "Over Sampling",
      "PSF Convolution",
      "Main Lens Galaxies",
      "External Shear",
      "Source Galaxy",
      "Extra Galaxy",
      "Ray Tracing",
      "Dataset",
      "Mask Extra Galaxies",
      "Visualize",
      "Tracer json",
      "Centre JSON Files",
      "Positions",
      "JAX Variant"
    ],
    "cross_refs": [
      "/guides/advanced/over_sampling.ipynb",
      "multi_galaxy/fit.py",
      "multi_galaxy/likelihood_function.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/start_here.py",
      "scripts/guides/using_jax.py",
      "scripts/imaging/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/simulator.ipynb",
    "path": "scripts/multi_galaxy/simulator.py",
    "summary": "This script simulates an example strong lens on the 'multi galaxy' scale, where two (or more) galaxies of comparable mass both contribute significantly to the lensing of a single background source. Neither galaxy is a minor perturber: they are **co-dominant deflectors**, and every one of them is modeled individually with its own free light and mass profiles.",
    "title": "Simulator: Multi Galaxy"
  },
  {
    "contents": [
      "Dataset Paths",
      "Simulate",
      "Sample Truth Distributions",
      "Sample Instances"
    ],
    "cross_refs": [
      "imaging/features/simulator_manual_signal_to_noise_ratio.ipynb",
      "imaging/simulator_sample.py",
      "multi_galaxy/simulator.ipynb"
    ],
    "notebook": "notebooks/multi_galaxy/simulator_sample.ipynb",
    "path": "scripts/multi_galaxy/simulator_sample.py",
    "summary": "This script illustrates how to simulate a sample of `Imaging` datasets of 'multi-galaxy' strong lenses, which can easily be used to simulate hundreds or thousands of them.",
    "title": "Simulator: Sample (Multi Galaxy)"
  },
  {
    "contents": [
      "Why A Regime Baseline Exists",
      "What Changes",
      "Source LP Pipeline",
      "Source Pix Pipeline 1",
      "Source Pix Pipeline 2",
      "Light LP Pipeline",
      "Mass Total Pipeline",
      "Dataset",
      "Centres",
      "Mask & Over Sampling",
      "SLaM Pipeline"
    ],
    "cross_refs": [
      "/slam.py",
      "group/slam.py",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py",
      "slam_start_here.py"
    ],
    "notebook": "notebooks/multi_galaxy/slam.ipynb",
    "path": "scripts/multi_galaxy/slam.py",
    "summary": "This script is the multi-galaxy regime's SLaM pipeline: the production path for fitting a lens with two or more co-dominant deflectors, as opposed to the single-search fits of `multi_galaxy/modeling.py`.",
    "title": "SLaM (Source, Light and Mass): Multi Galaxy"
  },
  {
    "contents": [
      "Simulated Dataset",
      "Mask",
      "Source Values",
      "Source Flux",
      "Source Magnification",
      "Single Deflector Comparison",
      "Tracer",
      "Parametric Source Models"
    ],
    "cross_refs": [
      "imaging/source_science.py",
      "multi_galaxy/modeling.py"
    ],
    "notebook": "notebooks/multi_galaxy/source_science.ipynb",
    "path": "scripts/multi_galaxy/source_science.py",
    "summary": "Source science focuses on studying the highly magnified properties of the background lensed source galaxy (or galaxies).",
    "title": "Source Science: Multi Galaxy"
  },
  {
    "contents": [
      "JAX",
      "Google Colab Setup",
      "Imports",
      "Dataset",
      "Extra Galaxy Removal",
      "Main Lens Galaxies",
      "Masking",
      "Model",
      "Model Fit",
      "Iterations Per Update",
      "Live Visual Update",
      "Result",
      "Extra Galaxy Removal GUI",
      "Model Your Own Lens",
      "Simulator",
      "Sample",
      "Wrap Up"
    ],
    "cross_refs": [
      "/multi_galaxy/simulator_sample.py",
      "autolens_workspace/scripts/multi_galaxy/modeling.py",
      "autolens_workspace/start_here.py",
      "cluster/start_here.ipynb",
      "group/start_here.ipynb",
      "imaging/start_here.ipynb",
      "multi_galaxy/modeling.py",
      "multi_galaxy/simulator.py"
    ],
    "notebook": "notebooks/multi_galaxy/start_here.ipynb",
    "path": "scripts/multi_galaxy/start_here.py",
    "summary": "Multi-galaxy strong lenses have **two or more galaxies of comparable mass which both contribute significantly to the lensing** of a single background source. Neither galaxy is a minor perturber \u2014 they are co-dominant deflectors, and every one of them gets its own free light and mass model.",
    "title": "Start Here: Multi Galaxy"
  },
  {
    "contents": [
      "Image Plane Multiple Images",
      "Point Source Host Galaxy",
      "Imaging",
      "Model",
      "Dataset & Mask",
      "Model Cookbook",
      "Search",
      "Analysis",
      "Run Time",
      "Result",
      "Point Source"
    ],
    "cross_refs": [
      "imaging/features/advanced/operated_light_profile/modeling.py",
      "linear_light_profiles.py",
      "point_source/start_here.ipynb",
      "start.here.py",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/point_source/features/deblending/modeling.ipynb",
    "path": "scripts/point_source/features/deblending/modeling.py",
    "summary": "The image-plane multiple-image positions of a lensed point source (e.g. a quasar or supernova) are used as the dataset in point-source modeling. For example, simulated values were input into the `PointDataset` object in the `point_source/start_here.ipynb` example.",
    "title": "Modeling Features: Deblending"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Point Solver",
      "Fluxes",
      "Output",
      "Tracer json"
    ],
    "cross_refs": [
      "/imaging/features/advanced/operated_light_profile/modeling.py",
      "autolens_workspace/notebooks/point_source/features/deblending/modeling.ipynb",
      "point_source/features/deblending/modeling.ipynb",
      "point_source/simulator.ipynb",
      "scripts/point_source/simulator.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/point_source/features/deblending/simulator.ipynb",
    "path": "scripts/point_source/features/deblending/simulator.py",
    "summary": "This script simulations a `Point` dataset of a galaxy-scale strong lens which is identical to the dataset simulated in the `start_here.ipynb` example, but where an image of the multiply imaged lensed point source (e.g. the quasar) and its lens galaxy are included.",
    "title": "Simulator: Debelending"
  },
  {
    "contents": [
      "Data Preparation",
      "Dataset",
      "Point Solver",
      "Extra Galaxies Centres",
      "Model",
      "Extra Galaxies Model",
      "Information Budget",
      "Name Pairing",
      "Search + Analysis",
      "Run Time",
      "Model-Fit",
      "Result",
      "Approaches to Extra Galaxies",
      "Wrap Up"
    ],
    "cross_refs": [
      "/imaging/data_preparation/examples/optional/extra_galaxies_centres.py",
      "cluster/modeling.py",
      "features/fluxes.py",
      "group/modeling.py",
      "point_source/modeling.py",
      "point_source/simulator.py",
      "point_source/start_here.ipynb",
      "simulator.py"
    ],
    "notebook": "notebooks/point_source/features/extra_galaxies/modeling.ipynb",
    "path": "scripts/point_source/features/extra_galaxies/modeling.py",
    "summary": "There may be extra galaxies projected near a lensed point source, for example a faint companion beside the main lens galaxy of a lensed quasar, whose mass contributes to the ray-tracing and therefore to where the multiple images appear.",
    "title": "Modeling Features: Extra Galaxies"
  },
  {
    "contents": [
      "Model",
      "Other Scripts",
      "Dataset Paths",
      "Ray Tracing",
      "Extra Galaxies",
      "Point Solver",
      "Fluxes",
      "Point Dataset",
      "Extra Galaxies Centres",
      "Imaging",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "/imaging/data_preparation/examples/optional/extra_galaxies_centres.py",
      "/point_source/features/extra_galaxies/modeling.ipynb",
      "imaging/simulator.py",
      "modeling.py",
      "point_source/modeling.py",
      "point_source/simulator.ipynb",
      "point_source/simulator.py"
    ],
    "notebook": "notebooks/point_source/features/extra_galaxies/simulator.ipynb",
    "path": "scripts/point_source/features/extra_galaxies/simulator.py",
    "summary": "Lensed point sources, for example a lensed quasar or supernova, frequently have small galaxies projected near the main lens galaxy. Unlike for extended sources, these galaxies do not blend with the source emission \u2014 a point source has no extended surface brightness to contaminate. What they do instead is perturb the deflection field, shifting the positions (and magnifications) of the multiple images by amounts that are small but easily measurable, because point-source astrometry is precise to a few milli-arcseconds.",
    "title": "Simulator: Extra Galaxies"
  },
  {
    "contents": [
      "Model",
      "Dataset",
      "Point Solver",
      "Search",
      "Analysis",
      "Run Times",
      "Result"
    ],
    "cross_refs": [
      "guides/point_source_pairing.py",
      "point_source/start_here.ipynb",
      "start.here.py",
      "start_here.ipynb",
      "start_here.py"
    ],
    "notebook": "notebooks/point_source/features/fluxes.ipynb",
    "path": "scripts/point_source/features/fluxes.py",
    "summary": "A measurable quantity of a point source is its flux\u2014the total amount of light received from each multiple image of the point source (e.g., the quasar images).",
    "title": "Modeling: Fluxes"
  },
  {
    "contents": [
      "Dataset",
      "Point Solver",
      "Model",
      "Name Pairing",
      "Search",
      "Analysis List",
      "Analysis Factor",
      "Factor Graph",
      "Model-Fit",
      "Result"
    ],
    "cross_refs": [
      "cluster/modeling.py",
      "multi_dataset/modeling.ipynb",
      "multi_dataset/modeling.py",
      "point_source/modeling.ipynb",
      "point_source/modeling.py",
      "simulator.py"
    ],
    "notebook": "notebooks/point_source/features/multiple_sources/modeling.ipynb",
    "path": "scripts/point_source/features/multiple_sources/modeling.py",
    "summary": "This script fits a `PointDataset` of a 'galaxy-scale' strong lens with multiple lensed point sources at different redshifts. The lens system is multi-plane: a foreground lens at z=0.5 deflects both background sources, while source_0 at z=1.0 is itself a deflector for source_1 at z=2.0 (the \"double Einstein cross\" configuration). Each source's multiple images are stored in their own `PointDataset`, and the two datasets are fitted jointly using the multi-dataset/factor-graph API:",
    "title": "Modeling: Multiple Sources"
  },
  {
    "contents": [
      "Dataset Paths",
      "Ray Tracing",
      "Point Solver",
      "Point Datasets",
      "Visualize",
      "Tracer json"
    ],
    "cross_refs": [
      "modeling.py",
      "point_source/simulator.ipynb",
      "scripts/point_source/simulator.py"
    ],
    "notebook": "notebooks/point_source/features/multiple_sources/simulator.ipynb",
    "path": "scripts/point_source/features/multiple_sources/simulator.py",
    "summary": "This script simulates `PointDataset` data of a strong lens which has multiple lensed point sources at different redshifts (the example below has two sources, but the same approach extends to any number).",
    "title": "Simulator: Multiple Sources"
  },
  {
    "contents": [
      "Dataset",
      "Centres + Luminosities",
      "The Relation",
      "Galaxies",
      "Point Solver",
      "How Much Does The Tier Move The Images?",
      "Fit",
      "CSV Interface.",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/scaling_relation/fit.py",
      "autolens_workspace/scripts/point_source/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/point_source/fit.py",
      "modeling.py",
      "point_source/fit.py",
      "slam.py"
    ],
    "notebook": "notebooks/point_source/features/scaling_relation/fit.ipynb",
    "path": "scripts/point_source/features/scaling_relation/fit.py",
    "summary": "Fits the point-source `scaling_relation` dataset at the simulator's truth values, so the tied tier can be inspected without a non-linear search in the way.",
    "title": "Features (Point Source): Scaling Relation Fit"
  },
  {
    "contents": [
      "Dataset",
      "Centres + Luminosities",
      "Step 1: The Relation",
      "Step 2: The Deflection Field",
      "Step 3: Solving The Lens Equation",
      "Step 4: Chi-Squared",
      "Wrap Up."
    ],
    "cross_refs": [
      "autolens_workspace/scripts/imaging/features/scaling_relation/likelihood_function.py",
      "autolens_workspace/scripts/point_source/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/point_source/fit.py",
      "fit.py",
      "modeling.py",
      "point_source/fit.py"
    ],
    "notebook": "notebooks/point_source/features/scaling_relation/likelihood_function.ipynb",
    "path": "scripts/point_source/features/scaling_relation/likelihood_function.py",
    "summary": "Describes how a scaling tier anchored on the brightest galaxy enters the point-source `log_likelihood`.",
    "title": "__Log Likelihood Function: Scaling Relation (Point Source)__"
  },
  {
    "contents": [
      "Dataset",
      "Point Solver",
      "Centres",
      "Luminosities",
      "Main Lens & Source",
      "Scaling Tier",
      "Model",
      "Zero Free Parameters",
      "Search / Analysis / Fit / Result.",
      "CSV Interface.",
      "Wrap Up."
    ],
    "cross_refs": [
      "/imaging/data_preparation/examples/optional/extra_galaxies_centres.py",
      "autolens_workspace/scripts/imaging/features/scaling_relation/modeling.py",
      "autolens_workspace/scripts/point_source/features/extra_galaxies/modeling.py",
      "autolens_workspace/scripts/point_source/modeling.py",
      "cluster/modeling.py",
      "fit.py",
      "likelihood_function.py",
      "point_source/features/extra_galaxies/modeling.py",
      "point_source/modeling.py",
      "slam.py"
    ],
    "notebook": "notebooks/point_source/features/scaling_relation/modeling.ipynb",
    "path": "scripts/point_source/features/scaling_relation/modeling.py",
    "summary": "Ties a population of foreground companions to the lens's own Einstein radius by a Faber-Jackson relation, so the whole tier costs **zero free parameters**:",
    "title": "Modeling Features (Point Source): Scaling Relation"
  },
  {
    "contents": [
      "Dataset Paths / Luminosity Convention",
      "Main Lens Galaxy",
      "Scaling Companions",
      "Source / Tracer",
      "Point Solver",
      "Positions / Fluxes / Point Dataset",
      "Accompanying Imaging",
      "Records"
    ],
    "cross_refs": [
      "modeling.py",
      "point_source/simulator.py"
    ],
    "notebook": "notebooks/point_source/features/scaling_relation/simulator.ipynb",
    "path": "scripts/point_source/features/scaling_relation/simulator.py",
    "summary": "Simulates the dataset for the `point_source/features/scaling_relation` feature: a quadruply imaged point source behind a lens with five foreground companions whose Einstein radii are tied to the lens's own by a Faber-Jackson relation.",
    "title": "Simulator: Scaling Relation (Point Source)"
  },
  {
    "contents": [
      "Model",
      "Dataset",
      "Point Solver",
      "Search",
      "Analysis",
      "Run Times",
      "Result",
      "Cosmology"
    ],
    "cross_refs": [
      "point_source/start_here.ipynb",
      "start.here.py",
      "start_here.ipynb"
    ],
    "notebook": "notebooks/point_source/features/time_delays.ipynb",
    "path": "scripts/point_source/features/time_delays.py",
    "summary": "A measurable quantity of a point source is its time delay\u2014the time it takes for light to travel from the source to the observer for each multiple image of the point source (e.g., the quasar images). This is often expressed as the relative time delay between each image and the image with the shortest time delay, which is often referred to as the \"reference image.\"",
    "title": "Modeling: Time Delays"
  },
  {
    "contents": [
      "Lensed Point Source",
      "Point Source",
      "Point Solver",
      "Number of Solutions",
      "Solving the Lens Equation",
      "Triangle Tracing",
      "Dataset",
      "Name Pairing",
      "Fitting",
      "Chi Squared",
      "Solved Source Centre",
      "Fluxes",
      "Flux Point Dataset",
      "Flux Fitting",
      "Time Delays",
      "Time Delay Fitting",
      "New User Wrap Up",
      "Shape Solver"
    ],
    "cross_refs": [
      "guides/point_source_pairing.py",
      "modeling.py",
      "point_source/features/fluxes.py",
      "point_source/features/time_delays.py",
      "scripts/point_source/simulator.py",
      "simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/point_source/fit.ipynb",
    "path": "scripts/point_source/fit.py",
    "summary": "--------------------",
    "title": "Guide: Point Sources"
  },
  {
    "contents": [
      "Not Using Light Profiles",
      "Model",
      "Dataset",
      "Point Solver",
      "Model Composition",
      "Name Pairing",
      "Coordinates",
      "Search",
      "Unique Identifier",
      "Live Visual Update",
      "Chi Squared",
      "Analysis",
      "JAX",
      "VRAM Use",
      "Run Times",
      "Output Folder Layout",
      "Result",
      "Results",
      "Modeling Customization"
    ],
    "cross_refs": [
      "/point_source/start_here.py",
      "guides/point_source_pairing.py",
      "start_here.py"
    ],
    "notebook": "notebooks/point_source/modeling.ipynb",
    "path": "scripts/point_source/modeling.py",
    "summary": "This script is the starting point for lens modeling of point-source lens datasets, for example the multiple image positions of a lensed quasar.",
    "title": "Modeling: Start Here"
  },
  {
    "contents": [
      "Dataset",
      "Dataset Figures",
      "Dataset Subplot",
      "Fit",
      "Fit Figures",
      "Visualizer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "modeling.py",
      "scripts/imaging/plot.py",
      "scripts/point_source/fit.py"
    ],
    "notebook": "notebooks/point_source/plot.ipynb",
    "path": "scripts/point_source/plot.py",
    "summary": "This example shows how to plot a `PointDataset` and a `FitPointDataset` fit.",
    "title": "Plots: Point Source"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Ray Tracing",
      "Point Solver",
      "Point Datasets",
      "Visualize",
      "Tracer json",
      "Imaging",
      "Fluxes",
      "Point Dataset",
      "Time Delays",
      "JAX Variant (Advanced)"
    ],
    "cross_refs": [
      "imaging/simulator.py",
      "scripts/guides/using_jax.py"
    ],
    "notebook": "notebooks/point_source/simulator.ipynb",
    "path": "scripts/point_source/simulator.py",
    "summary": "This script is the starting point for simulating point source strong lens datasets, for example a lensed quasar or supernova, and it provides an overview of the lens simulation API.",
    "title": "Simulator: Start Here"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Point Solver",
      "Sample Model Distributions",
      "Simulate",
      "Sample Instances"
    ],
    "cross_refs": [
      "point_source/simulator.ipynb"
    ],
    "notebook": "notebooks/point_source/simulator_sample.ipynb",
    "path": "scripts/point_source/simulator_sample.py",
    "summary": "A multiply imaged lensed quasar with time delays can measure the Hubble constant, which is a fundamental Cosmological parameter that describes the rate of expansion of the universe. This is because the the difference between the geometric time delay and the physical time delay is proportional to the Hubble constant.",
    "title": "Simulator: Hubble Constant Time Delays"
  },
  {
    "contents": [
      "JAX",
      "Google Colab Setup",
      "Imports",
      "Dataset",
      "Point Solver",
      "Model",
      "Name Pairing",
      "Model Fit",
      "Live Visual Update",
      "Result",
      "Model Your Own Lens",
      "Fluxes and Time Delays",
      "Simulator",
      "Sample",
      "Wrap Up"
    ],
    "cross_refs": [
      "autolens_workspace/start_here.py",
      "cluster/start_here.ipynb",
      "group/start_here.ipynb",
      "guides/point_source_pairing.py",
      "modeling.py",
      "point_source/modeling.py",
      "scripts/point_source/simulator.py",
      "simulator.py"
    ],
    "notebook": "notebooks/point_source/start_here.ipynb",
    "path": "scripts/point_source/start_here.py",
    "summary": "Strong gravitational lenses often have point sources (e.g. quasars) that are being lensed, appearing as two or four distinct point-like images. These lenses are particularly useful for measuring cosmological parameters like the Hubble constant, and for studying the small-scale properties of dark matter.",
    "title": "Start Here: Point Source"
  },
  {
    "contents": [
      "Dataset (Strong)",
      "Dataset (Weak)",
      "Model",
      "Analysis Factors & Factor Graph",
      "Search & Model-Fit",
      "Result"
    ],
    "cross_refs": [
      "cluster/start_here.py",
      "modeling.py",
      "weak/features/strong_lensing/modeling.py",
      "weak/start_here.py"
    ],
    "notebook": "notebooks/weak/features/strong_lensing/a2744.ipynb",
    "path": "scripts/weak/features/strong_lensing/a2744.py",
    "summary": "This script constrains a **single cluster-scale mass model** of **Abell 2744** (\"Pandora's Cluster\", z = 0.308) using both its **strong-lensing** multiple images and its **weak-lensing** shear catalogue \u2014 real data on both sides, fitted jointly with one non-linear search via PyAutoFit's factor-graph API.",
    "title": "Real Data: Combined Strong + Weak Lensing of Abell 2744"
  },
  {
    "contents": [
      "Dataset",
      "Tracer",
      "Imaging Fit",
      "Weak Fit",
      "Joint Likelihood",
      "Shear Profile"
    ],
    "cross_refs": [
      "modeling.py",
      "scripts/weak/fit.py",
      "simulator.py"
    ],
    "notebook": "notebooks/weak/features/strong_lensing/fit.ipynb",
    "path": "scripts/weak/features/strong_lensing/fit.py",
    "summary": "This script fits the combined strong+weak dataset simulated by `simulator.py` in this folder with a single shared `Tracer`: the imaging data via `FitImaging` and the shear catalogue via `FitWeak`.",
    "title": "Fit: Combined Strong + Weak Lensing"
  },
  {
    "contents": [
      "Dataset",
      "Model",
      "Analysis List",
      "Analysis Factor & Factor Graph",
      "Search & Model-Fit",
      "Result"
    ],
    "cross_refs": [
      "fit.py",
      "simulator.py"
    ],
    "notebook": "notebooks/weak/features/strong_lensing/modeling.ipynb",
    "path": "scripts/weak/features/strong_lensing/modeling.py",
    "summary": "This script fits the combined dataset of `simulator.py` \u2014 an `Imaging` dataset of strongly lensed arcs and a `WeakDataset` of the surrounding shear field \u2014 with a **single lens mass model**, using PyAutoFit's factor-graph API to sample the joint likelihood with one non-linear search.",
    "title": "Modeling: Combined Strong + Weak Lensing"
  },
  {
    "contents": [
      "Dataset Paths",
      "Ray Tracing",
      "Imaging Simulation",
      "Weak Simulation",
      "Output"
    ],
    "cross_refs": [
      "scripts/imaging/simulator.py"
    ],
    "notebook": "notebooks/weak/features/strong_lensing/simulator.ipynb",
    "path": "scripts/weak/features/strong_lensing/simulator.py",
    "summary": "This script simulates the two faces of the same gravitational lens: an `Imaging` dataset of its strongly lensed arcs, and a `WeakDataset` of the weak shear it imprints on background galaxies at larger radii. Both are generated from **one** `Tracer`, so the datasets share a single true mass distribution \u2014 the setup the fit and modeling examples in this folder use to demonstrate joint strong+weak constraints.",
    "title": "Simulator: Combined Strong + Weak Lensing"
  },
  {
    "contents": [
      "Dataset",
      "Model",
      "Fit",
      "Visualization",
      "Shear Profile",
      "Notes"
    ],
    "cross_refs": [
      "scripts/weak/modeling.py",
      "scripts/weak/simulator.py"
    ],
    "notebook": "notebooks/weak/fit.ipynb",
    "path": "scripts/weak/fit.py",
    "summary": "This script shows how to fit a strong-lens mass model to a weak gravitational lensing shear catalogue. Where the `imaging` and `interferometer` workflows fit a 2D image of a lensed source, the weak-lensing workflow fits a set of (gamma_2, gamma_1) shear measurements at the (y, x) positions of background source galaxies \u2014 a ``WeakDataset`` produced by the simulator script in `scripts/weak/simulator.py`.",
    "title": "Fit: Weak Lensing"
  },
  {
    "contents": [
      "Dataset",
      "Lens Galaxy",
      "Shear Field Evaluation",
      "Residuals",
      "Chi Squared",
      "Noise Normalization Term",
      "Calculate The Log Likelihood",
      "Fit",
      "Analysis",
      "Wrap Up"
    ],
    "cross_refs": [
      "scripts/imaging/likelihood_function.py",
      "scripts/weak/fit.py",
      "scripts/weak/modeling.py",
      "scripts/weak/simulator.py"
    ],
    "notebook": "notebooks/weak/likelihood_function.ipynb",
    "path": "scripts/weak/likelihood_function.py",
    "summary": "This script provides a step-by-step guide of the **PyAutoLens** likelihood function for fitting a lens mass model to a weak gravitational lensing shear catalogue (a `WeakDataset`). It is the weak-lensing companion of the guides for the other dataset types (e.g. `scripts/imaging/likelihood_function.py`), following the same style and level of detail.",
    "title": "__Log Likelihood Function: Weak Lensing__"
  },
  {
    "contents": [
      "Dataset",
      "Model",
      "Search",
      "Analysis",
      "Run Times",
      "Model-Fit",
      "Output Folder Layout",
      "Result"
    ],
    "cross_refs": [
      "fit.py",
      "scripts/imaging/modeling.py",
      "scripts/weak/fit.py",
      "scripts/weak/likelihood_function.py",
      "scripts/weak/simulator.py",
      "simulator.py",
      "start_here.py"
    ],
    "notebook": "notebooks/weak/modeling.ipynb",
    "path": "scripts/weak/modeling.py",
    "summary": "This script fits a lens mass model to a weak gravitational lensing shear catalogue using a non-linear search. It is the weak-lensing analogue of `scripts/imaging/modeling.py`: where that script infers a lens model from a 2D image of a lensed source, this script infers one from the (gamma_2, gamma_1) shear measurements of background source galaxies \u2014 a `WeakDataset` produced by `scripts/weak/simulator.py`.",
    "title": "Modeling: Weak Lensing"
  },
  {
    "contents": [
      "Dataset",
      "Dataset Figures",
      "Dataset Subplot",
      "Convergence Map",
      "Fit",
      "Fit Figures",
      "Fit Subplot",
      "Shear Profile",
      "Visualizer"
    ],
    "cross_refs": [
      "guides/plot/start_here.py",
      "modeling.py",
      "scripts/imaging/plot.py",
      "scripts/weak/fit.py",
      "scripts/weak/simulator.py"
    ],
    "notebook": "notebooks/weak/plot.ipynb",
    "path": "scripts/weak/plot.py",
    "summary": "This example shows how to plot a `WeakDataset` and a `FitWeak` fit.",
    "title": "Plots: Weak"
  },
  {
    "contents": [
      "Catalogue Download",
      "Catalogue Load & Projection",
      "Quality Cuts",
      "Weak Dataset",
      "Mass Map",
      "Model & Search",
      "Result"
    ],
    "cross_refs": [],
    "notebook": "notebooks/weak/real_data/a2744.ipynb",
    "path": "scripts/weak/real_data/a2744.py",
    "summary": "This script fits a dark-matter halo mass model to a **real weak-lensing shape catalogue** of the merging galaxy cluster Abell 2744 (\"Pandora's Cluster\", z = 0.308) \u2014 the first PyAutoLens weak-lensing analysis of real sky data, and the capstone of the weak-lensing example series.",
    "title": "Real Data: Weak Lensing of Abell 2744"
  },
  {
    "contents": [
      "Model",
      "Dataset Paths",
      "Ray Tracing",
      "Source Positions",
      "Simulator",
      "Output",
      "Visualize"
    ],
    "cross_refs": [
      "scripts/weak/modeling.py"
    ],
    "notebook": "notebooks/weak/simulator.ipynb",
    "path": "scripts/weak/simulator.py",
    "summary": "This script simulates a weak gravitational lensing shear catalogue. Unlike the imaging simulator (which produces a 2D image of the lensed source) the weak-lensing simulator produces a *catalogue* of (gamma_2, gamma_1) shear measurements at the (y, x) positions of a population of background source galaxies.",
    "title": "Simulator: Weak Lensing"
  },
  {
    "contents": [
      "JAX",
      "Google Colab Setup",
      "Imports",
      "Catalogue Download",
      "Catalogue Load & Projection",
      "Quality Cuts",
      "Weak Dataset",
      "Mass Map",
      "Model",
      "Model Fit",
      "Result",
      "Model Your Own Catalogue",
      "Simulator",
      "Wrap Up"
    ],
    "cross_refs": [
      "/weak/likelihood_function.py",
      "/weak/modeling.py",
      "/weak/real_data/a2744.py",
      "autolens_workspace/start_here.py",
      "scripts/weak/simulator.py"
    ],
    "notebook": "notebooks/weak/start_here.ipynb",
    "path": "scripts/weak/start_here.py",
    "summary": "Gravitational lensing does not stop at the spectacular arcs and multiple images of strong lensing. Every galaxy behind a massive structure is slightly sheared by its gravity \u2014 a percent-level distortion invisible in any single galaxy but measurable statistically across thousands. This is **weak lensing**, and it traces mass on scales far beyond the strong-lensing core.",
    "title": "Start Here: Weak Lensing"
  }
]