tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e5c32bf2",
   "metadata": {},
   "source": [
    "# FUSE Introductory Tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd96d876",
   "metadata": {},
   "source": [
    "Download this tutorial from the [FuseExamples repository](https://github.com/ProjectTorreyPines/FuseExamples/blob/master/tutorial.ipynb)\n",
    "\n",
    "-----------\n",
    "\n",
    "**NOTE**: Julia is a Just In Time (JIT) programming language. The first time something is executed it will take longer because of the compilation process. Subsequent calls the the same code will be blazingly fast.\n",
    "\n",
    "-----------\n",
    "\n",
    "Import the necessary packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dedcc3f3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "using Plots # for plotting\n",
    "using FUSE # this will also import IMAS in the current namespace"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69aaa109",
   "metadata": {},
   "source": [
    "## Starting from a use-case\n",
    "\n",
    "FUSE comes with some predefined [use-cases](https://fuse.help/stable/cases.html), some of which are used for regression testing.\n",
    "\n",
    "Note that some use cases are for non-nuclear experiments and certain Actors like Blankets or BalanceOfPlant will not perform any actions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbfe6fd2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.test_cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a081be5",
   "metadata": {},
   "source": [
    "Get initial parameters (`ini`) and actions (`act`) for a given use-case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be075861",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ini, act = FUSE.case_parameters(:KDEMO);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bc42414",
   "metadata": {},
   "source": [
    "Modifying [`ini` parameters](https://fuse.help/stable/ini.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae14546c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ini.equilibrium.B0 = 7.8\n",
    "ini.equilibrium.R0 = 6.5;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70d5163e",
   "metadata": {},
   "source": [
    "Modifying [`act` parameters](https://fuse.help/stable/act.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6d97d33",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "act.ActorCoreTransport.model = :FluxMatcher;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6df8497",
   "metadata": {},
   "source": [
    "Initialize the data dictionary (`dd`) using the 0D parameters.\n",
    "\n",
    "**NOTE:** `init()` does not return a self-consistent solution, just a plausible starting point to initialize our simulations!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "990d8f4b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd = FUSE.init(ini, act);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "159ab116",
   "metadata": {},
   "source": [
    "We can `@checkin` and `@checkout` variables with an associated tag.\n",
    "\n",
    "This is handy to save and restore our progress (we'll use this later)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c3d43cb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "@checkin :init dd ini act"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7efd020f",
   "metadata": {},
   "source": [
    "## Exploring the data dictionary\n",
    "* FUSE stores data following the IMAS data schema.\n",
    "* The root of the data structure is `dd`, which stands for \"Data Dictionary\".\n",
    "* More details are available in the [documentation](https://fuse.help/stable/dd.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b04000bb",
   "metadata": {},
   "source": [
    "Display part of the equilibrium data in `dd`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cfb9458",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd.equilibrium.time_slice[2].boundary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a472582",
   "metadata": {},
   "source": [
    "this can be done up to a certain depth with `print_tree`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21efefcd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print_tree(dd.equilibrium.time_slice[2].boundary; maxdepth=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "650098eb",
   "metadata": {},
   "source": [
    "## Plotting data from `dd`\n",
    "FUSE uses `Plots.jl` recipes for visualizing data from `dd`.\n",
    "\n",
    "This allows different plots to be shown when calling `plot()` on different items in the data structure.\n",
    "\n",
    "Learn more about Plots.jl [here](https://docs.juliaplots.org)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a0811d8",
   "metadata": {},
   "source": [
    "For example plotting the equilibrium..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6c8a5f4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.equilibrium)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf57b390",
   "metadata": {},
   "source": [
    "...or the core profiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "766b0a4c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.core_profiles)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa192aba-0ecb-438b-a235-31b2996d5178",
   "metadata": {},
   "source": [
    "Whant to know what arguments can be passed? use `help_plot()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76e2983b-cb96-4f13-9a33-6c452b3a9767",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "help_plot(dd.equilibrium; core_profiles_overlay=true, psi_levels_in=21, psi_levels_out=5, show_secondary_separatrix=true, coordinate=:psi_norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c69ee40f",
   "metadata": {},
   "source": [
    "These plots can be composed by calling `plot!()` instead of `plot()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6e349e4-a41c-4381-ab86-079d895006f7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.equilibrium; color=:gray, cx=true)\n",
    "plot!(dd.build; equilibrium=false, pf_active=false)\n",
    "plot!(dd.pf_active)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "317f0a61-888e-4b3a-bbe6-5e87149421f8",
   "metadata": {},
   "source": [
    "Plotting an array..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b3bbe7d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.core_profiles.profiles_1d[1].pressure_thermal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bafd019",
   "metadata": {},
   "source": [
    "...is different from plotting a field from the IDS (which plots the quantity against its coordinate and with units)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45061042",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.core_profiles.profiles_1d[1], :pressure_thermal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d8004d0",
   "metadata": {},
   "source": [
    "Customizing plot attributes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b64fa40",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.core_profiles.profiles_1d[1], :pressure_thermal; label=\"\", linewidth=2, color=:red, labelfontsize=25)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "274eda41",
   "metadata": {},
   "source": [
    "## Working with time series"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ef5eb81",
   "metadata": {},
   "source": [
    "The IMAS data structure supports time-dependent data, and IMAS.jl provides ways to handle time data efficiently."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7e507fe",
   "metadata": {},
   "source": [
    "Each `dd` has a `global_time` attribute, and actors operate at such time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c51c8662",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd.global_time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfbe1c3f",
   "metadata": {},
   "source": [
    "Here we see that equilibrium has mulitiple time_slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b329d70",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd.equilibrium.time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "177586fc",
   "metadata": {},
   "source": [
    "Accessing time-dependent arrays of structures, via integer index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57c18ccd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "eqt = dd.equilibrium.time_slice[2]\n",
    "eqt.time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97706563",
   "metadata": {},
   "source": [
    "At a given time, by passing the time as a floating point number (in seconds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dda7afb8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "eqt = dd.equilibrium.time_slice[0.0]\n",
    "eqt.time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7877d43",
   "metadata": {},
   "source": [
    "At the global time, leaving the square brackets empty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ed200cc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "eqt = dd.equilibrium.time_slice[]\n",
    "eqt.time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32804282",
   "metadata": {},
   "source": [
    "Using the `@ddtime` macro to access and modify time-dependent arrays at `dd.global_time`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81c6ac02",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd.equilibrium.vacuum_toroidal_field.b0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcb40620",
   "metadata": {},
   "source": [
    "Accessing data at `dd.global_time`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee9abd62",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_b0 = @ddtime(dd.equilibrium.vacuum_toroidal_field.b0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c70c968d",
   "metadata": {},
   "source": [
    "Writin data at `dd.global_time`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b5ce244",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "@ddtime(dd.equilibrium.vacuum_toroidal_field.b0 = my_b0 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f28d52f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd.equilibrium.vacuum_toroidal_field.b0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89db4eca",
   "metadata": {},
   "source": [
    "## Expressions in `dd`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17e903e1",
   "metadata": {},
   "source": [
    "Some fields in the data dictionary are expressions (ie. Functions).\n",
    "For example `dd.core_profiles.profiles_1d[].pressure` is dynamically calculated as the product of thermal densities and temperature with addition of fast ions contributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ac653fd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print_tree(dd.core_profiles.profiles_1d[1]; maxdepth=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3fc0883",
   "metadata": {},
   "source": [
    "accessing a dynamic expression, automatically evaluates it (in the `pressure` example, we get an array with data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0381410a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd.core_profiles.profiles_1d[1].electrons.pressure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b14e20d",
   "metadata": {},
   "source": [
    "In addition to evaluating expressions by accessing them, expressions in the tree can be evaluated using `IMAS.freeze()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d279add",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print_tree(IMAS.freeze(dd.core_profiles.profiles_1d[1]); maxdepth=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f58baf0d",
   "metadata": {},
   "source": [
    "## Whole facility design"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00e31f13",
   "metadata": {},
   "source": [
    "Here we restore the `:init` checkpoint that we had previously stored. Resetting any changes to `dd`, `ini`, and `act` that we did in the meantime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19c34507",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "@checkout :init dd ini act"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8753f1f1",
   "metadata": {},
   "source": [
    "Actors in FUSE can be executed by passing two arguments to them: `dd` and `act`.\n",
    "Internally, actors can call other actors, creating workflows.\n",
    "For example, the `ActorWholeFacility` can be used to to get a self-consistent stationary whole facility design.\n",
    "The `actors:` print statements with their nested output tell us what actors are calling other actors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95d5c319",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorWholeFacility(dd, act);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2307c45",
   "metadata": {},
   "source": [
    "Like before we can checkpoint results for later use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1cdb384",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "@checkin :awf dd ini act"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1ba74d8",
   "metadata": {},
   "source": [
    "## Running a custom workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e37520c7",
   "metadata": {},
   "source": [
    "Let's now run a series of actors similar to what `ActorWholeFacility` does\n",
    "and play around with plotting to get a sense of what each individual actor does."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d85d75b8",
   "metadata": {},
   "source": [
    "Let's start again from after the initialization stage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97b28d4f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "@checkout :init dd ini act"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "531541bd-c629-4ad4-87f5-cfc5dd48dd22",
   "metadata": {},
   "source": [
    "Let's start by positioning the PF coils, so that we stand a chance to reproduce the desired plasma shape.\n",
    "This will be important to ensure the stability of the `ActorStationaryPlasma` that we are going to run next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7f2563d-7203-4af7-83c0-5b51383f7c96",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "actor = FUSE.ActorPFdesign(dd, act);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd3d3386",
   "metadata": {},
   "source": [
    "The `ActorStationaryPlasma` iterates between plasma transport, pedestal, equilibrium and sources to return a self-consistent plasma solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "108a4d3e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "peq = plot(dd.equilibrium; label=\"before\")\n",
    "pcp = plot(dd.core_profiles; color=:gray, label=\"before\")\n",
    "FUSE.ActorStationaryPlasma(dd, act);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "009d587d",
   "metadata": {},
   "source": [
    "we can compare equilibrium before and after the self-consistency loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e78aa15b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot!(peq, dd.equilibrium; label=\"after\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f2336bc",
   "metadata": {},
   "source": [
    "we can compare core_profiles before and after the self-consistency loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "509aa9d1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot!(pcp, dd.core_profiles; label=\"after\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3a7e753",
   "metadata": {},
   "source": [
    "here are the sources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d57368d0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.core_sources)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c530c583",
   "metadata": {},
   "source": [
    "and the flux-matched transport"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8dac604",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.core_transport)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffff8599",
   "metadata": {},
   "source": [
    "HFS sizing actor changes the thickness of the OH and TF layers on the high field side to satisfy current and stresses constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6b91640",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.build)\n",
    "FUSE.ActorHFSsizing(dd, act);\n",
    "plot!(dd.build; cx=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76ac9860",
   "metadata": {},
   "source": [
    "The stresses on the center stack are stored in the `solid_mechanics` IDS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14cf9cd4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.solid_mechanics.center_stack.stress)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "077beda1",
   "metadata": {},
   "source": [
    "LFS sizing actors change location of the outer TF leg to meet ripple requirements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13cc3c0c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot(dd.build)\n",
    "FUSE.ActorLFSsizing(dd, act);\n",
    "plot!(dd.build; cx=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41ecc017",
   "metadata": {},
   "source": [
    "A custom `show()` method is defined to print the summary of `dd.build.layer`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25d56dd1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd.build.layer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "933e9dfc",
   "metadata": {},
   "source": [
    "ActorHFSsizing and ActorLFSsizing only change the layer's thicknesses, so we then need to trigger a build of the 2D cross-sections after them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6d45157",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorCXbuild(dd, act);\n",
    "plot(dd.build)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f92020f5",
   "metadata": {},
   "source": [
    "Generate passive structures information (for now the vacuum vessel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb9bd2ba",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorPassiveStructures(dd, act)\n",
    "plot(dd.pf_passive)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "970cce23",
   "metadata": {},
   "source": [
    "We can now give the PF coils their final position given the new build"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff2f41a4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "actor = FUSE.ActorPFdesign(dd, act);\n",
    "plot(actor)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48a57bf5",
   "metadata": {},
   "source": [
    "With information about both pf_active and pf_passive we can now evaluate vertical stability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6108cd23",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorVerticalStability(dd, act)\n",
    "IMAS.freeze(dd.mhd_linear)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce991a8b",
   "metadata": {},
   "source": [
    "The `ActorNeutronics` calculates the heat flux on the first wall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cfcf810",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorNeutronics(dd, act);\n",
    "p = plot(; layout=2, size=(900, 350))\n",
    "plot!(p, dd.neutronics.time_slice[].wall_loading, subplot=1)\n",
    "plot!(p, FUSE.define_neutrons(dd, 100000)[1], dd.equilibrium.time_slice[]; subplot=1, colorbar_entry=false)\n",
    "plot!(p, dd.neutronics.time_slice[].wall_loading; cx=false, subplot=2, ylabel=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eadbc151",
   "metadata": {},
   "source": [
    "The `ActorBlanket` will change the thickess of the first wall, breeder, shield, and Li6 enrichment to achieve target TBR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97ff0bc5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorBlanket(dd, act);\n",
    "print_tree(IMAS.freeze(dd.blanket); maxdepth=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fcf3826",
   "metadata": {},
   "source": [
    "The `ActorDivertors` actor calculates the divertors heat flux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87649f9d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorDivertors(dd, act);\n",
    "print_tree(IMAS.freeze(dd.divertors); maxdepth=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb9bfa55",
   "metadata": {},
   "source": [
    "The `ActorBalanceOfPlant` calculates the optimal cooling flow rates for the heat sources (breeder, divertor, and wall) and get an efficiency for the electricity conversion cycle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5ecf002",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorBalanceOfPlant(dd, act);\n",
    "IMAS.freeze(dd.balance_of_plant)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99e8fc82",
   "metadata": {},
   "source": [
    "`ActorCosting` will break down the capital and operational costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee0e2f53",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.ActorCosting(dd, act)\n",
    "plot(dd.costing)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9fbf769",
   "metadata": {},
   "source": [
    "Let's checkpoint our results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0a25792",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "@checkin :manual dd ini act"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c60964cd",
   "metadata": {},
   "source": [
    "## Saving and loading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76065bbc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tutorial_temp_dir = tempdir()\n",
    "filename = joinpath(tutorial_temp_dir, \"$(ini.general.casename).json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50c47846",
   "metadata": {},
   "source": [
    "When saving data to be shared outside of FUSE, one can set `freeze=true` so that all expressions in the dd are evaluated and saved to file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efe51cba",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "IMAS.imas2json(dd, filename; freeze=false, strict=false);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25979af8",
   "metadata": {},
   "source": [
    "Load from JSON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49dda79d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd1 = IMAS.json2imas(filename);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aa9e672",
   "metadata": {},
   "source": [
    "## Comparing two IDSs\n",
    "We can introduce a change in the `dd1` and spot it with the `diff` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbb3fb67",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dd1.equilibrium.time_slice[1].time = -100.0\n",
    "IMAS.diff(dd.equilibrium, dd1.equilibrium)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ca829bc",
   "metadata": {},
   "source": [
    "## Summary\n",
    "Snapshot of `dd` in 0D quantities (evaluated at `dd.global_time`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc34ae4a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.extract(dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef1e91d4",
   "metadata": {},
   "source": [
    "Extract + plots saved to PDF (or printed to screen it `filename` is omitted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1464cbd5-b398-4cef-845c-79d2508fff3f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "filename = joinpath(tutorial_temp_dir, \"$(ini.general.casename).pdf\")\n",
    "FUSE.digest(dd)#, filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8adcfa84-4414-4372-b8bd-8b6aae566a21",
   "metadata": {
    "tags": []
   },
   "source": [
    "## More things"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c13a874c-64cd-48f3-8aac-cd6f5e5611c8",
   "metadata": {
    "tags": []
   },
   "source": [
    "disable or enable printing of what actor is executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9451ce84-5bad-43ff-8bdb-6d52f2955b9c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FUSE.actor_logging(dd, false) # or true"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia (8 threads) 1.11.1",
   "language": "julia",
   "name": "julia-_8-threads_-1.11"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}