{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
   "metadata": {},
   "source": [
    "# Example use case: Zero-age stellar luminosity function in binaries\n",
    "\n",
    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of binary stars using binary_c. \n",
    "\n",
    "Before you go through this notebook, you should look at notebook_luminosity_function.ipynb which is for the - conceptually more simple - single stars.\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",
    "from binarycpython.utils.grid import Population\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",
      "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",
    " )\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",
    "* 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' : 1.0 }"
   ]
  },
  {
   "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": [
    "# Set up the binary grid in \"cubic\" M1 - M2=q*M1 - log10 period space\n",
    "\n",
    "population = Population()\n",
    "\n",
    "# resolution on each side of the cube, with more stars for the primary mass\n",
    "nres = 10\n",
    "resolution = {\"M_1\": 4*nres,\n",
    "              \"q\": nres,\n",
    "              \"per\": nres}\n",
    "\n",
    "massrange = [0.07,100]\n",
    "logperrange = [0.15, 5.5]\n",
    "\n",
    "population.add_grid_variable(\n",
    "    name=\"lnm1\",\n",
    "    longname=\"Primary mass\",\n",
    "    valuerange=massrange,\n",
    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
    "    precode=\"M_1=math.exp(lnm1)\",\n",
    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
    "    dphasevol=\"dlnm1\",\n",
    "    parameter_name=\"M_1\",\n",
    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
    ")\n",
    "\n",
    "# Mass ratio\n",
    "population.add_grid_variable(\n",
    "     name=\"q\",\n",
    "     longname=\"Mass ratio\",\n",
    "     valuerange=[\"0.1/M_1\", 1],\n",
    "     resolution=\"{}\".format(resolution['q']),\n",
    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
    "     dphasevol=\"dq\",\n",
    "     precode=\"M_2 = q * M_1\",\n",
    "     parameter_name=\"M_2\",\n",
    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
    " )\n",
    "\n",
    "# Orbital period\n",
    "population.add_grid_variable(\n",
    "    name=\"log10per\", # in days\n",
    "    longname=\"log10(Orbital_Period)\",\n",
    "    valuerange=[0.15, 5.5],\n",
    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
    "    parameter_name=\"orbital_period\",\n",
    "    dphasevol=\"dlog10per\",\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 \n",
    "#\n",
    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STARn\n",
    "#\n",
    "# where:\n",
    "#\n",
    "# n = PRIMARY    = 0 is star 0 (primary star)\n",
    "# n = SECONDARY  = 1 is star 1 (secondary star)\n",
    "# n = UNRESOLVED = 2 is the unresolved system (both stars added)\n",
    "\n",
    "PRIMARY = 0\n",
    "SECONDARY = 1\n",
    "UNRESOLVED = 2\n",
    "\n",
    "custom_logging_statement = \"\"\"\n",
    "// select ZAMS\n",
    "if(stardata->model.model_number == 0 &&\n",
    "   stardata->model.time == 0)\n",
    "{\n",
    "    // loop over the stars individually (equivalent to a resolved binary) \n",
    "    Foreach_star(star)\n",
    "    {\n",
    "        // select main-sequence stars\n",
    "        if(star->stellar_type <= MAIN_SEQUENCE)\n",
    "        {\n",
    "            /* Note that we use Printf - with a capital P! */\n",
    "           Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
    "                  star->starnum,\n",
    "                  stardata->model.time, // 1\n",
    "                  stardata->common.zero_age.mass[0], // 2\n",
    "                  star->mass, // 3\n",
    "                  star->luminosity, // 4\n",
    "                  stardata->model.probability // 5\n",
    "           );\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    // unresolved MS-MS binary\n",
    "    if(stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
    "       stardata->star[1].stellar_type <= MAIN_SEQUENCE) \n",
    "    {\n",
    "        Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
    "                  2,\n",
    "                  stardata->model.time, // 1\n",
    "                  stardata->common.zero_age.mass[0] + stardata->common.zero_age.mass[1], // 2\n",
    "                  stardata->star[0].mass + stardata->star[1].mass, // 3\n",
    "                  stardata->star[0].luminosity + stardata->star[1].luminosity, // 4\n",
    "                  stardata->model.probability // 5\n",
    "           );\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",
    "import re\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",
    "        \n",
    "        # check if we match a ZERO_AGE_MAIN_SEQUENCE_STAR\n",
    "        match = re.search('ZERO_AGE_MAIN_SEQUENCE_STAR(\\d)',line) \n",
    "        if match:\n",
    "            nstar = match.group(1) \n",
    "            #print(\"matched star\",nstar)\n",
    "\n",
    "            # obtain the line of data in dictionary form \n",
    "            linedata = datalinedict(line,parameters)\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'][int(nstar)][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 `amt_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": [
      "adding: amt_cores=4 to grid_options\n",
      "Running the population now, this may take a little while...\n",
      "Creating and loading custom logging functionality\n",
      "Generating grid code\n",
      "Generating grid code\n",
      "Constructing/adding: lnm1\n",
      "Constructing/adding: q\n",
      "Constructing/adding: log10per\n",
      "Saving grid code to grid_options\n",
      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
      "Grid code loaded\n",
      "Grid has handled 256 stars\n",
      "with a total probability of 0.6149734610296649\n",
      "Total starcount for this run will be: 256\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2021-09-10 22:26:10,473 DEBUG    Process-2] --- Setting up processor: process-0\n",
      "[2021-09-10 22:26:10,475 DEBUG    Process-3] --- Setting up processor: process-1\n",
      "[2021-09-10 22:26:10,478 DEBUG    Process-4] --- Setting up processor: process-2\n",
      "[2021-09-10 22:26:10,481 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
      "[2021-09-10 22:26:10,482 DEBUG    Process-5] --- Setting up processor: process-3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process 0 started at 2021-09-10T22:26:10.491896.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf510>Process 1 started at 2021-09-10T22:26:10.491948.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf480>\n",
      "\n",
      "Process 2 started at 2021-09-10T22:26:10.496677.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf3f0>\n",
      "Process 3 started at 2021-09-10T22:26:10.498669.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf180>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2021-09-10 22:26:10,510 DEBUG    MainProcess] --- Signaling stop to processes\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating grid code\n",
      "Generating grid code\n",
      "Constructing/adding: lnm1\n",
      "Constructing/adding: q\n",
      "Constructing/adding: log10per\n",
      "Saving grid code to grid_options\n",
      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
      "Grid code loaded\n",
      "158/256  61.7% complete 22:26:15 ETA=    3.2s tpr=3.22e-02 ETF=22:26:18 mem:509.0MB\n",
      "199/256  77.7% complete 22:26:20 ETA=    7.3s tpr=1.28e-01 ETF=22:26:27 mem:476.9MB\n",
      "238/256  93.0% complete 22:26:25 ETA=    2.3s tpr=1.28e-01 ETF=22:26:27 mem:481.7MB\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2021-09-10 22:26:27,631 DEBUG    Process-3] --- Process-1 is finishing.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process 1 finished:\n",
      "\tgenerator started at 2021-09-10T22:26:10.475399, done at 2021-09-10T22:26:27.634804 (total: 17.159405s of which 17.104907512664795s interfacing with binary_c).\n",
      "\tRan 61 systems with a total probability of 0.1439494161909395.\n",
      "\tThis thread had 0 failing systems with a total probability of 0.\n",
      "\tSkipped a total of 0 systems because they had 0 probability\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2021-09-10 22:26:27,639 DEBUG    Process-3] --- Process-1 is finished.\n",
      "[2021-09-10 22:26:27,698 DEBUG    Process-5] --- Process-3 is finishing.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process 3 finished:\n",
      "\tgenerator started at 2021-09-10T22:26:10.482470, done at 2021-09-10T22:26:27.701828 (total: 17.219358s of which 17.162050247192383s interfacing with binary_c).\n",
      "\tRan 67 systems with a total probability of 0.17251417460118773.\n",
      "\tThis thread had 0 failing systems with a total probability of 0.\n",
      "\tSkipped a total of 0 systems because they had 0 probability\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2021-09-10 22:26:27,705 DEBUG    Process-5] --- Process-3 is finished.\n",
      "[2021-09-10 22:26:27,769 DEBUG    Process-4] --- Process-2 is finishing.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process 2 finished:\n",
      "\tgenerator started at 2021-09-10T22:26:10.478464, done at 2021-09-10T22:26:27.771291 (total: 17.292827s of which 17.243471384048462s interfacing with binary_c).\n",
      "\tRan 56 systems with a total probability of 0.14306289954535925.\n",
      "\tThis thread had 0 failing systems with a total probability of 0.\n",
      "\tSkipped a total of 0 systems because they had 0 probability\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2021-09-10 22:26:27,774 DEBUG    Process-4] --- Process-2 is finished.\n",
      "[2021-09-10 22:26:27,865 DEBUG    Process-2] --- Process-0 is finishing.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process 0 finished:\n",
      "\tgenerator started at 2021-09-10T22:26:10.473000, done at 2021-09-10T22:26:27.867175 (total: 17.394175s of which 17.331928491592407s interfacing with binary_c).\n",
      "\tRan 72 systems with a total probability of 0.1554469706921749.\n",
      "\tThis thread had 0 failing systems with a total probability of 0.\n",
      "\tSkipped a total of 0 systems because they had 0 probability\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2021-09-10 22:26:27,869 DEBUG    Process-2] --- Process-0 is finished.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Population-bc3a5f915411445699f8cf6438817ff1 finished! The total probability was: 0.6149734610296613. It took a total of 17.603368997573853s to run 256 systems on 4 cores\n",
      "There were no errors found in this run.\n",
      "Done population run!\n"
     ]
    }
   ],
   "source": [
    "# set number of threads\n",
    "population.set(\n",
    "    # verbose output is not required    \n",
    "    verbosity=1,\n",
    "    # set number of threads (i.e. number of CPU cores we use)\n",
    "    amt_cores=4,\n",
    "    )\n",
    "\n",
    "# Evolve the population - this is the slow, number-crunching step\n",
    "print(\"Running the population now, this may take a little while...\")\n",
    "analytics = population.evolve()  \n",
    "print(\"Done population run!\")\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': 'bc3a5f915411445699f8cf6438817ff1', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.6149734610296613, 'total_count': 256, 'start_timestamp': 1631305570.458824, 'end_timestamp': 1631305588.062193, 'total_mass_run': 5246.190724478048, 'total_probability_weighted_mass_run': 0.6347400152389439, '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",
    "titles = { 0 : \"Primary\",\n",
    "           1 : \"Secondary\",\n",
    "           2 : \"Unresolved\" }\n",
    "\n",
    "# choose to plot the \n",
    "# PRIMARY, SECONDARY or UNRESOLVED\n",
    "nstar = UNRESOLVED\n",
    "\n",
    "plots = {}\n",
    "\n",
    "# pad the distribution with zeros where data is missing\n",
    "for n in range(0,3):\n",
    "    pad_output_distribution(population.grid_results['luminosity distribution'][n],\n",
    "                            binwidth['luminosity'])\n",
    "    plots[titles[n] + ' ZAMS luminosity distribution'] = population.grid_results['luminosity distribution'][n]\n",
    "\n",
    "# make pandas dataframe from our sorted dictionary of data\n",
    "plot_data = pd.DataFrame.from_dict(plots)\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": [
    "You can see that the secondary stars are dimmer than the primaries - which you expect given they are lower in mass (by definition q=M2/M1<1). \n",
    "\n",
    "Weirdly, in some places the primary distribution may exceed the unresolved distribution. This is a bit unphysical, but in this case is usually caused by limited resolution. If you increase the number of stars in the grid, this problem should go away (at a cost of more CPU time). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99e25a72-54e6-4826-b0e5-4a02460b857d",
   "metadata": {},
   "outputs": [],
   "source": [
    "Things to try:\n",
    "* Massive stars: can you see the effects of wind mass loss and rejuvenation in these stars?\n",
    "* Alter the metallicity, does this make much of a difference?\n",
    "* Change the binary fraction. Here we assume a 100% binary fraction, but a real population is a mixture of single and binary stars.\n",
    "* How might you go about comparing these computed observations to real stars?\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?"
   ]
  }
 ],
 "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
