doc/interactive_tutorial/10-Radiative_transfer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "# preamble script to check and install AMUSE components if necessary\n",
    "\n",
    "# required packages for this tutorial:\n",
    "PACKAGES=\"mpi4py amuse-framework amuse-sse amuse-seba amuse-sphray\"\n",
    "# skip in case a full development install is present\n",
    "pip show amuse-devel && exit 0\n",
    "for package in ${PACKAGES} \n",
    "do\n",
    "  pip show ${package} || pip install ${package}\n",
    "done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# the following fixes are highly recommended\n",
    "\n",
    "#allow oversubscription for openMPI\n",
    "import os\n",
    "os.environ[\"OMPI_MCA_rmaps_base_oversubscribe\"]=\"true\"\n",
    "\n",
    "# use lower cpu resources for idle codes\n",
    "from amuse.support import options\n",
    "options.GlobalOptions.instance().override_value_for_option(\"polling_interval_in_milliseconds\", 10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Radiative Transfer in AMUSE: example with Stellar Evolution\n",
    "\n",
    "In this exercise you will learn to design a simple numerical experiment using a radiative transfer code, coupled to stellar evolution (in highly idealized fashion)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## imports\n",
    "\n",
    "first we import a radiative tranfer code and a stellar evolution code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from amuse.community.sphray.interface import Sphray\n",
    "from amuse.community.seba.interface import Seba"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "next, a simple initial condition for the gas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from amuse.ext.molecular_cloud import new_ism_cube"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "then the AMUSE units and constants module, and the Particle object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from amuse.units import units, constants\n",
    "from amuse.datamodel import Particle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "take a moment to consider the following:\n",
    "\n",
    "1. what are the pros and cons of importing all the components seperately versus the:\n",
    "\n",
    "        from amuse.lab import *\n",
    "\n",
    "   statement used in the tutorial?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting started\n",
    "\n",
    "The above imports make available a number of classes, which you are probably unfamiliar with - there are a number of ways to get information about these\n",
    "(without reading the manual!):\n",
    "   \n",
    "    print(help(new_ism_cube))\n",
    "for the community codes, it is always a good idea to readup on the respective code papers:\n",
    "\n",
    "    code = Sphray()\n",
    "    code.print_literature_references()\n",
    "or print out its parameters:\n",
    "\n",
    "    print(code.parameters)\n",
    "or:\n",
    "\n",
    "    help(code.parameters)\n",
    "\n",
    "1. play around with these way to get information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## coupling rad transfer and stellar evolution\n",
    "\n",
    "consider the code below (which is slightly modified from the code you have seen before in the tutorial 6):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tend = 5. | units.Myr\n",
    "\n",
    "gas = new_ism_cube(\n",
    "    5000,\n",
    "    1 | units.kpc,\n",
    "    0.01 | (units.amu / units.cm**3),\n",
    ")\n",
    "gas.h_smooth = 0.1 | units.kpc\n",
    "gas.xion = 0.00\n",
    "sources = Particle(\n",
    "    1,\n",
    "    position=[0,0,0] | units.parsec,\n",
    "    luminosity=1 | 1.e50 / units.s,\n",
    "    SpcType=0,\n",
    ").as_set()\n",
    "\n",
    "rad = Sphray()\n",
    "rad.parameters.box_size = 2.0 | units.kpc\n",
    "rad.parameters.number_of_rays= 10000 | units.Myr**-1\n",
    "\n",
    "rad.gas_particles.add_particles(gas)\n",
    "rad.src_particles.add_particles(sources)\n",
    "rad.evolve_model(tend)\n",
    "scatter(\n",
    "    rad.gas_particles.position.lengths().value_in(units.kpc),\n",
    "    rad.gas_particles.xion,\n",
    ")\n",
    "rad.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## including stellar evolution\n",
    "\n",
    "we are going to include sources based on a stellar evolution for a 30 MSun star.\n",
    "\n",
    "1. copy and change the above code to set the ionizing luminosity to a value calculated from the initial model of the stellar evolution code using the function you wrote in the previous exercise. For this, you need to generate the source with a mass instead of a luminosity. Note that a particle in a stellar evolution code also has an attribute luminosity, but this is the total bolometric luminosity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## time dependence\n",
    "\n",
    "next, we want to add time dependence. This will be done by simply alternating stellar evolution and radiative transfer, updating the luminoisty of the source as the star evolves. For this we need a way to update the luminosity in SPHRay, this can be done using a channel:\n",
    "    \n",
    "    channel_to_rad=sources.new_channel_to(rad.src_particles)\n",
    "    channel_to_rad.copy_attributes([\"x\",\"y\",\"z\",\"luminosity\",\"SpcType\"])\n",
    "\n",
    "similarly, we can copy the attributes needed for the calculation of the luminosity from the stellar evolution code se:\n",
    "\n",
    "    channel_from_se=se.particles.new_channel_to(sources)\n",
    "    channel_from_se.copy_attributes([\"radius\",\"temperature\"])\n",
    "\n",
    "1. change the code to evolve the model taking substeps dt, and make a plot every dtplot\n",
    "2. change the code to co-evolve the stellar evolution\n",
    "3. change the code to update the ionizing luminosity (using the above channel) every dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if you have time you can consider the following:\n",
    "    \n",
    "1. change the code so that instead of a single star, it contains radiation from a population of stars.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from amuse.ic.salpeter import new_salpeter_mass_distribution"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}