{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "y0-qhx2RboBl",
        "__2evNYrqMP4",
        "EfOu5NpPXQ2V",
        "F7zO6b9W7qMh",
        "eAxBsw4nbuK_",
        "5HQmiE__cxel",
        "esbloYcadHb0",
        "5bNhtQFLfwGk",
        "A32olff-mR9o",
        "67VoCKB2oukO",
        "3ilWOpdvpSEr",
        "GexwO0V5prZm",
        "TY-raQGGqbrj",
        "M2wNgn3ath9s"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "### Preamble"
      ],
      "metadata": {
        "id": "i9AQs7_jTjlo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "    import pgmuvi\n",
        "except (ImportError, ModuleNotFoundError):\n",
        "    %pip install -q git+https://github.com/ICSM/pgmuvi.git\n",
        "    import pgmuvi"
      ],
      "metadata": {
        "id": "g4ZTxhIV69P4"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Imports and seeds for reproducibility\n",
        "import gpytorch\n",
        "from gpytorch.likelihoods import FixedNoiseGaussianLikelihood\n",
        "\n",
        "seed = 0\n",
        "import torch\n",
        "torch.manual_seed(seed)\n",
        "\n",
        "import numpy as np\n",
        "np.random.seed(seed)\n",
        "\n",
        "import random\n",
        "random.seed(seed)\n",
        "\n",
        "from pgmuvi.lightcurve import Lightcurve\n",
        "from gpytorch.constraints import Interval\n",
        "import pgmuvi.gps as gps\n",
        "from pgmuvi import synthetic\n",
        "from pgmuvi.preprocess import subsample_lightcurve\n",
        "\n",
        "SEED = 0\n",
        "TRAINING_ITER = 1000\n",
        "DTYPE = torch.float64\n",
        "DEVICE = torch.device(\"cpu\")"
      ],
      "metadata": {
        "id": "OgsFewYt62Tu"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### The `Lightcurve` object\n",
        "\n",
        "##### The central object in `pgmuvi` is the `Lightcurve` class. It can store either a light curve defined for a single wavelength (a \"1D light curve\") or a set of light-curve observations defined over time and wavelength (a \"2D light curve\").\n",
        "\n",
        "##### At the very least, a `Lightcurve` stores:\n",
        "\n",
        "- `xdata` — the independent-variable data\n",
        "  - for a 1D light curve: time\n",
        "  - for a 2D light curve: a 2-column array, with time in the first column and wavelength in the second\n",
        "- `ydata` — the flux values\n",
        "- `yerr` — the flux uncertainties, if available\n",
        "- `band` — an optional array of per-row string labels, mainly useful for manipulating 2D light curves\n",
        "\n",
        "##### In addition to the core arrays, the class also supports a small amount of lightweight metadata:\n",
        "\n",
        "- `name` — a human-readable name for the light curve\n",
        "- `time_units` — passed at construction time so that the time axis can be converted internally to **days**\n",
        "\n",
        "This is useful, but it is also important to be precise about what the class does **not** currently provide.\n",
        "\n",
        "##### The current implementation is **not** a general metadata container.\n",
        "\n",
        "For example, there is no dedicated built-in schema for storing and round-tripping arbitrary metadata such as:\n",
        "\n",
        "- source name\n",
        "- telescope/instrument\n",
        "- photometric system\n",
        "- physical flux units\n",
        "- provenance information\n",
        "\n",
        "So if you need richer metadata, you should currently manage that outside the `Lightcurve` object or extend the class explicitly.\n",
        "\n",
        "##### A `Lightcurve` object can be instantiated either by providing `xdata`, `ydata`, and optionally `yerr` directly, or by reading a CSV file with `Lightcurve.from_csv()`.\n",
        "\n",
        "### In this notebook, we will demonstrate some features available for `Lightcurve` objects to manipulate 1D and 2D light curve data."
      ],
      "metadata": {
        "id": "LNM0_slx6uy-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Data structure and invariants\n",
        "\n",
        "Before using the `Lightcurve` object, it is essential to understand the assumptions it makes about the input data. Many downstream methods (especially period finding and GP fitting) will silently fail or produce misleading results if these assumptions are violated.\n",
        "\n",
        "#### Core inputs\n",
        "\n",
        "A `Lightcurve` is constructed from:\n",
        "\n",
        "- `time` — observation times\n",
        "- `flux` — measured flux values\n",
        "- `flux_err` — uncertainties on flux\n",
        "- `wavelength` — wavelength(s) corresponding to the observations\n",
        "- `band` *(optional but recommended)* — string labels identifying each wavelength channel\n",
        "\n",
        "---\n",
        "\n",
        "#### Shape expectations\n",
        "\n",
        "##### 1D lightcurve (single band)\n",
        "- `time`: shape `(N,)`\n",
        "- `flux`: shape `(N,)`\n",
        "- `flux_err`: shape `(N,)`\n",
        "- `wavelength`: scalar or `(N,)`\n",
        "- `band`: single string or `(N,)` constant\n",
        "\n",
        "##### 2D lightcurve (multi-band)\n",
        "- `time`: shape `(N,)`\n",
        "- `flux`: shape `(N, M)`\n",
        "- `flux_err`: shape `(N, M)`\n",
        "- `wavelength`: shape `(M,)`\n",
        "- `band`: shape `(M,)` (array of strings)\n",
        "\n",
        "Each column in `flux` corresponds to one band.\n",
        "\n",
        "---\n",
        "\n",
        "#### Critical invariants\n",
        "\n",
        "The following must hold:\n",
        "\n",
        "1. `len(time) == flux.shape[0] == flux_err.shape[0]`\n",
        "2. `flux.shape == flux_err.shape`\n",
        "3. Number of bands must match:\n",
        "   - `flux.shape[1] == len(wavelength) == len(band)` (for 2D case)\n",
        "4. No implicit reshaping is performed — mismatches should raise errors\n",
        "\n",
        "---\n",
        "\n",
        "#### Common pitfalls\n",
        "\n",
        "- Mixing 1D and 2D inputs unintentionally\n",
        "- Providing `band` labels as floats instead of strings\n",
        "- Mismatched number of bands vs flux columns\n",
        "- Silent broadcasting errors if shapes are inconsistent\n",
        "- Unsorted time arrays (not always enforced!)\n",
        "\n",
        "---\n",
        "\n",
        "In the next cell, we explicitly test these constraints."
      ],
      "metadata": {
        "id": "y0-qhx2RboBl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from pgmuvi.lightcurve import Lightcurve\n",
        "\n",
        "# ------------------------------------------------------------\n",
        "# Valid 2-D example\n",
        "#\n",
        "# In this codebase, a multiband light curve is stored with:\n",
        "#   xdata.shape == (N, 2)\n",
        "# where:\n",
        "#   xdata[:, 0] = time\n",
        "#   xdata[:, 1] = wavelength\n",
        "#\n",
        "# ydata and yerr are 1-D arrays of length N\n",
        "# band is optional, but if provided for 2-D data it must be a\n",
        "# 1-D array of strings with exactly one label per observation row\n",
        "# (so len(band) == N, not number of unique wavelengths).\n",
        "# ------------------------------------------------------------\n",
        "\n",
        "xdata = np.array([\n",
        "    [0.0, 1.25],\n",
        "    [1.0, 1.25],\n",
        "    [2.0, 1.25],\n",
        "    [0.5, 2.20],\n",
        "    [1.5, 2.20],\n",
        "    [2.5, 2.20],\n",
        "], dtype=float)\n",
        "\n",
        "ydata = np.array([10.0, 10.4, 10.2, 7.8, 8.1, 7.9], dtype=float)\n",
        "yerr = np.array([0.2, 0.2, 0.2, 0.15, 0.15, 0.15], dtype=float)\n",
        "\n",
        "band = np.array([\"J\", \"J\", \"J\", \"K\", \"K\", \"K\"])\n",
        "\n",
        "lc = Lightcurve(\n",
        "    xdata,\n",
        "    ydata,\n",
        "    yerr=yerr,\n",
        "    band=band,\n",
        ")\n",
        "\n",
        "print(\"Valid Lightcurve created.\")\n",
        "print(\"xdata shape:\", lc.xdata.shape)\n",
        "print(\"ydata shape:\", lc.ydata.shape)\n",
        "print(\"ndim:\", lc.ndim)\n",
        "print(\"band:\", lc.band)\n",
        "\n",
        "\n",
        "# ------------------------------------------------------------\n",
        "# Invalid example 1: band length mismatch\n",
        "#\n",
        "# For 2-D light curves, band must have one entry per row.\n",
        "# ------------------------------------------------------------\n",
        "try:\n",
        "    bad_band = np.array([\"J\", \"K\"])  # incorrect length\n",
        "    lc_bad_band = Lightcurve(\n",
        "        xdata,\n",
        "        ydata,\n",
        "        yerr=yerr,\n",
        "        band=bad_band,\n",
        "    )\n",
        "except Exception as e:\n",
        "    print(\"\\nExpected failure (band length mismatch):\")\n",
        "    print(type(e).__name__, e)\n",
        "\n",
        "\n",
        "# ------------------------------------------------------------\n",
        "# Invalid example 2: band is not 1-D\n",
        "# ------------------------------------------------------------\n",
        "try:\n",
        "    bad_band_shape = np.array([[\"J\"], [\"J\"], [\"J\"], [\"K\"], [\"K\"], [\"K\"]])\n",
        "    lc_bad_band_shape = Lightcurve(\n",
        "        xdata,\n",
        "        ydata,\n",
        "        yerr=yerr,\n",
        "        band=bad_band_shape,\n",
        "    )\n",
        "except Exception as e:\n",
        "    print(\"\\nExpected failure (band must be 1-D):\")\n",
        "    print(type(e).__name__, e)\n",
        "\n",
        "\n",
        "# ------------------------------------------------------------\n",
        "# Invalid example 3: NaN in xdata\n",
        "#\n",
        "# The xdata setter explicitly rejects NaNs.\n",
        "# ------------------------------------------------------------\n",
        "try:\n",
        "    xdata_nan = xdata.copy()\n",
        "    xdata_nan[2, 0] = np.nan\n",
        "    lc_nan = Lightcurve(\n",
        "        xdata_nan,\n",
        "        ydata,\n",
        "        yerr=yerr,\n",
        "        band=band,\n",
        "    )\n",
        "except Exception as e:\n",
        "    print(\"\\nExpected failure (NaN in xdata):\")\n",
        "    print(type(e).__name__, e)\n",
        "\n",
        "\n",
        "# ------------------------------------------------------------\n",
        "# Valid 1-D example\n",
        "#\n",
        "# For a 1-D light curve:\n",
        "#   xdata is just time\n",
        "#   ydata is flux\n",
        "#   yerr is flux uncertainty\n",
        "#\n",
        "# band may be omitted, or may be a single shared label.\n",
        "# ------------------------------------------------------------\n",
        "time = np.array([0.0, 1.0, 2.0, 3.0], dtype=float)\n",
        "flux = np.array([12.1, 12.4, 12.0, 12.3], dtype=float)\n",
        "flux_err = np.array([0.1, 0.1, 0.1, 0.1], dtype=float)\n",
        "\n",
        "lc_1d = Lightcurve(\n",
        "    time,\n",
        "    flux,\n",
        "    yerr=flux_err,\n",
        "    band=np.array([\"V\"]),\n",
        ")\n",
        "\n",
        "print(\"\\nValid 1-D Lightcurve created.\")\n",
        "print(\"xdata shape:\", lc_1d.xdata.shape)\n",
        "print(\"ydata shape:\", lc_1d.ydata.shape)\n",
        "print(\"ndim:\", lc_1d.ndim)\n",
        "print(\"band:\", lc_1d.band)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V-ijunBUcBXH",
        "outputId": "5ae83954-cdc4-44e4-e8c3-4c6122bbf66c"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Valid Lightcurve created.\n",
            "xdata shape: torch.Size([6, 2])\n",
            "ydata shape: torch.Size([6])\n",
            "ndim: 2\n",
            "band: ['J' 'J' 'J' 'K' 'K' 'K']\n",
            "\n",
            "Expected failure (band length mismatch):\n",
            "ValueError Length of 'band' (2) does not match the expected number of rows (6).\n",
            "\n",
            "Expected failure (band must be 1-D):\n",
            "ValueError 'band' must be a 1-D array-like of strings (shape (n,)); got shape (6, 1).\n",
            "\n",
            "Valid 1-D Lightcurve created.\n",
            "xdata shape: torch.Size([4])\n",
            "ydata shape: torch.Size([4])\n",
            "ndim: 1\n",
            "band: ['V']\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.12/dist-packages/pgmuvi/lightcurve.py:1840: UserWarning: The function expects a torch.Tensor as input.Your data will be converted to a tensor.\n",
            "  xdata = self._ensure_tensor(xdata)\n",
            "/usr/local/lib/python3.12/dist-packages/pgmuvi/lightcurve.py:1841: UserWarning: The function expects a torch.Tensor as input.Your data will be converted to a tensor.\n",
            "  ydata = self._ensure_tensor(ydata)\n",
            "/usr/local/lib/python3.12/dist-packages/pgmuvi/lightcurve.py:1843: UserWarning: The function expects a torch.Tensor as input.Your data will be converted to a tensor.\n",
            "  yerr = self._ensure_tensor(yerr)\n",
            "/tmp/ipykernel_2728/3967147311.py:89: UserWarning: Dropped 1 row(s) containing non-finite (NaN or Inf) values.\n",
            "  lc_nan = Lightcurve(\n",
            "/tmp/ipykernel_2728/3967147311.py:89: UserWarning: Fewer than 10 elements remain after dropping 1 rows, take care interpreting results!\n",
            "  lc_nan = Lightcurve(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Minimal demonstration of lightweight metadata currently supported by Lightcurve\n",
        "\n",
        "import numpy as np\n",
        "from pgmuvi.lightcurve import Lightcurve\n",
        "\n",
        "time_hours = np.array([0.0, 12.0, 24.0, 36.0], dtype=float)\n",
        "flux = np.array([1.0, 1.1, 0.9, 1.05], dtype=float)\n",
        "flux_err = np.array([0.05, 0.05, 0.05, 0.05], dtype=float)\n",
        "\n",
        "lc_meta = Lightcurve(\n",
        "    time_hours,\n",
        "    flux,\n",
        "    yerr=flux_err,\n",
        "    name=\"Example light curve\",\n",
        "    time_units=\"hr\",\n",
        "    band=np.array([\"V\"]),\n",
        ")\n",
        "\n",
        "print(\"name:\", lc_meta.name)\n",
        "print(\"band:\", lc_meta.band)\n",
        "print(\"xdata (stored internally in days):\")\n",
        "print(lc_meta.xdata)\n",
        "\n",
        "print(\"\\nDoes the object expose a dedicated metadata container?\")\n",
        "print(\"meta attribute present ->\", hasattr(lc_meta, \"meta\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ccPqUmfd0dfy",
        "outputId": "c17f64e8-4a72-4a12-e6fa-ca8502d2d8d1"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name: Example light curve\n",
            "band: ['V']\n",
            "xdata (stored internally in days):\n",
            "tensor([0.0000, 0.5000, 1.0000, 1.5000])\n",
            "\n",
            "Does the object expose a dedicated metadata container?\n",
            "meta attribute present -> False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Missing and non-finite data\n",
        "\n",
        "The current `Lightcurve` implementation does **not** expose a dedicated masking interface such as a boolean mask attribute or a `.mask()` method.\n",
        "\n",
        "Instead, the behavior is:\n",
        "\n",
        "1. **At direct construction time (`Lightcurve(...)`)**\n",
        "   - if the main data arrays are 1D in the supported standard format, rows containing **NaN or Inf** in `xdata`, `ydata`, or `yerr` are dropped automatically\n",
        "   - a warning is emitted if rows are dropped\n",
        "   - if no valid rows remain, a `ValueError` is raised\n",
        "\n",
        "2. **At CSV read time (`Lightcurve.from_csv(...)`)**\n",
        "   - rows containing missing values in the relevant columns are dropped automatically before the object is constructed\n",
        "   - empty strings in string-valued columns are also treated as missing\n",
        "   - if all rows are dropped, a `ValueError` is raised\n",
        "\n",
        "So the package currently follows a **drop-invalid-rows** strategy rather than a **mask-and-retain** strategy.\n",
        "\n",
        "This is important because it means:\n",
        "\n",
        "- the number of rows in the final `Lightcurve` may be smaller than the input data\n",
        "- invalid rows are not preserved for later masking/unmasking\n",
        "- if you want custom masking logic, you should apply it **before** constructing the `Lightcurve`"
      ],
      "metadata": {
        "id": "__2evNYrqMP4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import warnings\n",
        "from pgmuvi.lightcurve import Lightcurve\n",
        "\n",
        "# Example: direct Lightcurve construction drops rows with NaN/Inf\n",
        "x_bad = np.array([\n",
        "    [0.0, 0.8],\n",
        "    [1.0, 0.8],\n",
        "    [2.0, 0.8],\n",
        "    [3.0, 0.8],\n",
        "], dtype=float)\n",
        "\n",
        "y_bad = np.array([1.0, np.nan, 1.2, np.inf], dtype=float)\n",
        "yerr_bad = np.array([0.1, 0.1, 0.1, 0.1], dtype=float)\n",
        "band_bad = np.array([\"band 1\", \"band 1\", \"band 1\", \"band 1\"])\n",
        "\n",
        "with warnings.catch_warnings(record=True) as w:\n",
        "    warnings.simplefilter(\"always\")\n",
        "    try:\n",
        "      lc_clean = Lightcurve(\n",
        "          x_bad,\n",
        "          y_bad,\n",
        "          yerr=yerr_bad,\n",
        "          band=band_bad,\n",
        "      )\n",
        "      print(\"Input number of rows:\", len(y_bad))\n",
        "      print(\"Rows retained in Lightcurve:\", len(lc_clean.ydata))\n",
        "      print(\"Retained xdata:\")\n",
        "      print(lc_clean.xdata)\n",
        "    except Exception as e:\n",
        "      print(\"Expected failure:\")\n",
        "      print(type(e).__name__, e)\n",
        "if w:\n",
        "    print(\"\\nWarning emitted during construction:\")\n",
        "    print(str(w[0].message))\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YGL-tx2aqSwK",
        "outputId": "91c3145c-d753-4af6-a7f3-4d97533356bd"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input number of rows: 4\n",
            "Rows retained in Lightcurve: 2\n",
            "Retained xdata:\n",
            "tensor([[0.0000, 0.8000],\n",
            "        [2.0000, 0.8000]])\n",
            "\n",
            "Warning emitted during construction:\n",
            "The function expects a torch.Tensor as input.Your data will be converted to a tensor.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: CSV reading also drops invalid rows automatically\n",
        "\n",
        "csv_text = \"\"\"time,wavelength,flux,flux_err,band\n",
        "0.0,0.8,1.00,0.10,band 1\n",
        "1.0,0.8,nan,0.10,band 1\n",
        "2.0,0.8,1.20,0.10,band 1\n",
        "3.0,0.8,1.30,0.10,\n",
        "4.0,0.8,1.40,0.10,band 1\n",
        "\"\"\"\n",
        "\n",
        "with open(\"lightcurve_with_missing_rows.csv\", \"w\") as f:\n",
        "    f.write(csv_text)\n",
        "\n",
        "with warnings.catch_warnings(record=True) as w:\n",
        "    warnings.simplefilter(\"always\")\n",
        "    lc_csv_clean = Lightcurve.from_csv(\"lightcurve_with_missing_rows.csv\")\n",
        "\n",
        "print(\"Rows retained after from_csv:\", len(lc_csv_clean.ydata))\n",
        "print(\"Retained xdata:\")\n",
        "print(lc_csv_clean.xdata)\n",
        "print(\"Retained band labels:\")\n",
        "print(lc_csv_clean.band)\n",
        "\n",
        "if w:\n",
        "    print(\"\\nWarning emitted during CSV read:\")\n",
        "    print(str(w[0].message))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0i3HnP6WqjsF",
        "outputId": "54364922-af34-4879-c20c-8e5016e9aab4"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rows retained after from_csv: 4\n",
            "Retained xdata:\n",
            "tensor([0., 2., 3., 4.])\n",
            "Retained band labels:\n",
            "['band 1']\n",
            "\n",
            "Warning emitted during CSV read:\n",
            "Dropped 1 row(s) containing NaN values.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Generating synthetic data\n",
        "\n",
        "##### Synthetic data can of course be generated manually, but PGMUVI also has built-in methods to generate such data. We will demonstrate both these methods below."
      ],
      "metadata": {
        "id": "EfOu5NpPXQ2V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following generates a 1D light curve with data generated manually"
      ],
      "metadata": {
        "id": "z4K44q72Zyfo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\" Manual method: generate a perturbed sine curve with one period component\"\"\"\n",
        "\n",
        "P = np.random.uniform(30, 300)  # 137. #Days!\n",
        "print(\"True period: \", P, \" days\")\n",
        "n_data = 400\n",
        "jd_min = 2450000\n",
        "n_periods = np.random.uniform(3, 10)\n",
        "jd_max = jd_min + P * (n_periods)\n",
        "print(\"Simulating for \", n_periods, \" periods\")\n",
        "\n",
        "# generate data from a simple case - superimpose two sine curves and add noise\n",
        "timestamps_1d = torch.Tensor(\n",
        "    np.random.uniform(jd_min, jd_max, size=n_data)\n",
        ")  # generate random x data here\n",
        "fluxes_1d = torch.sin(timestamps_1d * (2 * np.pi / P))  # generate random y data here\n",
        "fluxes_1d += 0.1 * torch.randn_like(fluxes_1d)\n",
        "flux_err_1d = 0.1 * fluxes_1d.abs()\n",
        "\n",
        "lc1d_manual = Lightcurve(timestamps_1d, fluxes_1d, yerr=flux_err_1d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-5Ot_lMaYKzY",
        "outputId": "2fdb68b0-66b4-48b2-b7d8-4f0543767012"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True period:  178.17964606037768  days\n",
            "Simulating for  8.006325564606936  periods\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use the `synthetic.py` script instead. The following generates a 2D light curve with a single period component"
      ],
      "metadata": {
        "id": "e8qnUIknZ31t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"Generate a set of mono-periodic light curves using synthetic.py\"\"\"\n",
        "\n",
        "n_per_band = (25, 40) # number of data points per light curve limited to this range\n",
        "\n",
        "SINGLE_DATASET_CONFIG = dict(\n",
        "    period=150,\n",
        "    t_span=150 * 2.3,\n",
        "    n_per_band=n_per_band,\n",
        "    wavelengths=[0.8, 1.2, 2.2], # wavelengths in µm\n",
        "    amplitude_law=\"extinction\",\n",
        "    seed=SEED,\n",
        ")\n",
        "\n",
        "lc2d_synth_1comp = synthetic.make_chromatic_sinusoid_2d(**SINGLE_DATASET_CONFIG)"
      ],
      "metadata": {
        "id": "YvRCRPz3Yo2q"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "`synthetic.py` also generates a multi-component 2D light curve. The following creates a set of light curves with 2 components and a phase lag."
      ],
      "metadata": {
        "id": "XA_RxRRkaApv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\" Generate a set of light curves with two period components and a phase lag\"\"\"\n",
        "n_per_band = (25, 40) # number of data points per light curve limited to this range\n",
        "\n",
        "MULTI_DATASET_CONFIG = dict(\n",
        "    components=[\n",
        "        {\"period\": 150.0, \"amplitude_fraction\": 1.0, \"phase\": 0.0},\n",
        "        {\"period\": 66.0, \"amplitude_fraction\": 0.3, \"phase\": np.pi / 2 * 0.85},\n",
        "    ],\n",
        "    t_span=150 * 2.3,\n",
        "    n_per_band=n_per_band,\n",
        "    wavelengths=[0.8, 1.2, 2.2],\n",
        "    amplitude_law=\"extinction\",\n",
        "    noise_level=0.05,\n",
        "    seed=SEED,\n",
        ")\n",
        "\n",
        "lc2d_synth_2comp = synthetic.make_multi_sinusoid_chromatic_2d(**MULTI_DATASET_CONFIG)"
      ],
      "metadata": {
        "id": "uIcFZAQaZF2H"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Visualization using the `.plot()` method"
      ],
      "metadata": {
        "id": "F7zO6b9W7qMh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "_ = lc1d_manual.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "id": "l6o91EGH6vJD",
        "outputId": "1a1294f1-3fa0-4315-9001-46048facb2da"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "_ = lc2d_synth_1comp.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 89
        },
        "id": "SXpvedv7asf2",
        "outputId": "3f8af6e3-b09a-4e76-e37a-17006ebeb686"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASkVJREFUeJzt3Xl4VNXh//HPJJAQEpKwBJKQQNgEo2xl+6Y2uEVA0OJ3jILFgmhRWQoUN7C/AtVaBC1LK+4KFlGpMYi1iCJrhAiCIqsUMJYQCKskJIFAkvP7w2a+DFkhyWz3/XqeeZ7MuefeOXMzk3zuueeeazPGGAEAAFiQn7sbAAAA4C4EIQAAYFkEIQAAYFkEIQAAYFkEIQAAYFkEIQAAYFkEIQAAYFkEIQAAYFkEIQAAYFkEIcDH7du3T/369VNYWJhsNps+/PBDdzcJADwGQQjwcSNGjNCOHTv0zDPPaNGiRerZs2edvVZmZqb++Mc/qnfv3mrcuLGaNWumG264QZ9//nm11v/uu+/0+OOPq1u3bmrUqJGioqI0aNAgbdmypdz6WVlZuvvuuxUeHq7Q0FANHjxY33//fbl133jjDV199dVq0KCBOnTooL/97W9evc2L3XLLLbLZbBo3bpxT+cKFC2Wz2Sp8LF68uMy2lixZooSEBAUHBys8PFw///nPtXr1aqc6OTk5evzxx9WhQwcFBQWpdevWeuCBB3Tw4EGnekuXLlX//v0VHR2twMBAxcTEKDk5WTt37nSqt3bt2krb+cwzzzjqHjlyRJMnT9aNN96oRo0ayWazae3atRXum/Pnz+vPf/6zOnXqpAYNGqhFixYaNGiQDh06VOV+hTXUc3cDANSds2fPKj09Xb///e/L/JOsC8uWLdPMmTN1xx13aMSIESoqKtLf//533XLLLXrzzTc1cuTIStd//fXX9cYbb+jOO+/UmDFjlJOTo1deeUX/8z//oxUrVigpKclRNy8vTzfeeKNycnL05JNPqn79+pozZ46uv/56bdu2TU2bNnXUfeWVV/Twww/rzjvv1KRJk5SWlqbx48eroKBATzzxhNdt82KpqalKT08vd1nfvn21aNGiMuVz5szRt99+q5tvvtmpfPr06XrqqaeUnJys++67TxcuXNDOnTuVlZXlqFNSUqJbbrlFu3fv1pgxY3TVVVdp//79evHFF/Xpp59qz549atSokSRpx44daty4sSZMmKBmzZopOztbb775pnr37q309HR17dpVknT11VeX285Fixbps88+U79+/Rxle/fu1cyZM9WhQwd17ty5wvcuSRcuXNCgQYO0ceNGjRo1Sl26dNGPP/6oTZs2KScnRzExMRWuCwsxAHzWf/7zHyPJPPfcc7W2zby8vAqX7dy50xw/ftyp7Ny5c6ZTp04mJiamym1v2bLFnDlzxqnsxIkTJiIiwlx33XVO5TNnzjSSzObNmx1le/bsMf7+/mbKlCmOsoKCAtO0aVMzaNAgp/WHDRtmgoODzalTp7xum6XOnj1r4uLizFNPPWUkmbFjx5apc6mCggLTqFEjc8sttziVp6enG5vNZmbPnl3p+hs2bDCSzAsvvOBU/uabbxpJJjU1tdL1s7OzTb169cxDDz1UZVvbt29vOnTo4FSWm5trTp48aYwx5v333zeSzJo1a8pdf+bMmaZ+/fpm06ZNVb4WrIsgBMtbvXp1hX/AFy9ebCSZjRs3lrvuV199ZSSZhQsXllm2YsUKI8n885//NMb89Ad8woQJpnXr1iYgIMBERESYpKQks3Xr1grbVlBQYDp27Gg6duxoCgoKHOUnT540kZGRJiEhwRQVFZW77rRp04wkp0fr1q0dy7/++mszYMAA06hRIxMcHGxuuukmk56e7rSNBQsWGElm7dq1ZvTo0SYiIsKEh4dX2N6KTJo0yUgyubm5l72uMcbY7XbTpEkTp7JevXqZXr16lanbr18/065dO8fzf/3rX0aS+de//uVUb+PGjUaSWbRokddts9Qf//hH06pVK1NQUFDtILRkyZJyP7NDhgwxUVFRpri42JSUlJQJpKU++eQTI8m8//775ZZ/8sknlb5+SUmJCQ0NNUOGDKm03qZNm4wkM3369ArrVBaEiouLTXR0tLn77ruNMcZcuHDB5OfnV/qasCbGCMHybrjhBsXGxpY7XmLx4sVq166dEhISyl23Z8+eatu2rf7xj3+UWbZkyRI1btxY/fv3lyQ9/PDDeumll3TnnXfqxRdf1KOPPqqgoCDt2bOnwrYFBQXprbfe0v79+/X73//eUT527Fjl5ORo4cKF8vf3L3ddu92uOXPmSJLuueceLVq0SHPnzpUk7dq1S4mJifr222/1+OOP6w9/+IMyMjJ0ww03aNOmTWW2NWbMGO3evVtTp07V5MmTK2xvRbKzs9WwYUM1bNjwstctXb9Zs2aO5yUlJdq+fXu545169+6tAwcO6MyZM5Kkb775RpLK1O3Ro4f8/Pwcy71lm6UOHjyoZ599VjNnzlRQUFCZ7Vdk8eLFCgoKkt1udypftWqVevXqpb/+9a+KiIhwjNF64YUXnOr17NlTwcHB+sMf/qDVq1crKytL69at0+OPP65evXo5nb4sdfr0aR0/flw7duzQb37zG+Xm5pY5LVdeOyVp2LBh1X5vF9u9e7cOHz6sLl266MEHH1RwcLCCg4PVpUsXrVmz5oq2CR/l7iQGeIIpU6aYwMBAc/r0aUfZsWPHTL169cy0adOqXLd+/fpOpy4KCwtNeHi4uf/++x1lYWFh1Tpir+g1/Pz8zPr16x1HwXPnzq1yvYyMjHJPjd1xxx0mICDAHDhwwFF2+PBh06hRI9O3b19HWWmP0C9+8YsKe56qsm/fPtOgQQPz61//+orWX79+vbHZbOYPf/iDo+z48eNGknnqqafK1J8/f76RZL777jtjjDFjx441/v7+5W47IiLCDB061Ku2WSo5Odn8/Oc/dzxXNXqETp48aQICAhy9JKVOnTplJJmmTZuakJAQ89xzz5klS5aYAQMGGEnm5Zdfdqr/8ccfm6ioKKfexv79+1fYi9SxY0dHvZCQEPP//t//M8XFxRW2s6ioyLRo0cL07t270vdTWY9Qamqq4z116NDBLFiwwCxYsMB06NDBBAQEmG+//bbSbcM66BECJA0fPlyFhYVKSUlxlC1ZskRFRUW69957K113yJAhunDhglJTUx1ln332mU6fPq0hQ4Y4ysLDw7Vp0yYdPnz4sts3ffp0XXPNNRoxYoTGjBmj66+/XuPHj7/s7UhScXGxPvvsM91xxx1q27atozwqKkq/+tWv9MUXXyg3N9dpnVGjRlXY81SZgoIC3XXXXQoKCtKzzz572esfO3ZMv/rVr9SmTRs9/vjjjvKzZ89KkgIDA8us06BBA6c6Z8+eVUBAQLnbb9CggVM9b9imJK1Zs0YffPCBo4evulJSUnT+/PkyvSx5eXmSpJMnT+r111/Xo48+qrvvvlv/+te/FB8frz/96U9O9SMiItS9e3c988wz+vDDDzV9+nSlpaVVOBh+wYIFWrFihV588UVdffXVOnv2rIqLiyts56pVq3T06NEr7g26+D2dOXNGq1at0n333af77rtPn3/+uYwxmjVr1hVvG76FIARI6tSpk3r16uV0emzx4sX6n//5H7Vv377Sdbt27apOnTppyZIljrIlS5aoWbNmuummmxxls2bN0s6dOxUbG6vevXtr+vTpFV5CfamAgAC9+eabysjI0JkzZ7RgwQLZbLbLfJc/OX78uAoKCtSxY8cyy66++mqVlJQoMzPTqbxNmzaX/TrFxcUaOnSodu/erZSUFEVHR1/W+vn5+brtttt05swZLVu2TCEhIY5lpaeCCgsLy6x37tw5pzpBQUE6f/58ua9x7tw5p3resM2ioiKNHz9ev/71r9WrV69y61dk8eLFatKkiW699Van8tJt169fX8nJyY5yPz8/DRkyRIcOHXJcGv/999/rxhtv1P33368nn3xSgwcP1rRp0/Tiiy8qJSVFn3zySZnXTUhIUP/+/TV69Gh9+umnevvttzVlypRK2+nv7+90IHG5St/Tddddp9jYWEd5q1at9Itf/EIbN2684m3DtxCEgP8aPny41q1bp0OHDunAgQP68ssvq+wNKjVkyBCtWbNGJ06cUGFhoT766CPdeeedqlfv/2aouPvuu/X999/rb3/7m6Kjo/Xcc8/pmmuuKfcfR3k+/fRTST/9U9y3b9/lv8EauJwxKKVGjRqljz/+WAsXLnQKhNVx/vx52e12bd++XcuWLdO1117rtLxJkyYKDAzUkSNHyqxbWlYavKKiolRcXKxjx46VeY2TJ0866nnLNv/+979r7969euihh/TDDz84HtJPvR8//PCDCgoKyrzewYMHlZaWprvuukv169d3WtakSRM1aNBATZs2LdPz17x5c0nSjz/+KOmnuYnOnTun2267zaneL3/5S0nShg0byrz2xRo3bqybbrqp3DF50k89Y0uXLlVSUpJatGhR6bYqU7q/yttG8+bNHe8HIAgB/zV06FD5+/vr3Xff1eLFi1W/fv1qH5EOGTJERUVF+uCDD/TJJ58oNzdXQ4cOLVMvKipKY8aM0YcffqiMjAw1bdrUabK4imzfvl1PPfWURo4cqe7du+s3v/mNcnJyLvs9Sj+d1mjYsKH27t1bZtl3330nPz8/pyPoK/HYY49pwYIFmjNnju65557LWrekpETDhw/XqlWr9M477+j6668vU8fPz0+dO3cud6LFTZs2qW3bto65bLp16yZJZepu2bJFJSUljuXess2DBw/qwoULuu6669SmTRvHQ/opJLVp00afffZZmdd79913ZYwp93STn5+funXrpuPHj5fplSo9lRsRESFJOnr0qIwxZU5tXbhwQdJPPVZVOXv2bIWf348++khnzpyp0WkxSercubPq16/vNAdSqcOHDzveD8BgaeAiv/zlL02XLl3MVVddZW6//fbLWrdz587mxhtvNEOHDnVchlyqqKjIaSB2qV69epmePXtWut3z58+b7t27m7i4OJObm2u+/fZbExAQYEaOHFllmyobLB0YGGgyMjIcZdnZ2SY0NLTcwdJfffVVla9VatasWUaSefLJJyutd/r0abNnz54y+2XMmDFGknnllVcqXf/ZZ58t07bvvvvO+Pv7myeeeMJRVlBQYJo0aWJuu+02p/Xvvfde07BhQ8ecNN6yzT179pilS5eWeUgyAwcONEuXLjWHDx8us7+6dOliWrVqZUpKSsrdn3PmzDGSzKuvvuooO3v2rGnbtq2Jj493lD3//PNGklmwYIHT+nPnzjWSzHvvvecoO3r0aJnXycjIMI0aNTKJiYnltuOXv/yladiwYYUDry9W1TxCgwcPNv7+/mbPnj2Ost27dxt/f38zZsyYKrcPayAIARdJSUlxXN2yZMmSy1r3T3/6k/Hz8zMNGzY0v/3tb52W/fjjjyY4ONiMGDHCzJ4927z66qvm7rvvNpLMX/7yl0q3O3XqVGOz2czq1audXkvlzDlzqYqC0M6dO01wcLBp2bKleeaZZ8zMmTNN27ZtTWBgoPnyyy8d9S43CJVeqdOhQwezaNGiMo/s7Owy2774H2rpP+OEhIRy1794Msfc3FzTrl0707x5czNr1iwzZ84cExsba6Kjo82xY8ec2lV6hVZycrJ57bXXzPDhw40k88wzzzjV85ZtlkeVXDW2Y8cOI8lMnjy5wvULCgrMNddcY+rXr28effRR89e//tX06tXL+Pv7m+XLlzvqnThxwkRGRpqAgAAzfvx488orr5iHHnrI+Pv7m2uuucYUFhY66jZv3tzcc889ZubMmebVV181jz32mGnSpIlp0KCB2bBhQ5k2nDx50tSvX7/MFXKXevrpp83TTz9thg4daiSZ+++/31F2sV27dpmQkBATFRVlZsyYYWbMmGGioqJMRESEOXToUKWvAesgCAEXKSwsNI0bNzZhYWHm7Nmzl7Xuvn37HCHqiy++KLPdxx57zHTt2tUxgWHXrl3Niy++WOk2t27daurVq1cmWBUVFZlevXqZ6Oho8+OPP1a4fkVByJifJlTs37+/CQkJMQ0bNjQ33nhjmYkjLzcIlTeJ48WPi4/cywtCI0aMqHT9i3uwjDEmMzPTJCcnm9DQUBMSEmJuu+02s2/fvnLb9uqrr5qOHTuagIAA065dOzNnzpxye0e8ZZuXqiwITZ482Ugy27dvr3QbR48eNSNGjDBNmjQxgYGBpk+fPmbFihVl6h06dMjcf//9pk2bNiYgIMBERUWZUaNGlZlVfNq0aaZnz56mcePGpl69eiY6OtoMHTq0wna8/PLLRpL56KOPqnyvFT0utXXrVpOUlGSCg4NNo0aNzODBg82///3vSrcPa7EZY0wtnWUDvF5RUZGio6N1++2364033nB3cwAAdYzB0sBFPvzwQx0/flzDhw93d1MAAC5AjxCgn67g2b59u55++mk1a9ZMX3/9tbubBABwAXqEAEkvvfSSRo8erebNm+vvf/+7u5sDAHAReoQAAIBl0SMEAAAsiyAEAAAsq17VVaytpKREhw8fVqNGja74JpcAAMC1jDE6c+aMoqOj5edXcb8PQagKhw8frvF9lwAAgHtkZmYqJiamwuUEoSqU3hAxMzNToaGhbm4NAADul5+fr+joaEk/dRgEBwe7uUVl5ebmKjY21vF/vCIEoSqUng4LDQ0lCAEAIMnf39/xc2hoqEcGoVJVDWthsDQAALAsghAAALAsghAAALAsxgjVkuLiYl24cMHdzUAN1K9f3+m8NwDA9xGEasgYo+zsbJ0+fdrdTUEtCA8PV2RkJHNGAYBFEIRqqDQENW/eXA0bNuQfqJcyxqigoEDHjh2TJEVFRbm5RQAAVyAI1UBxcbEjBDVt2tTdzUENBQUFSZKOHTum5s2bc5oMACyAwdI1UDomqGHDhm5uCWpL6e+S8V4AYA0EoVrA6TDfwe8SAKyFIOQB8vPzZbPZZLPZlJ+f7+7mAABgGQQhVCouLk5z5851dzNqja+9HwBAzRCEPEBxcbHj5/Xr1zs9r0uZmZm6//77FR0drYCAALVu3VoTJkzQyZMnXfL6AAC4G0HIzVJTUxUfH+94PnDgQMXFxSk1NbVOX/f7779Xz549tW/fPr377rvav3+/Xn75Za1atUoJCQk6depUnb5+RYqLi1VSUuKW1wYAWA9ByI1SU1OVnJysrKwsp/KsrCwlJyfXaRgaO3asAgIC9Nlnn+n6669Xq1atdOutt+rzzz9XVlaWfv/73zvqnjlzRvfcc4+Cg4PVsmVLzZ8/37HMGKPp06erVatWCgwMVHR0tMaPH+9YXlhYqEcffVQtW7ZUcHCw+vTpo7Vr1zqWL1y4UOHh4froo48UHx+vwMBAvf7662rQoEGZSSonTJigm266yfH8iy++UGJiooKCghQbG6vx48c7jbE6duyYbr/9dgUFBalNmzZavHhxLe5BAIAvIAi5SXFxsSZMmCBjTJllpWUTJ06sk9Nkp06d0qeffqoxY8Y45s4pFRkZqWHDhmnJkiWOdjz33HPq2rWrvvnmG02ePFkTJkzQypUrJUkffPCB5syZo1deeUX79u3Thx9+qM6dOzu2N27cOKWnp+u9997T9u3bddddd2nAgAHat2+fo05BQYFmzpyp119/Xbt27dKwYcMUHh6uDz74wFGnuLhYS5Ys0bBhwyRJBw4c0IABA3TnnXdq+/btWrJkib744guNGzfOsc59992nzMxMrVmzRikpKXrxxRcdEyYCACBJMqhUTk6OkWRycnLKLDt79qzZvXu3OXv27GVvd82aNUZSlY81a9bUwrtw9uWXXxpJZunSpeUunz17tpFkjh49alq3bm0GDBjgtHzIkCHm1ltvNcYY85e//MVcddVV5vz582W285///Mf4+/ubrKwsp/Kbb77ZTJkyxRhjzIIFC4wks23bNqc6EyZMMDfddJPj+aeffmoCAwPNjz/+aIwx5oEHHjAPPvig0zppaWnGz8/PnD171uzdu9dIMps3b3Ys37Nnj5Fk5syZU+G+qcnvFHUvLy/P8d3Iy8tzd3MAy/KG72Jl/78vRo+Qmxw5cqRW610JU05vVHkSEhLKPN+zZ48k6a677tLZs2fVtm1bjRo1SkuXLlVRUZEkaceOHSouLtZVV12lkJAQx2PdunU6cOCAY3sBAQHq0qWL02sMGzZMa9eu1eHDhyVJixcv1qBBgxQeHi5J+vbbb7Vw4UKn7fbv318lJSXKyMjQnj17VK9ePfXo0cOxzU6dOjnWBwBA4hYbblPde1nVxT2v2rdvL5vNpj179uh///d/yyzfs2ePGjdurIiIiCq3FRsbq7179+rzzz/XypUrNWbMGD333HNat26d8vLy5O/vr61bt5a5XUVISIjj56CgoDITGfbq1Uvt2rXTe++9p9GjR2vp0qVauHChY3leXp4eeughp/FIpVq1aqV///vfVbYdAACCkJskJiYqJiZGWVlZ5fbM2Gw2xcTEKDExsdZfu2nTprrlllv04osv6ne/+53TOKHs7GwtXrxYw4cPd4STL7/80mn9L7/8UldffbXjeVBQkG6//XbdfvvtGjt2rDp16qQdO3aoe/fuKi4u1rFjx67ofQwbNkyLFy9WTEyM/Pz8NGjQIMeyn/3sZ9q9e7fat29f7rqdOnVSUVGRtm7dql69ekmS9u7dW2YANgDA2jg15ib+/v6aN2+epLK3dSh9Pnfu3Dq78ecLL7ygwsJC9e/fX+vXr1dmZqZWrFihW265RS1bttQzzzzjqLthwwbNmjVL//73vzV//ny9//77mjBhgqSfrvp64403tHPnTn3//fd6++23FRQUpNatW+uqq67SsGHDNHz4cKWmpiojI0ObN2/WjBkz9K9//avKNg4bNkxff/21nnnmGSUnJyswMNCx7IknntDGjRs1btw4bdu2Tfv27dOyZcscg6U7duyoAQMG6KGHHtKmTZu0detW/eY3vykzOBwAYG0EITey2+1KSUlRdHS0U3lMTIxSUlJkt9vr7LU7dOigLVu2qG3btrr77rvVrl07Pfjgg7rxxhuVnp6uJk2aOOo+8sgj2rJli7p3764//elPmj17tvr37y9JCg8P12uvvabrrrtOXbp00eeff65//vOfatq0qSRpwYIFGj58uB555BF17NhRd9xxh7766iu1atWqyja2b99evXv31vbt2x1Xi5Xq0qWL1q1bp3//+99KTExU9+7dNXXqVKd9uWDBAkVHR+v666+X3W7Xgw8+qObNm9fG7gMA+Aibqe6IWYvKzc1VWFiYcnJyFBoa6rTs3LlzysjIUJs2bdSgQYMav4YkLV++XP369auzniBUrrZ+p6gb+fn5jvFleXl5Cg4OdnOLAGvyhu9iZf+/L0aPkAe4OPT07duXEAQAgIsQhDxAcHCwjDEyxnhkqgYA4GLuukdmXSAIAQCAanPXPTLrCkEIAABUizvvkVlXCEK1gPHmvoPfJQCUz533yKxLBKEaqF+/vqSfbhoK31D6uyz93QIAfpKWlqZDhw5VuNwYo8zMTKWlpbmwVTXHzNI14O/vr/DwcMcdzRs2bFhmckR4B2OMCgoKdOzYMYWHh3PlHgBcwhPukVkXCEI1FBkZKUmOMATvFh4e7vidAgD+jzvvkVmXCEI1ZLPZFBUVpebNm+vChQvubg5qoH79+vQEAUAF3HmPzLpEEKol/v7+/BMFAPis0ntkJicny2azOYUhV9wjs64wWBoAAFSLO++RWVfoEQIAANVmt9uVlJTkM/fIpEcIAABcFl+6RyZBCAAAi8nPz5fNZpPNZlN+fr67m+NWBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZXheE5s+fr7i4ODVo0EB9+vTR5s2bK6ybmpqqnj17Kjw8XMHBwerWrZsWLVrkwtYCAABP5lVBaMmSJZo0aZKmTZumr7/+Wl27dlX//v0rvM9XkyZN9Pvf/17p6enavn27Ro4cqZEjR+rTTz91ccsBAIAnspnybhjiofr06aNevXrphRdekCSVlJQoNjZWv/3tbzV58uRqbeNnP/uZBg0apKeffrpa9XNzcxUWFqacnByFhoZecdsB1Fx+fr5CQkIkSXl5eQoODnZziwDvVNPvkjd8F6v7/9treoTOnz+vrVu3KikpyVHm5+enpKQkpaenV7m+MUarVq3S3r171bdv3wrrFRYWKjc31+kBAAB8k9cEoRMnTqi4uFgtWrRwKm/RooWys7MrXC8nJ0chISEKCAjQoEGD9Le//U233HJLhfVnzJihsLAwxyM2NrbW3gMAAPAsXhOErlSjRo20bds2ffXVV3rmmWc0adIkrV27tsL6U6ZMUU5OjuORmZnpusYCAACX8pqbrjZr1kz+/v46evSoU/nRo0cVGRlZ4Xp+fn5q3769JKlbt27as2ePZsyYoRtuuKHc+oGBgQoMDKy1dgMAAM/lNT1CAQEB6tGjh1atWuUoKykp0apVq5SQkFDt7ZSUlKiwsLAumggAALyM1/QISdKkSZM0YsQI9ezZU71799bcuXOVn5+vkSNHSpKGDx+uli1basaMGZJ+Gu/Ts2dPtWvXToWFhVq+fLkWLVqkl156yZ1vAwAAeAivCkJDhgzR8ePHNXXqVGVnZ6tbt25asWKFYwD1wYMH5ef3f51c+fn5GjNmjA4dOqSgoCB16tRJb7/9toYMGeKutwAAADyIV80j5A7MIwR4Dm+YuwTwBswj9H+8ZowQAABAbSMIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIebD8/HzZbDbZbDbl5+e7uzmA2xUXFzt+Xr9+vdNzAN7FU/7HEYQAeIXU1FTFx8c7ng8cOFBxcXFKTU11Y6sAeDuCEACPl5qaquTkZGVlZTmVZ2VlKTk5mTAE4IoRhAB4tOLiYk2YMEHGmDLLSssmTpzIaTIAV4QgBMCjpaWl6dChQxUuN8YoMzNTaWlpLmwVAF9BEALg0Y4cOVKr9QDgYgQhAB4tKiqqVusBwMUIQgA8WmJiomJiYmSz2cpdbrPZFBsbq8TERBe3DIAvIAgB8Gj+/v6aN2+eJJUJQ6XP586dK39/f5e3DYD3IwgB8Hh2u10pKSmKjo52Ko+JiVFKSorsdrubWgbA29VzdwMAoDrsdruSkpIUFhYmSVq+fLn69etHTxCAGvG6HqH58+crLi5ODRo0UJ8+fbR58+YK67722mtKTExU48aN1bhxYyUlJVVaH4Bnuzj09O3blxAEoMa8KggtWbJEkyZN0rRp0/T111+ra9eu6t+/v44dO1Zu/bVr1+qee+7RmjVrlJ6ertjYWPXr16/M7LQAAMCavCoIzZ49W6NGjdLIkSMVHx+vl19+WQ0bNtSbb75Zbv3FixdrzJgx6tatmzp16qTXX39dJSUlWrVqlYtbDgAAPJHXBKHz589r69atSkpKcpT5+fkpKSlJ6enp1dpGQUGBLly4oCZNmtRVMwEAgBfxmsHSJ06cUHFxsVq0aOFU3qJFC3333XfV2sYTTzyh6OhopzB1qcLCQhUWFjqe5+bmXlmDAQCAx/OaHqGaevbZZ/Xee+9p6dKlatCgQYX1ZsyYobCwMMcjNjbWha0EAACu5DVBqFmzZvL399fRo0edyo8eParIyMhK133++ef17LPP6rPPPlOXLl0qrTtlyhTl5OQ4HpmZmTVuOwAA8ExeE4QCAgLUo0cPp4HOpQOfExISKlxv1qxZevrpp7VixQr17NmzytcJDAxUaGio0wMAAPgmrxkjJEmTJk3SiBEj1LNnT/Xu3Vtz585Vfn6+Ro4cKUkaPny4WrZsqRkzZkiSZs6cqalTp+qdd95RXFycsrOzJUkhISEKCQlx2/sAAACewauC0JAhQ3T8+HFNnTpV2dnZ6tatm1asWOEYQH3w4EH5+f1fJ9dLL72k8+fPKzk52Wk706ZN0/Tp013ZdAAA4IG8KghJ0rhx4zRu3Lhyl61du9bp+Q8//FD3DQIAwMsUFxc7fl6/fr2lb1fjNWOEAABAzaWmpio+Pt7xfODAgYqLi1NqaqobW+U+BCEAACwiNTVVycnJZW41lZWVpeTkZEuGIYIQ6lx+fr5sNptsNpvy8/Pd3RwAsKTi4mJNmDBBxpgyy0rLJk6c6HTarCLBwcEyxsgYo+Dg4FpvqysRhAAAsIC0tDQdOnSowuXGGGVmZiotLc2FrXI/ghAAABZw5MiRWq3nKwhCAABYQFRUVK3W8xUEIQAALCAxMVExMTGy2WzlLrfZbIqNjVViYqKLW+ZeBCEAACzA399f8+bNk6QyYaj0+dy5cy03nxBBCAAAi7Db7UpJSVF0dLRTeUxMjFJSUmS3293UMvfxupmlAQDAlbPb7UpKSlJYWJgkafny5cwsDQAArOPi0NO3b1/LhiCJIAQAACyMIAQAACyLIAQAgBtw+yHPQBACAACWRRACAACWRRACAACWRRACAACWRRACAACWRRACAABlWOWqNoIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAACwLIIQAECSde42DlyMIAQAACyLIAT8F0fDAGA9BCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCGL4nYSAAAQhAAAgIURhAAAcLOQkBB66N2EIAQAACyLIAQAACzL64LQ/PnzFRcXpwYNGqhPnz7avHlzhXV37dqlO++8U3FxcbLZbJo7d67rGgoAADyeVwWhJUuWaNKkSZo2bZq+/vprde3aVf3799exY8fKrV9QUKC2bdvq2WefVWRkpItbCwAAPJ1XBaHZs2dr1KhRGjlypOLj4/Xyyy+rYcOGevPNN8ut36tXLz333HMaOnSoAgMDXdxaAADg6bwmCJ0/f15bt25VUlKSo8zPz09JSUlKT0+vtdcpLCxUbm6u0wMAAPgmrwlCJ06cUHFxsVq0aOFU3qJFC2VnZ9fa68yYMUNhYWGOR2xsbK1tGwAAeBavCUKuMmXKFOXk5DgemZmZ7m4SAACoI/Xc3YDqatasmfz9/XX06FGn8qNHj9bqQOjAwEDGEwEAYBFe0yMUEBCgHj16aNWqVY6ykpISrVq1SgkJCW5sWd0pLi52/Lx+/Xqn5wAAoOa8JghJ0qRJk/Taa6/prbfe0p49ezR69Gjl5+dr5MiRkqThw4drypQpjvrnz5/Xtm3btG3bNp0/f15ZWVnatm2b9u/f7663UG2pqamKj493PB84cKDi4uKUmprqxlYBAOBbvCoIDRkyRM8//7ymTp2qbt26adu2bVqxYoVjAPXBgwd15MgRR/3Dhw+re/fu6t69u44cOaLnn39e3bt3129+8xt3vYVqSU1NVXJysrKyspzKs7KylJycTBgCAHg9TznrYTPGGLe8spfIzc1VWFiYcnJyFBoaWuevV1xcrLi4OB06dKjc5TabTTExMcrIyJC/v/8Vv05+fr5CQkIkSXl5eQoODr7ibXnSa9WEt7TTyvgd1S32r2tdvL9LuWq/V+d3XZefh9TUVI0fP97pgD8mJkbz5s2T3W6vldeo7v9vr+oRsoK0tLQKQ5AkGWOUmZmptLQ0F7YKAIDa4WlnPQhCHubiU3u1UQ8AcGXy8/Nls9lks9mUn5/v7ub4hOLiYk2YMEHlnYwqLZs4caJLT5MRhDxMVFRUrdYDfElwcLCMMTLGcNoG8EKeeNaDIORhEhMTFRMTI5vNVu5ym82m2NhYJSYmurhlvs9TBu4BsAYr/o3xxLMeBCEP4+/vr3nz5klSmTBU+nzu3Lk1GiiNspiuAIArXfo3p9SyZcvc0BrX8cSzHpcdhEaMGKH169fXRVvwX3a7XSkpKYqOjnYqj4mJUUpKSq2NqMdPPG3g3uViHAPgXSr6myNJ9957r8f/zakJTzzrcdlBKCcnR0lJSerQoYP+/Oc/l/uLRM3Z7Xbt3r3b8Xz58uXKyMhwSQiy0j9WTxy4B8B3VfY3p5Qv/83xxLMelx2EPvzwQ2VlZWn06NFasmSJ4uLidOuttyolJUUXLlyoizZa1sUfhL59+3I6rA544sA9AL6Lvzmed9bjisYIRUREaNKkSfr222+1adMmtW/fXr/+9a8VHR2t3/3ud9q3b19ttxOoE544cA+A7+Jvzk/cedbjUjUaLH3kyBGtXLlSK1eulL+/vwYOHKgdO3YoPj5ec+bMqa02AnXGEwfuAfBd/M35P55y1uOyg9CFCxf0wQcf6LbbblPr1q31/vvva+LEiTp8+LDeeustff755/rHP/6hp556qi7aCy/kyZele+LAPQC+i785nueyg1BUVJRGjRql1q1ba/PmzdqyZYsefvhhp/t43HjjjQoPD6/NdsJLefpl6Z44cA+A76rsb04p/ua41mUHoTlz5ujw4cOaP3++unXrVm6d8PBwZWRk1LRt8HLecll6RQP3jDF6++23ma6gEla6whCoLRX9zZHE3xw3uOwg9Otf/1oNGjSoi7bAh3jbZemXDtwrNXjwYDe0BoCv42+O52BmadQJb7xElK5oAK7E3xzPQBBCneASUQCANyAIoU5wiSgAwBsQhFAnuEQUAOANCEKoE1yWDgDwBgQh1BlPu58MgMp58uSnVsY0FXWLIIQ65Un3kwFQMU+f/BSoKwQh1DlPuZ8MgPJ5y+SnQF0gCAGAhXnb5KdAbSMIAYCFeePkp6i54OBgGWNkjFFwcLC7m+NWBCHAhzHIElVh8lNYHUEI8HJc6YOaYPJTWB1BCPBiXOmDmmLyU1gdQQjwUlzpg9pw8eSnl2LyU1gBQQjwQlzpg9pkt9v19ttvlym3+uSnnHa2BoIQ4IWqe6XPhg0bXNgqeLKqBs4PHjzY6bnVJz/ltLN1EIQAL1TdK3iys7PruCXwVVae/JTTztZCEIJP89XLx6t7BU9kZGQdtwTwLZx2th6CEOCFqnulz3XXXefilgHejQkmrYcgBHihi6/0uTQMcaUPcOWYYNJ6CEKAl7Lb7UpJSVF0dLRTudWv9AFqggkmrYcgBHgxu92u3bt3O55b/UofoKaYYLJ2eNP4TIIQ4OUuPv1l5St9gNrAaWfrIQgBAHARTjv/xCoTShKEAAC4hNVPO1tpQkmCEFAJXz4KAlA5q552ttqEkgQhoBK+fBQEwPO4++DLihNKEoSA/1q2bFm55b56FATA87j74MuKE0oShAD9dBT0xBNPlLvMV4+CALiXJx58WXFCSYIQIGseBQFwn+LiYj3++OPlLnPnwZcVJ5QkCAGy5lEQUJu8aQI9T5CWllZmMPLF3HXwZcUJJQlCgKx5FATAfTz14MuKE0oShABZ8ygIgPt48sGX1SaUJAgBsuZREAD3SUxMVMuWLStc7u6DLytNKEkQAv7LakdBANzH399fs2bNKneZpxx8WWVCSYIQcBErHQUBcK/BgweXW87Bl2t5XRCaP3++4uLi1KBBA/Xp00ebN2+utP7777+vTp06qUGDBurcubOWL1/uopbCW9XGURBX0AC4Ehx8uZ5XBaElS5Zo0qRJmjZtmr7++mt17dpV/fv317Fjx8qtv3HjRt1zzz164IEH9M033+iOO+7QHXfcoZ07d7q45QAAVM2XT0F5Kq8KQrNnz9aoUaM0cuRIxcfH6+WXX1bDhg315ptvllt/3rx5GjBggB577DFdffXVevrpp/Wzn/1ML7zwgotbDrjHxZOxufseRgDgibwmCJ0/f15bt25VUlKSo8zPz09JSUlKT08vd5309HSn+pLUv3//CusDviQ1NVXx8fGO5+6+hxFwJTjNjLrmNUHoxIkTKi4uVosWLZzKW7Rooezs7HLXyc7Ovqz6klRYWKjc3FynB+DJgoODZYyRMUbBwcGSfgpBycnJZWau5QayAODMa4KQq8yYMUNhYWGOR2xsrLubBFyW4uJiTZgwwXG/ootxA1kAcOY1QahZs2by9/fX0aNHncqPHj2qyMjIcteJjIy8rPqSNGXKFOXk5DgemZmZNW88LMedY3O4gSx8CePcUNe8JggFBASoR48eWrVqlaOspKREq1atUkJCQrnrJCQkONWXpJUrV1ZYX5ICAwMVGhrq9KhtnPP2be4em+Op9zACLpe7v0uwBq8JQpI0adIkvfbaa3rrrbe0Z88ejR49Wvn5+Ro5cqQkafjw4ZoyZYqj/oQJE7RixQr95S9/0Xfffafp06dry5YtGjdunLveAnycJ4zN8eR7GAHV5QnfJViDVwWhIUOG6Pnnn9fUqVPVrVs3bdu2TStWrHAMiD548KDTUe7Pf/5zvfPOO3r11VfVtWtXpaSk6MMPP9S1117rrrcAH1bbY3OutOeQG8jC2zHODa5Uz90NuFzjxo2rsEdn7dq1Zcruuusu3XXXXXXcKuDyxubccMMNddaO0hvIJicny2azOf0z8ZR7GAGV8ZTvEqzBq3qEAE/mSWNzuIEsvJknfZfg+whCQC3xtLE53EAW3qo2vktclILqIggBtaSqsTnST9NA/PznP3dZm2rjBrKAqzHODa5EEAJqSenYHEkV/gE/ceKE2rVrxxUvQCUq+y65cpxbebO2w/cQhCyKScrqRkVjcy7G5b9A1RjnBlchCFkQk5TVLbvdrh07dlS4vLqX/3pDWPWGNsJ71WScmzd8NoODg5WXl+fuZlgeQchimKTMNb788stKl1d1mwtvCKve0EZ4vysZ58ZnE5eDIGQhTFLmOtnZ2dWqV97lv94QVr2hjbAmPpu4XAQhC6nuJGUbNmxwYat8U2U39r3YpZf/ekNY9YY2wndczoBlPpu4EgQhC6nu5GPV7c1Axa677rpKl1d0+a833DneG9oIa+KziStBELKQ6k5SVt3eDFTs4nEMl3P5rzfMqOsNbYQ18dnElSAIWUh1JymrqjcDVSvtzv/ggw8u6/JfT5uduiavzd3t4Wp8NnElCEIW4imTlLmSuy+hvdzLf71hRl1vaCOsic8mrgRByGKsNEmZp1xCGxoa6hjseeutt1YaNL0hrHpDG+F67j7okHzzs5mfn6+QkBB3N8OnEYQsyAo34/TmS2i9Iax6QxvhOp5y0CHx2cQVMKhUTk6OkWRycnJqbZt5eXlGkpFk8vLyalyvtttQ269bl++jPEVFRSYmJsbxmpc+bDabiY2NNUVFRXXelpoo/exJMsuXL7+i9tb1vq+NNsI1qvosXPy7vJy/eR988IGx2Wzlfs9sNpv54IMPavutVIu3fDYv/r1U9ffYVX9Dy3vty33d6qzrqr9PVX2W6RGCz/GVS2i94c7xntzG/Px82Ww22Ww25efnu7s5Hu3SHh1Juuaaa6rs0fHkeXs8+bMJz0IQgs/hElqg+mpyGtlXDjrc6dKQyGSPrkcQgs/hElqgemrao8NBR82U1xMXHx/v0WMYfRFBCD6HS2iB6qlpj44nH3Rczq053KGinrjDhw97/AUdvoYgBJ/ji5fQAnWhpj06HHRcmZr0xLlragJfRhCCT/KFS2g9/YgW3q+mPTocdFyZy+mJW7ZsmdMyd05N4KsIQvBZVpgvCaiJ2ujR8YWDDlerbk/csmXLdO+995Yp94b50LwJQQg+jUtogYrVVo8OBx2Xp7o9cYsXL/bIqQl8DUEIZXjCVPkAXKO2enQ46Ki+6vTERURE6Pjx4xVug6kJag9ByIO5Y4yIJ02VD6D2VHaAQ4+Oa1WnJ27YsGHV2hZTE9QcQQgO3nx/LgAVq84BDj06rlVRT1zLli2VkpKiwYMHV2s7zIdWcwQhSPLsqfIBXDkOcDzXpT1xkrRr1y7Z7XamJnAhghAkMVU+4Is4wPF8l/a8lT6/+PTZpXxlagJPmSKEIARJdTtVvqd82AGr4QDHu9ntdr399ttlypmaoHbVc3cD4Bk8eap8XLnSEApr4l5g3u/SsULLly9Xv379vLonyNPQIwRJTJUP+CIOcHwPA9lrH0EIkpgqH/BFHOAAVSMIwYGp8gHfwgEOUDWCEJwwsRrgWzjAASrHYGmUwcRqgG+x2+1KSkpSWFiYJAbcAhejRwgALIADHKB8BCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAADxAXl6egoOD3d0MyyEIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAy/KaIHTq1CkNGzZMoaGhCg8P1wMPPKC8vLxK13n11Vd1ww03KDQ0VDabTadPn3ZNYwEAgFfwmiA0bNgw7dq1SytXrtTHH3+s9evX68EHH6x0nYKCAg0YMEBPPvmki1oJAAC8ST13N6A69uzZoxUrVuirr75Sz549JUl/+9vfNHDgQD3//POKjo4ud72JEydKktauXeuilgIAAG/iFT1C6enpCg8Pd4QgSUpKSpKfn582bdpUq69VWFio3NxcpwcAoHLBwcEyxsgYw20i4FW8IghlZ2erefPmTmX16tVTkyZNlJ2dXauvNWPGDIWFhTkesbGxtbp9AADgOdwahCZPniybzVbp47vvvnNpm6ZMmaKcnBzHIzMz06WvDwCAtysuLnb8vH79eqfnnsatY4QeeeQR3XfffZXWadu2rSIjI3Xs2DGn8qKiIp06dUqRkZG12qbAwEAFBgbW6jYBALCK1NRUjR8/3vF84MCBiomJ0bx582S3293YsvK5NQhFREQoIiKiynoJCQk6ffq0tm7dqh49ekiSVq9erZKSEvXp06eumwkAAKohNTVVycnJMsY4lWdlZSk5OVkpKSkeF4a8YozQ1VdfrQEDBmjUqFHavHmzNmzYoHHjxmno0KGOK8aysrLUqVMnbd682bFedna2tm3bpv3790uSduzYoW3btunUqVNueR8AAPiq4uJiTZgwoUwIkuQomzhxosedJvOKICRJixcvVqdOnXTzzTdr4MCB+sUvfqFXX33VsfzChQvau3evCgoKHGUvv/yyunfvrlGjRkmS+vbtq+7du+ujjz5yefsBAPBlaWlpOnToUIXLjTHKzMxUWlqaC1tVNa+YR0iSmjRponfeeafC5XFxcWVS6PTp0zV9+vQ6bhkAADhy5Eit1nMVr+kRAgAAnisqKqpW67kKQQgAANRYYmKiYmJiZLPZyl1us9kUGxurxMREF7escgQh+DRmuwUA1/D399e8efMkqUwYKn0+d+5c+fv7u7xtlSEIAQCAMq7kQNJutyslJaXMPUBjYmI88tJ5yYsGSwMAAM9nt9uVlJSksLAwSdLy5cvVr18/j+sJKkWPEAAAqFUXh56+fft6bAiSCEIAAMDCCEIAAMCyGCME4IqVDqYEAG9FjxAAALAsghAAALAsgpAbXHzn3fXr13vcnXgBALAKgpCLpaamKj4+3vF84MCBiouLU2pqqhtbBcDqmIXdM116oMyBc+0jCLlQamqqkpOTlZWV5VSelZWl5ORkwhAAwOHSA2dJio+P539FLSMIuUhxcbEmTJhQ7hU2pWUTJ04k7QMAKjxwPnz4MAfOtYwg5CJpaWk6dOhQhcuNMcrMzFRaWpoLWwUA8DQcOLsWQchFjhw5Uqv1AAC+iQNn1yIIuUhUVFSt1gMA+CYOnF2LIOQiiYmJiomJkc1mK3e5zWZTbGysEhMTXdwyAIC7lHe1HgfOrkUQchF/f3/NmzdPksqEodLnc+fO9eg79AIA6h4Hzq5FEHIhu92ulJQURUdHO5XHxMQoJSVFdrvdTS0DAHgKDpxdiyDkYna7Xbt373Y8X758uTIyMghBAACHig6cW7ZsyYFzLePu825wcYrv27cvqR4AUIbdbldSUpLCwsIcZbt27VJoaKgbW+V76BECAMBDXXqgzIFz7SMIAQAAyyIIAQAAyyIIAQAAyyIIAQAAyyIIAQAAy+LyeQCwgNJbOcB75eXlOW7DgdpDjxAAALAsghAAALAsghAAALAsghAAALAsgpBFlQ6cNMYw+A4+qbi42PHz+vXrnZ4DQCmCEACfk5qaqvj4eMfzgQMHKi4uTqmpqW5sFQBPRBAC4FNSU1OVnJysrKwsp/KsrCwlJycThgA4IQgB8BnFxcWaMGFCufPllJZNnDiR02QAHAhCAHxGWlqaDh06VOFyY4wyMzOVlpbmwlYB8GQEIQA+48iRI7VaD4DvIwgB8BlRUVG1Wg+A7yMIAfAZiYmJiomJkc1mK3e5zWZTbGysEhMTXdwyAJ6KIATAZ/j7+2vevHmSVCYMlT6fO3eu/P39Xd42AJ6JIATAp9jtdqWkpCg6OtqpPCYmRikpKbLb7W5qGQBPVM/dDQCA2ma325WUlKSwsDBJ0vLly9WvXz96ggCUQY8QAJ90cejp27cvIQhAuQhCAADAsghCAADAsghCAADAsghCAADAsrwmCJ06dUrDhg1TaGiowsPD9cADDygvL6/S+r/97W/VsWNHBQUFqVWrVho/frxycnJc2GoAAODJvCYIDRs2TLt27dLKlSv18ccfa/369XrwwQcrrH/48GEdPnxYzz//vHbu3KmFCxdqxYoVeuCBB1zYagAA4Mlsxhjj7kZUZc+ePYqPj9dXX32lnj17SpJWrFihgQMH6tChQ2UmTqvI+++/r3vvvVf5+fmqV696Uyjl5uYqLCxMOTk5Cg0NveL3cLH8/HyFhIRIkvLy8hQcHFwr2wXwf/iewRd46+fYE9pd3f/fXtEjlJ6ervDwcEcIkqSkpCT5+flp06ZN1d5O6c6obggCAAC+zSsSQXZ2tpo3b+5UVq9ePTVp0kTZ2dnV2saJEyf09NNPV3o6TZIKCwtVWFjoeJ6bm3v5DQYAAF7BrT1CkydPls1mq/Tx3Xff1fh1cnNzNWjQIMXHx2v69OmV1p0xY4bCwsIcj9jY2Bq/PgAA8Exu7RF65JFHdN9991Vap23btoqMjNSxY8ecyouKinTq1ClFRkZWuv6ZM2c0YMAANWrUSEuXLlX9+vUrrT9lyhRNmjTJ8Tw3N5cwBACAj3JrEIqIiFBERESV9RISEnT69Glt3bpVPXr0kCStXr1aJSUl6tOnT4Xr5ebmqn///goMDNRHH32kBg0aVPlagYGBCgwMrP6bAAAAXssrBktfffXVGjBggEaNGqXNmzdrw4YNGjdunIYOHeq4YiwrK0udOnXS5s2bJf0Ugvr166f8/Hy98cYbys3NVXZ2trKzs1VcXOzOtwMAADyEVwyWlqTFixdr3Lhxuvnmm+Xn56c777xTf/3rXx3LL1y4oL1796qgoECS9PXXXzuuKGvfvr3TtjIyMhQXF+eytgMAAM/kNUGoSZMmeueddypcHhcXp4unRLrhhhvkBVMkAQAAN/KKU2MAAAB1gSAEAAAsiyAEAAAsiyAEAAAsiyAEAAAsiyAEAAAsiyAEAAAsiyAEAAAsy2smVHSX0kkZc3Nza22b+fn5jp9zc3O55QdQB/iewRd46+fYE9pd+n+7qsmVbYbplyt16NAh7j4PAICXyszMVExMTIXLCUJVKCkp0eHDh9WoUSPZbDZ3N8flcnNzFRsbq8zMTIWGhrq7OR6D/VIW+6R87JfysV/Kx34p35XsF2OMzpw5o+joaPn5VTwSiFNjVfDz86s0SVpFaGgoX8pysF/KYp+Uj/1SPvZL+dgv5bvc/RIWFlZlHQZLAwAAyyIIAQAAyyIIoVKBgYGaNm2aAgMD3d0Uj8J+KYt9Uj72S/nYL+Vjv5SvLvcLg6UBAIBl0SMEAAAsiyAEAAAsiyAEAAAsiyAEAAAsiyAETZ8+XTabzenRqVMnx/Jz585p7Nixatq0qUJCQnTnnXfq6NGjbmxx3Vi/fr1uv/12RUdHy2az6cMPP3RabozR1KlTFRUVpaCgICUlJWnfvn1OdU6dOqVhw4YpNDRU4eHheuCBB5SXl+fCd1H7qtov9913X5nPz4ABA5zq+Np+mTFjhnr16qVGjRqpefPmuuOOO7R3716nOtX53hw8eFCDBg1Sw4YN1bx5cz322GMqKipy5VupVdXZLzfccEOZz8vDDz/sVMfX9stLL72kLl26OCYDTEhI0CeffOJYbsXPilT1fnHVZ4UgBEnSNddcoyNHjjgeX3zxhWPZ7373O/3zn//U+++/r3Xr1unw4cOy2+1ubG3dyM/PV9euXTV//vxyl8+aNUt//etf9fLLL2vTpk0KDg5W//79de7cOUedYcOGadeuXVq5cqU+/vhjrV+/Xg8++KCr3kKdqGq/SNKAAQOcPj/vvvuu03Jf2y/r1q3T2LFj9eWXX2rlypW6cOGC+vXr53Sjyaq+N8XFxRo0aJDOnz+vjRs36q233tLChQs1depUd7ylWlGd/SJJo0aNcvq8zJo1y7HMF/dLTEyMnn32WW3dulVbtmzRTTfdpMGDB2vXrl2SrPlZkareL5KLPisGljdt2jTTtWvXcpedPn3a1K9f37z//vuOsj179hhJJj093UUtdD1JZunSpY7nJSUlJjIy0jz33HOOstOnT5vAwEDz7rvvGmOM2b17t5FkvvrqK0edTz75xNhsNpOVleWyttelS/eLMcaMGDHCDB48uMJ1rLBfjh07ZiSZdevWGWOq971Zvny58fPzM9nZ2Y46L730kgkNDTWFhYWufQN15NL9Yowx119/vZkwYUKF61hhvxhjTOPGjc3rr7/OZ+USpfvFGNd9VugRgiRp3759io6OVtu2bTVs2DAdPHhQkrR161ZduHBBSUlJjrqdOnVSq1atlJ6e7q7mulxGRoays7Od9kNYWJj69Onj2A/p6ekKDw9Xz549HXWSkpLk5+enTZs2ubzNrrR27Vo1b95cHTt21OjRo3Xy5EnHMivsl5ycHElSkyZNJFXve5Oenq7OnTurRYsWjjr9+/dXbm6u0xGxN7t0v5RavHixmjVrpmuvvVZTpkxRQUGBY5mv75fi4mK99957ys/PV0JCAp+V/7p0v5RyxWeFm65Cffr00cKFC9WxY0cdOXJEf/zjH5WYmKidO3cqOztbAQEBCg8Pd1qnRYsWys7Odk+D3aD0vV78hSt9XrosOztbzZs3d1per149NWnSxKf31YABA2S329WmTRsdOHBATz75pG699Valp6fL39/f5/dLSUmJJk6cqOuuu07XXnutJFXre5OdnV3u56l0mbcrb79I0q9+9Su1bt1a0dHR2r59u5544gnt3btXqampknx3v+zYsUMJCQk6d+6cQkJCtHTpUsXHx2vbtm2W/qxUtF8k131WCELQrbfe6vi5S5cu6tOnj1q3bq1//OMfCgoKcmPL4A2GDh3q+Llz587q0qWL2rVrp7Vr1+rmm292Y8tcY+zYsdq5c6fTuDpUvF8uHhvWuXNnRUVF6eabb9aBAwfUrl07VzfTZTp27Kht27YpJydHKSkpGjFihNatW+fuZrldRfslPj7eZZ8VTo2hjPDwcF111VXav3+/IiMjdf78eZ0+fdqpztGjRxUZGemeBrpB6Xu99EqOi/dDZGSkjh075rS8qKhIp06dstS+atu2rZo1a6b9+/dL8u39Mm7cOH388cdas2aNYmJiHOXV+d5ERkaW+3kqXebNKtov5enTp48kOX1efHG/BAQEqH379urRo4dmzJihrl27at68eZb/rFS0X8pTV58VghDKyMvL04EDBxQVFaUePXqofv36WrVqlWP53r17dfDgQafzuL6uTZs2ioyMdNoPubm52rRpk2M/JCQk6PTp09q6daujzurVq1VSUuL4AlvBoUOHdPLkSUVFRUnyzf1ijNG4ceO0dOlSrV69Wm3atHFaXp3vTUJCgnbs2OEUEleuXKnQ0FDHqQFvU9V+Kc+2bdskyenz4mv7pTwlJSUqLCy07GelIqX7pTx19lm5woHd8CGPPPKIWbt2rcnIyDAbNmwwSUlJplmzZubYsWPGGGMefvhh06pVK7N69WqzZcsWk5CQYBISEtzc6tp35swZ880335hvvvnGSDKzZ88233zzjfnPf/5jjDHm2WefNeHh4WbZsmVm+/btZvDgwaZNmzbm7Nmzjm0MGDDAdO/e3WzatMl88cUXpkOHDuaee+5x11uqFZXtlzNnzphHH33UpKenm4yMDPP555+bn/3sZ6ZDhw7m3Llzjm342n4ZPXq0CQsLM2vXrjVHjhxxPAoKChx1qvreFBUVmWuvvdb069fPbNu2zaxYscJERESYKVOmuOMt1Yqq9sv+/fvNU089ZbZs2WIyMjLMsmXLTNu2bU3fvn0d2/DF/TJ58mSzbt06k5GRYbZv324mT55sbDab+eyzz4wx1vysGFP5fnHlZ4UgBDNkyBATFRVlAgICTMuWLc2QIUPM/v37HcvPnj1rxowZYxo3bmwaNmxo/vd//9ccOXLEjS2uG2vWrDGSyjxGjBhhjPnpEvo//OEPpkWLFiYwMNDcfPPNZu/evU7bOHnypLnnnntMSEiICQ0NNSNHjjRnzpxxw7upPZXtl4KCAtOvXz8TERFh6tevb1q3bm1GjRrldDmrMb63X8rbH5LMggULHHWq87354YcfzK233mqCgoJMs2bNzCOPPGIuXLjg4ndTe6raLwcPHjR9+/Y1TZo0MYGBgaZ9+/bmscceMzk5OU7b8bX9cv/995vWrVubgIAAExERYW6++WZHCDLGmp8VYyrfL678rNiMMab6/UcAAAC+gzFCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCACzl+PHjioyM1J///GdH2caNGxUQEOB0B3AA1sC9xgBYzvLly3XHHXdo48aN6tixo7p166bBgwdr9uzZ7m4aABcjCAGwpLFjx+rzzz9Xz549tWPHDn311VcKDAx0d7MAuBhBCIAlnT17Vtdee60yMzO1detWde7c2d1NAuAGjBECYEkHDhzQ4cOHVVJSoh9++MHdzQHgJvQIAbCc8+fPq3fv3urWrZs6duyouXPnaseOHWrevLm7mwbAxQhCACznscceU0pKir799luFhITo+uuvV1hYmD7++GN3Nw2Ai3FqDIClrF27VnPnztWiRYsUGhoqPz8/LVq0SGlpaXrppZfc3TwALkaPEAAAsCx6hAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGX9f7iG3dDz/yE3AAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "_ = lc2d_synth_2comp.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 89
        },
        "id": "hwo3xu8la4mD",
        "outputId": "d6942e6c-7f81-480b-952a-2b07b3ddb5e6"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Input/output to CSV\n",
        "\n",
        "##### We can use the `.from_csv()` and `.to_csv()` methods.\n",
        "\n",
        "A few important details from the current code base:\n",
        "\n",
        "- `.to_csv()` always writes the columns\n",
        "  - `time`\n",
        "  - `wavelength`\n",
        "  - `flux`\n",
        "- it also writes\n",
        "  - `flux_error` if `yerr` is present\n",
        "  - `band` if the `Lightcurve` has a `band` attribute\n",
        "- for a **1D** light curve, the exported `wavelength` column is written as `0.0` for every row\n",
        "- `.from_csv()` auto-detects standard column names and reconstructs either\n",
        "  - a **1D** light curve, or\n",
        "  - a **2D** light curve if a numeric wavelength column with multiple unique values is present\n",
        "- if a string-valued band-ID column is present in the CSV, `.from_csv()` can populate the `band` attribute automatically\n",
        "\n",
        "Because of this, a useful sanity check is a **round-trip** test:\n",
        "\n",
        "```python\n",
        "lc.to_csv(...)\n",
        "lc2 = Lightcurve.from_csv(...)\n",
        "```"
      ],
      "metadata": {
        "id": "FIkZHCNsbRg-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Simple CSV round-trip for a 1D light curve\n",
        "\n",
        "outpath=\"lc1d_manual.csv\"\n",
        "_ = lc1d_manual.to_csv(outpath)\n",
        "lc_read = Lightcurve.from_csv(outpath)\n",
        "\n",
        "print(\"Written file:\", outpath)\n",
        "print(\"Original ndim:\", lc1d_manual.ndim)\n",
        "print(\"Read-back ndim:\", lc_read.ndim)\n",
        "\n",
        "print(\"\\nArray comparisons:\")\n",
        "print(\"xdata equal ->\", np.allclose(np.asarray(lc1d_manual.xdata), np.asarray(lc_read.xdata)))\n",
        "print(\"ydata equal ->\", np.allclose(np.asarray(lc1d_manual.ydata), np.asarray(lc_read.ydata)))\n",
        "\n",
        "if lc1d_manual.yerr is not None and lc_read.yerr is not None:\n",
        "    print(\"yerr equal  ->\", np.allclose(np.asarray(lc1d_manual.yerr), np.asarray(lc_read.yerr)))\n",
        "else:\n",
        "    print(\"yerr equal  ->\", lc1d_manual.yerr is None and lc_read.yerr is None)\n",
        "\n",
        "print(\"\\nBand information:\")\n",
        "print(\"original band ->\", lc1d_manual.band)\n",
        "print(\"read-back band ->\", lc_read.band)"
      ],
      "metadata": {
        "id": "aAEjzIbibiuw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "496f109a-27e1-4a75-c446-0cd39d83d9e7"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Written file: lc1d_manual.csv\n",
            "Original ndim: 1\n",
            "Read-back ndim: 1\n",
            "\n",
            "Array comparisons:\n",
            "xdata equal -> True\n",
            "ydata equal -> True\n",
            "yerr equal  -> True\n",
            "\n",
            "Band information:\n",
            "original band -> None\n",
            "read-back band -> None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# CSV round-trip for a 2D light curve with band labels\n",
        "\n",
        "outpath_2d = \"lc2d_synth_1comp.csv\"\n",
        "_ = lc2d_synth_1comp.to_csv(outpath_2d)\n",
        "lc2d_read = Lightcurve.from_csv(outpath_2d)\n",
        "\n",
        "print(\"Written file:\", outpath_2d)\n",
        "print(\"Original ndim:\", lc2d_synth_1comp.ndim)\n",
        "print(\"Read-back ndim:\", lc2d_read.ndim)\n",
        "\n",
        "print(\"\\nShape checks:\")\n",
        "print(\"xdata shape:\", np.asarray(lc2d_synth_1comp.xdata).shape, \"->\", np.asarray(lc2d_read.xdata).shape)\n",
        "print(\"ydata shape:\", np.asarray(lc2d_synth_1comp.ydata).shape, \"->\", np.asarray(lc2d_read.ydata).shape)\n",
        "\n",
        "print(\"\\nArray comparisons:\")\n",
        "print(\"xdata equal ->\", np.allclose(np.asarray(lc2d_synth_1comp.xdata), np.asarray(lc2d_read.xdata)))\n",
        "print(\"ydata equal ->\", np.allclose(np.asarray(lc2d_synth_1comp.ydata), np.asarray(lc2d_read.ydata)))\n",
        "\n",
        "if lc2d_synth_1comp.yerr is not None and lc2d_read.yerr is not None:\n",
        "    print(\"yerr equal  ->\", np.allclose(np.asarray(lc2d_synth_1comp.yerr), np.asarray(lc2d_read.yerr)))\n",
        "else:\n",
        "    print(\"yerr equal  ->\", lc2d_synth_1comp.yerr is None and lc2d_read.yerr is None)\n",
        "\n",
        "print(\"\\nBand comparisons:\")\n",
        "print(\"original unique bands ->\", np.unique(lc2d_synth_1comp.band) if lc2d_synth_1comp.band is not None else None)\n",
        "print(\"read-back unique bands ->\", np.unique(lc2d_read.band) if lc2d_read.band is not None else None)\n",
        "\n",
        "if lc2d_synth_1comp.band is not None and lc2d_read.band is not None:\n",
        "    print(\"band array equal ->\", np.array_equal(np.asarray(lc2d_synth_1comp.band), np.asarray(lc2d_read.band)))\n",
        "else:\n",
        "    print(\"band array equal ->\", lc2d_synth_1comp.band is None and lc2d_read.band is None)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sUilvFrDtuKY",
        "outputId": "65ae1440-2b6e-4af6-c491-21e441be1ba2"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Written file: lc2d_synth_1comp.csv\n",
            "Original ndim: 2\n",
            "Read-back ndim: 2\n",
            "\n",
            "Shape checks:\n",
            "xdata shape: (106, 2) -> (106, 2)\n",
            "ydata shape: (106,) -> (106,)\n",
            "\n",
            "Array comparisons:\n",
            "xdata equal -> True\n",
            "ydata equal -> True\n",
            "yerr equal  -> True\n",
            "\n",
            "Band comparisons:\n",
            "original unique bands -> None\n",
            "read-back unique bands -> None\n",
            "band array equal -> True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### The `band` attribute; selecting, dropping, merging, and concatenating light curves.\n",
        "\n",
        "These operations are easy to misuse if one assumes Python-list-like in-place behavior.\n",
        "\n",
        "In the current code base:\n",
        "\n",
        "- `select_bands()` returns a **new** `Lightcurve`\n",
        "- `drop_bands()` returns a **new** `Lightcurve`\n",
        "- `merge()` returns a **new** `Lightcurve`\n",
        "- `Lightcurve.concat()` returns a **new** `Lightcurve`\n",
        "- `Lightcurve.from_csv()` creates a **new** `Lightcurve`\n",
        "- `to_csv()` writes a file to disk and returns the output path; it does **not** modify the object\n",
        "\n",
        "So none of the light-curve manipulation methods demonstrated in this section operate in place.\n",
        "\n",
        "This matters because code such as\n",
        "\n",
        "```python\n",
        "lc.select_bands(['band 2'])\n",
        "```\n",
        "does **not** alter `lc` unless the returned object is assigned:\n",
        "```python\n",
        "lc2 = lc.select_bands(['band 2'])\n",
        "```\n",
        "\n",
        "The same logic applies to `drop_bands()`, `merge()`, and `concat()`."
      ],
      "metadata": {
        "id": "eAxBsw4nbuK_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Populating the `band` attribute\n",
        "##### `band` can be populated as follows if it doesn't already exist"
      ],
      "metadata": {
        "id": "5HQmiE__cxel"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bands = ['band 1', 'band 2', 'band 3']\n",
        "u, c = np.unique(lc2d_synth_1comp.xdata[:, 1], return_counts=True)\n",
        "ks = np.argsort(u)\n",
        "band_value = np.repeat('band 1', lc2d_synth_1comp.xdata[:, 1].shape)\n",
        "for uu in u[ks]:\n",
        "  idx = np.where(lc2d_synth_1comp.xdata[:, 1] == uu)[0]\n",
        "  band_value[idx] = bands[ks[np.where(u == uu)[0][0]]]\n",
        "\n",
        "lc2d_synth_1comp.band = band_value"
      ],
      "metadata": {
        "id": "Qbf_kmJV82Jt"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### We can now write the updated Lightcurve object to a file for posterity"
      ],
      "metadata": {
        "id": "iSCGkPuWdB1y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "_ = lc2d_synth_1comp.to_csv(\"lightcurve_band123.csv\")"
      ],
      "metadata": {
        "id": "X2crbauNHjzO"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### `select_bands`\n",
        "\n",
        "##### Once a `band` attribute is available, we can select a subset of the light curve into a new `Lightcurve` object.\n",
        "\n",
        "A few important details from the current implementation:\n",
        "\n",
        "- selection is based **only** on the `band` attribute\n",
        "- the wavelength values in `xdata[:, 1]` are **not** used for selection\n",
        "- the input must be a sequence (`list`, `tuple`, or `numpy.ndarray`) of string labels\n",
        "- a bare string such as `lc.select_bands(\"band 2\")` is **not** allowed\n",
        "- numeric selectors such as `1`, `1.0`, etc. are rejected\n",
        "- if none of the requested labels are present, a `ValueError` is raised\n",
        "- the returned object preserves the original row ordering\n",
        "- this method returns a **new** `Lightcurve`; it does **not** modify the original in place\n",
        "\n",
        "Also note that repeated labels in `band` are expected: for a 2D light curve, the same band label appears in many rows, one per observation in that band."
      ],
      "metadata": {
        "id": "esbloYcadHb0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc23 = lc2d_synth_1comp.select_bands(['band 2', 'band 3'])\n",
        "\n",
        "print(\"Original object unchanged?\")\n",
        "print(\"  lc23 is lc2d_synth_1comp ->\", lc23 is lc2d_synth_1comp)\n",
        "\n",
        "print(f\"\\nNo. of observations in lc2d_synth_1comp: {lc2d_synth_1comp.xdata[:, 1].shape}\")\n",
        "print(\"Breakdown by band:\")\n",
        "u, c = np.unique(lc2d_synth_1comp.band, return_counts=True)\n",
        "for uu, cc in zip(u, c):\n",
        "    print(uu, cc)\n",
        "\n",
        "print(f\"\\nNo. of observations in lc23: {lc23.xdata[:, 1].shape}\")\n",
        "print(\"Breakdown by band:\")\n",
        "u, c = np.unique(lc23.band, return_counts=True)\n",
        "for uu, cc in zip(u, c):\n",
        "    print(uu, cc)\n",
        "\n",
        "print(\"\\nFirst few selected band labels (row ordering preserved):\")\n",
        "print(lc23.band[:10])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NI4Rl0U4dS5W",
        "outputId": "948345ec-88a5-4077-d842-d504cb62e4b3"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original object unchanged?\n",
            "  lc23 is lc2d_synth_1comp -> False\n",
            "\n",
            "No. of observations in lc2d_synth_1comp: torch.Size([106])\n",
            "Breakdown by band:\n",
            "band 1 38\n",
            "band 2 35\n",
            "band 3 33\n",
            "\n",
            "No. of observations in lc23: torch.Size([68])\n",
            "Breakdown by band:\n",
            "band 2 35\n",
            "band 3 33\n",
            "\n",
            "First few selected band labels (row ordering preserved):\n",
            "['band 2' 'band 2' 'band 2' 'band 2' 'band 2' 'band 2' 'band 2' 'band 2'\n",
            " 'band 2' 'band 2']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Edge cases for select_bands()\n",
        "\n",
        "cases = [\n",
        "    (\"bare string\", lambda: lc2d_synth_1comp.select_bands(\"band 2\")),\n",
        "    (\"numeric selector\", lambda: lc2d_synth_1comp.select_bands([2])),\n",
        "    (\"float selector\", lambda: lc2d_synth_1comp.select_bands([2.0])),\n",
        "    (\"missing band\", lambda: lc2d_synth_1comp.select_bands([\"band 999\"])),\n",
        "]\n",
        "\n",
        "for label, func in cases:\n",
        "    try:\n",
        "        _ = func()\n",
        "        print(f\"{label}: unexpectedly succeeded\")\n",
        "    except Exception as e:\n",
        "        print(f\"{label}: {type(e).__name__}: {e}\")\n",
        "        print(\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OafEpqlykhF_",
        "outputId": "75194bce-721a-4414-a6b0-a32b355c5321"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "bare string: TypeError: 'bands' must be a sequence of band labels (list, tuple, or numpy.ndarray), not a bare string. To select a single band wrap it in a list: select_bands(['band 2'])\n",
            "\n",
            "numeric selector: TypeError: Numeric selectors are not supported by select_bands; got 'int' (2). Use a string band label instead.\n",
            "\n",
            "float selector: TypeError: Numeric selectors are not supported by select_bands; got 'float' (2.0). Use a string band label instead.\n",
            "\n",
            "missing band: ValueError: None of the requested band labels ['band 999'] were found in this Lightcurve's 'band' attribute.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### `drop_bands`\n",
        "\n",
        "##### We can also create a new `Lightcurve` object by removing one or more bands from the original.\n",
        "\n",
        "The validation rules are similar to those for `select_bands`:\n",
        "\n",
        "- removal is based **only** on the `band` attribute\n",
        "- the input must be a sequence of strings\n",
        "- a bare string is rejected\n",
        "- if a requested label is not present, this is a **no-op** for that label\n",
        "- if all rows would be removed, a `ValueError` is raised\n",
        "- the method returns a **new** `Lightcurve`; it does **not** modify the original in place\n",
        "\n",
        "So `drop_bands()` differs from `select_bands()` in one important way:\n",
        "\n",
        "- `select_bands()` raises an error if none of the requested labels exist\n",
        "- `drop_bands()` simply returns a copy of the original object if the requested labels do not occur"
      ],
      "metadata": {
        "id": "5bNhtQFLfwGk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc1 = lc2d_synth_1comp.drop_bands(['band 2', 'band 3'])\n",
        "\n",
        "print(\"Original object unchanged?\")\n",
        "print(\"  lc1 is lc2d_synth_1comp ->\", lc1 is lc2d_synth_1comp)\n",
        "\n",
        "print(f\"\\nNo. of observations in lc1: {lc1.xdata[:, 1].shape}\")\n",
        "print(\"Breakdown by band:\")\n",
        "u, c = np.unique(lc1.band, return_counts=True)\n",
        "for uu, cc in zip(u, c):\n",
        "    print(uu, cc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NNYGBr4p9ivG",
        "outputId": "9ab8d2f8-c3c2-4e07-89bb-3dbb4002dd6d"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original object unchanged?\n",
            "  lc1 is lc2d_synth_1comp -> False\n",
            "\n",
            "No. of observations in lc1: torch.Size([38])\n",
            "Breakdown by band:\n",
            "band 1 38\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Edge cases for drop_bands()\n",
        "\n",
        "# 1. Dropping a non-existent band: no-op copy\n",
        "lc_noop = lc2d_synth_1comp.drop_bands(['band 999'])\n",
        "print(\"Dropping a non-existent band leaves the content unchanged:\")\n",
        "print(\"  same number of rows ->\", len(lc_noop.ydata) == len(lc2d_synth_1comp.ydata))\n",
        "print(\"  same unique bands    ->\", np.array_equal(np.unique(lc_noop.band), np.unique(lc2d_synth_1comp.band)))\n",
        "\n",
        "# 2. Invalid selectors\n",
        "cases = [\n",
        "    (\"bare string\", lambda: lc2d_synth_1comp.drop_bands(\"band 2\")),\n",
        "    (\"numeric selector\", lambda: lc2d_synth_1comp.drop_bands([2])),\n",
        "]\n",
        "\n",
        "for label, func in cases:\n",
        "    try:\n",
        "        _ = func()\n",
        "        print(f\"{label}: unexpectedly succeeded\")\n",
        "    except Exception as e:\n",
        "        print(f\"{label}: {type(e).__name__}: {e}\")\n",
        "        print(\"\")\n",
        "\n",
        "# 3. Removing all available bands\n",
        "try:\n",
        "    all_bands = list(np.unique(lc2d_synth_1comp.band))\n",
        "    _ = lc2d_synth_1comp.drop_bands(all_bands)\n",
        "    print(\"remove all bands: unexpectedly succeeded\")\n",
        "except Exception as e:\n",
        "    print(f\"remove all bands: {type(e).__name__}: {e}\")\n",
        "    print(\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mdyI42NLkvw3",
        "outputId": "2cbe2ab6-d763-4eaf-9b95-82efa73594bc"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dropping a non-existent band leaves the content unchanged:\n",
            "  same number of rows -> True\n",
            "  same unique bands    -> True\n",
            "bare string: TypeError: 'bands' must be a sequence of labels (list, tuple, or numpy.ndarray), not a bare string. To drop a single band wrap it in a list: drop_bands(['band 2'])\n",
            "\n",
            "numeric selector: TypeError: Each element of 'bands' must be a string; got 'int'.\n",
            "\n",
            "remove all bands: ValueError: All rows were removed by drop_bands; no data remains.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### `merge`\n",
        "\n",
        "##### Data from one `Lightcurve` object can be merged into another by appending one or more **new bands**.\n",
        "\n",
        "Important behavior in the current code base:\n",
        "\n",
        "- `merge()` requires `self` to be a **2D** `Lightcurve`\n",
        "- `other` must be:\n",
        "  - another `Lightcurve`, or\n",
        "  - the path to a CSV file containing a light curve\n",
        "- `other` must represent **new constituent band(s)**:\n",
        "  - duplicate **band labels** are conflicts\n",
        "  - duplicate **wavelengths** are also conflicts\n",
        "- by default, conflicts raise a `ValueError`\n",
        "- with `on_conflict=\"skip\"`, conflicting constituent bands are skipped with a `UserWarning`\n",
        "- `merge()` returns a **new** 2D `Lightcurve`; it does **not** modify the original in place\n",
        "\n",
        "Also note:\n",
        "\n",
        "- if `other` is **1D**, you must supply `wavelength=...`\n",
        "- if a 1D `other` has no `band` attribute, you must also supply `band=...`\n",
        "- if `other` is already 2D, you must **not** supply `wavelength`"
      ],
      "metadata": {
        "id": "lOeIxEgFgZ10"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc123 = lc23.merge(lc1)\n",
        "\n",
        "print(\"merge returns a new object:\")\n",
        "print(\"  lc123 is lc23 ->\", lc123 is lc23)\n",
        "print(\"  lc123 is lc1  ->\", lc123 is lc1)\n",
        "\n",
        "print(f\"\\nNo. of observations in lc123: {lc123.xdata[:, 1].shape}\")\n",
        "print(\"Breakdown by band:\")\n",
        "u, c = np.unique(lc123.band, return_counts=True)\n",
        "for uu, cc in zip(u, c):\n",
        "    print(uu, cc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mNi6dJf3gMOk",
        "outputId": "7db9a7bb-4985-4e85-d2ae-2c05d1bf4d28"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "merge returns a new object:\n",
            "  lc123 is lc23 -> False\n",
            "  lc123 is lc1  -> False\n",
            "\n",
            "No. of observations in lc123: torch.Size([106])\n",
            "Breakdown by band:\n",
            "band 1 38\n",
            "band 2 35\n",
            "band 3 33\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### `merge()` also accepts a CSV file name as its argument and reads in the light curve before merging.\n",
        "\n",
        "This is convenient, but the same conflict rules still apply:\n",
        "\n",
        "- duplicate band labels are not allowed\n",
        "- duplicate wavelengths are not allowed\n",
        "- `on_conflict=\"raise\"` is the default"
      ],
      "metadata": {
        "id": "lSffXiVMg7hE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc23.to_csv('lightcurve_band23.csv')\n",
        "lc123 = lc1.merge(\"lightcurve_band23.csv\")\n",
        "print(f\"No. of observations in lc123: {lc123.xdata[:, 1].shape}\")\n",
        "print(\"Breakdown by band:\")\n",
        "u, c = np.unique(lc123.band, return_counts=True)\n",
        "for uu, cc in zip(u, c):\n",
        "  print(uu, cc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QPvjkA8ohDyc",
        "outputId": "7e10cfb3-d4b4-4312-f517-69c6722b39c0"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No. of observations in lc123: torch.Size([106])\n",
            "Breakdown by band:\n",
            "band 1 38\n",
            "band 2 35\n",
            "band 3 33\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### If the CSV file contains a **1D** light curve, `merge()` needs enough information to promote it to 2D.\n",
        "\n",
        "That means:\n",
        "\n",
        "- `wavelength=...` is required\n",
        "- if the 1D input has no `band` attribute, you must also pass `band=...`\n",
        "\n",
        "Without this information, the 1D input cannot be turned into a constituent band of a 2D light curve."
      ],
      "metadata": {
        "id": "HQhwWFg3jvRI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc1.to_csv(\"lightcurve_band1.csv\")\n",
        "lc123 = lc23.merge(\"lightcurve_band1.csv\", wavelength=0.8)\n",
        "print(f\"No. of observations in lc123: {lc123.xdata[:, 1].shape}\")\n",
        "print(\"Breakdown by band:\")\n",
        "u, c = np.unique(lc123.band, return_counts=True)\n",
        "for uu, cc in zip(u, c):\n",
        "  print(uu, cc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "ibvN_hm-j26L",
        "outputId": "977fcf81-c6ae-4c8e-984f-bfccbee07361"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No. of observations in lc123: torch.Size([106])\n",
            "Breakdown by band:\n",
            "b 38\n",
            "band 2 35\n",
            "band 3 33\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Failure cases for merge()\n",
        "\n",
        "# 1. Attempt to merge a duplicate band / wavelength\n",
        "try:\n",
        "    _ = lc23.merge(lc23)\n",
        "    print(\"duplicate merge: unexpectedly succeeded\")\n",
        "except Exception as e:\n",
        "    print(\"duplicate merge:\", type(e).__name__, e)\n",
        "\n",
        "# 2. The same duplicate merge, but skipping conflicts\n",
        "try:\n",
        "    lc_skip = lc23.merge(lc23, on_conflict=\"skip\")\n",
        "    print(\"\\nmerge(..., on_conflict='skip') succeeded\")\n",
        "    print(\"Unique bands in result:\", np.unique(lc_skip.band))\n",
        "except Exception as e:\n",
        "    print(\"skip-conflict merge failed:\", type(e).__name__, e)\n",
        "    print(\"\")\n",
        "\n",
        "# 3. Supplying wavelength for an already-2D input is not allowed\n",
        "try:\n",
        "    _ = lc23.merge(lc1, wavelength=0.8)\n",
        "    print(\"2D merge with wavelength: unexpectedly succeeded\")\n",
        "except Exception as e:\n",
        "    print(\"\\n2D merge with wavelength:\", type(e).__name__, e)\n",
        "    print(\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k03tZjsynd-1",
        "outputId": "34d6e036-2415-4ecc-f243-e37482a0954c"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "duplicate merge: ValueError Conflict detected: band np.str_('band 2') already exists in 'self'. Use on_conflict='skip' to skip conflicting bands.\n",
            "\n",
            "merge(..., on_conflict='skip') succeeded\n",
            "Unique bands in result: ['band 2' 'band 3']\n",
            "\n",
            "2D merge with wavelength: ValueError 'wavelength' must not be provided when 'other' is already a 2-D lightcurve.\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/tmp/ipykernel_2728/2310318970.py:12: UserWarning: Skipping band np.str_('band 2') from 'other': band np.str_('band 2') already exists in 'self'.\n",
            "  lc_skip = lc23.merge(lc23, on_conflict=\"skip\")\n",
            "/tmp/ipykernel_2728/2310318970.py:12: UserWarning: Skipping band np.str_('band 3') from 'other': band np.str_('band 3') already exists in 'self'.\n",
            "  lc_skip = lc23.merge(lc23, on_conflict=\"skip\")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### `concat`\n",
        "\n",
        "##### `Lightcurve.concat()` combines multiple light curves into a **new 2D Lightcurve**.\n",
        "\n",
        "Compared with `merge()`:\n",
        "\n",
        "- `merge()` is an **instance method** operating on one base object plus one additional input\n",
        "- `concat()` is a **class method** that combines a list of inputs\n",
        "\n",
        "Like `merge()`, `concat()` enforces uniqueness of constituent bands:\n",
        "\n",
        "- no duplicate **band labels**\n",
        "- no duplicate **wavelengths**\n",
        "\n",
        "It also supports a mixture of inputs:\n",
        "\n",
        "- `Lightcurve` objects\n",
        "- CSV file names\n",
        "\n",
        "For a **1D** input, promotion to 2D is only possible if the object already carries enough wavelength metadata internally. Otherwise `concat()` raises an error."
      ],
      "metadata": {
        "id": "ZbQptFTpj8Lb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc123 = Lightcurve.concat([lc1, lc23])\n",
        "lc123 = Lightcurve.concat([\"lightcurve_band23.csv\", lc1])"
      ],
      "metadata": {
        "id": "LH_1M9oq-X-0"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### `concat()` checks for duplicate constituent bands across all inputs.\n",
        "\n",
        "A conflict is triggered if either of the following appears in more than one input:\n",
        "\n",
        "- the same **band label**\n",
        "- the same **wavelength**\n",
        "\n",
        "By default this raises a `ValueError`."
      ],
      "metadata": {
        "id": "YVXVl2AfkyrN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc_1 = lc1\n",
        "try:\n",
        "  lc123 = Lightcurve.concat([lc1, lc23, lc_1])\n",
        "except Exception as e:\n",
        "  print(type(e).__name__, e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a6dIHsttk4k4",
        "outputId": "5a59c061-88d5-4bba-ac96-26c5715b1cd4",
        "collapsed": true
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ValueError Conflict detected: band np.str_('band 1') appears in more than one input. Use on_conflict='skip' to skip conflicting bands.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### `on_conflict=\"raise\"` is the default so that duplicate constituent bands are not ignored silently.\n",
        "\n",
        "If `on_conflict=\"skip\"` is used, conflicting bands are skipped and a `UserWarning` is emitted instead.\n",
        "\n",
        "One more important difference from `merge()`:\n",
        "\n",
        "- `concat()` cannot always promote a 1D light curve automatically\n",
        "- the 1D object must already carry a scalar wavelength internally (for example in `wavelength`, `wave`, or `lambda_`)\n",
        "- otherwise `concat()` raises a `ValueError`"
      ],
      "metadata": {
        "id": "mA59ivwwlZkN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc_1 = lc1\n",
        "lc123 = Lightcurve.concat([lc1, lc23, lc_1], on_conflict=\"skip\")"
      ],
      "metadata": {
        "id": "ge1-ab8mlmKC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a242e5c-0dbc-4d56-a62e-91b1ae0eb49e"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/tmp/ipykernel_2728/2348824447.py:2: UserWarning: Skipping band np.str_('band 1'): band np.str_('band 1') appears in more than one input.\n",
            "  lc123 = Lightcurve.concat([lc1, lc23, lc_1], on_conflict=\"skip\")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Additional concat failure mode:\n",
        "# a 1D input cannot be promoted to 2D unless it carries scalar wavelength metadata\n",
        "\n",
        "lc1d_no_wavelength = Lightcurve(\n",
        "    lc1d_manual.xdata,\n",
        "    lc1d_manual.ydata,\n",
        "    yerr=lc1d_manual.yerr,\n",
        "    band=lc1d_manual.band,\n",
        ")\n",
        "\n",
        "# Remove possible scalar wavelength metadata if present\n",
        "for attr in (\"wavelength\", \"wave\", \"lambda_\"):\n",
        "    if hasattr(lc1d_no_wavelength, attr):\n",
        "        try:\n",
        "            setattr(lc1d_no_wavelength, attr, None)\n",
        "        except Exception:\n",
        "            pass\n",
        "\n",
        "try:\n",
        "    _ = Lightcurve.concat([lc23, lc1d_no_wavelength])\n",
        "    print(\"concat with 1D input lacking wavelength metadata: unexpectedly succeeded\")\n",
        "except Exception as e:\n",
        "    print(\"concat with 1D input lacking wavelength metadata:\", type(e).__name__, e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "domMWIrOoGzB",
        "outputId": "c5099920-ae39-4aa0-a9e2-e736fd2633d5"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "concat with 1D input lacking wavelength metadata: ValueError All inputs must have band information if any one of them does. Found a mix of inputs with and without 'band'.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Copy vs in-place semantics for `select_bands`, `drop_bands`, `merge`, and `concat`"
      ],
      "metadata": {
        "id": "A32olff-mR9o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Demonstrate copy vs in-place semantics for the main manipulation methods\n",
        "\n",
        "print(\"Original unique bands in lc2d_synth_1comp:\")\n",
        "print(np.unique(lc2d_synth_1comp.band))\n",
        "\n",
        "# 1. select_bands without assignment: original object is unchanged\n",
        "_ = lc2d_synth_1comp.select_bands(['band 2'])\n",
        "print(\"\\nAfter calling select_bands(...) without assignment:\")\n",
        "print(np.unique(lc2d_synth_1comp.band))\n",
        "\n",
        "# 2. drop_bands without assignment: original object is unchanged\n",
        "_ = lc2d_synth_1comp.drop_bands(['band 2'])\n",
        "print(\"\\nAfter calling drop_bands(...) without assignment:\")\n",
        "print(np.unique(lc2d_synth_1comp.band))\n",
        "\n",
        "# 3. with assignment, a new object is produced\n",
        "lc_selected = lc2d_synth_1comp.select_bands(['band 2'])\n",
        "lc_dropped = lc2d_synth_1comp.drop_bands(['band 2'])\n",
        "\n",
        "print(\"\\nBands in lc_selected:\")\n",
        "print(np.unique(lc_selected.band))\n",
        "\n",
        "print(\"\\nBands in lc_dropped:\")\n",
        "print(np.unique(lc_dropped.band))\n",
        "\n",
        "print(\"\\nObject identity checks:\")\n",
        "print(\"lc_selected is lc2d_synth_1comp ->\", lc_selected is lc2d_synth_1comp)\n",
        "print(\"lc_dropped  is lc2d_synth_1comp ->\", lc_dropped is lc2d_synth_1comp)\n",
        "\n",
        "# 4. merge also returns a new object\n",
        "lc_merged = lc_selected.merge(lc_dropped)\n",
        "print(\"\\nlc_merged is lc_selected ->\", lc_merged is lc_selected)\n",
        "print(\"lc_merged is lc_dropped  ->\", lc_merged is lc_dropped)\n",
        "\n",
        "# 5. concat returns a new object\n",
        "lc_concat = Lightcurve.concat([lc_selected, lc_dropped])\n",
        "print(\"\\nlc_concat is lc_selected ->\", lc_concat is lc_selected)\n",
        "print(\"lc_concat is lc_dropped  ->\", lc_concat is lc_dropped)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U9oqTOYEl9WI",
        "outputId": "ef3734d4-b358-4b1b-d10d-1e364ff24bd2"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original unique bands in lc2d_synth_1comp:\n",
            "['band 1' 'band 2' 'band 3']\n",
            "\n",
            "After calling select_bands(...) without assignment:\n",
            "['band 1' 'band 2' 'band 3']\n",
            "\n",
            "After calling drop_bands(...) without assignment:\n",
            "['band 1' 'band 2' 'band 3']\n",
            "\n",
            "Bands in lc_selected:\n",
            "['band 2']\n",
            "\n",
            "Bands in lc_dropped:\n",
            "['band 1' 'band 3']\n",
            "\n",
            "Object identity checks:\n",
            "lc_selected is lc2d_synth_1comp -> False\n",
            "lc_dropped  is lc2d_synth_1comp -> False\n",
            "\n",
            "lc_merged is lc_selected -> False\n",
            "lc_merged is lc_dropped  -> False\n",
            "\n",
            "lc_concat is lc_selected -> False\n",
            "lc_concat is lc_dropped  -> False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Subsampling light curves\n",
        "\n",
        "Large light curves can become expensive to work with, especially before downstream methods such as `fit_LS()` and `fit()`.\n",
        "\n",
        "In the current code base, there are **two separate controls**:\n",
        "\n",
        "- `max_samples`\n",
        "- `max_samples_per_band`\n",
        "\n",
        "These do **not** behave the same way for 1D and 2D light curves.\n",
        "\n",
        "#### 1D light curves\n",
        "If the total number of points exceeds `max_samples`, the object is automatically subsampled and the reduced data are stored in the resulting `Lightcurve`.\n",
        "\n",
        "#### 2D light curves\n",
        "For multiband data, `max_samples_per_band` is the parameter that actually triggers subsampling. Each band is checked independently, and only bands above the threshold are reduced.\n",
        "\n",
        "By contrast, for 2D light curves, `max_samples` is mainly a **compute-budget advisory**: if the total number of rows is very large, a warning is issued to indicate that later calculations may become slow.\n",
        "\n",
        "This matters because a 2D `Lightcurve` stores one row per observation, so memory use and execution time both scale with the total number of rows."
      ],
      "metadata": {
        "id": "rrwkji1Llwp-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### We will demonstrate subsampling on a light curve with a large number of points. We will also demonstrate how subsampling works with a 2D `Lightcurve` object."
      ],
      "metadata": {
        "id": "67VoCKB2oukO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate a light curve at a new wavelength with a large number of data points\n",
        "\n",
        "n_per_band = (5000, 10000) # number of data points per light curve limited to this range\n",
        "\n",
        "# generate a set of light curves with two period components and a phase lag\n",
        "# dataset_type=\"make_multi_sinusoid_chromatic_2d\", # series of synthetic light curves with two period components and a phase lag\n",
        "MULTI_DATASET_CONFIG = dict(\n",
        "    components=[\n",
        "        {\"period\": 150.0, \"amplitude_fraction\": 1.0, \"phase\": 0.0},\n",
        "        {\"period\": 66.0, \"amplitude_fraction\": 0.3, \"phase\": np.pi / 2 * 0.85},\n",
        "    ],\n",
        "    t_span=150 * 2.3,\n",
        "    n_per_band=n_per_band,\n",
        "    wavelengths=[0.95],\n",
        "    amplitude_law=\"extinction\",\n",
        "    noise_level=0.05,\n",
        "    seed=SEED,\n",
        ")\n",
        "\n",
        "lc1_5 = synthetic.make_multi_sinusoid_chromatic_2d(**MULTI_DATASET_CONFIG)\n",
        "lc1_5.band = np.repeat('band 1.5', lc1_5.xdata[:, 0].shape)\n",
        "lc1_5.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "id": "IpxyBxCtGcCP",
        "outputId": "22cc0027-09d9-4001-cfba-63000a5c5280",
        "collapsed": true
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.12/dist-packages/pgmuvi/synthetic.py:907: UserWarning: Lightcurve has 9253 points, which exceeds max_samples=1000. Execution may be slow. Consider setting max_samples_per_band to reduce the total size of the lightcurve.\n",
            "  return Lightcurve(x, y, yerr=yerr)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<Figure size 640x480 with 1 Axes>]"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### Note the `UserWarning` that already suggests adjusting two arguments: `max_samples` and `max_samples_per_band`. These are explained below."
      ],
      "metadata": {
        "id": "3ilWOpdvpSEr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let us first merge this new light curve into the existing data:"
      ],
      "metadata": {
        "id": "HF21Jy72pjEA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc123 = Lightcurve.from_csv(\"lightcurve_band123.csv\")\n",
        "\n",
        "lc1234 = lc123.merge(lc1_5)\n",
        "print(lc1234.xdata.shape)\n",
        "print(np.unique(lc1234.band))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "67YIIb09HPdN",
        "outputId": "8b610e66-1a3b-4074-fc5c-2b3767567a01"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([9359, 2])\n",
            "['band 1' 'band 1.5' 'band 2' 'band 3']\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.12/dist-packages/pgmuvi/lightcurve.py:10574: UserWarning: Lightcurve has 9359 points, which exceeds max_samples=1000. Execution may be slow. Consider setting max_samples_per_band to reduce the total size of the lightcurve.\n",
            "  return type(self)(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### PGMUVI can generate a report summarising the sampling quality of the data. Based on various criteria (see `preprocess/quality.py`), the code suggests whether a band should be included when executing `fit_LS` or `fit`.\n",
        "\n",
        "There are **two related but distinct interfaces** here:\n",
        "\n",
        "1. `.compute_sampling_metrics()` / `.compute_sampling_metrics_per_band()`  \n",
        "   These return numerical diagnostics such as:\n",
        "   - number of points\n",
        "   - baseline\n",
        "   - median and mean cadence\n",
        "   - Nyquist period\n",
        "   - Nyquist frequency\n",
        "   - longest detectable period\n",
        "   - maximum gap fraction\n",
        "   - duty cycle\n",
        "\n",
        "2. `.assess_sampling_quality()` / `.assess_sampling_quality_per_band()`  \n",
        "   These apply threshold-based quality gates and return a recommendation about whether the light curve is suitable for later analysis.\n",
        "\n",
        "The second interface is what is used internally when a `Lightcurve` is instantiated with `check_sampling=True`.\n",
        "\n",
        "For 2D light curves, `check_sampling=True` checks each wavelength independently. Bands that fail are removed automatically, and a `ValueError` is raised only if **no** bands pass."
      ],
      "metadata": {
        "id": "GexwO0V5prZm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Numerical sampling diagnostics per band\n",
        "\n",
        "sampling_metrics = lc1234.compute_sampling_metrics_per_band()\n",
        "\n",
        "print(\"Summary:\")\n",
        "print(sampling_metrics[\"summary\"])\n",
        "\n",
        "print(\"\\nPer-band metrics:\")\n",
        "for wl, metrics in sampling_metrics.items():\n",
        "    if wl == \"summary\":\n",
        "        continue\n",
        "    print(f\"\\nWavelength = {wl}\")\n",
        "    print(f\"  n_points                  = {metrics['n_points']}\")\n",
        "    print(f\"  baseline                  = {metrics['baseline']:.3f}\")\n",
        "    print(f\"  median_cadence            = {metrics['median_cadence']:.3f}\")\n",
        "    print(f\"  mean_cadence              = {metrics['mean_cadence']:.3f}\")\n",
        "    print(f\"  nyquist_period            = {metrics['nyquist_period']:.3f}\")\n",
        "    print(f\"  nyquist_frequency         = {metrics['nyquist_frequency']:.6f}\")\n",
        "    print(f\"  longest_detectable_period = {metrics['longest_detectable_period']:.3f}\")\n",
        "    print(f\"  max_gap_fraction          = {metrics['max_gap_fraction']:.3f}\")\n",
        "    print(f\"  duty_cycle                = {metrics['duty_cycle']:.3f}\")\n",
        "\n",
        "print(\"\\nQuality-gate assessment:\")\n",
        "sampling_quality = lc1234.assess_sampling_quality_per_band(verbose=False)\n",
        "print(sampling_quality[\"summary\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bEpWauDmH8mG",
        "outputId": "4523157b-2263-47e5-e2ca-8e0faa5828c8"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Summary:\n",
            "{'n_bands': 4, 'min_points_across_bands': 33, 'max_gap_fraction_worst_band': 0.15367545487568915, 'median_nyquist_period': 12.191802978515625}\n",
            "\n",
            "Per-band metrics:\n",
            "\n",
            "Wavelength = 0.800000011920929\n",
            "  n_points                  = 38\n",
            "  baseline                  = 343.093\n",
            "  median_cadence            = 5.649\n",
            "  mean_cadence              = 9.273\n",
            "  nyquist_period            = 11.298\n",
            "  nyquist_frequency         = 0.088508\n",
            "  longest_detectable_period = 171.546\n",
            "  max_gap_fraction          = 0.125\n",
            "  duty_cycle                = 0.626\n",
            "\n",
            "Wavelength = 0.949999988079071\n",
            "  n_points                  = 9253\n",
            "  baseline                  = 344.962\n",
            "  median_cadence            = 0.026\n",
            "  mean_cadence              = 0.037\n",
            "  nyquist_period            = 0.053\n",
            "  nyquist_frequency         = 18.933858\n",
            "  longest_detectable_period = 172.481\n",
            "  max_gap_fraction          = 0.001\n",
            "  duty_cycle                = 0.708\n",
            "\n",
            "Wavelength = 1.2000000476837158\n",
            "  n_points                  = 35\n",
            "  baseline                  = 333.439\n",
            "  median_cadence            = 6.543\n",
            "  mean_cadence              = 9.807\n",
            "  nyquist_period            = 13.085\n",
            "  nyquist_frequency         = 0.076423\n",
            "  longest_detectable_period = 166.719\n",
            "  max_gap_fraction          = 0.154\n",
            "  duty_cycle                = 0.687\n",
            "\n",
            "Wavelength = 2.200000047683716\n",
            "  n_points                  = 33\n",
            "  baseline                  = 322.731\n",
            "  median_cadence            = 7.350\n",
            "  mean_cadence              = 10.085\n",
            "  nyquist_period            = 14.700\n",
            "  nyquist_frequency         = 0.068029\n",
            "  longest_detectable_period = 161.366\n",
            "  max_gap_fraction          = 0.152\n",
            "  duty_cycle                = 0.752\n",
            "\n",
            "Quality-gate assessment:\n",
            "{'n_bands': 4, 'n_passing': 2, 'passing_wavelengths': [0.800000011920929, 0.949999988079071], 'failing_wavelengths': [1.2000000476837158, 2.200000047683716]}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Demonstrate what check_sampling=True does during Lightcurve construction.\n",
        "#\n",
        "# For a 2D light curve, each band is checked independently.\n",
        "# Bands that fail the sampling criteria are removed automatically.\n",
        "\n",
        "lc_checked = Lightcurve(\n",
        "    lc1234.xdata,\n",
        "    lc1234.ydata,\n",
        "    yerr=lc1234.yerr,\n",
        "    band=lc1234.band,\n",
        "    check_sampling=True,\n",
        ")\n",
        "\n",
        "print(\"Original wavelengths:\")\n",
        "print(np.unique(lc1234.xdata[:, 1]))\n",
        "\n",
        "print(\"\\nRetained wavelengths after check_sampling=True:\")\n",
        "print(np.unique(lc_checked.xdata[:, 1]))\n",
        "\n",
        "print(\"\\nOriginal observation count:\", len(lc1234.ydata))\n",
        "print(\"Retained observation count:\", len(lc_checked.ydata))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UvvfA1PYhz88",
        "outputId": "9cfe4837-de21-4512-d78f-de6c39725d65"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original wavelengths:\n",
            "[0.8  0.95 1.2  2.2 ]\n",
            "\n",
            "Retained wavelengths after check_sampling=True:\n",
            "[0.8  0.95]\n",
            "\n",
            "Original observation count: 9359\n",
            "Retained observation count: 9291\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/tmp/ipykernel_2728/4055812079.py:6: UserWarning: Skipping band λ=1.2000000476837158 due to poor temporal sampling: Poor SNR: median=2.4 < 3.0, fraction>=3.0=29% < 50%\n",
            "  lc_checked = Lightcurve(\n",
            "/tmp/ipykernel_2728/4055812079.py:6: UserWarning: Skipping band λ=2.200000047683716 due to poor temporal sampling: Poor SNR: median=0.6 < 3.0, fraction>=3.0=0% < 50%\n",
            "  lc_checked = Lightcurve(\n",
            "/tmp/ipykernel_2728/4055812079.py:6: UserWarning: Retaining 2/4 wavelength bands after sampling-quality filtering (skipping λ = [1.2, 2.2]).\n",
            "  lc_checked = Lightcurve(\n",
            "/tmp/ipykernel_2728/4055812079.py:6: UserWarning: Lightcurve has 9291 points, which exceeds max_samples=1000. Execution may be slow. Consider setting max_samples_per_band to reduce the total size of the lightcurve.\n",
            "  lc_checked = Lightcurve(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### A single light curve can be subsampled as follows:"
      ],
      "metadata": {
        "id": "TY-raQGGqbrj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "idx = subsample_lightcurve(lc1_5.xdata[:, 0], max_samples=100)\n",
        "lc_sub = Lightcurve(xdata=lc1_5.xdata[idx, 0], ydata=lc1_5.ydata[idx],\n",
        "                    yerr=lc1_5.yerr[idx], band=[lc1_5.band[idx[0]]])\n",
        "_ = lc1_5.plot()\n",
        "_ = lc_sub.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "id": "hAUvURzyImQV",
        "outputId": "c3521908-7568-45b2-a164-55afde94b223"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### The `max_samples_per_band` argument determines which bands in a 2D `Lightcurve` object need to be subsampled.\n",
        "\n",
        "Bands with fewer than `max_samples_per_band` points are left unchanged.\n",
        "\n",
        "However, there is an important practical distinction:\n",
        "\n",
        "- `max_samples_per_band` controls **automatic row reduction**\n",
        "- `max_samples` controls the **warning threshold** for the total number of rows in a 2D light curve\n",
        "\n",
        "So for large 2D datasets:\n",
        "\n",
        "- increasing `max_samples_per_band` preserves more information but may slow later analysis\n",
        "- decreasing `max_samples_per_band` reduces the per-band row count and can make later methods more tractable\n",
        "- setting `max_samples` to a larger value suppresses warnings, but does **not** itself reduce the size of a 2D light curve\n",
        "\n",
        "In short: for 2D light curves, `max_samples_per_band` is the real performance knob."
      ],
      "metadata": {
        "id": "3_Ec_Dabqp3k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "_ = lc1234.to_csv(\"lightcurve_bands1234.csv\")\n",
        "print(f\"No. of observations in lc1234: {lc1234.xdata[:, 1].shape}\")\n",
        "print(\"Breakdown by band:\")\n",
        "u, c = np.unique(lc1234.band, return_counts=True)\n",
        "for uu, cc in zip(u, c):\n",
        "  print(uu, cc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yx5moesLRsEm",
        "outputId": "a7bb8ccc-9485-4e8d-845f-a36ba911ea6d"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No. of observations in lc1234: torch.Size([9359])\n",
            "Breakdown by band:\n",
            "band 1 38\n",
            "band 1.5 9253\n",
            "band 2 35\n",
            "band 3 33\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### We set `max_samples` such that subsampling is only applied to the band that actually needs it:"
      ],
      "metadata": {
        "id": "gGnKDg4lrzcD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lc = Lightcurve.from_csv(\"lightcurve_bands1234.csv\", max_samples=1000,\n",
        "                         max_samples_per_band=98)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Dd9qgPAsIiw",
        "outputId": "15485708-8e2b-4833-b048-c8ad529f4707"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.12/dist-packages/pgmuvi/lightcurve.py:824: UserWarning: The following bands exceed max_samples_per_band=98 and were randomly subsampled: λ=0.949999988079071. Set max_samples_per_band=None to disable subsampling.\n",
            "The subsampled 2D light curve has the following structure:\n",
            "    λ=0.800000011920929: 38 points\n",
            "    λ=0.949999988079071: 98 points\n",
            "    λ=1.2000000476837158: 35 points\n",
            "    λ=2.200000047683716: 33 points\n",
            "  return cls(xdata=x, ydata=y, yerr=yerr, **kwargs)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Simple size / memory sanity check before and after subsampling\n",
        "\n",
        "def lightcurve_size_report(lc_obj, label):\n",
        "    x_nbytes = np.asarray(lc_obj.xdata).nbytes\n",
        "    y_nbytes = np.asarray(lc_obj.ydata).nbytes\n",
        "    yerr_nbytes = 0 if lc_obj.yerr is None else np.asarray(lc_obj.yerr).nbytes\n",
        "    band_nbytes = 0 if getattr(lc_obj, \"band\", None) is None else np.asarray(lc_obj.band).nbytes\n",
        "\n",
        "    print(label)\n",
        "    print(f\"  n_rows               = {len(lc_obj.ydata)}\")\n",
        "    print(f\"  xdata shape          = {np.asarray(lc_obj.xdata).shape}\")\n",
        "    print(f\"  ydata shape          = {np.asarray(lc_obj.ydata).shape}\")\n",
        "    print(f\"  approx numeric bytes = {x_nbytes + y_nbytes + yerr_nbytes}\")\n",
        "    print(f\"  approx band bytes    = {band_nbytes}\")\n",
        "    print(f\"  approx total bytes   = {x_nbytes + y_nbytes + yerr_nbytes + band_nbytes}\")\n",
        "\n",
        "print(\"Before subsampling:\")\n",
        "lightcurve_size_report(lc1234, \"lc1234\")\n",
        "\n",
        "print(\"\\nAfter subsampling:\")\n",
        "lightcurve_size_report(lc, \"lc\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEcMQPAPyTfQ",
        "outputId": "d369688f-e9a7-47ed-df79-4a349bdd9e18"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Before subsampling:\n",
            "lc1234\n",
            "  n_rows               = 9359\n",
            "  xdata shape          = (9359, 2)\n",
            "  ydata shape          = (9359,)\n",
            "  approx numeric bytes = 149744\n",
            "  approx band bytes    = 299488\n",
            "  approx total bytes   = 449232\n",
            "\n",
            "After subsampling:\n",
            "lc\n",
            "  n_rows               = 204\n",
            "  xdata shape          = (204, 2)\n",
            "  ydata shape          = (204,)\n",
            "  approx numeric bytes = 3264\n",
            "  approx band bytes    = 6528\n",
            "  approx total bytes   = 9792\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### We can visualize the subsampled `Lightcurve` object:"
      ],
      "metadata": {
        "id": "M2wNgn3ath9s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "_ = lc.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        },
        "id": "Zuh69Ihrtmy6",
        "outputId": "5e007673-08ef-4a48-e949-ffdefc99ae15"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Statistical tests for variability\n",
        "\n",
        "##### PGMUVI can run simple statistical tests to determine whether the light curve at a given wavelength shows statistically significant variability. This is useful for deciding whether a band is worth sending to later analysis steps.\n",
        "\n",
        "The variability logic uses three reported quantities:\n",
        "\n",
        "1. **Weighted chi-squared test**\n",
        "   - tests whether the light curve is consistent with a constant value within the reported uncertainties\n",
        "   - reported via `chi2`, `dof`, and `p_value`\n",
        "\n",
        "2. **Fractional variability**, `F_var`\n",
        "   - measures whether the intrinsic variability amplitude is astrophysically meaningful after accounting for measurement errors\n",
        "   - compared against the threshold `fvar_min`\n",
        "\n",
        "3. **Stetson K**\n",
        "   - reported as a **diagnostic shape/coherence metric**\n",
        "   - compared against `stetson_k_min`\n",
        "   - **important:** in the current code base, this does **not** veto a light curve that already passes the required chi-squared and `F_var` tests\n",
        "\n",
        "For a 2D `Lightcurve`, the method `.check_variability_per_band()` evaluates each wavelength independently and returns:\n",
        "\n",
        "- one diagnostics dictionary per wavelength\n",
        "- a summary giving the number of variable bands and their wavelengths\n",
        "\n",
        "Bands can then be filtered automatically with `.filter_variable_bands()`.\n",
        "\n",
        "Below, we first inspect the full per-band diagnostics, and then demonstrate how to retain only the bands that pass the required variability gates."
      ],
      "metadata": {
        "id": "4oIuH7s9tyZ8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "variability_results = lc1234.check_variability_per_band()\n",
        "\n",
        "print(\"Summary:\")\n",
        "print(variability_results[\"summary\"])\n",
        "\n",
        "print(\"\\nPer-band diagnostics:\")\n",
        "for wl, diag in variability_results.items():\n",
        "    if wl == \"summary\":\n",
        "        continue\n",
        "\n",
        "    print(f\"\\nWavelength = {wl}\")\n",
        "    print(f\"  n_points   = {diag['n_points']}\")\n",
        "    print(f\"  chi2       = {diag['chi2']:.3f}\")\n",
        "    print(f\"  dof        = {diag['dof']}\")\n",
        "    print(f\"  p_value    = {diag['p_value']:.6g}\")\n",
        "    print(f\"  F_var      = {diag['fvar']:.6f}\")\n",
        "    print(f\"  Stetson K  = {diag['stetson_k']:.6f}\")\n",
        "    print(f\"  decision   = {diag['decision']}\")\n",
        "    print(f\"  tests      = {diag['tests_passed']}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "er4tEvdeIi1X",
        "outputId": "a9adc37b-9017-4420-a921-e6f800e0380b"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Summary:\n",
            "{'n_bands': 4, 'n_variable': 3, 'variable_wavelengths': [0.800000011920929, 0.949999988079071, 1.2000000476837158]}\n",
            "\n",
            "Per-band diagnostics:\n",
            "\n",
            "Wavelength = 0.800000011920929\n",
            "  n_points   = 38\n",
            "  chi2       = 5971.864\n",
            "  dof        = 37\n",
            "  p_value    = 0\n",
            "  F_var      = 6.291266\n",
            "  Stetson K  = 0.890367\n",
            "  decision   = VARIABLE; DIAGNOSTIC: stetson_k=0.890<ref=0.950\n",
            "  tests      = {'chi2_test': True, 'fvar_test': True, 'stetson_test': False, 'min_points': True}\n",
            "\n",
            "Wavelength = 0.949999988079071\n",
            "  n_points   = 9253\n",
            "  chi2       = 3085250.623\n",
            "  dof        = 9252\n",
            "  p_value    = 0\n",
            "  F_var      = 7.141045\n",
            "  Stetson K  = 0.853211\n",
            "  decision   = VARIABLE; DIAGNOSTIC: stetson_k=0.853<ref=0.950\n",
            "  tests      = {'chi2_test': True, 'fvar_test': True, 'stetson_test': False, 'min_points': True}\n",
            "\n",
            "Wavelength = 1.2000000476837158\n",
            "  n_points   = 35\n",
            "  chi2       = 450.622\n",
            "  dof        = 34\n",
            "  p_value    = 3.19429e-74\n",
            "  F_var      = 5.267337\n",
            "  Stetson K  = 0.892560\n",
            "  decision   = VARIABLE; DIAGNOSTIC: stetson_k=0.893<ref=0.950\n",
            "  tests      = {'chi2_test': True, 'fvar_test': True, 'stetson_test': False, 'min_points': True}\n",
            "\n",
            "Wavelength = 2.200000047683716\n",
            "  n_points   = 33\n",
            "  chi2       = 26.952\n",
            "  dof        = 32\n",
            "  p_value    = 0.720074\n",
            "  F_var      = 0.820750\n",
            "  Stetson K  = 0.810382\n",
            "  decision   = NOT VARIABLE: p_value=0.7201 >= alpha=0.01; DIAGNOSTIC: stetson_k=0.810<ref=0.950\n",
            "  tests      = {'chi2_test': False, 'fvar_test': True, 'stetson_test': False, 'min_points': True}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Keep only bands that pass the required variability gates.\n",
        "# In the current implementation, Stetson K is diagnostic only:\n",
        "# a band is kept if it passes the chi2 and F_var requirements.\n",
        "\n",
        "lc_variable = lc1234.filter_variable_bands()\n",
        "\n",
        "print(\"Original wavelengths:\")\n",
        "print(np.unique(lc1234.xdata[:, 1]))\n",
        "\n",
        "print(\"\\nWavelengths retained after variability filtering:\")\n",
        "print(np.unique(lc_variable.xdata[:, 1]))\n",
        "\n",
        "print(\"\\nOriginal number of observations:\", len(lc1234.ydata))\n",
        "print(\"Retained number of observations:\", len(lc_variable.ydata))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8CKhjnqcj5VW",
        "outputId": "b5e1f02d-07c5-4991-989d-bd231362689b"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original wavelengths:\n",
            "[0.8  0.95 1.2  2.2 ]\n",
            "\n",
            "Wavelengths retained after variability filtering:\n",
            "[0.8  0.95 1.2 ]\n",
            "\n",
            "Original number of observations: 9359\n",
            "Retained number of observations: 9326\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.12/dist-packages/pgmuvi/lightcurve.py:5111: UserWarning: Lightcurve has 9326 points, which exceeds max_samples=1000. Execution may be slow. Consider setting max_samples_per_band to reduce the total size of the lightcurve.\n",
            "  return Lightcurve(new_x, new_y, yerr=new_yerr)\n"
          ]
        }
      ]
    }
  ]
}