{
    "cells": [
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "ac239cd1-f884-4e1c-9388-4792e14523f7",
            "metadata": {},
            "source": [
                "# Mode Selection"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "aeabdaec-2798-484a-9082-bbd16b39891d",
            "metadata": {},
            "source": [
                "The mode selection module is paramount to the computational efficiency of this model. Below we show how we perform this selection operation by moving from a set of amplitudes to only those that contribute. "
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "bb073cd3-50c2-48d2-9480-94ee5812c2a3",
            "metadata": {},
            "source": [
                "### Mode selection by power contribution"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "6c29b9a9-3afd-4811-bb1d-5b89b7c0eb60",
            "metadata": {},
            "source": [
                "Modes can also be weighted by a Power Spectral Density (PSD) function from your favorite sensitivity curve. "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "id": "4e745231",
            "metadata": {},
            "outputs": [],
            "source": [
                "import numpy as np\n",
                "import matplotlib.pyplot as plt\n",
                "\n",
                "import few\n",
                "\n",
                "from few.trajectory.inspiral import EMRIInspiral\n",
                "from few.trajectory.ode import SchwarzEccFlux\n",
                "from few.amplitude.romannet import RomanAmplitude\n",
                "from few.utils.ylm import GetYlms\n",
                "from few.utils.modeselector import ModeSelector\n",
                "\n",
                "# tune few configuration\n",
                "cfg_set = few.get_config_setter(reset=True)\n",
                "\n",
                "# Uncomment if you want to force CPU or GPU usage\n",
                "# Leave commented to let FEW automatically select the best available hardware\n",
                "#   - To force CPU usage:\n",
                "# cfg_set.enable_backends(\"cpu\")\n",
                "#   - To force GPU usage with CUDA 12.x\n",
                "# cfg_set.enable_backends(\"cuda12x\", \"cpu\")\n",
                "#   - To force GPU usage with CUDA 11.x\n",
                "# cfg_set.enable_backends(\"cuda11x\", \"cpu\")\n",
                "\n",
                "cfg_set.set_log_level(\"info\");"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "id": "6d77f2f0-c925-4a75-b9e2-ba8b1c71c16f",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "We reduced the mode content from 3843 modes to 43 modes.\n"
                    ]
                }
            ],
            "source": [
                "# first, lets get amplitudes for a trajectory\n",
                "traj = EMRIInspiral(func=SchwarzEccFlux)\n",
                "\n",
                "# parameters\n",
                "M = 1e5\n",
                "mu = 1e1\n",
                "p0 = 10.0\n",
                "e0 = 0.7\n",
                "theta = np.pi / 3.0\n",
                "phi = np.pi / 2.0\n",
                "\n",
                "t, p, e, x, Phi_phi, Phi_theta, Phi_r = traj(M, mu, 0.0, p0, e0, 1.0)\n",
                "\n",
                "# get amplitudes along trajectory\n",
                "amp = RomanAmplitude()\n",
                "\n",
                "# Schwarzschild\n",
                "a = 0.0\n",
                "\n",
                "teuk_modes = amp(a, p, e, x)\n",
                "\n",
                "# get ylms\n",
                "ylm_gen = GetYlms(assume_positive_m=False)\n",
                "ylms = ylm_gen(amp.unique_l, amp.unique_m, theta, phi).copy()[amp.inverse_lm]\n",
                "\n",
                "# select modes\n",
                "\n",
                "mode_selector = ModeSelector(\n",
                "    amp.l_arr_no_mask, amp.m_arr_no_mask, amp.n_arr_no_mask, force_backend=\"cpu\"\n",
                ")\n",
                "\n",
                "eps = 1e-1  # tolerance on mode contribution to total power\n",
                "\n",
                "modeinds = [amp.l_arr, amp.m_arr, amp.n_arr]\n",
                "(teuk_modes_in, ylms_in, ls, ms, ns) = mode_selector(\n",
                "    teuk_modes, ylms, modeinds, eps=eps\n",
                ")\n",
                "\n",
                "print(\n",
                "    \"We reduced the mode content from {} modes to {} modes.\".format(\n",
                "        teuk_modes.shape[1], teuk_modes_in.shape[1]\n",
                "    )\n",
                ")"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "d4c9c705-6ff0-4344-98f5-2df726f5399d",
            "metadata": {},
            "source": [
                "### Mode selection by noise-weighted power contribution"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "id": "27d8205f-7854-47c6-90a3-3e7e1a4ffe2c",
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "New t array outside bounds of input t array. These points are filled with edge values.\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "We reduced the mode content from 3843 modes to 30 modes when using noise-weighting.\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 640x480 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "from few.summation.interpolatedmodesum import CubicSplineInterpolant\n",
                "\n",
                "# produce sensitivity function\n",
                "noise = np.genfromtxt(\"files/LPA.txt\", names=True)\n",
                "f, PSD = (\n",
                "    np.asarray(noise[\"f\"], dtype=np.float64),\n",
                "    np.asarray(noise[\"ASD\"], dtype=np.float64) ** 2,\n",
                ")\n",
                "\n",
                "sens_fn = CubicSplineInterpolant(f, PSD)\n",
                "\n",
                "# select modes with noise weighting\n",
                "\n",
                "# provide sensitivity function kwarg\n",
                "mode_selector_noise_weighted = ModeSelector(\n",
                "    amp.l_arr_no_mask, amp.m_arr_no_mask, amp.n_arr_no_mask, sensitivity_fn=sens_fn\n",
                ")\n",
                "\n",
                "eps = 1e-1  # tolerance on mode contribution to total power\n",
                "\n",
                "fund_freq_args = (M, a, p, e, x, t)\n",
                "\n",
                "modeinds = [amp.l_arr, amp.m_arr, amp.n_arr]\n",
                "(teuk_modes_in, ylms_in, ls, ms, ns) = mode_selector_noise_weighted(\n",
                "    teuk_modes, ylms, modeinds, fund_freq_args=fund_freq_args, eps=eps\n",
                ")\n",
                "\n",
                "print(\n",
                "    \"We reduced the mode content from {} modes to {} modes when using noise-weighting.\".format(\n",
                "        teuk_modes.shape[1], teuk_modes_in.shape[1]\n",
                "    )\n",
                ")\n",
                "# plot histogram of modes\n",
                "plt.figure()\n",
                "plt.hist(ns, bins=100, label=\"n\")\n",
                "plt.xlabel(\"n\")\n",
                "plt.ylabel(\"Number of radial modes\")\n",
                "plt.show()\n",
                "\n",
                "plt.figure()\n",
                "plt.hist(ms, bins=100, label=\"n\")\n",
                "plt.xlabel(\"n\")\n",
                "plt.ylabel(\"Number of azimuthal modes\")\n",
                "plt.show()"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "29b8ae88-5120-4389-8985-0bfa0e985bdd",
            "metadata": {},
            "source": [
                "### Compare the two waves with and without noise-weighting"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "id": "78787276-fc0b-4bbf-be78-2c8b2570bc4c",
            "metadata": {},
            "outputs": [],
            "source": [
                "from few.waveform import FastSchwarzschildEccentricFlux\n",
                "from few.utils.utility import get_mismatch\n",
                "\n",
                "\n",
                "noise_weighted_mode_selector_kwargs = dict(sensitivity_fn=sens_fn)\n",
                "\n",
                "inspiral_kwargs = {\n",
                "    \"DENSE_STEPPING\": 0,  # we want a sparsely sampled trajectory\n",
                "    \"buffer_length\": int(1e3),  # all of the trajectories will be well under len = 1000\n",
                "}\n",
                "\n",
                "# keyword arguments for inspiral generator (RomanAmplitude)\n",
                "amplitude_kwargs = {\n",
                "    \"buffer_length\": int(1e3),  # all of the trajectories will be well under len = 1000\n",
                "}\n",
                "\n",
                "# keyword arguments for Ylm generator (GetYlms)\n",
                "Ylm_kwargs = {\n",
                "    \"assume_positive_m\": False  # if we assume positive m, it will generate negative m for all m>0\n",
                "}\n",
                "\n",
                "# keyword arguments for summation generator (InterpolatedModeSum)\n",
                "sum_kwargs = {\n",
                "    \"pad_output\": False,\n",
                "}\n",
                "\n",
                "few_base = FastSchwarzschildEccentricFlux(\n",
                "    inspiral_kwargs=inspiral_kwargs,\n",
                "    amplitude_kwargs=amplitude_kwargs,\n",
                "    Ylm_kwargs=Ylm_kwargs,\n",
                "    sum_kwargs=sum_kwargs,\n",
                ")\n",
                "\n",
                "few_noise_weighted = FastSchwarzschildEccentricFlux(\n",
                "    inspiral_kwargs=inspiral_kwargs,\n",
                "    amplitude_kwargs=amplitude_kwargs,\n",
                "    Ylm_kwargs=Ylm_kwargs,\n",
                "    sum_kwargs=sum_kwargs,\n",
                "    mode_selector_kwargs=noise_weighted_mode_selector_kwargs,\n",
                ")\n",
                "\n",
                "M = 1e6\n",
                "mu = 1e1\n",
                "p0 = 12.0\n",
                "e0 = 0.3\n",
                "theta = np.pi / 3.0\n",
                "phi = np.pi / 4.0\n",
                "dist = 1.0\n",
                "dt = 10.0\n",
                "T = 0.001\n",
                "\n",
                "wave_base = few_base(M, mu, p0, e0, theta, phi, dist=dist, dt=dt, T=T, eps=1e-2)\n",
                "wave_weighted = few_noise_weighted(\n",
                "    M, mu, p0, e0, theta, phi, dist=dist, dt=dt, T=T, eps=1e-2\n",
                ")\n",
                "\n",
                "plt.plot(wave_base.real, label=\"base\")\n",
                "plt.plot(wave_weighted.real, label=\"noise-weighted\")\n",
                "plt.legend()\n",
                "print(\"mismatch:\", get_mismatch(wave_base, wave_weighted))\n",
                "print(\"base modes:\", few_base.num_modes_kept)\n",
                "print(\"noise-weighted modes:\", few_noise_weighted.num_modes_kept)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "afb70d37-ea69-480e-873b-dce6168690dc",
            "metadata": {},
            "source": [
                "### Specific mode selection"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "51cc143c-4e89-4a69-a559-69495862bd1b",
            "metadata": {},
            "source": [
                "The user can also select a specific set of modes to use in the waveform."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "id": "80bef8b1-2012-41da-ae42-8d0348b43d65",
            "metadata": {},
            "outputs": [],
            "source": [
                "# l = 2, m = 2 wave\n",
                "specific_modes = [(2, 2, n) for n in range(-30, 31)]\n",
                "\n",
                "wave_22 = few_base(\n",
                "    M, mu, p0, e0, theta, phi, dist=dist, dt=dt, T=T, mode_selection=specific_modes\n",
                ")\n",
                "\n",
                "plt.plot(wave_22.real)\n",
                "\n",
                "print(\"mismatch with full wave:\", get_mismatch(wave_22, wave_base))"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "31e4d556-6fc1-44f8-bebd-7dd7e66f8f12",
            "metadata": {},
            "source": [
                "### Turn off ($-m$)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "id": "50c6d486-b640-445f-a267-db5a74aba714",
            "metadata": {},
            "source": [
                "By default, symmetry is used to generate $-m$ modes. To turn this off and only use modes with ($m$), provide `False` to the `include_minus_m` kwarg. This only affects the waveform when `mode_selection` is a list of specific modes. "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "id": "02df5c52-76d9-471f-af8a-2ce49931d32e",
            "metadata": {
                "scrolled": true
            },
            "outputs": [],
            "source": [
                "%matplotlib inline\n",
                "# l = 2, m = 2 wave without m = -2\n",
                "specific_modes = [(2, 2, n) for n in range(-30, 31)]\n",
                "\n",
                "specific_modes_minus_m = [(2, -2, n) for n in range(-30, 31)]\n",
                "\n",
                "wave_22_pos_m = few_base(\n",
                "    M,\n",
                "    mu,\n",
                "    p0,\n",
                "    e0,\n",
                "    theta,\n",
                "    phi,\n",
                "    dist=dist,\n",
                "    dt=dt,\n",
                "    T=0.001,\n",
                "    mode_selection=specific_modes,\n",
                "    include_minus_m=False,\n",
                ")\n",
                "\n",
                "wave_22_minus_m = few_base(\n",
                "    M,\n",
                "    mu,\n",
                "    p0,\n",
                "    e0,\n",
                "    theta,\n",
                "    phi,\n",
                "    dist=dist,\n",
                "    dt=dt,\n",
                "    T=0.001,\n",
                "    mode_selection=specific_modes_minus_m,\n",
                "    include_minus_m=False,\n",
                ")\n",
                "\n",
                "plt.plot(wave_22_pos_m.real, label=\"+m\")\n",
                "plt.plot(wave_22_minus_m.real, label=\"-m\", ls=\"--\")\n",
                "plt.legend()\n",
                "print(\n",
                "    \"mismatch with 22 wave with + and - m:\",\n",
                "    get_mismatch(wave_22_minus_m, wave_22_pos_m),\n",
                ")\n",
                "\n",
                "print(\n",
                "    \"mismatch with 22 original wave with adding + and - m\",\n",
                "    get_mismatch(wave_22, wave_22_pos_m + wave_22_minus_m),\n",
                ")"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "fuck",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.13.2"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 5
}