{ "cells": [ { "cell_type": "markdown", "id": "fd77aec4", "metadata": {}, "source": [ "# Model\n", "\n", "As shown previously, when `Simulation.from_config()` is called, a `SimulationState` object is created. This is done via the class method `SimulationState.from_config()`. This model object contains important information about the shell structure, density, abundance, radiative temperature, and dilution factor throughout the supernova.\n", "\n", "Throughout this notebook, we show various configuration inputs into the TARDIS model and the resulting model. In interactive mode, these parameters can be varied to explore how the model changes. Editing configuration parameters in the notebook is explained [here](../../io/configuration/tutorial_read_configuration.ipynb).\n", "\n", "This notebook is based on the [built-in TARDIS models](../../io/configuration/components/models/index.rst#built-in-structure-density-and-abundance), but these parameters can also be input via [custom model configurations](../../io/configuration/components/models/index.rst#custom-model-configurations), the [CSVY model](../../io/configuration/components/models/index.rst#csvy-model) or the [custom abundance widget](../../io/visualization/how_to_abundance_widget.ipynb).\n", "\n", "## Shell Structure\n", "\n", "TARDIS models supernovae as expanding homologously. This means that at the beginning of the explosion, the\n", "supernova starts at a single point and proceeds to expand radially outward such that the ratio of the velocity of\n", "the ejecta to the distance from the ejecta to the supernova's center is uniform throughout the supernova. As an\n", "example, if the outer edge of the ejecta moves outward at some velocity $v_\\mathrm{boundary\\_outer}$, the\n", "velocity of the ejecta half way between the outer edge and the center would be\n", "$\\frac{v_\\mathrm{boundary\\_outer}}{2}$. The animation below demonstrates this type of expansion.\n", "\n", "TARDIS simulates radiative transfer between an inner boundary (the photosphere) and an outer\n", "boundary (the outer edge of the supernova ejecta). The velocity of the inner boundary\n", "$v_\\mathrm{boundary\\_inner}$ and the velocity of the outer boundary $v_\\mathrm{boundary\\_outer}$ are\n", "supplied in the configuration file, as well as the time after the explosion for\n", "which TARDIS is calculating the spectrum ($t_\\mathrm{explosion}$). The radii of the inner and outer boundaries\n", "are therefore calculated by $r_\\mathrm{boundary\\_inner}=v_\\mathrm{boundary\\_inner}*t_\\mathrm{explosion}$ and\n", "$r_\\mathrm{boundary\\_outer}=v_\\mathrm{boundary\\_outer}*t_\\mathrm{explosion}$. Plasma at a distance $r$\n", "from the center of the supernova would then be traveling outward at a speed $v=\\frac{r}{r_\\mathrm{boundary\\_outer}}v_\\mathrm{boundary\\_outer} = \\frac{r}{t_\\mathrm{explosion}}$. This is\n", "also shown in the animation.\n", "\n", "Additionally, TARDIS divides the space between the inner and outer computational boundaries into cells -- radial\n", "shells for which the state/condition of the ejecta is (spatially) constant. In the animation, 6 cells are shown,\n", "being divided by the light blue lines. As TARDIS is a time-independent code which calculates the spectra at an\n", "instant in time, the radii of the boundaries (either of the computational domain or of the cells) do not change\n", "throughout the simulation.\n", "\n", "\n", "\n", "\n", "We now demonstrate how the shell structure works using the TARDIS code." ] }, { "cell_type": "code", "execution_count": null, "id": "f48c4843", "metadata": {}, "outputs": [], "source": [ "# We import the necessary packages\n", "from tardis.io.configuration.config_reader import Configuration\n", "from tardis.model import SimulationState\n", "from tardis.io.atom_data import download_atom_data\n", "from tardis.io.atom_data.base import AtomData\n", "from astropy import units as u\n", "import matplotlib.pyplot as plt\n", "import copy\n", "\n", "# We download the atomic data needed to run the simulation\n", "download_atom_data('kurucz_cd23_chianti_H_He')\n", "atom_data = AtomData.from_hdf('kurucz_cd23_chianti_H_He.h5')" ] }, { "cell_type": "code", "execution_count": null, "id": "8b3a14a9", "metadata": {}, "outputs": [], "source": [ "# Set up a base configuration to use throughout the notebook\n", "base_config = Configuration.from_yaml(\"tardis_example.yml\")" ] }, { "cell_type": "markdown", "id": "cee054e9", "metadata": {}, "source": [ "In the cell below, we set up a model. We use the [specific structure](../../io/configuration/components/models/index.rst#specific-structure) where we supply $t_\\mathrm{explosion}$, the velocity of the inner and outer boundaries of the supernova (labeled `start` and `stop`), and the number of shells (labeled `num`). The shells are then evenly spaced between the inner and outer boundaries of the supernova. The time after the explosion, the inner and outer velocities, and the number of shells can be varied to get different shell structures. The `SimulationState` object stores information about the model in the following attributes: `velocity` shows the velocity of the shell boundaries, `v_inner` shows the velocities of the inner boundaries of each shell, `v_outer` shows the velocity of the outer boundaries of each shell, and `v_middle` shows the velocity of the middle of each shell. Similarly, `radius`, `r_inner`, `r_outer`, and `r_middle` show the radii of each shell boundary, the inner boundaries, the outer boundaries, and the middles of each shell, respectively. `v_inner_boundary` shows the velocity of the inner boundary of the computational domain, and `v_outer_boundary` shows the velocity of the outer boundary of the computational domain. Finally, `volume` shows the volume of each shell, calculated via the formula of the volume of a spherical shell: $V=\\frac{4}{3}\\pi (r_\\mathrm{outer}^3-r_\\mathrm{inner}^3)$." ] }, { "cell_type": "code", "execution_count": null, "id": "17752fd2", "metadata": { "scrolled": false }, "outputs": [], "source": [ "shell_config = copy.deepcopy(base_config)\n", "\n", "shell_config.supernova.time_explosion = 10 * u.day\n", "\n", "# This line is necessary to indicate we are using a built-in shell structure.\n", "# Do not change it.\n", "shell_config.model.structure.type = 'specific'\n", "\n", "shell_config.model.structure.velocity.start = 1000 * u.km/u.s\n", "shell_config.model.structure.velocity.stop = 2000 * u.km/u.s\n", "shell_config.model.structure.velocity.num = 20\n", "\n", "shell_simulation_state = SimulationState.from_config(shell_config, atom_data=atom_data)\n", "\n", "print('velocity:\\n', shell_simulation_state.velocity)\n", "print('v_inner:\\n', shell_simulation_state.v_inner)\n", "print('v_outer:\\n', shell_simulation_state.v_outer)\n", "print('v_middle:\\n', shell_simulation_state.v_middle)\n", "print('v_inner_boundary:\\n', shell_simulation_state.v_inner_boundary)\n", "print('v_outer_boundary:\\n', shell_simulation_state.v_outer_boundary)\n", "print('radius:\\n', shell_simulation_state.radius)\n", "print('r_inner:\\n', shell_simulation_state.r_inner)\n", "print('r_outer:\\n', shell_simulation_state.r_outer)\n", "print('r_middle:\\n', shell_simulation_state.r_middle)\n", "print('volume:\\n', shell_simulation_state.volume)" ] }, { "cell_type": "markdown", "id": "1ee56110", "metadata": {}, "source": [ "Notice that `radius = velocity*time_explosion`, and similarly for `r_inner`, `r_outer`, and `r_middle`. You can get the radius of the photosphere via `v_inner_boundary*time_explosion` and outer edge of the supernova via `v_boundary_outer*time_explosion`.\n", "\n", "
\n", " \n", "Note\n", "\n", "Using the built-in shell structure, as shown here, the shells are all equally spaced. This is not necessarily the case if one uses the [file structure](../../io/configuration/components/models/index.rst#file-structure), [CSVY model](../../io/configuration/components/models/index.rst#csvy-model), or [custom abundance widget](../../io/visualization/how_to_abundance_widget.ipynb).\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "59159ccd", "metadata": {}, "source": [ "## Density\n", "\n", "We now look at how TARDIS models the density inside each shell. If you use the [built-in densities](../../io/configuration/components/models/index.rst#density), TARDIS allows you to choose between the four models discussed below. The [file structure](../../io/configuration/components/models/index.rst#file-structure), [CSVY model](../../io/configuration/components/models/index.rst#csvy-model), and [custom abundance widget](../../io/visualization/how_to_abundance_widget.ipynb) options allow more freedom in assigning densities to each shell.\n", "\n", "In general, the density in the supernova at a specific moment in time is a function of the radius or velocity of the ejecta (either can be used, since the radius and velocity are linearly related at any moment of time). Since the shell velocities do not change over time, it is more simple to write the densities as a function of ejecta velocity. If we do this, the time-dependence of the density is simple. We know the total mass of the ejecta is constant in each shell due to the nature of homologous expansion. The inner and outer radii of each shell increase linearly over time, meaning the volume increases as time cubed. Since density is mass divided by volume, the density is inverse-cubic in time. Mathematically, if $\\rho(v,t_\\mathrm{explosion})$ is the density at a velocity $v$ after a time $t_\\mathrm{explosion}$, given some characteristic time $t_0$, we have\n", "\n", "$$\\rho(v,t_\\mathrm{explosion})=\\rho(v,t_0)*\\left(\\frac{t_0}{t_\\mathrm{explosion}}\\right)^3$$\n", "\n", "where $\\rho(v,t_0)$ is the density at $t_\\mathrm{explosion}=t_0$. Notice that this gives the desired time dependence -- for example, at $t_\\mathrm{explosion}=2t_0$, $\\rho(v,t_\\mathrm{explosion})=\\rho(v,t_0)/8$, exactly an inverse-cube relationship.\n", "\n", "Since the state of the ejecta, including the density, is the same throughout the shell, we determine the shell's density by plugging the velocity/radius at the center of the shell into the density function. We now explore the various built-in density profiles. For each profile, we build an example model using the density profile and example parameters (which can be varied in interactive mode), print the densities in each shell, and show a graph of density versus radius (specifically the radius at the center of each shell).\n", "\n", "Note that the density in each shell is stored in the `density` attribute of the `SimulationState` object.\n", "\n", "### Branch85 W7 Density\n", "\n", "The first built-in density profile is the well-known W7 density model. There are no density-specific parameters that should be edited (see [here](../../io/configuration/components/models/index.rst#branch85-w7-density) for the default values) as this is a well-established model. The shell structure can be varied as usual to see the effects of the shell structure on the W7 density." ] }, { "cell_type": "code", "execution_count": null, "id": "b478ff70", "metadata": { "scrolled": false }, "outputs": [], "source": [ "w7_density_config = copy.deepcopy(base_config)\n", "\n", "w7_density_config.supernova.time_explosion = 10 * u.day\n", "\n", "# This line is necessary to indicate we are using a built-in shell structure\n", "# and density. Do not change it.\n", "w7_density_config.model.structure.type = 'specific'\n", "\n", "w7_density_config.model.structure.velocity.start = 1000 * u.km/u.s\n", "w7_density_config.model.structure.velocity.stop = 2000 * u.km/u.s\n", "w7_density_config.model.structure.velocity.num = 20\n", "\n", "w7_density_config.model.structure.density.type = 'branch85_w7'\n", "\n", "w7_density_model = SimulationState.from_config(w7_density_config, atom_data=atom_data)\n", "\n", "print('density:\\n', w7_density_model.density)\n", "\n", "plt.plot(w7_density_model.r_middle, w7_density_model.density)\n", "plt.xlabel(f'Radius ({w7_density_model.r_middle.unit})')\n", "plt.ylabel(f'Density ({w7_density_model.density.unit})');" ] }, { "cell_type": "markdown", "id": "246f16cf", "metadata": {}, "source": [ "In the cell below, we show the time dependence of the W7 density profile by comparing the density plots for models at two different times." ] }, { "cell_type": "code", "execution_count": null, "id": "fd23d9a0", "metadata": {}, "outputs": [], "source": [ "w7_modified_config = copy.deepcopy(w7_density_config)\n", "\n", "w7_modified_config.supernova.time_explosion = 12 * u.day\n", "\n", "w7_modified_model = SimulationState.from_config(w7_modified_config, atom_data=atom_data)\n", "\n", "print('density:\\n', w7_modified_model.density)\n", "\n", "plt.plot(w7_density_model.r_middle,\n", " w7_density_model.density,\n", " label=f't_explosion = {w7_density_config.supernova.time_explosion}')\n", "plt.plot(w7_modified_model.r_middle,\n", " w7_modified_model.density,\n", " label=f't_explosion = {w7_modified_config.supernova.time_explosion}')\n", "plt.xlabel(f'Radius ({w7_density_model.r_middle.unit})')\n", "plt.ylabel(f'Density ({w7_density_model.density.unit})')\n", "plt.legend();" ] }, { "cell_type": "markdown", "id": "be7160e4", "metadata": {}, "source": [ "For the other density models described below, time dependence works similarly, and readers are encouraged to test out how they change over time. However, for brevity, we omit more explicit examples in this notebook." ] }, { "cell_type": "markdown", "id": "e0e1797c", "metadata": {}, "source": [ "### Uniform Density\n", "\n", "The uniform density profile sets the density in each shell to a constant value (with respect to velocity/radius). That is,\n", "\n", "$$\\rho(v,t_0)=\\mathrm{value}$$\n", "and thus\n", "$$\\rho(v,t_\\mathrm{explosion})=\\mathrm{value}*\\left(\\frac{t_0}{t_\\mathrm{explosion}}\\right)^3.$$\n", "\n", "The parameters that can be varied, besides the shell structure, are thus the characteristic time $t_0$, and the value of the density at time $t_0$. The schema can be found [here](../../io/configuration/components/models/index.rst#uniform-density)." ] }, { "cell_type": "code", "execution_count": null, "id": "b57d1646", "metadata": { "scrolled": false }, "outputs": [], "source": [ "uni_density_config = copy.deepcopy(base_config)\n", "\n", "uni_density_config.supernova.time_explosion = 10 * u.day\n", "\n", "# This line is necessary to indicate we are using a built-in shell structure\n", "# and density. Do not change it.\n", "uni_density_config.model.structure.type = 'specific'\n", "\n", "uni_density_config.model.structure.velocity.start = 1000 * u.km/u.s\n", "uni_density_config.model.structure.velocity.stop = 2000 * u.km/u.s\n", "uni_density_config.model.structure.velocity.num = 20\n", "\n", "uni_density_config.model.structure.density.type = 'uniform'\n", "uni_density_config.model.structure.density.time_0 = 1 * u.day\n", "uni_density_config.model.structure.density.value = 5e-10 * u.kg/u.cm**3\n", "\n", "uni_density_model = SimulationState.from_config(uni_density_config, atom_data=atom_data)\n", "\n", "print('density:\\n', uni_density_model.density)\n", "\n", "plt.plot(uni_density_model.r_middle, uni_density_model.density)\n", "plt.xlabel(f'Radius ({uni_density_model.r_middle.unit})')\n", "plt.ylabel(f'Density ({uni_density_model.density.unit})');" ] }, { "cell_type": "markdown", "id": "4c441e1b", "metadata": {}, "source": [ "### Power Law Density\n", "\n", "The power law density profile uses the following equation:\n", "\n", "$$\\rho(v,t_0)=\\rho_0\\left(\\frac{v}{v_0}\\right)^{\\rm exponent}$$\n", "and thus\n", "$$\\rho(v,t_\\mathrm{explosion})=\\rho_0\\left(\\frac{v}{v_0}\\right)^{\\rm exponent}\\left(\\frac{t_0}{t_\\mathrm{explosion}}\\right)^3.$$\n", "\n", "Thus, the relevant parameters are $t_0$, $\\rho_0$, $v_0$, and the exponent. We recommend that the exponent be negative for a sensible density profile. The schema can be found [here](../../io/configuration/components/models/index.rst#power-law-density).\n", "\n", "Note here that $\\rho_0$ is the density at time $t_0$ and velocity $v_0$." ] }, { "cell_type": "code", "execution_count": null, "id": "bc1f4ed3", "metadata": { "scrolled": false }, "outputs": [], "source": [ "pow_density_config = copy.deepcopy(base_config)\n", "\n", "pow_density_config.supernova.time_explosion = 10 * u.day\n", "\n", "# This line is necessary to indicate we are using a built-in shell structure\n", "# and density.\n", "pow_density_config.model.structure.type = 'specific'\n", "\n", "pow_density_config.model.structure.velocity.start = 1000 * u.km/u.s\n", "pow_density_config.model.structure.velocity.stop = 2000 * u.km/u.s\n", "pow_density_config.model.structure.velocity.num = 20\n", "\n", "pow_density_config.model.structure.density.type = 'power_law'\n", "pow_density_config.model.structure.density.time_0 = 1 * u.day\n", "pow_density_config.model.structure.density.rho_0 = 5e-10 * u.kg/u.cm**3\n", "pow_density_config.model.structure.density.v_0 = 500 * u.km/u.s\n", "pow_density_config.model.structure.density.exponent = -2\n", "\n", "pow_density_model = SimulationState.from_config(pow_density_config, atom_data=atom_data)\n", "\n", "print('density:\\n', pow_density_model.density)\n", "\n", "plt.plot(pow_density_model.r_middle, pow_density_model.density)\n", "plt.xlabel(f'Radius ({pow_density_model.r_middle.unit})')\n", "plt.ylabel(f'Density ({pow_density_model.density.unit})');" ] }, { "cell_type": "markdown", "id": "12e08f18", "metadata": {}, "source": [ "### Exponential Density\n", "\n", "The exponential density profile uses the following equation:\n", "\n", "$$\\rho(v,t_0)=\\rho_0e^{-v/v_0}$$\n", "and thus\n", "$$\\rho(v,t_\\mathrm{explosion})=\\rho_0e^{-v/v_0}\\left(\\frac{t_0}{t_\\mathrm{explosion}}\\right)^3.$$\n", "\n", "Thus, the relevant parameters are $t_0$, $\\rho_0$, and $v_0$. The schema can be found [here](../../io/configuration/components/models/index.rst#exponential-density).\n", "\n", "Note here again that $\\rho_0$ is the density at time $t_0$ and velocity $v_0$." ] }, { "cell_type": "code", "execution_count": null, "id": "d55f0468", "metadata": {}, "outputs": [], "source": [ "exp_density_config = copy.deepcopy(base_config)\n", "\n", "exp_density_config.supernova.time_explosion = 10 * u.day\n", "\n", "# This line is necessary to indicate we are using a built-in shell structure\n", "# and density.\n", "exp_density_config.model.structure.type = 'specific'\n", "\n", "exp_density_config.model.structure.velocity.start = 1000 * u.km/u.s\n", "exp_density_config.model.structure.velocity.stop = 2000 * u.km/u.s\n", "exp_density_config.model.structure.velocity.num = 20\n", "\n", "exp_density_config.model.structure.density.type = 'exponential'\n", "exp_density_config.model.structure.density.time_0 = 1 * u.day\n", "exp_density_config.model.structure.density.rho_0 = 5e-10 * u.kg/u.cm**3\n", "exp_density_config.model.structure.density.v_0 = 500 * u.km/u.s\n", "\n", "exp_density_model = SimulationState.from_config(exp_density_config, atom_data=atom_data)\n", "\n", "print('density:\\n', exp_density_model.density)\n", "\n", "plt.plot(exp_density_model.r_middle, exp_density_model.density)\n", "plt.xlabel(f'Radius ({exp_density_model.r_middle.unit})')\n", "plt.ylabel(f'Density ({exp_density_model.density.unit})');" ] }, { "cell_type": "markdown", "id": "cfd06a7c", "metadata": {}, "source": [ "## Abundance\n", "\n", "The `SimulationState` also carries important information about elemental abundances in each shell. These are mass abundances -- that is, the abundance of oxygen is the fraction of the shell's mass that is made up of oxygen.\n", "\n", "The only built-in abundance model that TARDIS offers is a uniform abundance, meaning each shell has identical abundances. Like density, however, the [file abundance](../../io/configuration/components/models/index.rst#file-abundance), [CSVY model](../../io/configuration/components/models/index.rst#csvy-model), and [custom abundance widget](../../io/visualization/how_to_abundance_widget.ipynb) methods allow users more freedom with assigning different abundances in each shell.\n", "\n", "A table of abundances in each shell is stored in the `abundance` attribute of the `SimulationState` object.\n", "\n", "In this first example, the abundances in each shell do not depend on the time after the explosion and are identical to those provided in the configuration." ] }, { "cell_type": "code", "execution_count": null, "id": "c7396b49", "metadata": {}, "outputs": [], "source": [ "abund_config = copy.deepcopy(base_config)\n", "\n", "abund_config.supernova.time_explosion = 10 * u.day\n", "\n", "# We add the abundances in this form to overwrite the elements in the\n", "# base configuration.\n", "abund_config.model.abundances = {'type':'uniform',\n", " 'O':.2,\n", " 'Ca':.25,\n", " 'Mg':.15,\n", " 'Si':.3,\n", " 'He': .1}\n", "\n", "abund_model = SimulationState.from_config(abund_config, atom_data=atom_data)\n", "\n", "abund_model.abundance" ] }, { "cell_type": "markdown", "id": "b45e6de1", "metadata": {}, "source": [ "In the next example, we show how TARDIS handles radioactive isotopes which are often present in supernovae. Specific isotopes such as `Ni56` (nickel-56 with 28 protons and 28 neutrons) or `Cr51` (chromium-51 with 24 protons and 27 neutrons) can be provided in the configuration.\n", "\n", "If any radioactive isotope is provided, the abundances provided are assumed to be the abundances at the time of the explosion. TARDIS then uses [pyne](http://pyne.io) to calculate the decay products of these isotopes after a time $t_\\mathrm{explosion}$. This is demonstrated in the example below.\n", "\n", "If an isotope mass number is not supplied, TARDIS uses the most stable form of the atom (for example, `Ni` refers to the stable nickel-58)." ] }, { "cell_type": "code", "execution_count": null, "id": "6ab8f445", "metadata": {}, "outputs": [], "source": [ "abund_isotopes_config = copy.deepcopy(base_config)\n", "\n", "abund_isotopes_config.supernova.time_explosion = 10 * u.day\n", "\n", "abund_isotopes_config.model.structure.velocity.num = 20\n", "\n", "abund_isotopes_config.model.abundances = {'type':'uniform',\n", " 'O':.3,\n", " 'Ni56':.2,\n", " 'Ni57':.1,\n", " 'Cr51':.4}\n", "\n", "abund_isotopes_simulation_state = SimulationState.from_config(abund_isotopes_config, atom_data=atom_data)\n", "\n", "abund_isotopes_simulation_state.abundance" ] }, { "cell_type": "markdown", "id": "9fded236", "metadata": {}, "source": [ "## Temperatures\n", "\n", "The model also includes information about the temperature of the photosphere/inner boundary, labeled as $T_\\mathrm{inner}$, and the temperature of the plasma in each cell, called the radiative temperature and labeled as $T_\\mathrm{rad}$. As will be explained, both of these quantities are be updated throughout the simulation, so the calculations in this section are the initial guesses.\n", "\n", "TARDIS initially calculates $T_\\mathrm{inner}$ as the temperature of a [blackbody](https://en.wikipedia.org/wiki/Black-body_radiation) such that the luminosity of the photosphere (see [initialization](../montecarlo/initialization.ipynb)) matches the requested output luminosity of the entire supernova $L_\\mathrm{requested}$, which is specified in the [spectrum configuration](../../io/configuration/components/spectrum.rst):\n", "\n", "$$T_{\\mathrm{inner}}=\\left(\\frac{L_\\mathrm{requested}}{4 \\pi r_{\\mathrm{boundary\\_inner}}^2 \\sigma_{\\mathrm{R}}}\\right)^{1/4}$$\n", "\n", "where $\\sigma_{\\mathrm{R}}$ is the Stefan-Boltzmann constant and $r_{\\mathrm{boundary\\_inner}}$ is once again the radius of the photosphere, calculated as part of the shell structure. Because of light-matter interactions, the output luminosity of the supernova will not be the same as the luminosity of the photosphere, so the photospheric temperature is updated throughout the simulation as part of the convergence process in order to match the output luminosity to the requested luminosity (see [Updating Plasma and Convergence](../update_and_conv/update_and_conv.ipynb)).\n", "\n", "Next, TARDIS calculates the initial guess for the radiative temperature in each shell. This temperature is also updated throughout the simulation based on light-matter interactions (see once again [Updating Plasma and Convergence](../update_and_conv/update_and_conv.ipynb)). The initial guess for $T_\\mathrm{rad}$ is calculated using [Wien's Law](https://en.wikipedia.org/wiki/Wien%27s_displacement_law). Wien's Law states that the temperature of a blackbody is inversely proportional to the blackbody's peak wavelength. The proportionality constant, labeled $b$, is approximately $2.898*10^{-3} m*K$. In equation form,\n", "\n", "$$T=\\frac{b}{\\lambda_\\mathrm{peak}}.$$\n", "\n", "Since we know $T_\\mathrm{inner}$ (from the previous calculation), at the photosphere, we have $\\lambda_\\mathrm{peak,inner}=\\frac{b}{T_\\mathrm{inner}}$. Now, when the ejecta is moving at a velocity $v$, $\\lambda_\\mathrm{peak}$ is doppler shifted (in more technical language, we find the peak wavelength in the co-moving frame, see [reference frames](../montecarlo/propagation.rst#reference-frames)). The doppler factor is (approximately) $1+\\frac{\\Delta v}{c}$ where $\\Delta v$ is the difference between $v$ and the velocity at the photosphere (i.e. $\\Delta v = v-v_\\mathrm{boundary\\_inner}$). So,\n", "\n", "$$\\lambda_\\mathrm{peak}(v)=\\left(1+\\frac{v-v_\\mathrm{boundary\\_inner}}{c}\\right)\\lambda_\\mathrm{peak,inner}=\\left(1+\\frac{v-v_\\mathrm{boundary\\_inner}}{c}\\right)\\frac{b}{T_\\mathrm{inner}}.$$\n", "\n", "Thus, the temperature at a velocity $v$ is\n", "\n", "$$T_\\mathrm{rad}(v)=\\frac{b}{\\lambda_\\mathrm{peak}(v)}=\\frac{T_\\mathrm{inner}}{1+\\frac{v-v_\\mathrm{boundary\\_inner}}{c}}.$$\n", "\n", "As with density, the radiative temperature is modeled as constant throughout the shell, so we determine the temperature of the shell based on the ejecta's velocity at the center of the shell.\n", "\n", "
\n", " \n", "Note\n", "\n", "Specific initial guesses for the photospheric and radiative temperatures not based on the above calculations can also be input in the [plasma configuration](../../io/configuration/components/plasma.rst) (for both) or in the [CSVY model](../../io/configuration/components/models/index.rst#csvy-model) (radiative temperature only).\n", "\n", "
\n", "\n", "Using the parameters below, we print off the initial photospheric temperature and radiative temperature in each shell, and plot temperature versus radius, including a point for the temperature of the photosphere." ] }, { "cell_type": "code", "execution_count": null, "id": "6489e3fb", "metadata": {}, "outputs": [], "source": [ "t_rad_config = copy.deepcopy(base_config)\n", "\n", "t_rad_config.supernova.time_explosion = 10 * u.day\n", "\n", "# In the configuration file, but not here, the luminosity requested can be\n", "# given on a logarithmic scale based on the luminosity of the sun.\n", "t_rad_config.supernova.luminosity_requested = 4e44 * u.erg/u.s\n", "\n", "# This line is necessary to indicate we are using a built-in shell structure\n", "# and density. Do not change it.\n", "t_rad_config.model.structure.type = 'specific'\n", "\n", "t_rad_config.model.structure.velocity.start = 1000 * u.km/u.s\n", "t_rad_config.model.structure.velocity.stop = 2000 * u.km/u.s\n", "t_rad_config.model.structure.velocity.num = 20\n", "\n", "t_radiative_simulation_state = SimulationState.from_config(t_rad_config, atom_data=atom_data)\n", "\n", "print('t_inner:\\n', t_radiative_simulation_state.t_inner)\n", "print('t_rad:\\n', t_radiative_simulation_state.t_radiative)\n", "\n", "plt.plot(t_radiative_simulation_state.r_middle, t_radiative_simulation_state.t_radiative)\n", "plt.scatter(t_radiative_simulation_state.radius[0], t_radiative_simulation_state.t_inner)\n", "plt.xlabel(f'Radius ({t_radiative_simulation_state.r_middle.unit})')\n", "plt.ylabel(f'Radiative Temperature ({t_radiative_simulation_state.t_radiative.unit})');" ] }, { "cell_type": "markdown", "id": "292067b3", "metadata": {}, "source": [ "## Dilution Factor\n", "\n", "The dilution factor $W$ describes the fraction of the energy from a blackbody that \"reaches\" the observer. That is, it is the ratio of the energy density at the observer to the energy density of the blackbody. This heavily depends on light-matter interactions, as matter can shield or amplify the energy coming from the blackbody, in this case the photosphere. However, in the absence of other material, the dilution factor is purely geometric, called the geometric dilution factor. The geometric dilution factor at a point is the fraction of the point's \"field of view\" that the blackbody takes up, as shown in the figure below.\n", "\n", "\n", "\n", "Using geometry (in 3D, where the photosphere in the figure is a sphere, not a circle), the fraction of the point's \"field of view\" taken up by the sphere is\n", "\n", "$$\\frac{1}{2}\\left(1-\\sqrt{1-\\frac{r_\\mathrm{boundary\\_inner}^2}{r^2}}\\right)$$\n", "\n", "where $r_\\mathrm{boundary\\_inner}$ is the radius of the circle in the picture (the photosphere in terms of TARDIS). This is the geometric dilution factor.\n", "\n", "\n", "Like the radiative temperature, the dilution factor in each cell changes throughout the simulation based on the light-matter interactions (see [Updating Plasma and Convergence](../update_and_conv/update_and_conv.ipynb)). TARDIS uses the geometric dilution factor as the initial guess for the dilution factor in each cell, plugging in the radius at the center of the cell to determine the initial dilution factor in the cell. \n", "\n", "
\n", " \n", "Note\n", "\n", "An initial guess for the dilution factor in each cell not based on the geometric dilution factor can be input via the [CSVY model](../../io/configuration/components/models/index.rst#csvy-model).\n", "\n", "
\n", "\n", "We print off the dilution factor in each cell and plot the dilution factor versus radius for a certain shell structure:" ] }, { "cell_type": "code", "execution_count": null, "id": "ab1f9ac8", "metadata": { "scrolled": false }, "outputs": [], "source": [ "dilution_factor_config = copy.deepcopy(base_config)\n", "\n", "dilution_factor_config.supernova.time_explosion = 10 * u.day\n", "\n", "# This line is necessary to indicate we are using a built-in shell structure\n", "# and density. Do not change it.\n", "dilution_factor_config.model.structure.type = 'specific'\n", "\n", "dilution_factor_config.model.structure.velocity.start = 1000 * u.km/u.s\n", "dilution_factor_config.model.structure.velocity.stop = 2000 * u.km/u.s\n", "dilution_factor_config.model.structure.velocity.num = 20\n", "\n", "dilution_factor_simulation_state = SimulationState.from_config(dilution_factor_config, atom_data=atom_data)\n", "\n", "print(f'dilution_factor: {dilution_factor_simulation_state.dilution_factor}')\n", "\n", "plt.plot(dilution_factor_simulation_state.r_middle, dilution_factor_simulation_state.dilution_factor)\n", "plt.xlabel(f'Radius ({dilution_factor_simulation_state.r_middle.unit})')\n", "plt.ylabel(f'Dilution Factor');" ] } ], "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.16" } }, "nbformat": 4, "nbformat_minor": 5 }