{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Example use case: Massive star luminosity\n",
    "\n",
    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of single stars using binary_c. \n",
    "\n",
    "We start by loading in some standard Python modules and the binary_c module.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from binarycpython.utils.functions import temp_dir\n",
    "from binarycpython.utils.grid import Population\n",
    "\n",
    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_luminosity\")\n",
    "\n",
    "# help(Population) # Uncomment this line to see the public functions of this object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
   "metadata": {},
   "source": [
    "## Setting up the Population object\n",
    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
    "\n",
    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "79ab50b7-591f-4883-af09-116d1835a751",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adding: max_evolution_time=0.1 to BSE_options\n",
      "adding: tmp_dir=/tmp/binary_c_python-izzard/notebooks/notebook_luminosity to grid_options\n",
      "verbosity is 1\n"
     ]
    }
   ],
   "source": [
    "# Create population object\n",
    "population = Population()\n",
    "\n",
    "# If you want verbosity, set this before other things\n",
    "population.set(verbosity=1)\n",
    "\n",
    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
    "# Those that are present in the default grid_options are set in grid_options\n",
    "# All other values that you set are put in a custom_options dict\n",
    "population.set(\n",
    "    # binary_c physics options\n",
    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
    "    tmp_dir=TMP_DIR,\n",
    ")\n",
    "\n",
    "# We can access the options through \n",
    "print(\"verbosity is\", population.grid_options['verbosity'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
   "metadata": {},
   "source": [
    "## Adding grid variables\n",
    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
    "\n",
    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
    "\n",
    "To add a grid variable to the population object we use `population.add_grid_variable`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "68c84521-9ae8-4020-af7a-5334173db969",
   "metadata": {},
   "outputs": [],
   "source": [
    "# help(population.add_grid_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
   "metadata": {},
   "source": [
    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "import binarycpython.utils.distribution_functions\n",
    "# help(binarycpython.utils.distribution_functions)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
   "metadata": {},
   "source": [
    "First let us set up some global variables that will be useful throughout.\n",
    "\n",
    "* The resolution is the number of stars we simulate in our model population.\n",
    "* The massrange is a list of the min and max masses\n",
    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set resolution and mass range that we simulate\n",
    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
    "# distribution binwidths : \n",
    "# (log10) luminosity distribution\n",
    "binwidth = { 'luminosity' : 0.5 }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
   "metadata": {},
   "source": [
    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "47979841-2c26-4b26-8945-603d013dc93a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mass\n",
    "population = Population()\n",
    "population.set(\n",
    "    tmp_dir=TMP_DIR,\n",
    ")\n",
    "population.add_grid_variable(\n",
    "    name=\"M_1\",\n",
    "    longname=\"Primary mass\",\n",
    "    valuerange=massrange,\n",
    "    samplerfunc=\"const({min}, {max}, {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
    "    probdist=\"{probtot}/({max} - {min})\".format(probtot = total_probability, min = massrange[0], max = massrange[1]), # dprob/dm1 : all stars are equally likely so this is 1.0 / (Mmax - Mmin)\n",
    "    dphasevol=\"dM_1\",\n",
    "    parameter_name=\"M_1\",\n",
    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
   "metadata": {},
   "source": [
    "## Setting logging and handling the output\n",
    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
    "\n",
    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
    "\n",
    "In the code below we will set up both the custom logging and a parse function to handle that output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create custom logging statement\n",
    "#\n",
    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
    "#\n",
    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STAR\n",
    "\n",
    "custom_logging_statement = \"\"\"\n",
    "if(stardata->model.model_number == 0 &&\n",
    "   stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
    "   stardata->model.time == 0)\n",
    "{\n",
    "   /* Note that we use Printf - with a capital P! */\n",
    "   Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR %30.12e %g %g %g %g\\\\n\",\n",
    "          stardata->model.time, // 1\n",
    "          stardata->common.zero_age.mass[0], // 2\n",
    "          stardata->star[0].mass, // 3\n",
    "          stardata->star[0].luminosity, // 4\n",
    "          stardata->model.probability // 5\n",
    "      );\n",
    "};\n",
    "\"\"\"\n",
    "\n",
    "population.set(\n",
    "    C_logging_code=custom_logging_statement\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
   "metadata": {},
   "source": [
    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fd197154-a8ce-4865-8929-008d3483101a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
    "from binarycpython.utils.functions import bin_data,datalinedict\n",
    "\n",
    "def parse_function(self, output):\n",
    "    \"\"\"\n",
    "    Example parse function\n",
    "    \"\"\"\n",
    "    \n",
    "    # list of the data items\n",
    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
    "    \n",
    "    # Loop over the output.\n",
    "    for line in output.splitlines():\n",
    "        # obtain the line of data in dictionary form \n",
    "        linedata = datalinedict(line,parameters)\n",
    "        \n",
    "        # Check the header and act accordingly\n",
    "        if linedata['header'] == \"ZERO_AGE_MAIN_SEQUENCE_STAR\":\n",
    "            \n",
    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
    "                                             binwidth['luminosity'])\n",
    "            \n",
    "            # append the data to the results_dictionary \n",
    "            self.grid_results['luminosity distribution'][binned_log_luminosity] += linedata['probability'] \n",
    "            \n",
    "            #print (self.grid_results)\n",
    "    \n",
    "    # verbose reporting\n",
    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
    "    \n",
    "# Add the parsing function\n",
    "population.set(\n",
    "    parse_function=parse_function,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
   "metadata": {},
   "source": [
    "## Evolving the grid\n",
    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
    "\n",
    "This will start up the processing of all the systems. We can control how many cores are used by settings `num_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
    "\n",
    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing dry run to calculate total starcount and probability\n",
      "Generating grid code\n",
      "Grid has handled 40 stars with a total probability of 1\n",
      "**************************************\n",
      "* Total starcount for this run is 40 *\n",
      "*       Total probability is 1       *\n",
      "**************************************\n",
      "\n",
      "Generating grid code\n",
      "**********************************************************\n",
      "*  Population-b6213f2eb7f94d3196cf966b7b76b9f9 finished! *\n",
      "*               The total probability is 1.              *\n",
      "*  It took a total of 6.99s to run 40 systems on 2 cores *\n",
      "*                  = 13.98s of CPU time.                 *\n",
      "*              Maximum memory use 472.211 MB             *\n",
      "**********************************************************\n",
      "\n",
      "There were no errors found in this run.\n"
     ]
    }
   ],
   "source": [
    "# set number of threads\n",
    "population.set(\n",
    "    # verbose output is not required    \n",
    "    verbosity=0,\n",
    "    # set number of threads (i.e. number of CPU cores we use)\n",
    "    num_cores=2,\n",
    "    )\n",
    "\n",
    "# Evolve the population - this is the slow, number-crunching step\n",
    "analytics = population.evolve()  \n",
    "\n",
    "# Show the results (debugging)\n",
    "# print (population.grid_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
   "metadata": {},
   "source": [
    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'population_name': 'b6213f2eb7f94d3196cf966b7b76b9f9', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.9999999999999998, 'total_count': 40, 'start_timestamp': 1635760806.5066257, 'end_timestamp': 1635760813.4966016, 'total_mass_run': 2001.3999999999996, 'total_probability_weighted_mass_run': 50.03499999999999, 'zero_prob_stars_skipped': 0}\n"
     ]
    }
   ],
   "source": [
    "print(analytics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[None]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from binarycpython.utils.functions import pad_output_distribution\n",
    "\n",
    "# set up seaborn for use in the notebook\n",
    "sns.set(rc={'figure.figsize':(20,10)})\n",
    "sns.set_context(\"notebook\",\n",
    "                font_scale=1.5,\n",
    "                rc={\"lines.linewidth\":2.5})\n",
    "                    \n",
    "\n",
    "# this saves a lot of typing! \n",
    "ldist = population.grid_results['luminosity distribution']\n",
    "\n",
    "# pad the distribution with zeros where data is missing\n",
    "pad_output_distribution(ldist,\n",
    "                        binwidth['luminosity'])\n",
    "\n",
    "# make pandas dataframe from our sorted dictionary of data\n",
    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
    "\n",
    "# make the plot\n",
    "p = sns.lineplot(data=plot_data)\n",
    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
    "p.set_ylabel(\"Number of stars\")\n",
    "p.set(yscale=\"log\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
   "metadata": {},
   "source": [
    "Does this look like a reasonable stellar luminosity function to you? The implication is that the most likely stellar luminosity is 10<sup>5.8</sup> L<sub>☉</sub>! Clearly, this is not very realistic... let's see what went wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e32c3bbf-390f-45da-ad9c-cc3e7c9449dc",
   "metadata": {},
   "source": [
    "## ZAMS Luminosity distribution with the initial mass function\n",
    "\n",
    "In the previous example, all the stars in our grid had an equal weighting. This is very unlikely to be true in reality: indeed, we know that low mass stars are far more likely than high mass stars.  So we now include an initial mass function as a three-part power law based on Kroupa (2001). Kroupa's distribution is a three-part power law: we have a function that does this for us (it's very common to use power laws in astrophysics).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1f37d2c0-1108-4ab9-a309-20b1e6b6e3fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Update the probability distribution to use the three-part power law IMF \n",
    "population.update_grid_variable(\n",
    "    name=\"M_1\",\n",
    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6f4463e8-1935-45f2-8c5f-e7b215f8dc47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing dry run to calculate total starcount and probability\n",
      "Generating grid code\n",
      "Grid has handled 40 stars with a total probability of 0.218222\n",
      "**************************************\n",
      "* Total starcount for this run is 40 *\n",
      "*    Total probability is 0.218222   *\n",
      "**************************************\n",
      "\n",
      "Generating grid code\n",
      "**********************************************************\n",
      "*  Population-4b8c7f4a86e445099d73f27dffaad94b finished! *\n",
      "*           The total probability is 0.218222.           *\n",
      "*  It took a total of 7.95s to run 40 systems on 2 cores *\n",
      "*                  = 15.89s of CPU time.                 *\n",
      "*              Maximum memory use 587.984 MB             *\n",
      "**********************************************************\n",
      "\n",
      "There were no errors found in this run.\n"
     ]
    }
   ],
   "source": [
    "# Clean and re-evolve the population \n",
    "population.clean()\n",
    "analytics = population.evolve()  \n",
    "\n",
    "# Show the results (debugging)\n",
    "# print (population.grid_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "cfe45a9e-1121-43b6-b6b6-4de6f8946a18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[None]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot luminosity distribution\n",
    "ldist = population.grid_results['luminosity distribution']\n",
    "\n",
    "# pad the distribution with zeros where data is missing\n",
    "pad_output_distribution(ldist,\n",
    "                        binwidth['luminosity'])\n",
    "\n",
    "# make pandas dataframe from our sorted dictionary of data\n",
    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
    "\n",
    "# make the plot\n",
    "p = sns.lineplot(data=plot_data)\n",
    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
    "p.set_ylabel(\"Number of stars\")\n",
    "p.set(yscale=\"log\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0546f2f3-4732-4841-8ef3-565fbf6b9961",
   "metadata": {},
   "source": [
    "This distribution is peaked at low luminosity, as one expects from observations, but the resolution is clearly not great because it's not smooth - it's spiky! \n",
    "\n",
    "If you noticed above, the total probability of the grid was about 0.2. Given that the total probability of a probability distribution function should be 1.0, this shows that our sampling is (very) poor. \n",
    "\n",
    "We could simply increase the resolution to compensate, but this is very CPU intensive and a complete waste of time and resources. Instead, let's try sampling the masses of the stars in a smarter way."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "673031c9-7d80-45d4-b209-301c127d3edf",
   "metadata": {
    "tags": []
   },
   "source": [
    "## A better-sampled grid\n",
    "\n",
    "The IMF has many more low-mass stars than high-mass stars. So, instead of sampling M1 linearly, we can sample it in log space. \n",
    "\n",
    "To do this we first rename the mass grid variable so that it is clear we are working in (natural) logarithmic phase space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5956f746-e3b9-4912-b75f-8eb0af66d3f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rename the old variable (M_1) because we want it to be called lnM_1 now\n",
    "population.rename_grid_variable(\"M_1\",\"lnM_1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "532f691c-c1f6-46cc-84f2-970ec1216e40",
   "metadata": {},
   "source": [
    "Next, we change the spacing function so that it works in the log space. We also adapt the probability calculation so that it calculates dprob/dlnM = M * dprob/dM. Finally, we set the precode to compute M_1 because binary_c requires the actual mass, not the logarithm of the mass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "108d470a-bb21-40b0-8387-2caa7ab0f923",
   "metadata": {},
   "outputs": [],
   "source": [
    "# update the sampling, note that the IMF is dprob/dM1, and the phase \n",
    "# space is now sampled in lnM1, so we multiply by M_1 to \n",
    "# because  M * dprob/dM = dprob/dlnM\n",
    "population.update_grid_variable(\n",
    "    name=\"lnM_1\",\n",
    "    samplerfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
    "    dphasevol=\"dlnM_1\",\n",
    "    parameter_name=\"M_1\",\n",
    "    precode=\"M_1=math.exp(lnM_1)\",\n",
    ")\n",
    "# print(population.grid_options[\"_grid_variables\"]) # debugging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fb8db646-f3d0-4ccd-81ba-7fde23f29c79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing dry run to calculate total starcount and probability\n",
      "Generating grid code\n",
      "Grid has handled 40 stars with a total probability of 0.995631\n",
      "**************************************\n",
      "* Total starcount for this run is 40 *\n",
      "*    Total probability is 0.995631   *\n",
      "**************************************\n",
      "\n",
      "Generating grid code\n",
      "**********************************************************\n",
      "*  Population-7a2e4301f5224b2cb8939d2297df0aad finished! *\n",
      "*           The total probability is 0.995631.           *\n",
      "*  It took a total of 4.77s to run 40 systems on 2 cores *\n",
      "*                   = 9.55s of CPU time.                 *\n",
      "*              Maximum memory use 621.930 MB             *\n",
      "**********************************************************\n",
      "\n",
      "There were no errors found in this run.\n"
     ]
    }
   ],
   "source": [
    "# Clean and re-evolve the population \n",
    "population.clean()\n",
    "analytics = population.evolve()  \n",
    "\n",
    "# Show the results (debugging)\n",
    "# print (population.grid_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "182b1094-5057-4ccf-bac6-9b0e560ad4f6",
   "metadata": {},
   "source": [
    "You should see that the total probability is very close to 1.0, as you would expect for a well-sampled grid. The total will never be exactly 1.0, but that is because we are running a simulation, not a perfect copy of reality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "68ee1e56-21e5-48f4-b74c-50e48685ae94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot luminosity distribution\n",
    "ldist = population.grid_results['luminosity distribution']\n",
    "\n",
    "# pad the distribution with zeros where data is missing\n",
    "pad_output_distribution(ldist,\n",
    "                        binwidth['luminosity'])\n",
    "\n",
    "# make pandas dataframe from our sorted dictionary of data\n",
    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
    "\n",
    "# make the plot\n",
    "p = sns.lineplot(data=plot_data)\n",
    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
    "p.set_ylabel(\"Number of stars\")\n",
    "p.set(yscale=\"log\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31fe91bb-177d-4e4e-90cf-298a3f8a8b61",
   "metadata": {},
   "source": [
    "Most stars are low mass red dwarfs, with small luminosities. Without the IMF weighting, our model population would have got this completely wrong! \n",
    "\n",
    "As you increase the resolution, you will see this curve becomes even smoother. The wiggles in the curve are (usually) sampling artefacts because the curve should monotonically brighten above about log(*L*/L<sub>☉</sub>)=-2. \n",
    " \n",
    "Remember you can play with the binwidth too. If you want a very accurate distribution you need a narrow binwidth, but then you'll also need high resolution (lots of stars) so lots of CPU time, hence cost, CO<sub>2</sub>, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba032bd8-b4a2-4558-9fd9-8e1e03d7d162",
   "metadata": {},
   "source": [
    "Things to try:\n",
    "\n",
    " * Change the resolution to make the distributions smoother: what about error bars, how would you do that?\n",
    " * Different initial distributions: the Kroupa distribution isn't the only one out there\n",
    " * Change the metallicity and mass ranges\n",
    " * What about a non-constant star formation rate? This is more of a challenge!\n",
    " * What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?\n",
    " * Binary stars! (see notebook_luminosity_function_binaries.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5abd0935-3957-4859-80c1-6f5d7ce4b614",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}