{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3D Stellar wind\n",
    "\n",
    "---\n",
    "In this example, we consider an smoothed-particle hydrodynamics (SPH) model of a companion-perturbed stellar wind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy             as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "from astropy import units, constants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "---\n",
    "\n",
    "## Model setup\n",
    "First we download a snapshot of this SPH model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_file = '3D_stellar_wind_data/wind.setup'\n",
    "input_file = '3D_stellar_wind_data/wind.in'\n",
    "dump_file  = '3D_stellar_wind_data/wind.dump'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2024-08-12 15:29:41--  https://raw.githubusercontent.com/Ensor-code/phantom-models/main/Malfait%2B2024a/v10e00/wind.setup\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.110.133, 185.199.111.133, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 1209 (1.2K) [text/plain]\n",
      "Saving to: ‘3D_stellar_wind_data/wind.setup’\n",
      "\n",
      "3D_stellar_wind_dat 100%[===================>]   1.18K  --.-KB/s    in 0s      \n",
      "\n",
      "2024-08-12 15:29:41 (32.8 MB/s) - ‘3D_stellar_wind_data/wind.setup’ saved [1209/1209]\n",
      "\n",
      "--2024-08-12 15:29:42--  https://raw.githubusercontent.com/Ensor-code/phantom-models/main/Malfait%2B2024a/v10e00/wind.in\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.110.133, 185.199.111.133, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 5579 (5.4K) [text/plain]\n",
      "Saving to: ‘3D_stellar_wind_data/wind.in’\n",
      "\n",
      "3D_stellar_wind_dat 100%[===================>]   5.45K  --.-KB/s    in 0s      \n",
      "\n",
      "2024-08-12 15:29:42 (30.4 MB/s) - ‘3D_stellar_wind_data/wind.in’ saved [5579/5579]\n",
      "\n",
      "--2024-08-12 15:29:43--  https://raw.githubusercontent.com/Ensor-code/phantom-models/main/Malfait%2B2024a/v10e00/wind_v10e00\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.110.133, 185.199.111.133, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 70236960 (67M) [application/octet-stream]\n",
      "Saving to: ‘3D_stellar_wind_data/wind.dump’\n",
      "\n",
      "3D_stellar_wind_dat 100%[===================>]  66.98M  51.0MB/s    in 1.3s    \n",
      "\n",
      "2024-08-12 15:29:44 (51.0 MB/s) - ‘3D_stellar_wind_data/wind.dump’ saved [70236960/70236960]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!wget 'https://raw.githubusercontent.com/Ensor-code/phantom-models/main/Malfait%2B2024a/v10e00/wind.setup'  --output-document $setup_file\n",
    "!wget 'https://raw.githubusercontent.com/Ensor-code/phantom-models/main/Malfait%2B2024a/v10e00/wind.in'     --output-document $input_file\n",
    "!wget 'https://raw.githubusercontent.com/Ensor-code/phantom-models/main/Malfait%2B2024a/v10e00/wind_v10e00' --output-document $dump_file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use [plons](https://github.com/Ensor-code/plons) to open the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plons\n",
    "\n",
    "setupData = plons.LoadSetup(f'{os.getcwd()}/3D_stellar_wind_data', 'wind')\n",
    "dumpData  = plons.LoadFullDump(f'{os.getcwd()}/{dump_file}', setupData)\n",
    "\n",
    "position = dumpData[\"position\"]*1e-2   # position vectors [cm   -> m]\n",
    "velocity = dumpData[\"velocity\"]*1e3    # velocity vectors [km/s -> m/s]\n",
    "rho      = dumpData[\"rho\"]             # density          [g/cm^3]\n",
    "tmp      = dumpData[\"Tgas\"]            # temperature      [K]\n",
    "tmp[tmp<2.7] = 2.7                     # Cut-off temperatures below 2.7 K\n",
    "\n",
    "# Unpack velocities\n",
    "v_x, v_y, v_z = velocity.T\n",
    "\n",
    "# Convert rho (total density) to H2 abundance\n",
    "nH2 = rho * 1.0e+6 * constants.N_A.si.value / 2.02\n",
    "\n",
    "# Define turbulence at 150 m/s\n",
    "v_trb = 150.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we map the particle data to a regular Cartesian mesh."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pomme.haar import Haar\n",
    "\n",
    "# Map point data to a regular grid\n",
    "haar = Haar(position, q=8)\n",
    "# Zoom in on the centre region to avoid edge effects\n",
    "imin = 2**(haar.q-3)\n",
    "imax = 3*imin\n",
    "# Map data to a regular grid\n",
    "nH2_dat = haar.map_data(nH2, interpolate=True)[-1][imin:imax,imin:imax,imin:imax]\n",
    "tmp_dat = haar.map_data(tmp, interpolate=True)[-1][imin:imax,imin:imax,imin:imax]\n",
    "v_x_dat = haar.map_data(v_x, interpolate=True)[-1][imin:imax,imin:imax,imin:imax]\n",
    "v_y_dat = haar.map_data(v_y, interpolate=True)[-1][imin:imax,imin:imax,imin:imax]\n",
    "v_z_dat = haar.map_data(v_z, interpolate=True)[-1][imin:imax,imin:imax,imin:imax]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### TensorModel\n",
    "With all the data in place, we can start building a pomme model.\n",
    "First, we store all model parameters as a TensorModel object and store this in an HDF5 file.\n",
    "We will use this later as the ground truth to verify our reconstructions against."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pomme.model import TensorModel\n",
    "\n",
    "model = TensorModel(shape=nH2_dat.shape, sizes=haar.xyz_L)\n",
    "model['log_H2'          ] = np.log(nH2_dat).astype(np.float64)\n",
    "model['log_temperature' ] = np.log(tmp_dat).astype(np.float64)\n",
    "model['velocity_x'      ] =        v_x_dat .astype(np.float64)\n",
    "model['velocity_y'      ] =        v_y_dat .astype(np.float64)\n",
    "model['velocity_z'      ] =        v_z_dat .astype(np.float64)\n",
    "model['log_v_turbulence'] = np.log(v_trb)*np.ones(model.shape, dtype=np.float64)\n",
    "model.save('3D_stellar_wind_truth.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### GeneralModel\n",
    "First, we define the functions that can generate the model distributions from the model parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from pomme.utils import planck, T_CMB\n",
    "\n",
    "def get_velocity(model):\n",
    "    \"\"\"\n",
    "    Get the velocity from the TensorModel.\n",
    "    \"\"\"\n",
    "    return model['velocity_z']\n",
    "\n",
    "def get_temperature(model):\n",
    "    \"\"\"\n",
    "    Get the temperature from the TensorModel.\n",
    "    \"\"\"\n",
    "    return torch.exp(model['log_temperature'])\n",
    "\n",
    "def get_abundance(model, l):\n",
    "    \"\"\"\n",
    "    Get the abundance from the TensorModel.\n",
    "    \"\"\"\n",
    "    # Define the assumed molecular fractions w.r.t. H2\n",
    "    X_mol = [3.0e-4, 5.0e-6]\n",
    "    # Return the abundance\n",
    "    return torch.exp(model['log_H2']) * X_mol[l]\n",
    "\n",
    "def get_turbulence(model):\n",
    "    \"\"\"\n",
    "    Get the turbulence from the TensorModel.\n",
    "    \"\"\"\n",
    "    return torch.exp(model['log_v_turbulence'])\n",
    "\n",
    "def get_boundary_condition(model, frequency):\n",
    "    \"\"\"\n",
    "    Get the boundary condition from the TensorModel.\n",
    "    model: TensorModel\n",
    "        The TensorModel object containing the model.\n",
    "    frequency: float\n",
    "        Frequency at which to evaluate the boundary condition.\n",
    "    \"\"\"\n",
    "    # Compute the incoming boundary intensity\n",
    "    Ibdy  = torch.ones((model.shape[0], model.shape[1], len(frequency)), dtype=torch.float64)\n",
    "    Ibdy *= planck(temperature=T_CMB, frequency=frequency)\n",
    "    # Return the result\n",
    "    return Ibdy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using these functions, we can build a GeneralModel object that can be used to generate synthetic observations or reconstruct the required parameters. (Cfr. the SphericalModel class for spherically symmetric models.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pomme.model import GeneralModel\n",
    "\n",
    "gmodel_truth = GeneralModel(model=model)\n",
    "gmodel_truth.get_velocity           = get_velocity\n",
    "gmodel_truth.get_abundance          = get_abundance\n",
    "gmodel_truth.get_turbulence         = get_turbulence\n",
    "gmodel_truth.get_temperature        = get_temperature\n",
    "gmodel_truth.get_boundary_condition = get_boundary_condition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Spectral lines\n",
    "We base our reconstructions on synthetic observations of two commonly observed rotational lines CO $J=4-3$ and SiO $J=3-2$. We explicitly provide the molar mass for SiO, since this is not extracted correctly from the line data file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have selected line:\n",
      "    CO(J=4-3)\n",
      "Please check the properties that were inferred:\n",
      "    Frequency         4.610407682e+11  Hz\n",
      "    Einstein A coeff  6.126000000e-06  1/s\n",
      "    Molar mass        28.0101          g/mol\n",
      "You have selected line:\n",
      "    sio-h2(J=03-02)\n",
      "Please check the properties that were inferred:\n",
      "    Frequency         1.302686830e+11  Hz\n",
      "    Einstein A coeff  1.058000000e-04  1/s\n",
      "    Molar mass        44.0849          g/mol\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/frederikd/.local/lib/python3.9/site-packages/astroquery/lamda/core.py:145: UserWarning: The first time a LAMDA function is called, it must assemble a list of valid molecules and URLs.  This list will be cached so future operations will be faster.\n",
      "  warnings.warn(\"The first time a LAMDA function is called, it must \"\n"
     ]
    }
   ],
   "source": [
    "from pomme.lines import Line\n",
    "from pomme.utils import get_molar_mass\n",
    "\n",
    "lines = [\n",
    "    Line(species_name='CO',     transition=3),\n",
    "    Line(species_name='sio-h2', transition=2, molar_mass=get_molar_mass('SiO'))\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Frequencies\n",
    "Next, we define the velocity/frequency range.\n",
    "We observe the lines in 100 frequency bins, centred around the lines, with a spacing of 120 m/s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "vdiff = 120   # velocity increment size [m/s]\n",
    "nfreq = 100   # number of frequencies\n",
    "\n",
    "velocities  = nfreq * vdiff * torch.linspace(-1, +1, nfreq, dtype=torch.float64)\n",
    "frequencies = [(1.0 + velocities / constants.c.si.value) * line.frequency for line in lines]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Synthetic observations\n",
    "We can now generate synthetic observations, directly from the Model object.\n",
    "We will use these later to derive our reconstructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "obss = gmodel_truth.image(lines, frequencies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the resulting synthetic spectral line observations.\n",
    "pomme provides some convenient wrappers for matploltib to explore the spectral data cubes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "867ebd14e02c47cd88b18dae4f536c04",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=49, description='z', max=99), Output()), _dom_classes=('widget-interact'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5587d360c0c14274a290e7b4f1fa0da9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=49, description='z', max=99), Output()), _dom_classes=('widget-interact'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e5a15b4675524c0aacc2fc571a041ac6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=31, description='i', max=63), IntSlider(value=31, description='j', max=6…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b2db747cfdb74f51882b431f562bee89",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=31, description='i', max=63), IntSlider(value=31, description='j', max=6…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function pomme.plot.plot_spectrum.<locals>.plot(i, j)>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pomme.plot import plot_cube_2D, plot_spectrum\n",
    "\n",
    "plot_cube_2D(np.log(obss[0]))\n",
    "plot_cube_2D(np.log(obss[1]))\n",
    "\n",
    "plot_spectrum(np.log(obss[0]))\n",
    "plot_spectrum(np.log(obss[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Reconstruction setup\n",
    "In this example, we will try to reconstruct the CO abundance, radial velocity, and temperature distribution.\n",
    "Since we will only assume a radial component in our velocity field, we need to adapt the corresponding function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_velocity_from_1D(model):\n",
    "    \"\"\"\n",
    "    Get the velocity from the 1D data.\n",
    "    \"\"\" \n",
    "    # Extract the radial unit vector field from the model\n",
    "    d = torch.from_numpy(model.get_radial_direction(origin='centre'))\n",
    "    # Return the (strictly radial) velocity field\n",
    "    return torch.exp(model['log_velocity_r']) * d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we define the model object for the reconstruction. Note that in the gmodel defined above, all the right parameters are already stored, so we need a new one for the reconstruction.\n",
    "We take, $n_{\\text{CO}}^{\\text{init}}(r) = 5.0 \\times 10^{14} \\, \\text{m}^{-3} \\, (r_{\\text{in}}/r)^{2} $, as initial guess for the CO abundance distribution, and initialise both the velocity and the temperature with the correct values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "gmodel_recon = GeneralModel(gmodel_truth.model)\n",
    "gmodel_recon.get_velocity           = get_velocity_from_1D\n",
    "gmodel_recon.get_abundance          = get_abundance\n",
    "gmodel_recon.get_turbulence         = get_turbulence\n",
    "gmodel_recon.get_temperature        = get_temperature\n",
    "gmodel_recon.get_boundary_condition = get_boundary_condition\n",
    "\n",
    "# Initial guess parameters\n",
    "n_H2_in = 5.0e+13\n",
    "v_in    = 1.0e+2\n",
    "v_inf   = 1.0e+4\n",
    "beta    = 1.0\n",
    "T_in    = 5.0e+3\n",
    "epsilon = 0.5\n",
    "\n",
    "rs = gmodel_recon.model.get_radius(origin='centre')\n",
    "\n",
    "model['log_H2'          ] = np.log(n_H2_in * (rs.min()/rs)**2)\n",
    "model['log_velocity_r'  ] = np.log(v_in + (v_inf - v_in) * (1.0 - rs.min()/rs)**beta)\n",
    "model['log_temperature' ] = np.log(T_in * (rs.min()/rs)**epsilon)\n",
    "\n",
    "# Fix all parameters, except for the ones we want to fit\n",
    "model.fix_all()\n",
    "model.free(['log_H2', 'log_velocity_r', 'log_temperature'])\n",
    "\n",
    "# Save the initial guess\n",
    "model.save('3D_stellar_wind_recon_init.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can explore the model parameters with the info() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable key:              Free/Fixed:   Field:    Min:           Mean:          Max:\n",
      "  log_H2                     Free          True     +2.326e+01     +2.451e+01     +3.154e+01\n",
      "  log_temperature            Free          True     +6.446e+00     +6.759e+00     +8.517e+00\n",
      "  velocity_x                 Fixed         True     -1.958e+04     +4.669e+00     +1.754e+04\n",
      "  velocity_y                 Fixed         True     -1.741e+04     -2.048e+02     +2.137e+04\n",
      "  velocity_z                 Fixed         True     -9.749e+03     -7.321e+01     +9.680e+03\n",
      "  log_v_turbulence           Fixed         True     +5.011e+00     +5.011e+00     +5.011e+00\n",
      "  log_velocity_r             Free          True     +4.605e+00     +9.178e+00     +9.195e+00\n",
      "sizes: [7.46717267e+13 7.46169581e+13 7.36127621e+13]\n",
      "shape: (64, 64, 64)\n"
     ]
    }
   ],
   "source": [
    "gmodel_recon.model.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Loss functions\n",
    "We first create Loss object that can conveniently store the different losses.\n",
    "We will use a reproduction loss (split into an averaged and relative component), a smoothness, and a continuity loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pomme.loss import Loss, diff_loss\n",
    "\n",
    "losses = Loss(['avg', 'rel', 'smt', 'cnt'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "#### Reproduction loss\n",
    "We split the reproduction loss into an averaged and a relative component,\n",
    "\\begin{equation*}\n",
    "\\mathcal{L}_{\\text{rep}}\\big(f(\\boldsymbol{m}), \\boldsymbol{o} \\big)\n",
    "\\ = \\\n",
    "\\mathcal{L}_{\\text{rep}}\\Big( \\big\\langle f(\\boldsymbol{m}) \\big\\rangle, \\, \\left\\langle\\boldsymbol{o}\\right\\rangle \\Big)\n",
    "\\ + \\\n",
    "\\mathcal{L}_{\\text{rep}}\\left( \\frac{f(\\boldsymbol{m})}{\\big\\langle f(\\boldsymbol{m})\\big\\rangle}, \\, \\frac{\\boldsymbol{o}}{\\left\\langle \\boldsymbol{o}\\right\\rangle} \\right) ,\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define averaging and relative function\n",
    "avg = lambda arr: arr.mean(axis=-1)\n",
    "rel = lambda arr: torch.einsum(\"...f, ... -> ...f\", arr, 1.0/avg(arr))\n",
    "\n",
    "def avg_loss(smodel, imgs):\n",
    "    \"\"\"\n",
    "    Compute the average loss.\n",
    "    \"\"\"\n",
    "    return torch.nn.functional.mse_loss(avg(imgs), avg(obss))\n",
    "\n",
    "def rel_loss(smodel, imgs):\n",
    "    \"\"\"\n",
    "    Compute the relative loss.\n",
    "    \"\"\"\n",
    "    return torch.nn.functional.mse_loss(rel(imgs), rel(obss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "#### Smoothness loss\n",
    "The smoothnes loss is defined as,\n",
    "\\begin{equation}\n",
    "\\mathcal{L}[q] \\ = \\ \\int \\text{d} \\boldsymbol{x} \\ \\| \\nabla q(\\boldsymbol{x})\\|^{2}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def smoothness_loss(gmodel):\n",
    "    \"\"\"\n",
    "    Smoothness loss for CO, velocity, and temperature distributions.\n",
    "    \"\"\"\n",
    "    # Compute and return the loss\n",
    "    return (   diff_loss(gmodel.model['log_H2'         ]) \\\n",
    "             + diff_loss(gmodel.model['log_velocity_r' ]) \\\n",
    "             + diff_loss(gmodel.model['log_temperature']) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "#### Continuity loss\n",
    "The regularisation loss that assumes a steady state and enforces the continuity equation, in 3D reads,\n",
    "\\begin{equation*}\n",
    "\\mathcal{L}[\\rho, \\boldsymbol{v}]\n",
    "\\ = \\\n",
    "\\int \\text{d}\\boldsymbol{x} \\ \\frac{1}{\\rho^{2}} \\big( \\nabla \\cdot \\left( \\rho \\, \\boldsymbol{v} \\right) \\big)^{2}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def steady_state_cont_loss(gmodel):\n",
    "    \"\"\"\n",
    "    Loss assuming steady state hydrodynamics, i.e. vanishing time derivatives.\n",
    "    \"\"\"\n",
    "    # Extract the relevant variables form the model\n",
    "    rho           = gmodel.get_abundance(gmodel.model, 0)   # line number does not matter here\n",
    "    v_x, v_y, v_z = gmodel.get_velocity (gmodel.model)\n",
    "    # Continuity equation (steady state): div(ρ v) = 0\n",
    "    loss_cont = gmodel.model.diff_x(rho * v_x) + gmodel.model.diff_y(rho * v_y) + gmodel.model.diff_z(rho * v_z)\n",
    "    # Squared average over the model\n",
    "    loss_cont = torch.mean((loss_cont / rho)**2)\n",
    "    # Return losses\n",
    "    return loss_cont"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Fit function\n",
    "With everything in place, we can finally define the fit function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.optim import Adam\n",
    "from tqdm        import tqdm\n",
    "\n",
    "def fit(losses, gmodel, N_epochs=10, lr=1.0e-1, w_avg=1.0, w_rel=1.0, w_smt=1.0, w_cnt=1.0):\n",
    "    # Define optimiser\n",
    "    optimizer = Adam(model.free_parameters(), lr=lr)\n",
    "    # Iterate optimiser\n",
    "    for _ in tqdm(range(N_epochs)):\n",
    "        # Forward model\n",
    "        imgs = gmodel.image(lines, frequencies)\n",
    "        # Compute the losses\n",
    "        losses['avg'] = w_avg * avg_loss(gmodel, imgs)\n",
    "        losses['rel'] = w_rel * rel_loss(gmodel, imgs)\n",
    "        losses['smt'] = w_smt * smoothness_loss(gmodel)\n",
    "        losses['cnt'] = w_cnt * steady_state_cont_loss(gmodel)\n",
    "        # Set gradients to zero\n",
    "        optimizer.zero_grad()\n",
    "        # Backpropagate gradients\n",
    "        losses.tot().backward()\n",
    "        # Update parameters\n",
    "        optimizer.step()\n",
    "    # Return the images and losses\n",
    "    return imgs, losses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can fit the model to the synthetic data.\n",
    "First, to determine the relative weights for each loss function in the total loss, we run 3 iterations and observe the loss values. Then, we define the weight of each individual loss function by the inverse of its current value (renormalisation step), such that in the following iterations they all contribute equally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3/3 [00:42<00:00, 14.11s/it]\n"
     ]
    }
   ],
   "source": [
    "imgs, losses = fit(losses, gmodel_recon,\n",
    "    N_epochs = 3,\n",
    "    lr       = 1.0e-1,\n",
    "    w_avg    = 1.0e+0,\n",
    "    w_rel    = 1.0e+0,\n",
    "    w_smt    = 1.0e+0,\n",
    "    w_cnt    = 1.0e+0,\n",
    ")\n",
    "losses.renormalise_all()   # Renormalise the losses\n",
    "losses.reset()             # Reset the losses to renormalised values\n",
    "\n",
    "# Save the (partially) reconstructed model\n",
    "gmodel_recon.model.save('3D_stellar_wind_recon_000.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the renormalised weights in place, we now run 100 iterations of the reconstruction algorithm.\n",
    "Note that one can still specify relative weights for the losses, these are an additional factor to the renormalisation. Here, we take them all equal to one, such that all losses contribute equally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [22:09<00:00, 13.30s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 780x520 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "imgs, losses = fit(losses, gmodel_recon,\n",
    "    N_epochs = 100,\n",
    "    lr       = 1.0e-1,\n",
    "    w_avg    = 1.0e+0,\n",
    "    w_rel    = 1.0e+0,\n",
    "    w_smt    = 1.0e+0,\n",
    "    w_cnt    = 1.0e+0,\n",
    ")\n",
    "gmodel_recon.model.save('3D_stellar_wind_recon_100.h5')\n",
    "losses.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we run an additional 500 itereations of the reconstruction algortihm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [18:03<00:00, 10.84s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 780x520 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imgs, losses = fit(losses, gmodel_recon,\n",
    "    N_epochs = 500,\n",
    "    lr       = 1.0e-1,\n",
    "    w_avg    = 1.0e+0,\n",
    "    w_rel    = 1.0e+0,\n",
    "    w_smt    = 1.0e+0,\n",
    "    w_cnt    = 1.0e+0,\n",
    ")\n",
    "gmodel_recon.model.save('3D_stellar_wind_recon_600.h5')\n",
    "losses.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "gmodel_recon.model = TensorModel.load('3D_stellar_wind_recon_600.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e0c11853366c471db84f77cc9a66c577",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=31, description='z', max=63), Output()), _dom_classes=('widget-interact'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function pomme.plot.plot_cube_2D.<locals>.plot(z)>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_cube_2D(gmodel_recon.model['log_H2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f27f2f04174f455d94c2d7efe9316f37",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=31, description='z', max=63), Output()), _dom_classes=('widget-interact'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function pomme.plot.plot_cube_2D.<locals>.plot(z)>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_cube_2D(gmodel_recon.model['log_temperature'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "80d0b4e832de45ebaaa7a29b856af8fe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=31, description='z', max=63), Output()), _dom_classes=('widget-interact'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function pomme.plot.plot_cube_2D.<locals>.plot(z)>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_cube_2D(gmodel_recon.model['log_velocity_r'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that, although we started form an spherically symmetric initial guess, we can recover the spiral structure in the abundance, temperature, and velocity distributions.\n",
    "See [our paper](https://ui.adsabs.harvard.edu/abs/2024arXiv240218525D/abstract) for a complete analysis of this model and the reconstruciton."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "magritte",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}