tutorials/12-getting-started-with-JAC.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting started with JAC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A brief note ahead to the user if you this and other tutorials as standard Jupyter notebooks (not JupyterLab):** In order improve the *appearance* of the individual cell-outputs of this and other notebooks and to better read/display the *wide tables* from the various interactive calls and computations, you can create or modify the file ~/.jupyter/custom/custom.css in your home directory and add the line: $\\quad$ div.output_area pre { font-size: 7pt;}. Overall, however, the detailed appearance of all fonts and details is not alway easy to control for plain notebooks. In **JupyterLab**, you can simple use `<ctrl> +/-` in order to enlarge/decrease the font size, and for some cell output from JAC, it is indeed advisible to do so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using Pkg; Pkg.activate(joinpath(@__DIR__, \"..\"))   # activate the JAC environment\n",
    "using JAC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Welcome to **JAC**, the **Jena Atomic Calculator**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... that provides various tools for performing atomic (structure) calculations of different kind and complexity. Apart from the computation of atomic (many-electron) amplitudes, properties and processes, **JAC supports interactive, restricted-active space (RAS) and cascade computations**. It also help perform a few simple *hydrogenic* and *semi-empirical* estimates as well as simplify symbolic expressions from Racah's algebra. --- Let's use  `? JAC` in order to obtain more information about this toolbox:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mJ\u001b[22m\u001b[0m\u001b[1mA\u001b[22m\u001b[0m\u001b[1mC\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\texttt{module JAC}       ... Jena Atomic Calculator (JAC) provides tools for performing atomic (structure) calculations at various degrees of complexity          and sophistication. It has been designed to not only calculate atomic level structures and properties [such as g-factors or         hyperfine and isotope-shift parameters] but also transition amplitudes between bound-state levels [for the anapole moment, dipole          operator, electron electric-dipole moment, parity non-conservation, etc.] and, in particular, (atomic) transition probabilities,          Auger rates, photoionization cross sections, radiative and dielectronic recombination rates as well as cross sections for many          other (elementary) processes. JAC also facilitates interactive computations, the simulation of atomic cascades, the time-evolution          of statistical tensors, a few semi-empirical estimates of atomic properties as well as the simplification of symbolic expressions         from Racah's algebra. – In addition, the JAC module supports the display of level energies, electron and photon spectra,          radial orbitals and other atomic data.\n",
       "\n",
       "\\textbf{\\texttt{Perform (atomic) computations of different complexity:}}       JAC will eventually support \\textbf{ten kinds} of computations which can be summarized as follows:\n",
       "\n",
       "\\begin{itemize}\n",
       "\\item Atomic computations, based on explicitly specified electron configurations.\n",
       "\n",
       "\n",
       "\\item Restricted active-space computations (RAS).\n",
       "\n",
       "\n",
       "\\item Interactive computations.\n",
       "\n",
       "\n",
       "\\item Atomic cascade computations (partly implemented).\n",
       "\n",
       "\n",
       "\\item Atomic representations (Green and close-coupling functions, complex rotation; partly implemented).\n",
       "\n",
       "\n",
       "\\item Atomic responses (partly implemented).\n",
       "\n",
       "\n",
       "\\item Atomic descriptors for machine learning algorithms (not yet implemented).\n",
       "\n",
       "\n",
       "\\item Time-evolution of statistical tensors in (intense) light pusles (not yet implemented).\n",
       "\n",
       "\n",
       "\\item Semi-empirical estimates of cross sections, etc. (partly implemented).\n",
       "\n",
       "\n",
       "\\item Symbolic evaluation of expressions from Racah's algebra, etc.\n",
       "\n",
       "\\end{itemize}\n",
       "\\textbf{\\texttt{Further details and information}}\n",
       "\n",
       "\\begin{verbatim}\n",
       "    + Kinds of atomic implementation                                       [cf. ? Details.kindsOfComputation]\n",
       "    + Atomic amplitudes (partly) implemented in JAC                        [cf. ? Details.amplitudes]\n",
       "    + Atomic level properties (partly) implemented in JAC                  [cf. ? Details.properties]\n",
       "    + Atomic processes (partly) implemented in JAC                         [cf. ? Details.processes]\n",
       "    + Interactive use of JAC procedures                                    [cf. ? Details.interactive]\n",
       "    + Design principles and limitations of the JAC program                 [cf. ? Details.design]\n",
       "    + Data types, structs and name conventions of the JAC module           [cf. ? Details.datatypes]\n",
       "    + Atomic cascade computations and approximations                       [cf. ? Details.decayCascades]\n",
       "    + Use of (em) light pulses in the time evolution of statist. tensors   [cf. ? Details.pulses]\n",
       "    + Why Julia ?                                                          [cf. ? Details.whyJulia]\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "`module JAC`       ... Jena Atomic Calculator (JAC) provides tools for performing atomic (structure) calculations at various degrees of complexity          and sophistication. It has been designed to not only calculate atomic level structures and properties [such as g-factors or         hyperfine and isotope-shift parameters] but also transition amplitudes between bound-state levels [for the anapole moment, dipole          operator, electron electric-dipole moment, parity non-conservation, etc.] and, in particular, (atomic) transition probabilities,          Auger rates, photoionization cross sections, radiative and dielectronic recombination rates as well as cross sections for many          other (elementary) processes. JAC also facilitates interactive computations, the simulation of atomic cascades, the time-evolution          of statistical tensors, a few semi-empirical estimates of atomic properties as well as the simplification of symbolic expressions         from Racah's algebra. – In addition, the JAC module supports the display of level energies, electron and photon spectra,          radial orbitals and other atomic data.\n",
       "\n",
       "**`Perform (atomic) computations of different complexity:`**       JAC will eventually support **ten kinds** of computations which can be summarized as follows:\n",
       "\n",
       "  * Atomic computations, based on explicitly specified electron configurations.\n",
       "  * Restricted active-space computations (RAS).\n",
       "  * Interactive computations.\n",
       "  * Atomic cascade computations (partly implemented).\n",
       "  * Atomic representations (Green and close-coupling functions, complex rotation; partly implemented).\n",
       "  * Atomic responses (partly implemented).\n",
       "  * Atomic descriptors for machine learning algorithms (not yet implemented).\n",
       "  * Time-evolution of statistical tensors in (intense) light pusles (not yet implemented).\n",
       "  * Semi-empirical estimates of cross sections, etc. (partly implemented).\n",
       "  * Symbolic evaluation of expressions from Racah's algebra, etc.\n",
       "\n",
       "**`Further details and information`**\n",
       "\n",
       "```\n",
       "    + Kinds of atomic implementation                                       [cf. ? Details.kindsOfComputation]\n",
       "    + Atomic amplitudes (partly) implemented in JAC                        [cf. ? Details.amplitudes]\n",
       "    + Atomic level properties (partly) implemented in JAC                  [cf. ? Details.properties]\n",
       "    + Atomic processes (partly) implemented in JAC                         [cf. ? Details.processes]\n",
       "    + Interactive use of JAC procedures                                    [cf. ? Details.interactive]\n",
       "    + Design principles and limitations of the JAC program                 [cf. ? Details.design]\n",
       "    + Data types, structs and name conventions of the JAC module           [cf. ? Details.datatypes]\n",
       "    + Atomic cascade computations and approximations                       [cf. ? Details.decayCascades]\n",
       "    + Use of (em) light pulses in the time evolution of statist. tensors   [cf. ? Details.pulses]\n",
       "    + Why Julia ?                                                          [cf. ? Details.whyJulia]\n",
       "```\n"
      ],
      "text/plain": [
       "  \u001b[36mmodule JAC\u001b[39m ... Jena Atomic Calculator (JAC) provides tools for performing\n",
       "  atomic (structure) calculations at various degrees of complexity and\n",
       "  sophistication. It has been designed to not only calculate atomic level\n",
       "  structures and properties [such as g-factors or hyperfine and isotope-shift\n",
       "  parameters] but also transition amplitudes between bound-state levels [for\n",
       "  the anapole moment, dipole operator, electron electric-dipole moment, parity\n",
       "  non-conservation, etc.] and, in particular, (atomic) transition\n",
       "  probabilities, Auger rates, photoionization cross sections, radiative and\n",
       "  dielectronic recombination rates as well as cross sections for many other\n",
       "  (elementary) processes. JAC also facilitates interactive computations, the\n",
       "  simulation of atomic cascades, the time-evolution of statistical tensors, a\n",
       "  few semi-empirical estimates of atomic properties as well as the\n",
       "  simplification of symbolic expressions from Racah's algebra. – In addition,\n",
       "  the JAC module supports the display of level energies, electron and photon\n",
       "  spectra, radial orbitals and other atomic data.\n",
       "\n",
       "  \u001b[1m\u001b[36mPerform (atomic) computations of different complexity:\u001b[39m\u001b[22m JAC will eventually\n",
       "  support \u001b[1mten kinds\u001b[22m of computations which can be summarized as follows:\n",
       "\n",
       "    •    Atomic computations, based on explicitly specified electron\n",
       "        configurations.\n",
       "\n",
       "    •    Restricted active-space computations (RAS).\n",
       "\n",
       "    •    Interactive computations.\n",
       "\n",
       "    •    Atomic cascade computations (partly implemented).\n",
       "\n",
       "    •    Atomic representations (Green and close-coupling functions,\n",
       "        complex rotation; partly implemented).\n",
       "\n",
       "    •    Atomic responses (partly implemented).\n",
       "\n",
       "    •    Atomic descriptors for machine learning algorithms (not yet\n",
       "        implemented).\n",
       "\n",
       "    •    Time-evolution of statistical tensors in (intense) light pusles\n",
       "        (not yet implemented).\n",
       "\n",
       "    •    Semi-empirical estimates of cross sections, etc. (partly\n",
       "        implemented).\n",
       "\n",
       "    •    Symbolic evaluation of expressions from Racah's algebra, etc.\n",
       "\n",
       "  \u001b[1m\u001b[36mFurther details and information\u001b[39m\u001b[22m\n",
       "\n",
       "\u001b[36m      + Kinds of atomic implementation                                       [cf. ? Details.kindsOfComputation]\u001b[39m\n",
       "\u001b[36m      + Atomic amplitudes (partly) implemented in JAC                        [cf. ? Details.amplitudes]\u001b[39m\n",
       "\u001b[36m      + Atomic level properties (partly) implemented in JAC                  [cf. ? Details.properties]\u001b[39m\n",
       "\u001b[36m      + Atomic processes (partly) implemented in JAC                         [cf. ? Details.processes]\u001b[39m\n",
       "\u001b[36m      + Interactive use of JAC procedures                                    [cf. ? Details.interactive]\u001b[39m\n",
       "\u001b[36m      + Design principles and limitations of the JAC program                 [cf. ? Details.design]\u001b[39m\n",
       "\u001b[36m      + Data types, structs and name conventions of the JAC module           [cf. ? Details.datatypes]\u001b[39m\n",
       "\u001b[36m      + Atomic cascade computations and approximations                       [cf. ? Details.decayCascades]\u001b[39m\n",
       "\u001b[36m      + Use of (em) light pulses in the time evolution of statist. tensors   [cf. ? Details.pulses]\u001b[39m\n",
       "\u001b[36m      + Why Julia ?                                                          [cf. ? Details.whyJulia]\u001b[39m"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? JAC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "H'm, this tells us a lot of details which we still need to better understand. To quickly list the atomic properties, that have been (partly) considered in JAC, we can use `? Details.properties`   or some other of the listed calls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\textbf{\\texttt{Atomic properties}}\n",
       "\n",
       "Apart from approximate level energies and eigenvectors, JAC (will) support the computation of the following level properties:\n",
       "\n",
       "\\begin{itemize}\n",
       "\\item AlphaX        ... alpha variations; differential sensitivity parameters.\n",
       "\n",
       "\n",
       "\\item Einstein      ... Einstein A, B coefficients and oscillator strength; although these coefficients are not an                    original level property, the Einstein module treats these computations within a single                    basis/multiplet and, hence, cannot include relaxation effects, etc. The Einstein                    feature of JAC can be used, however, for a quick overview to transition probabilities                    or in order to simplify cascade computations.\n",
       "\n",
       "\n",
       "\\item FormF         ... Standard and modified atomic form factors.\n",
       "\n",
       "\n",
       "\\item Greens        ... Greens function of an atomic level.\n",
       "\n",
       "\n",
       "\\item HFS           ... Hyperfine A and B parameters.\n",
       "\n",
       "\n",
       "\\item Isotope       ... Isotope shift M and F parameters.\n",
       "\n",
       "\n",
       "\\item LandeJ        ... Lande g\\_J factors.\n",
       "\n",
       "\n",
       "\\item LandeF        ... Lande g\\_F factors.\n",
       "\n",
       "\n",
       "\\item Polarity      ... Static and dynamic polarizibilities of atomic levels.\n",
       "\n",
       "\n",
       "\\item Plasma        ... CI computations including interactions from various plasma models.\n",
       "\n",
       "\n",
       "\\item Yields        ... Fluoerescence and Auger yields of atomic levels.\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "**`Atomic properties`**\n",
       "\n",
       "Apart from approximate level energies and eigenvectors, JAC (will) support the computation of the following level properties:\n",
       "\n",
       "  * AlphaX        ... alpha variations; differential sensitivity parameters.\n",
       "  * Einstein      ... Einstein A, B coefficients and oscillator strength; although these coefficients are not an                    original level property, the Einstein module treats these computations within a single                    basis/multiplet and, hence, cannot include relaxation effects, etc. The Einstein                    feature of JAC can be used, however, for a quick overview to transition probabilities                    or in order to simplify cascade computations.\n",
       "  * FormF         ... Standard and modified atomic form factors.\n",
       "  * Greens        ... Greens function of an atomic level.\n",
       "  * HFS           ... Hyperfine A and B parameters.\n",
       "  * Isotope       ... Isotope shift M and F parameters.\n",
       "  * LandeJ        ... Lande g_J factors.\n",
       "  * LandeF        ... Lande g_F factors.\n",
       "  * Polarity      ... Static and dynamic polarizibilities of atomic levels.\n",
       "  * Plasma        ... CI computations including interactions from various plasma models.\n",
       "  * Yields        ... Fluoerescence and Auger yields of atomic levels.\n"
      ],
      "text/plain": [
       "  \u001b[1m\u001b[36mAtomic properties\u001b[39m\u001b[22m\n",
       "\n",
       "  Apart from approximate level energies and eigenvectors, JAC (will) support\n",
       "  the computation of the following level properties:\n",
       "\n",
       "    •    AlphaX ... alpha variations; differential sensitivity parameters.\n",
       "\n",
       "    •    Einstein ... Einstein A, B coefficients and oscillator strength;\n",
       "        although these coefficients are not an original level property,\n",
       "        the Einstein module treats these computations within a single\n",
       "        basis/multiplet and, hence, cannot include relaxation effects,\n",
       "        etc. The Einstein feature of JAC can be used, however, for a quick\n",
       "        overview to transition probabilities or in order to simplify\n",
       "        cascade computations.\n",
       "\n",
       "    •    FormF ... Standard and modified atomic form factors.\n",
       "\n",
       "    •    Greens ... Greens function of an atomic level.\n",
       "\n",
       "    •    HFS ... Hyperfine A and B parameters.\n",
       "\n",
       "    •    Isotope ... Isotope shift M and F parameters.\n",
       "\n",
       "    •    LandeJ ... Lande g_J factors.\n",
       "\n",
       "    •    LandeF ... Lande g_F factors.\n",
       "\n",
       "    •    Polarity ... Static and dynamic polarizibilities of atomic levels.\n",
       "\n",
       "    •    Plasma ... CI computations including interactions from various\n",
       "        plasma models.\n",
       "\n",
       "    •    Yields ... Fluoerescence and Auger yields of atomic levels."
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Details.properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the design of JAC, we first of all **aim for a precise language** that (i) is simple enough for both, seldom and a more frequent use of this package, (ii) highlights the underlying physics and (iii) avoids most technical slang that is often unnecessary but quite common to many other codes. An intuitive picture about the level or hyperfine structure of an atom, its properties as well as possible excitation and/or decay processes should (always) come first in order to generate the desired data: By making use of suitable data types (`struct`), **we indeed wish to introduce a language close to the underlying formalism.** --- While JAC is overall based on a rather large number $(> 300)$ of such types, a few simple examples are:\n",
    "\n",
    "  + (atomic) `Shell`:                 $\\quad$1s, 2s, 2p, ...\n",
    "  + `Subshell`:                       $\\quad$1s_1/2, 2s_1/2, 2p_1/2, 2p_3/2, ...\n",
    "  + (electron) `Configuration`:       $\\quad$1s^2 2s^2 2p^6 3s $\\quad$  or $\\quad$  [Ne] 3s, ...\n",
    "  + `Level`:                          $\\quad$1s^2 2s^2  ^1S_0, ...\n",
    "  \n",
    "and many other terms (types) that we shall explain later.  \n",
    "\n",
    "\n",
    "Let us simply start, for instance, with specifying and assigning the $1s$ and $2p$ shells:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2p"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w1s = Shell(\"1s\")\n",
    "w2p = Shell(\"2p\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can readily specify and assign any (relativistic) subshell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2p_1/2, 2p_3/2)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Subshell(\"2p_1/2\"),   Subshell(\"2p_3/2\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In JAC, we make use of these `Shell`'s and `Subshell`'s whenever they will naturally occur in describing the level structure or the excitation, decay or occupation of an atom, and this both at input and output. If you have *forgotten* how to specify such a subshell (constructor), simply *ask*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mS\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mb\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mh\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1ml\u001b[22m\u001b[0m\u001b[1ml\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\texttt{struct  Basics.Subshell}  ... defines a type for the allowed values of a relativistic subhell.  \n",
       "\n",
       "\\begin{verbatim}\n",
       "+ n        ::Int64  ... principal quantum number \n",
       "+ kappa    ::Int64  ... relativistic angular quantum number\n",
       "\\end{verbatim}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\texttt{Basics.Subshell(sa::String)}  ... constructor for a given String, such as 1s\\emph{1/2, 2s}1/2, 2p\\_3/2, ... .\n",
       "\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\texttt{AngularCoefficientsRatip2013.Subshell(nk::Fnkappa)}       ... constructor to define a Subshell (instance) from the quantum numbers n, kappa.\n",
       "\n"
      ],
      "text/markdown": [
       "`struct  Basics.Subshell`  ... defines a type for the allowed values of a relativistic subhell.  \n",
       "\n",
       "```\n",
       "+ n        ::Int64  ... principal quantum number \n",
       "+ kappa    ::Int64  ... relativistic angular quantum number\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "`Basics.Subshell(sa::String)`  ... constructor for a given String, such as 1s*1/2, 2s*1/2, 2p_3/2, ... .\n",
       "\n",
       "---\n",
       "\n",
       "`AngularCoefficientsRatip2013.Subshell(nk::Fnkappa)`       ... constructor to define a Subshell (instance) from the quantum numbers n, kappa.\n"
      ],
      "text/plain": [
       "  \u001b[36mstruct  Basics.Subshell\u001b[39m ... defines a type for the allowed values of a\n",
       "  relativistic subhell. \n",
       "\n",
       "\u001b[36m  + n        ::Int64  ... principal quantum number \u001b[39m\n",
       "\u001b[36m  + kappa    ::Int64  ... relativistic angular quantum number\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "  \u001b[36mBasics.Subshell(sa::String)\u001b[39m ... constructor for a given String, such as\n",
       "  1s\u001b[4m1/2, 2s\u001b[24m1/2, 2p_3/2, ... .\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "  \u001b[36mAngularCoefficientsRatip2013.Subshell(nk::Fnkappa)\u001b[39m ... constructor to define\n",
       "  a Subshell (instance) from the quantum numbers n, kappa."
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Subshell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, we can interactively also specify any electron configuration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mC\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mg\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m \u001b[0m\u001b[1mC\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mg\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22mR Abstra\u001b[0m\u001b[1mc\u001b[22mtC\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mg\u001b[22m\u001b[0m\u001b[1mu\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22mRestriction\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\texttt{struct  ManyElectron.Configuration}       ... defines a struct for a non-relativistic electron configuration that is fully speficied by its shell notations          (such as \"1s\", \"2s\", \"2p\", ....) and the corresponding occupation numbers (>= 0). An electron configuration          is independent of any order of the shells, and a zero occupation is assumed for all shells that do not appear as a          key in the shell (dictionary). Therefore, the number of keys do not allow any conclusion about the underlying orbital          space of any considered computation that include more than just a single configuration.\n",
       "\n",
       "\\begin{verbatim}\n",
       "+ shells         ::Dict{Shell,Int64}   ... Dictionary that maps shells to their occupation.\n",
       "+ NoElectrons    ::Int64               ... No. of electrons.\n",
       "\\end{verbatim}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\texttt{ManyElectron.Configuration(sa::String)}       ... constructor for a given configuration string, such as \"[He]\", \"[Ne]\", \"[Ne] 3s 3p\\^{}6\"  or \"1s 2p\\^{}6 3s\\^{}2 3p\".\n",
       "\n"
      ],
      "text/markdown": [
       "`struct  ManyElectron.Configuration`       ... defines a struct for a non-relativistic electron configuration that is fully speficied by its shell notations          (such as \"1s\", \"2s\", \"2p\", ....) and the corresponding occupation numbers (>= 0). An electron configuration          is independent of any order of the shells, and a zero occupation is assumed for all shells that do not appear as a          key in the shell (dictionary). Therefore, the number of keys do not allow any conclusion about the underlying orbital          space of any considered computation that include more than just a single configuration.\n",
       "\n",
       "```\n",
       "+ shells         ::Dict{Shell,Int64}   ... Dictionary that maps shells to their occupation.\n",
       "+ NoElectrons    ::Int64               ... No. of electrons.\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "`ManyElectron.Configuration(sa::String)`       ... constructor for a given configuration string, such as \"[He]\", \"[Ne]\", \"[Ne] 3s 3p^6\"  or \"1s 2p^6 3s^2 3p\".\n"
      ],
      "text/plain": [
       "  \u001b[36mstruct  ManyElectron.Configuration\u001b[39m ... defines a struct for a\n",
       "  non-relativistic electron configuration that is fully speficied by its shell\n",
       "  notations (such as \"1s\", \"2s\", \"2p\", ....) and the corresponding occupation\n",
       "  numbers (>= 0). An electron configuration is independent of any order of the\n",
       "  shells, and a zero occupation is assumed for all shells that do not appear\n",
       "  as a key in the shell (dictionary). Therefore, the number of keys do not\n",
       "  allow any conclusion about the underlying orbital space of any considered\n",
       "  computation that include more than just a single configuration.\n",
       "\n",
       "\u001b[36m  + shells         ::Dict{Shell,Int64}   ... Dictionary that maps shells to their occupation.\u001b[39m\n",
       "\u001b[36m  + NoElectrons    ::Int64               ... No. of electrons.\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "  \u001b[36mManyElectron.Configuration(sa::String)\u001b[39m ... constructor for a given\n",
       "  configuration string, such as \"[He]\", \"[Ne]\", \"[Ne] 3s 3p^6\" or \"1s 2p^6\n",
       "  3s^2 3p\"."
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Configuration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Configuration: 1s^2 2s^2 2p^6 3s^2 3p^6 3d^5 4s^2 "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wc1 = Configuration(\"1s^2 2s^2 2p^5\")\n",
    "wc2 = Configuration(\"[Ar] 4s^2 3d^5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This input just shows three (very) simple examples and how how the details of some computation can be readily specified in line with our basic understanding of the atomic shell model. One can use  `? Details.datatypes`  in order to see a more complete list of most data structures that are speficic to the JAC module ... and which will give you a very **first impression about the size of the JAC program**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\textbf{\\texttt{Data types, structs and name conventions of the JAC module}}\n",
       "\n",
       "The use of a proper terminology and data structures has been found essential for developing the JAC module. Below, we list and briefly explain these data types and how they appear in atomic theory. Although we presently support just a (small) number of frequently requested \\emph{tasks} in  atomic structure and collision theory, we tried to define data types that are flexible enough to further extend these tools in the future. Following the Julia's standard conventions, all types (struct) are named in CamelCase notation.\n",
       "\n",
       "\\subsubsection{\\texttt{Abstract data types}}\n",
       "\\begin{itemize}\n",
       "\\item AbstractExcitationScheme     ... supports the selection of various (singleton) excitation schemes.\n",
       "\n",
       "\n",
       "\\item AbstractQedModel             ... supports the selection of various (singleton) QED models.\n",
       "\n",
       "\\end{itemize}\n",
       "\\subsubsection{\\texttt{Basic data types}}\n",
       "\\begin{itemize}\n",
       "\\item AngularJ64                   ... (positive, half-integer) angular momentum, j = 0, 1/2, 1, 3/2, ... .\n",
       "\n",
       "\n",
       "\\item AngularM64                   ... (half-integer) projection of ang. momentum, m = -1/2, 0, 1/2, ... can be initialized also                                   w.r.t AngularJ64().\n",
       "\n",
       "\n",
       "\\item CartesianVector              ... Cartesian vector of given type.\n",
       "\n",
       "\n",
       "\\item ContinuumNormalization       ... method for dealing with the normalization of continuum orbitals.\n",
       "\n",
       "\n",
       "\\item ContinuumPhase               ... method for determining the phase of continuum orbitals.\n",
       "\n",
       "\n",
       "\\item ContinuumSolutions           ... method for solving continuum orbitals.\n",
       "\n",
       "\n",
       "\\item Eigen                        ... represents eigenvalues and eigenvectors if different diagonalization procedures are used.\n",
       "\n",
       "\n",
       "\\item EmMultipole                  ... a multipole of the em field.\n",
       "\n",
       "\n",
       "\\item EmGauge                      ... an allowed gauge form for the em field, for instance, Coulomb, Babushkin, Magnetic, ...\n",
       "\n",
       "\n",
       "\\item EmProperty                   ... a given property in Coulomb (velocity) as well as Babushkin (length) gauge.\n",
       "\n",
       "\n",
       "\\item EmStokes                     ... (computed) Stokes parameter for the polarization of emitted radiation.\n",
       "\n",
       "\n",
       "\\item ExpStokes                    ... (experimentally) given Stokes parameter for the polarization of incoming radiation.\n",
       "\n",
       "\n",
       "\\item Guint                        ... specifier for dealing with graphical user interfaces (GUI).\n",
       "\n",
       "\n",
       "\\item LevelKey                     ... data type for identifying a level by its symmetry, energy, etc.\n",
       "\n",
       "\n",
       "\\item LevelSymmetry                ... total level symmetry (J, parity).\n",
       "\n",
       "\n",
       "\\item LineKey                      ..  data type for identifying a line by the keys of the initial and final level, ...\n",
       "\n",
       "\n",
       "\\item Model                        ... to keep the all nuclear parameters.\n",
       "\n",
       "\n",
       "\\item Parity                       ... standard parity values\n",
       "\n",
       "\n",
       "\\item Shell                        ... a non-relativistic shell.\n",
       "\n",
       "\n",
       "\\item SolidAngle`                  ... defines a type for a solid angle Omega = (theta, phi).\n",
       "\n",
       "\n",
       "\\item Subshell                     ... a relativistic subshell.\n",
       "\n",
       "\n",
       "\\item SubshellStateR               ... a relativistic antisymmetric subshell state within the seniority scheme.\n",
       "\n",
       "\n",
       "\\item TensorComp                   ... component of the statistical tensor as associated with an atomic level. \n",
       "\n",
       "\n",
       "\\item UseGauge                     ... an allowed gauge form requested for explicit computations: UseCoulomb or UseBabushkin.\n",
       "\n",
       "\n",
       "\\item Warnings                     ... for dealing with warnings that are made during a run or REPL session.\n",
       "\n",
       "\n",
       "\\item WeightedCartesian            ... Cartesian vector with weight factor of given type.\n",
       "\n",
       "\\end{itemize}\n",
       "\\subsubsection{\\texttt{Data types from many-electron theory}}\n",
       "\\begin{itemize}\n",
       "\\item AsfSettings                  ... settings for SCF and CI computations.\n",
       "\n",
       "\n",
       "\\item Atomic.Computation           ... atomic computation of a multiplet, including the SCF, CI and transition properties.\n",
       "\n",
       "\n",
       "\\item Basis                        ... (relativistic) atomic basis, including the configuration space and radial orbitals.\n",
       "\n",
       "\n",
       "\\item Bspline                      ... set of B-splines.\n",
       "\n",
       "\n",
       "\\item Configuration                ... (non-relativistic) electron configuration as specified by its shells and their occupation.\n",
       "\n",
       "\n",
       "\\item ConfigurationR               ... (relativistic) electron configuration as specified by its subshells and their occupation.\n",
       "\n",
       "\n",
       "\\item Level                        ... atomic level in terms of its quantum number, energy and a (possible) representation.\n",
       "\n",
       "\n",
       "\\item Multiplet                    ... an ordered list of atomic levels with a name.\n",
       "\n",
       "\n",
       "\\item Orbital                      ... (relativistic) radial orbital function that appears as 'building block' to define many-electron                                    states; more often than not, it just occurs as radial orbital on a given (radial) grid while the                                    angular dependence is given by the subshell label.\n",
       "\n",
       "\n",
       "\\item QedPetersburg                ... singleton data type for selecting QED calculations a la St. Petersburg.\n",
       "\n",
       "\n",
       "\\item QedSydney                    ... singleton data type for selecting QED calculations a la Sydney.\n",
       "\n",
       "\n",
       "\\item NoneQed                      ... singleton data type if no QED corrections are to be calculated.                 \n",
       "\n",
       "\n",
       "\\item Radial.Grid                  ... radial grid to represent the (radial) orbitals.\n",
       "\n",
       "\n",
       "\\item Radial.Potential             ... radial potential function.\n",
       "\n",
       "\n",
       "\\item Radial.Primitives            ... a list of radial functions, that may serve as a set of primitives in SCF computations, together                                    with several parameters for its definition.\n",
       "\n",
       "\n",
       "\\item Radial.SingleSymOrbitals     ... a list of radial orbitals with large and small component but of the same symmetry (kappa); such a                                    list may serves as (complete) single-electron basis to deal with second- and higher-order processes.\n",
       "\n",
       "\\end{itemize}\n",
       "\\subsubsection{\\texttt{Data types calculating level properties}}\n",
       "\\begin{itemize}\n",
       "\\item AbstractLevelProperty        ... an atomic level property that is supported by the JAC module, such as HFS, IsotopeShift, ....\n",
       "\n",
       "\n",
       "\\item Einstein.Settings            ... settings for Einstein A and B coefficients, calculated within a single given Multiplet.\n",
       "\n",
       "\n",
       "\\item Einstein.Outcome             ... (results of the) Einstein A and B coefficients for a single line.\n",
       "\n",
       "\n",
       "\\item Hfs.Settings                 ... settings for HFS A and B coefficients.\n",
       "\n",
       "\n",
       "\\item Hfs.Outcome                  ... (results of the) HFS A and B coefficients for a single level.\n",
       "\n",
       "\n",
       "\\item IsotopeShift.Outcome         ... (results of the) M and F isotope-shift parameters for a single level.\n",
       "\n",
       "\n",
       "\\item IsotopeShift.Settings        ... settings for the M and F isotope-shift parameters.\n",
       "\n",
       "\n",
       "\\item LandeZeeman.sublevelJ        ... specifies a magnetic sublevel with well-defined J.\n",
       "\n",
       "\n",
       "\\item LandeZeeman.sublevelF        ... specifies a magnetic hyperfine sublevel with well-defined F, M\\_f.\n",
       "\n",
       "\n",
       "\\item LandeZeeman.Outcome          ... (results of the) Lande factors and Zeeman splittings for a single level.\n",
       "\n",
       "\n",
       "\\item LandeZeeman.Settings         ... settings for the Lande factors and Zeeman splitting in an external magnetic field.\n",
       "\n",
       "\n",
       "\\item PlasmaShift.PlasmaModel      ... Model for dealing with the plasma environment.\n",
       "\n",
       "\n",
       "\\item PlasmaShift.Outcome          ... (results of the) plasma shifts and energies for a single level.\n",
       "\n",
       "\n",
       "\\item PlasmaShift.Settings         ... settings for including plasma interactions into the CI matrix.\n",
       "\n",
       "\\end{itemize}\n",
       "\\subsubsection{\\texttt{Data types for calculating (time-independent) atomic processes}}\n",
       "\\begin{itemize}\n",
       "\\item AtomicProcess                     ... an atomic process that is supported by the JAC module, such as Auger, photo, ....\n",
       "\n",
       "\n",
       "\\item AlphaVariation.Outcome            ... outcome of a alpha-variation computation, such as the K enhancement.\n",
       "\n",
       "\n",
       "\\item AlphaVariation.Settings           ... seetings for computing alpha variation parameters.\n",
       "\n",
       "\n",
       "\\item Auger.Channel                     ... Auger channel of well-defined energy and partial outgoing wave.\n",
       "\n",
       "\n",
       "\\item Auger.Line                        ... Auger line between (two) specified initial- and final-state levels and with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item Auger.Settings                    ... settings for computing Auger lines.\n",
       "\n",
       "\n",
       "\\item CoulombExcitation.Channel         ... Coulomb excitation channel of well-defined energy and partial wave.\n",
       "\n",
       "\n",
       "\\item CoulombExcitation.Line            ... Coulomb excitation line with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item CoulombExcitation.Settings        ... settings for computing Coulomb excitation  lines.\n",
       "\n",
       "\n",
       "\\item CoulombIonization.Channel         ... Coulomb ionization channel of well-defined energy and partial wave.\n",
       "\n",
       "\n",
       "\\item CoulombIonization.Line            ... Coulomb ionization line with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item CoulombIonization.Settings        ... settings for computing Coulomb ionization  lines.\n",
       "\n",
       "\n",
       "\\item Dielectronic.Channel              ... dielectronic-recombination channel of well-defined multipolarity and gauge as well as energy and                                        partial incoming wave.\n",
       "\n",
       "\n",
       "\\item Dielectronic.Line                 ... dielectronic recombination line between (three) specified initial-, intermediate and final-state                                        levels and with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item Dielectronic.Resonance            ... single dielectronic resonance that summarizes all Dielectronic.Line's for some fixed intermediate                                       level within the continuum. \n",
       "\n",
       "\n",
       "\\item Dielectronic.Settings             ... settings for computing dielectronic recombination lines.\n",
       "\n",
       "\n",
       "\\item DecayYield.Outcome                ... outcome of a decay yield computation.\n",
       "\n",
       "\n",
       "\\item DecayYield.Settings               ... settings for computing decay yields lines.\n",
       "\n",
       "\n",
       "\\item DoubleAuger.Channel               ... DoubleAuger channel of two partial outgoing waves with well-defined energy.\n",
       "\n",
       "\n",
       "\\item DoubleAuger.Line                  ... DoubleAuger line between (two) specified initial- and final-state levels and with (possible)                                        subchannels.\n",
       "\n",
       "\n",
       "\\item DoubleAuger.Settings              ... settings for computing DoubleAuger lines.\n",
       "\n",
       "\n",
       "\\item ImpactExcitation.Channel          ... electron-impact excitation channel of well-defined energies. partial waves and phases of the                                        incoming and outgoing electrons.\n",
       "\n",
       "\n",
       "\\item ImpactExcitation.Line             ... electron-impact excitation line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item ImpactExcitation.Settings         ... settings for computing electron-impact excitation lines.\n",
       "\n",
       "\n",
       "\\item ImpactExcitationAutoion.Channel   ... electron-impact excitation channel of well-defined energies, partial waves and phases of the                                        incoming and outgoing electrons.\n",
       "\n",
       "\n",
       "\\item ImpactExcitationAutoion.Pathway   ... electron-impact excitation line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item ImpactExcitationAutoion.Settings  ... settings for computing electron-impact excitation lines.\n",
       "\n",
       "\n",
       "\\item ImpactIonization.Channel          ... electron-impact ionization channel of well-defined energies, partial waves and phases of the                                        incoming and outgoing electrons.\n",
       "\n",
       "\n",
       "\\item ImpactIonization.Line             ... electron-impact ionization line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item ImpactIonization.Settings         ... settings for computing electron-impact ionization lines.\n",
       "\n",
       "\n",
       "\\item MultiPhotonDeExcitation.Channel   ... multi-photon excitation or decay channel with well-defined multipolarities and gauge.\n",
       "\n",
       "\n",
       "\\item MultiPhotonDeExcitation.Line      ... multi-photon excitation or decay line between (two) specified initial- and final-state levels                                        and with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item MultiPhotonDeExcitation.Settings  ... settings for computing multi-photon excitation or decay lines.\n",
       "\n",
       "\n",
       "\\item MultiPhotonIonization.Channel     ... multi-photon ionization channel with well-defined multipolarities, gauge as well as energy and                                        partial wave of the outgoing electron.\n",
       "\n",
       "\n",
       "\\item MultiPhotonIonization.Line        ... multi-photon ionization line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item MultiPhotonIonization.Settings    ... settings for computing multi-photon ionization lines.\n",
       "\n",
       "\n",
       "\\item MultiPhotonDoubleIon.Channel      ... multi-photon double ionization channel with well-defined multipolarities, gauge as well as energy                                       and partial waves of the (two) outgoing electrons.\n",
       "\n",
       "\n",
       "\\item MultiPhotonDoubleIon.Line         ... multi-photon double ionization line between (two) specified initial- and final-state levels and                                        with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item MultiPhotonDoubleIon.Settings     ... settings for computing multi-photon double ionization lines.\n",
       "\n",
       "\n",
       "\\item PairAnnihilation1Photon.Channel   ... positron-bound-electron pair annihilation (PEPA) with single-photon emission channel of                                        well-defined multipolarity, gauge as well as energy and partial incoming (positron) wave.\n",
       "\n",
       "\n",
       "\\item PairAnnihilation1Photon.Line      ... PEPA with single-photon emission line between (two) specified initial- and final-state levels and                                        with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item PairAnnihilation1Photon.Settings  ... settings for computing PEPA with single-photon emission lines.\n",
       "\n",
       "\n",
       "\\item PairAnnihilation2Photon.Channel   ... positron-bound-electron pair annihilation (PEPA) with two-photon emission channel of well-defined                                        multipolarities, gauge as well as energy and partial incoming (positron) wave.\n",
       "\n",
       "\n",
       "\\item PairAnnihilation2Photon.Line      ... PEPA with two-photon emission line between (two) specified initial- and final-state levels and                                        with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item PairAnnihilation2Photon.Settings  ... settings for computing PEPA with two-photon emission lines.\n",
       "\n",
       "\n",
       "\\item PairProduction.Channel            ... positron-bound-electron pair production (PEPP) by single-photon absorption channel of well-defined                                        multipolarity, gauge as well as energy and partial outgoing (positron) wave.\n",
       "\n",
       "\n",
       "\\item PairProduction.Line               ... PEPP by single-photon absorption line between (two) specified initial- and final-state levels and                                        with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item PairProduction.Settings           ... settings for computing PEPP lines.\n",
       "\n",
       "\n",
       "\\item PhotoExcitation.Line              ... photoexcitation line between (two) specified initial- and final- state levels and with (possible                                       JAC.PhotoEmission.Channel) subchannels.\n",
       "\n",
       "\n",
       "\\item PhotoExcitation.Settings          ... settings for computing photoexcitation lines.\n",
       "\n",
       "\n",
       "\\item PhotoExcitationAutoion.Channel    ... photo-excitation autoionization channel of well-defined energies of the incoming photon as well as                                        the partial wave and phase of the outgoing electron.\n",
       "\n",
       "\n",
       "\\item PhotoExcitationAutoion.Pathway    ... photo-excitation autoionization pathways between (three) specified initial-, intermediate and                                        final-state levels and with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item PhotoExcitationAutoion.Settings   ... settings for computing photo-excitation autoionization pathways.\n",
       "\n",
       "\n",
       "\\item PhotoIonization.Channel           ... photoionization channel of well-defined multipolarity, gauge as well as energy and partial                                        outgoing wave.\n",
       "\n",
       "\n",
       "\\item PhotoIonization.Line              ... photoionization line between (two) specified initial- and final-state levels and with (possible)                                        subchannels.\n",
       "\n",
       "\n",
       "\\item PhotoIonization.Settings          ... settings for computing photoionization lines.\n",
       "\n",
       "\n",
       "\\item PhotoRecombination.Channel        ... Rec channel of well-defined multipolarity and gauge as well as energy and partial incoming wave.\n",
       "\n",
       "\n",
       "\\item PhotoRecombination.Line           ... radiative electron capture line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item PhotoRecombination.Settings       ... settings for computing radiative electron capture lines.\n",
       "\n",
       "\n",
       "\\item PhotoEmission.Channel                 ... radiative channel of well-defined multipolarity and gauge.\n",
       "\n",
       "\n",
       "\\item PhotoEmission.Line                    ... radiative line between (two) specified initial- and final-state levels and with (possible) sublines.\n",
       "\n",
       "\n",
       "\\item PhotoEmission.Settings                ... settings for computing radiative lines.\n",
       "\n",
       "\n",
       "\\item RadiativeAuger.Channel            ... RadiativeAuger channel of a partial outgoing waves and one photon with well-defined energy.\n",
       "\n",
       "\n",
       "\\item RadiativeAuger.Line               ... RadiativeAuger line between (two) specified initial- and final-state levels and with (possible)                                        subchannels.\n",
       "\n",
       "\n",
       "\\item RadiativeAuger.Settings           ... settings for computing RadiativeAuger lines.\n",
       "\n",
       "\n",
       "\\item Radiative.Settings                ... settings for computing radiative lines.\n",
       "\n",
       "\n",
       "\\item RayleighCompton.Channel           ... RayleighCompton channel of an incoming and outgoing photon with well-defined energy.\n",
       "\n",
       "\n",
       "\\item RayleighCompton.Line              ... RayleighCompton line between (two) specified initial- and final-state levels and with (possible)                                        subchannels.\n",
       "\n",
       "\n",
       "\\item RayleighCompton.Settings          ... settings for computing RayleighCompton lines.\n",
       "\n",
       "\n",
       "\\item REDA.Channel                      ... resonant electron-excitation (sequential) double-autoionization (REDA) channel of well-defined                                        energies, partial waves and phases of the incoming and outgoing electrons.\n",
       "\n",
       "\n",
       "\\item REDA.Pathway                      ... resonant electron-excitation (sequential) double-autoionization (REDA) pathways.between (four)                                        specified initial-, (two) intrmediate and final-state levels and with (possible) subchannels.\n",
       "\n",
       "\n",
       "\\item REDA.Settings                     ... settings for computing resonant electron-excitation (sequential) double-autoionization (REDA)                                        pathways.\n",
       "\n",
       "\\end{itemize}\n",
       "\\subsubsection{\\texttt{Data types for calculating (time-dependent) atomic processes}}\n",
       "\\begin{itemize}\n",
       "\\item Pulse.Envelope                       ... defines a type for the envelope (function) of an em pulse with well-defined time delay,                                            amplitude and (normalized) shape function.\n",
       "\n",
       "\n",
       "\\item Pulse.ExperimentalCharacterization   ... to characterized an experimental or physically described em pulse in terms of its                                            propagation direction, frequency, maximum intensity, pulse length or No. of cycles, time-delay,                                            polarization, etc., i.e. of what is easily accesssible by an experiment.\n",
       "\n",
       "\n",
       "\\item Pulse.Gaussian                       ... a Gaussian light pulse that is used for evaluating time-dependent statistical tensors.\n",
       "\n",
       "\n",
       "\\item Pulse.Polarization                   ... defines the polarization of an em pulse in terms of its linear and circular degrees, the                                            direction of the polarization vector or some generalized polarization coefficients.\n",
       "\n",
       "\n",
       "\\item Pulse.PolarizationType               ... defines the polarization of an experimentally described light pulse as linear, left-circular, ..\n",
       "\n",
       "\n",
       "\\item Pulse.Shape                          ... defines a shape of a general em pulse as Gaussian, SineSquared, etc.\n",
       "\n",
       "\n",
       "\\item Pulse.SineSquared                    ... a SinSquared light pulse that is used for evaluating time-dependent statistical tensors.\n",
       "\n",
       "\\end{itemize}\n",
       "\\subsubsection{\\texttt{Data types for dealing wiht (time-dependent) statistical tensors}}\n",
       "\\begin{itemize}\n",
       "\\item Statistical.ResonanceR      ... a resonance state in the continuum with a well-defined bound-ionic core, one or several electrons                                    in the continuum, a widths as well as a loss rate due to \\emph{additional} decay processes that cannot be                                    accounted for explicitly.\n",
       "\n",
       "\n",
       "\\item Statistical.Tensor          ... represents a statistical tensor of given rank k, projection q and which generally depends upon two                                    resonances.\n",
       "\n",
       "\\end{itemize}\n",
       "\\subsubsection{\\texttt{Data types for advanced computations}}\n",
       "\\begin{itemize}\n",
       "\\item Atomic.CasComputation          ... an individual or a series of systematically enlarged SCF computations.\n",
       "\n",
       "\n",
       "\\item Atomic.CasStep                 ... single-step in an (systematically enlarged) SCF calculation.\n",
       "\n",
       "\n",
       "\\item Atomic.CasSettings             ... settings for CAS computation.\n",
       "\n",
       "\n",
       "\\item Cascade.Approach               ... a particular (computational) approach in which a cascade is considered.\n",
       "\n",
       "\n",
       "\\item Cascade.Block                  ... a block of configurations that are treatet together within a given cascade. \n",
       "\n",
       "\n",
       "\\item Cascade.Data                   ... all transition data of a cascade as given by a list of lines (of different type).\n",
       "\n",
       "\n",
       "\\item Cascade.Computation            ... definition of an atomic exciation/decay cascade from which the actual computations can be derived.\n",
       "\n",
       "\n",
       "\\item Cascade.Level (mutable)        ... defines a level specification for dealing with cascade transitions.\n",
       "\n",
       "\n",
       "\\item Cascade.LineIndex              ... defines a line index with regard to the various lineLists of data::Cascade.Data.\n",
       "\n",
       "\n",
       "\\item Cascade.Step                   ... an individual step of a Cascade.Computation that generally combines two ionization states of ions.\n",
       "\n",
       "\n",
       "\\item Cascade.Simulation             ... simulation of cascade data.\n",
       "\n",
       "\n",
       "\\item Cascade.SimulationSettings     ... defines settings for performing the simulation of some cascade (data).\n",
       "\n",
       "\n",
       "\\item Cascade.Settings               ... settings for cascade computations (not yet).\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "**`Data types, structs and name conventions of the JAC module`**\n",
       "\n",
       "The use of a proper terminology and data structures has been found essential for developing the JAC module. Below, we list and briefly explain these data types and how they appear in atomic theory. Although we presently support just a (small) number of frequently requested *tasks* in  atomic structure and collision theory, we tried to define data types that are flexible enough to further extend these tools in the future. Following the Julia's standard conventions, all types (struct) are named in CamelCase notation.\n",
       "\n",
       "### `Abstract data types`\n",
       "\n",
       "  * AbstractExcitationScheme     ... supports the selection of various (singleton) excitation schemes.\n",
       "  * AbstractQedModel             ... supports the selection of various (singleton) QED models.\n",
       "\n",
       "### `Basic data types`\n",
       "\n",
       "  * AngularJ64                   ... (positive, half-integer) angular momentum, j = 0, 1/2, 1, 3/2, ... .\n",
       "  * AngularM64                   ... (half-integer) projection of ang. momentum, m = -1/2, 0, 1/2, ... can be initialized also                                   w.r.t AngularJ64().\n",
       "  * CartesianVector              ... Cartesian vector of given type.\n",
       "  * ContinuumNormalization       ... method for dealing with the normalization of continuum orbitals.\n",
       "  * ContinuumPhase               ... method for determining the phase of continuum orbitals.\n",
       "  * ContinuumSolutions           ... method for solving continuum orbitals.\n",
       "  * Eigen                        ... represents eigenvalues and eigenvectors if different diagonalization procedures are used.\n",
       "  * EmMultipole                  ... a multipole of the em field.\n",
       "  * EmGauge                      ... an allowed gauge form for the em field, for instance, Coulomb, Babushkin, Magnetic, ...\n",
       "  * EmProperty                   ... a given property in Coulomb (velocity) as well as Babushkin (length) gauge.\n",
       "  * EmStokes                     ... (computed) Stokes parameter for the polarization of emitted radiation.\n",
       "  * ExpStokes                    ... (experimentally) given Stokes parameter for the polarization of incoming radiation.\n",
       "  * Guint                        ... specifier for dealing with graphical user interfaces (GUI).\n",
       "  * LevelKey                     ... data type for identifying a level by its symmetry, energy, etc.\n",
       "  * LevelSymmetry                ... total level symmetry (J, parity).\n",
       "  * LineKey                      ..  data type for identifying a line by the keys of the initial and final level, ...\n",
       "  * Model                        ... to keep the all nuclear parameters.\n",
       "  * Parity                       ... standard parity values\n",
       "  * Shell                        ... a non-relativistic shell.\n",
       "  * SolidAngle`                  ... defines a type for a solid angle Omega = (theta, phi).\n",
       "  * Subshell                     ... a relativistic subshell.\n",
       "  * SubshellStateR               ... a relativistic antisymmetric subshell state within the seniority scheme.\n",
       "  * TensorComp                   ... component of the statistical tensor as associated with an atomic level.\n",
       "  * UseGauge                     ... an allowed gauge form requested for explicit computations: UseCoulomb or UseBabushkin.\n",
       "  * Warnings                     ... for dealing with warnings that are made during a run or REPL session.\n",
       "  * WeightedCartesian            ... Cartesian vector with weight factor of given type.\n",
       "\n",
       "### `Data types from many-electron theory`\n",
       "\n",
       "  * AsfSettings                  ... settings for SCF and CI computations.\n",
       "  * Atomic.Computation           ... atomic computation of a multiplet, including the SCF, CI and transition properties.\n",
       "  * Basis                        ... (relativistic) atomic basis, including the configuration space and radial orbitals.\n",
       "  * Bspline                      ... set of B-splines.\n",
       "  * Configuration                ... (non-relativistic) electron configuration as specified by its shells and their occupation.\n",
       "  * ConfigurationR               ... (relativistic) electron configuration as specified by its subshells and their occupation.\n",
       "  * Level                        ... atomic level in terms of its quantum number, energy and a (possible) representation.\n",
       "  * Multiplet                    ... an ordered list of atomic levels with a name.\n",
       "  * Orbital                      ... (relativistic) radial orbital function that appears as 'building block' to define many-electron                                    states; more often than not, it just occurs as radial orbital on a given (radial) grid while the                                    angular dependence is given by the subshell label.\n",
       "  * QedPetersburg                ... singleton data type for selecting QED calculations a la St. Petersburg.\n",
       "  * QedSydney                    ... singleton data type for selecting QED calculations a la Sydney.\n",
       "  * NoneQed                      ... singleton data type if no QED corrections are to be calculated.\n",
       "  * Radial.Grid                  ... radial grid to represent the (radial) orbitals.\n",
       "  * Radial.Potential             ... radial potential function.\n",
       "  * Radial.Primitives            ... a list of radial functions, that may serve as a set of primitives in SCF computations, together                                    with several parameters for its definition.\n",
       "  * Radial.SingleSymOrbitals     ... a list of radial orbitals with large and small component but of the same symmetry (kappa); such a                                    list may serves as (complete) single-electron basis to deal with second- and higher-order processes.\n",
       "\n",
       "### `Data types calculating level properties`\n",
       "\n",
       "  * AbstractLevelProperty        ... an atomic level property that is supported by the JAC module, such as HFS, IsotopeShift, ....\n",
       "  * Einstein.Settings            ... settings for Einstein A and B coefficients, calculated within a single given Multiplet.\n",
       "  * Einstein.Outcome             ... (results of the) Einstein A and B coefficients for a single line.\n",
       "  * Hfs.Settings                 ... settings for HFS A and B coefficients.\n",
       "  * Hfs.Outcome                  ... (results of the) HFS A and B coefficients for a single level.\n",
       "  * IsotopeShift.Outcome         ... (results of the) M and F isotope-shift parameters for a single level.\n",
       "  * IsotopeShift.Settings        ... settings for the M and F isotope-shift parameters.\n",
       "  * LandeZeeman.sublevelJ        ... specifies a magnetic sublevel with well-defined J.\n",
       "  * LandeZeeman.sublevelF        ... specifies a magnetic hyperfine sublevel with well-defined F, M_f.\n",
       "  * LandeZeeman.Outcome          ... (results of the) Lande factors and Zeeman splittings for a single level.\n",
       "  * LandeZeeman.Settings         ... settings for the Lande factors and Zeeman splitting in an external magnetic field.\n",
       "  * PlasmaShift.PlasmaModel      ... Model for dealing with the plasma environment.\n",
       "  * PlasmaShift.Outcome          ... (results of the) plasma shifts and energies for a single level.\n",
       "  * PlasmaShift.Settings         ... settings for including plasma interactions into the CI matrix.\n",
       "\n",
       "### `Data types for calculating (time-independent) atomic processes`\n",
       "\n",
       "  * AtomicProcess                     ... an atomic process that is supported by the JAC module, such as Auger, photo, ....\n",
       "  * AlphaVariation.Outcome            ... outcome of a alpha-variation computation, such as the K enhancement.\n",
       "  * AlphaVariation.Settings           ... seetings for computing alpha variation parameters.\n",
       "  * Auger.Channel                     ... Auger channel of well-defined energy and partial outgoing wave.\n",
       "  * Auger.Line                        ... Auger line between (two) specified initial- and final-state levels and with (possible) subchannels.\n",
       "  * Auger.Settings                    ... settings for computing Auger lines.\n",
       "  * CoulombExcitation.Channel         ... Coulomb excitation channel of well-defined energy and partial wave.\n",
       "  * CoulombExcitation.Line            ... Coulomb excitation line with (possible) subchannels.\n",
       "  * CoulombExcitation.Settings        ... settings for computing Coulomb excitation  lines.\n",
       "  * CoulombIonization.Channel         ... Coulomb ionization channel of well-defined energy and partial wave.\n",
       "  * CoulombIonization.Line            ... Coulomb ionization line with (possible) subchannels.\n",
       "  * CoulombIonization.Settings        ... settings for computing Coulomb ionization  lines.\n",
       "  * Dielectronic.Channel              ... dielectronic-recombination channel of well-defined multipolarity and gauge as well as energy and                                        partial incoming wave.\n",
       "  * Dielectronic.Line                 ... dielectronic recombination line between (three) specified initial-, intermediate and final-state                                        levels and with (possible) subchannels.\n",
       "  * Dielectronic.Resonance            ... single dielectronic resonance that summarizes all Dielectronic.Line's for some fixed intermediate                                       level within the continuum.\n",
       "  * Dielectronic.Settings             ... settings for computing dielectronic recombination lines.\n",
       "  * DecayYield.Outcome                ... outcome of a decay yield computation.\n",
       "  * DecayYield.Settings               ... settings for computing decay yields lines.\n",
       "  * DoubleAuger.Channel               ... DoubleAuger channel of two partial outgoing waves with well-defined energy.\n",
       "  * DoubleAuger.Line                  ... DoubleAuger line between (two) specified initial- and final-state levels and with (possible)                                        subchannels.\n",
       "  * DoubleAuger.Settings              ... settings for computing DoubleAuger lines.\n",
       "  * ImpactExcitation.Channel          ... electron-impact excitation channel of well-defined energies. partial waves and phases of the                                        incoming and outgoing electrons.\n",
       "  * ImpactExcitation.Line             ... electron-impact excitation line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "  * ImpactExcitation.Settings         ... settings for computing electron-impact excitation lines.\n",
       "  * ImpactExcitationAutoion.Channel   ... electron-impact excitation channel of well-defined energies, partial waves and phases of the                                        incoming and outgoing electrons.\n",
       "  * ImpactExcitationAutoion.Pathway   ... electron-impact excitation line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "  * ImpactExcitationAutoion.Settings  ... settings for computing electron-impact excitation lines.\n",
       "  * ImpactIonization.Channel          ... electron-impact ionization channel of well-defined energies, partial waves and phases of the                                        incoming and outgoing electrons.\n",
       "  * ImpactIonization.Line             ... electron-impact ionization line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "  * ImpactIonization.Settings         ... settings for computing electron-impact ionization lines.\n",
       "  * MultiPhotonDeExcitation.Channel   ... multi-photon excitation or decay channel with well-defined multipolarities and gauge.\n",
       "  * MultiPhotonDeExcitation.Line      ... multi-photon excitation or decay line between (two) specified initial- and final-state levels                                        and with (possible) subchannels.\n",
       "  * MultiPhotonDeExcitation.Settings  ... settings for computing multi-photon excitation or decay lines.\n",
       "  * MultiPhotonIonization.Channel     ... multi-photon ionization channel with well-defined multipolarities, gauge as well as energy and                                        partial wave of the outgoing electron.\n",
       "  * MultiPhotonIonization.Line        ... multi-photon ionization line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "  * MultiPhotonIonization.Settings    ... settings for computing multi-photon ionization lines.\n",
       "  * MultiPhotonDoubleIon.Channel      ... multi-photon double ionization channel with well-defined multipolarities, gauge as well as energy                                       and partial waves of the (two) outgoing electrons.\n",
       "  * MultiPhotonDoubleIon.Line         ... multi-photon double ionization line between (two) specified initial- and final-state levels and                                        with (possible) subchannels.\n",
       "  * MultiPhotonDoubleIon.Settings     ... settings for computing multi-photon double ionization lines.\n",
       "  * PairAnnihilation1Photon.Channel   ... positron-bound-electron pair annihilation (PEPA) with single-photon emission channel of                                        well-defined multipolarity, gauge as well as energy and partial incoming (positron) wave.\n",
       "  * PairAnnihilation1Photon.Line      ... PEPA with single-photon emission line between (two) specified initial- and final-state levels and                                        with (possible) subchannels.\n",
       "  * PairAnnihilation1Photon.Settings  ... settings for computing PEPA with single-photon emission lines.\n",
       "  * PairAnnihilation2Photon.Channel   ... positron-bound-electron pair annihilation (PEPA) with two-photon emission channel of well-defined                                        multipolarities, gauge as well as energy and partial incoming (positron) wave.\n",
       "  * PairAnnihilation2Photon.Line      ... PEPA with two-photon emission line between (two) specified initial- and final-state levels and                                        with (possible) subchannels.\n",
       "  * PairAnnihilation2Photon.Settings  ... settings for computing PEPA with two-photon emission lines.\n",
       "  * PairProduction.Channel            ... positron-bound-electron pair production (PEPP) by single-photon absorption channel of well-defined                                        multipolarity, gauge as well as energy and partial outgoing (positron) wave.\n",
       "  * PairProduction.Line               ... PEPP by single-photon absorption line between (two) specified initial- and final-state levels and                                        with (possible) subchannels.\n",
       "  * PairProduction.Settings           ... settings for computing PEPP lines.\n",
       "  * PhotoExcitation.Line              ... photoexcitation line between (two) specified initial- and final- state levels and with (possible                                       JAC.PhotoEmission.Channel) subchannels.\n",
       "  * PhotoExcitation.Settings          ... settings for computing photoexcitation lines.\n",
       "  * PhotoExcitationAutoion.Channel    ... photo-excitation autoionization channel of well-defined energies of the incoming photon as well as                                        the partial wave and phase of the outgoing electron.\n",
       "  * PhotoExcitationAutoion.Pathway    ... photo-excitation autoionization pathways between (three) specified initial-, intermediate and                                        final-state levels and with (possible) subchannels.\n",
       "  * PhotoExcitationAutoion.Settings   ... settings for computing photo-excitation autoionization pathways.\n",
       "  * PhotoIonization.Channel           ... photoionization channel of well-defined multipolarity, gauge as well as energy and partial                                        outgoing wave.\n",
       "  * PhotoIonization.Line              ... photoionization line between (two) specified initial- and final-state levels and with (possible)                                        subchannels.\n",
       "  * PhotoIonization.Settings          ... settings for computing photoionization lines.\n",
       "  * PhotoRecombination.Channel        ... Rec channel of well-defined multipolarity and gauge as well as energy and partial incoming wave.\n",
       "  * PhotoRecombination.Line           ... radiative electron capture line between (two) specified initial- and final-state levels and with                                        (possible) subchannels.\n",
       "  * PhotoRecombination.Settings       ... settings for computing radiative electron capture lines.\n",
       "  * PhotoEmission.Channel                 ... radiative channel of well-defined multipolarity and gauge.\n",
       "  * PhotoEmission.Line                    ... radiative line between (two) specified initial- and final-state levels and with (possible) sublines.\n",
       "  * PhotoEmission.Settings                ... settings for computing radiative lines.\n",
       "  * RadiativeAuger.Channel            ... RadiativeAuger channel of a partial outgoing waves and one photon with well-defined energy.\n",
       "  * RadiativeAuger.Line               ... RadiativeAuger line between (two) specified initial- and final-state levels and with (possible)                                        subchannels.\n",
       "  * RadiativeAuger.Settings           ... settings for computing RadiativeAuger lines.\n",
       "  * Radiative.Settings                ... settings for computing radiative lines.\n",
       "  * RayleighCompton.Channel           ... RayleighCompton channel of an incoming and outgoing photon with well-defined energy.\n",
       "  * RayleighCompton.Line              ... RayleighCompton line between (two) specified initial- and final-state levels and with (possible)                                        subchannels.\n",
       "  * RayleighCompton.Settings          ... settings for computing RayleighCompton lines.\n",
       "  * REDA.Channel                      ... resonant electron-excitation (sequential) double-autoionization (REDA) channel of well-defined                                        energies, partial waves and phases of the incoming and outgoing electrons.\n",
       "  * REDA.Pathway                      ... resonant electron-excitation (sequential) double-autoionization (REDA) pathways.between (four)                                        specified initial-, (two) intrmediate and final-state levels and with (possible) subchannels.\n",
       "  * REDA.Settings                     ... settings for computing resonant electron-excitation (sequential) double-autoionization (REDA)                                        pathways.\n",
       "\n",
       "### `Data types for calculating (time-dependent) atomic processes`\n",
       "\n",
       "  * Pulse.Envelope                       ... defines a type for the envelope (function) of an em pulse with well-defined time delay,                                            amplitude and (normalized) shape function.\n",
       "  * Pulse.ExperimentalCharacterization   ... to characterized an experimental or physically described em pulse in terms of its                                            propagation direction, frequency, maximum intensity, pulse length or No. of cycles, time-delay,                                            polarization, etc., i.e. of what is easily accesssible by an experiment.\n",
       "  * Pulse.Gaussian                       ... a Gaussian light pulse that is used for evaluating time-dependent statistical tensors.\n",
       "  * Pulse.Polarization                   ... defines the polarization of an em pulse in terms of its linear and circular degrees, the                                            direction of the polarization vector or some generalized polarization coefficients.\n",
       "  * Pulse.PolarizationType               ... defines the polarization of an experimentally described light pulse as linear, left-circular, ..\n",
       "  * Pulse.Shape                          ... defines a shape of a general em pulse as Gaussian, SineSquared, etc.\n",
       "  * Pulse.SineSquared                    ... a SinSquared light pulse that is used for evaluating time-dependent statistical tensors.\n",
       "\n",
       "### `Data types for dealing wiht (time-dependent) statistical tensors`\n",
       "\n",
       "  * Statistical.ResonanceR      ... a resonance state in the continuum with a well-defined bound-ionic core, one or several electrons                                    in the continuum, a widths as well as a loss rate due to *additional* decay processes that cannot be                                    accounted for explicitly.\n",
       "  * Statistical.Tensor          ... represents a statistical tensor of given rank k, projection q and which generally depends upon two                                    resonances.\n",
       "\n",
       "### `Data types for advanced computations`\n",
       "\n",
       "  * Atomic.CasComputation          ... an individual or a series of systematically enlarged SCF computations.\n",
       "  * Atomic.CasStep                 ... single-step in an (systematically enlarged) SCF calculation.\n",
       "  * Atomic.CasSettings             ... settings for CAS computation.\n",
       "  * Cascade.Approach               ... a particular (computational) approach in which a cascade is considered.\n",
       "  * Cascade.Block                  ... a block of configurations that are treatet together within a given cascade.\n",
       "  * Cascade.Data                   ... all transition data of a cascade as given by a list of lines (of different type).\n",
       "  * Cascade.Computation            ... definition of an atomic exciation/decay cascade from which the actual computations can be derived.\n",
       "  * Cascade.Level (mutable)        ... defines a level specification for dealing with cascade transitions.\n",
       "  * Cascade.LineIndex              ... defines a line index with regard to the various lineLists of data::Cascade.Data.\n",
       "  * Cascade.Step                   ... an individual step of a Cascade.Computation that generally combines two ionization states of ions.\n",
       "  * Cascade.Simulation             ... simulation of cascade data.\n",
       "  * Cascade.SimulationSettings     ... defines settings for performing the simulation of some cascade (data).\n",
       "  * Cascade.Settings               ... settings for cascade computations (not yet).\n"
      ],
      "text/plain": [
       "  \u001b[1m\u001b[36mData types, structs and name conventions of the JAC module\u001b[39m\u001b[22m\n",
       "\n",
       "  The use of a proper terminology and data structures has been found essential\n",
       "  for developing the JAC module. Below, we list and briefly explain these data\n",
       "  types and how they appear in atomic theory. Although we presently support\n",
       "  just a (small) number of frequently requested \u001b[4mtasks\u001b[24m in atomic structure and\n",
       "  collision theory, we tried to define data types that are flexible enough to\n",
       "  further extend these tools in the future. Following the Julia's standard\n",
       "  conventions, all types (struct) are named in CamelCase notation.\n",
       "\n",
       "\u001b[1m  \u001b[36mAbstract data types\u001b[39m\u001b[22m\n",
       "\u001b[1m  –––––––––––––––––––––\u001b[22m\n",
       "\n",
       "    •    AbstractExcitationScheme ... supports the selection of various\n",
       "        (singleton) excitation schemes.\n",
       "\n",
       "    •    AbstractQedModel ... supports the selection of various (singleton)\n",
       "        QED models.\n",
       "\n",
       "\u001b[1m  \u001b[36mBasic data types\u001b[39m\u001b[22m\n",
       "\u001b[1m  ––––––––––––––––––\u001b[22m\n",
       "\n",
       "    •    AngularJ64 ... (positive, half-integer) angular momentum, j = 0,\n",
       "        1/2, 1, 3/2, ... .\n",
       "\n",
       "    •    AngularM64 ... (half-integer) projection of ang. momentum, m =\n",
       "        -1/2, 0, 1/2, ... can be initialized also w.r.t AngularJ64().\n",
       "\n",
       "    •    CartesianVector ... Cartesian vector of given type.\n",
       "\n",
       "    •    ContinuumNormalization ... method for dealing with the\n",
       "        normalization of continuum orbitals.\n",
       "\n",
       "    •    ContinuumPhase ... method for determining the phase of continuum\n",
       "        orbitals.\n",
       "\n",
       "    •    ContinuumSolutions ... method for solving continuum orbitals.\n",
       "\n",
       "    •    Eigen ... represents eigenvalues and eigenvectors if different\n",
       "        diagonalization procedures are used.\n",
       "\n",
       "    •    EmMultipole ... a multipole of the em field.\n",
       "\n",
       "    •    EmGauge ... an allowed gauge form for the em field, for instance,\n",
       "        Coulomb, Babushkin, Magnetic, ...\n",
       "\n",
       "    •    EmProperty ... a given property in Coulomb (velocity) as well as\n",
       "        Babushkin (length) gauge.\n",
       "\n",
       "    •    EmStokes ... (computed) Stokes parameter for the polarization of\n",
       "        emitted radiation.\n",
       "\n",
       "    •    ExpStokes ... (experimentally) given Stokes parameter for the\n",
       "        polarization of incoming radiation.\n",
       "\n",
       "    •    Guint ... specifier for dealing with graphical user interfaces\n",
       "        (GUI).\n",
       "\n",
       "    •    LevelKey ... data type for identifying a level by its symmetry,\n",
       "        energy, etc.\n",
       "\n",
       "    •    LevelSymmetry ... total level symmetry (J, parity).\n",
       "\n",
       "    •    LineKey .. data type for identifying a line by the keys of the\n",
       "        initial and final level, ...\n",
       "\n",
       "    •    Model ... to keep the all nuclear parameters.\n",
       "\n",
       "    •    Parity ... standard parity values\n",
       "\n",
       "    •    Shell ... a non-relativistic shell.\n",
       "\n",
       "    •    SolidAngle` ... defines a type for a solid angle Omega = (theta,\n",
       "        phi).\n",
       "\n",
       "    •    Subshell ... a relativistic subshell.\n",
       "\n",
       "    •    SubshellStateR ... a relativistic antisymmetric subshell state\n",
       "        within the seniority scheme.\n",
       "\n",
       "    •    TensorComp ... component of the statistical tensor as associated\n",
       "        with an atomic level. \n",
       "\n",
       "    •    UseGauge ... an allowed gauge form requested for explicit\n",
       "        computations: UseCoulomb or UseBabushkin.\n",
       "\n",
       "    •    Warnings ... for dealing with warnings that are made during a run\n",
       "        or REPL session.\n",
       "\n",
       "    •    WeightedCartesian ... Cartesian vector with weight factor of given\n",
       "        type.\n",
       "\n",
       "\u001b[1m  \u001b[36mData types from many-electron theory\u001b[39m\u001b[22m\n",
       "\u001b[1m  ––––––––––––––––––––––––––––––––––––––\u001b[22m\n",
       "\n",
       "    •    AsfSettings ... settings for SCF and CI computations.\n",
       "\n",
       "    •    Atomic.Computation ... atomic computation of a multiplet,\n",
       "        including the SCF, CI and transition properties.\n",
       "\n",
       "    •    Basis ... (relativistic) atomic basis, including the configuration\n",
       "        space and radial orbitals.\n",
       "\n",
       "    •    Bspline ... set of B-splines.\n",
       "\n",
       "    •    Configuration ... (non-relativistic) electron configuration as\n",
       "        specified by its shells and their occupation.\n",
       "\n",
       "    •    ConfigurationR ... (relativistic) electron configuration as\n",
       "        specified by its subshells and their occupation.\n",
       "\n",
       "    •    Level ... atomic level in terms of its quantum number, energy and\n",
       "        a (possible) representation.\n",
       "\n",
       "    •    Multiplet ... an ordered list of atomic levels with a name.\n",
       "\n",
       "    •    Orbital ... (relativistic) radial orbital function that appears as\n",
       "        'building block' to define many-electron states; more often than\n",
       "        not, it just occurs as radial orbital on a given (radial) grid\n",
       "        while the angular dependence is given by the subshell label.\n",
       "\n",
       "    •    QedPetersburg ... singleton data type for selecting QED\n",
       "        calculations a la St. Petersburg.\n",
       "\n",
       "    •    QedSydney ... singleton data type for selecting QED calculations a\n",
       "        la Sydney.\n",
       "\n",
       "    •    NoneQed ... singleton data type if no QED corrections are to be\n",
       "        calculated. \n",
       "\n",
       "    •    Radial.Grid ... radial grid to represent the (radial) orbitals.\n",
       "\n",
       "    •    Radial.Potential ... radial potential function.\n",
       "\n",
       "    •    Radial.Primitives ... a list of radial functions, that may serve\n",
       "        as a set of primitives in SCF computations, together with several\n",
       "        parameters for its definition.\n",
       "\n",
       "    •    Radial.SingleSymOrbitals ... a list of radial orbitals with large\n",
       "        and small component but of the same symmetry (kappa); such a list\n",
       "        may serves as (complete) single-electron basis to deal with\n",
       "        second- and higher-order processes.\n",
       "\n",
       "\u001b[1m  \u001b[36mData types calculating level properties\u001b[39m\u001b[22m\n",
       "\u001b[1m  –––––––––––––––––––––––––––––––––––––––––\u001b[22m\n",
       "\n",
       "    •    AbstractLevelProperty ... an atomic level property that is\n",
       "        supported by the JAC module, such as HFS, IsotopeShift, ....\n",
       "\n",
       "    •    Einstein.Settings ... settings for Einstein A and B coefficients,\n",
       "        calculated within a single given Multiplet.\n",
       "\n",
       "    •    Einstein.Outcome ... (results of the) Einstein A and B\n",
       "        coefficients for a single line.\n",
       "\n",
       "    •    Hfs.Settings ... settings for HFS A and B coefficients.\n",
       "\n",
       "    •    Hfs.Outcome ... (results of the) HFS A and B coefficients for a\n",
       "        single level.\n",
       "\n",
       "    •    IsotopeShift.Outcome ... (results of the) M and F isotope-shift\n",
       "        parameters for a single level.\n",
       "\n",
       "    •    IsotopeShift.Settings ... settings for the M and F isotope-shift\n",
       "        parameters.\n",
       "\n",
       "    •    LandeZeeman.sublevelJ ... specifies a magnetic sublevel with\n",
       "        well-defined J.\n",
       "\n",
       "    •    LandeZeeman.sublevelF ... specifies a magnetic hyperfine sublevel\n",
       "        with well-defined F, M_f.\n",
       "\n",
       "    •    LandeZeeman.Outcome ... (results of the) Lande factors and Zeeman\n",
       "        splittings for a single level.\n",
       "\n",
       "    •    LandeZeeman.Settings ... settings for the Lande factors and Zeeman\n",
       "        splitting in an external magnetic field.\n",
       "\n",
       "    •    PlasmaShift.PlasmaModel ... Model for dealing with the plasma\n",
       "        environment.\n",
       "\n",
       "    •    PlasmaShift.Outcome ... (results of the) plasma shifts and\n",
       "        energies for a single level.\n",
       "\n",
       "    •    PlasmaShift.Settings ... settings for including plasma\n",
       "        interactions into the CI matrix.\n",
       "\n",
       "\u001b[1m  \u001b[36mData types for calculating (time-independent) atomic processes\u001b[39m\u001b[22m\n",
       "\u001b[1m  ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\u001b[22m\n",
       "\n",
       "    •    AtomicProcess ... an atomic process that is supported by the JAC\n",
       "        module, such as Auger, photo, ....\n",
       "\n",
       "    •    AlphaVariation.Outcome ... outcome of a alpha-variation\n",
       "        computation, such as the K enhancement.\n",
       "\n",
       "    •    AlphaVariation.Settings ... seetings for computing alpha variation\n",
       "        parameters.\n",
       "\n",
       "    •    Auger.Channel ... Auger channel of well-defined energy and partial\n",
       "        outgoing wave.\n",
       "\n",
       "    •    Auger.Line ... Auger line between (two) specified initial- and\n",
       "        final-state levels and with (possible) subchannels.\n",
       "\n",
       "    •    Auger.Settings ... settings for computing Auger lines.\n",
       "\n",
       "    •    CoulombExcitation.Channel ... Coulomb excitation channel of\n",
       "        well-defined energy and partial wave.\n",
       "\n",
       "    •    CoulombExcitation.Line ... Coulomb excitation line with (possible)\n",
       "        subchannels.\n",
       "\n",
       "    •    CoulombExcitation.Settings ... settings for computing Coulomb\n",
       "        excitation lines.\n",
       "\n",
       "    •    CoulombIonization.Channel ... Coulomb ionization channel of\n",
       "        well-defined energy and partial wave.\n",
       "\n",
       "    •    CoulombIonization.Line ... Coulomb ionization line with (possible)\n",
       "        subchannels.\n",
       "\n",
       "    •    CoulombIonization.Settings ... settings for computing Coulomb\n",
       "        ionization lines.\n",
       "\n",
       "    •    Dielectronic.Channel ... dielectronic-recombination channel of\n",
       "        well-defined multipolarity and gauge as well as energy and partial\n",
       "        incoming wave.\n",
       "\n",
       "    •    Dielectronic.Line ... dielectronic recombination line between\n",
       "        (three) specified initial-, intermediate and final-state levels\n",
       "        and with (possible) subchannels.\n",
       "\n",
       "    •    Dielectronic.Resonance ... single dielectronic resonance that\n",
       "        summarizes all Dielectronic.Line's for some fixed intermediate\n",
       "        level within the continuum. \n",
       "\n",
       "    •    Dielectronic.Settings ... settings for computing dielectronic\n",
       "        recombination lines.\n",
       "\n",
       "    •    DecayYield.Outcome ... outcome of a decay yield computation.\n",
       "\n",
       "    •    DecayYield.Settings ... settings for computing decay yields lines.\n",
       "\n",
       "    •    DoubleAuger.Channel ... DoubleAuger channel of two partial\n",
       "        outgoing waves with well-defined energy.\n",
       "\n",
       "    •    DoubleAuger.Line ... DoubleAuger line between (two) specified\n",
       "        initial- and final-state levels and with (possible) subchannels.\n",
       "\n",
       "    •    DoubleAuger.Settings ... settings for computing DoubleAuger lines.\n",
       "\n",
       "    •    ImpactExcitation.Channel ... electron-impact excitation channel of\n",
       "        well-defined energies. partial waves and phases of the incoming\n",
       "        and outgoing electrons.\n",
       "\n",
       "    •    ImpactExcitation.Line ... electron-impact excitation line between\n",
       "        (two) specified initial- and final-state levels and with\n",
       "        (possible) subchannels.\n",
       "\n",
       "    •    ImpactExcitation.Settings ... settings for computing\n",
       "        electron-impact excitation lines.\n",
       "\n",
       "    •    ImpactExcitationAutoion.Channel ... electron-impact excitation\n",
       "        channel of well-defined energies, partial waves and phases of the\n",
       "        incoming and outgoing electrons.\n",
       "\n",
       "    •    ImpactExcitationAutoion.Pathway ... electron-impact excitation\n",
       "        line between (two) specified initial- and final-state levels and\n",
       "        with (possible) subchannels.\n",
       "\n",
       "    •    ImpactExcitationAutoion.Settings ... settings for computing\n",
       "        electron-impact excitation lines.\n",
       "\n",
       "    •    ImpactIonization.Channel ... electron-impact ionization channel of\n",
       "        well-defined energies, partial waves and phases of the incoming\n",
       "        and outgoing electrons.\n",
       "\n",
       "    •    ImpactIonization.Line ... electron-impact ionization line between\n",
       "        (two) specified initial- and final-state levels and with\n",
       "        (possible) subchannels.\n",
       "\n",
       "    •    ImpactIonization.Settings ... settings for computing\n",
       "        electron-impact ionization lines.\n",
       "\n",
       "    •    MultiPhotonDeExcitation.Channel ... multi-photon excitation or\n",
       "        decay channel with well-defined multipolarities and gauge.\n",
       "\n",
       "    •    MultiPhotonDeExcitation.Line ... multi-photon excitation or decay\n",
       "        line between (two) specified initial- and final-state levels and\n",
       "        with (possible) subchannels.\n",
       "\n",
       "    •    MultiPhotonDeExcitation.Settings ... settings for computing\n",
       "        multi-photon excitation or decay lines.\n",
       "\n",
       "    •    MultiPhotonIonization.Channel ... multi-photon ionization channel\n",
       "        with well-defined multipolarities, gauge as well as energy and\n",
       "        partial wave of the outgoing electron.\n",
       "\n",
       "    •    MultiPhotonIonization.Line ... multi-photon ionization line\n",
       "        between (two) specified initial- and final-state levels and with\n",
       "        (possible) subchannels.\n",
       "\n",
       "    •    MultiPhotonIonization.Settings ... settings for computing\n",
       "        multi-photon ionization lines.\n",
       "\n",
       "    •    MultiPhotonDoubleIon.Channel ... multi-photon double ionization\n",
       "        channel with well-defined multipolarities, gauge as well as energy\n",
       "        and partial waves of the (two) outgoing electrons.\n",
       "\n",
       "    •    MultiPhotonDoubleIon.Line ... multi-photon double ionization line\n",
       "        between (two) specified initial- and final-state levels and with\n",
       "        (possible) subchannels.\n",
       "\n",
       "    •    MultiPhotonDoubleIon.Settings ... settings for computing\n",
       "        multi-photon double ionization lines.\n",
       "\n",
       "    •    PairAnnihilation1Photon.Channel ... positron-bound-electron pair\n",
       "        annihilation (PEPA) with single-photon emission channel of\n",
       "        well-defined multipolarity, gauge as well as energy and partial\n",
       "        incoming (positron) wave.\n",
       "\n",
       "    •    PairAnnihilation1Photon.Line ... PEPA with single-photon emission\n",
       "        line between (two) specified initial- and final-state levels and\n",
       "        with (possible) subchannels.\n",
       "\n",
       "    •    PairAnnihilation1Photon.Settings ... settings for computing PEPA\n",
       "        with single-photon emission lines.\n",
       "\n",
       "    •    PairAnnihilation2Photon.Channel ... positron-bound-electron pair\n",
       "        annihilation (PEPA) with two-photon emission channel of\n",
       "        well-defined multipolarities, gauge as well as energy and partial\n",
       "        incoming (positron) wave.\n",
       "\n",
       "    •    PairAnnihilation2Photon.Line ... PEPA with two-photon emission\n",
       "        line between (two) specified initial- and final-state levels and\n",
       "        with (possible) subchannels.\n",
       "\n",
       "    •    PairAnnihilation2Photon.Settings ... settings for computing PEPA\n",
       "        with two-photon emission lines.\n",
       "\n",
       "    •    PairProduction.Channel ... positron-bound-electron pair production\n",
       "        (PEPP) by single-photon absorption channel of well-defined\n",
       "        multipolarity, gauge as well as energy and partial outgoing\n",
       "        (positron) wave.\n",
       "\n",
       "    •    PairProduction.Line ... PEPP by single-photon absorption line\n",
       "        between (two) specified initial- and final-state levels and with\n",
       "        (possible) subchannels.\n",
       "\n",
       "    •    PairProduction.Settings ... settings for computing PEPP lines.\n",
       "\n",
       "    •    PhotoExcitation.Line ... photoexcitation line between (two)\n",
       "        specified initial- and final- state levels and with (possible\n",
       "        JAC.PhotoEmission.Channel) subchannels.\n",
       "\n",
       "    •    PhotoExcitation.Settings ... settings for computing\n",
       "        photoexcitation lines.\n",
       "\n",
       "    •    PhotoExcitationAutoion.Channel ... photo-excitation autoionization\n",
       "        channel of well-defined energies of the incoming photon as well as\n",
       "        the partial wave and phase of the outgoing electron.\n",
       "\n",
       "    •    PhotoExcitationAutoion.Pathway ... photo-excitation autoionization\n",
       "        pathways between (three) specified initial-, intermediate and\n",
       "        final-state levels and with (possible) subchannels.\n",
       "\n",
       "    •    PhotoExcitationAutoion.Settings ... settings for computing\n",
       "        photo-excitation autoionization pathways.\n",
       "\n",
       "    •    PhotoIonization.Channel ... photoionization channel of\n",
       "        well-defined multipolarity, gauge as well as energy and partial\n",
       "        outgoing wave.\n",
       "\n",
       "    •    PhotoIonization.Line ... photoionization line between (two)\n",
       "        specified initial- and final-state levels and with (possible)\n",
       "        subchannels.\n",
       "\n",
       "    •    PhotoIonization.Settings ... settings for computing\n",
       "        photoionization lines.\n",
       "\n",
       "    •    PhotoRecombination.Channel ... Rec channel of well-defined\n",
       "        multipolarity and gauge as well as energy and partial incoming\n",
       "        wave.\n",
       "\n",
       "    •    PhotoRecombination.Line ... radiative electron capture line\n",
       "        between (two) specified initial- and final-state levels and with\n",
       "        (possible) subchannels.\n",
       "\n",
       "    •    PhotoRecombination.Settings ... settings for computing radiative\n",
       "        electron capture lines.\n",
       "\n",
       "    •    PhotoEmission.Channel ... radiative channel of well-defined\n",
       "        multipolarity and gauge.\n",
       "\n",
       "    •    PhotoEmission.Line ... radiative line between (two) specified\n",
       "        initial- and final-state levels and with (possible) sublines.\n",
       "\n",
       "    •    PhotoEmission.Settings ... settings for computing radiative lines.\n",
       "\n",
       "    •    RadiativeAuger.Channel ... RadiativeAuger channel of a partial\n",
       "        outgoing waves and one photon with well-defined energy.\n",
       "\n",
       "    •    RadiativeAuger.Line ... RadiativeAuger line between (two)\n",
       "        specified initial- and final-state levels and with (possible)\n",
       "        subchannels.\n",
       "\n",
       "    •    RadiativeAuger.Settings ... settings for computing RadiativeAuger\n",
       "        lines.\n",
       "\n",
       "    •    Radiative.Settings ... settings for computing radiative lines.\n",
       "\n",
       "    •    RayleighCompton.Channel ... RayleighCompton channel of an incoming\n",
       "        and outgoing photon with well-defined energy.\n",
       "\n",
       "    •    RayleighCompton.Line ... RayleighCompton line between (two)\n",
       "        specified initial- and final-state levels and with (possible)\n",
       "        subchannels.\n",
       "\n",
       "    •    RayleighCompton.Settings ... settings for computing\n",
       "        RayleighCompton lines.\n",
       "\n",
       "    •    REDA.Channel ... resonant electron-excitation (sequential)\n",
       "        double-autoionization (REDA) channel of well-defined energies,\n",
       "        partial waves and phases of the incoming and outgoing electrons.\n",
       "\n",
       "    •    REDA.Pathway ... resonant electron-excitation (sequential)\n",
       "        double-autoionization (REDA) pathways.between (four) specified\n",
       "        initial-, (two) intrmediate and final-state levels and with\n",
       "        (possible) subchannels.\n",
       "\n",
       "    •    REDA.Settings ... settings for computing resonant\n",
       "        electron-excitation (sequential) double-autoionization (REDA)\n",
       "        pathways.\n",
       "\n",
       "\u001b[1m  \u001b[36mData types for calculating (time-dependent) atomic processes\u001b[39m\u001b[22m\n",
       "\u001b[1m  ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\u001b[22m\n",
       "\n",
       "    •    Pulse.Envelope ... defines a type for the envelope (function) of\n",
       "        an em pulse with well-defined time delay, amplitude and\n",
       "        (normalized) shape function.\n",
       "\n",
       "    •    Pulse.ExperimentalCharacterization ... to characterized an\n",
       "        experimental or physically described em pulse in terms of its\n",
       "        propagation direction, frequency, maximum intensity, pulse length\n",
       "        or No. of cycles, time-delay, polarization, etc., i.e. of what is\n",
       "        easily accesssible by an experiment.\n",
       "\n",
       "    •    Pulse.Gaussian ... a Gaussian light pulse that is used for\n",
       "        evaluating time-dependent statistical tensors.\n",
       "\n",
       "    •    Pulse.Polarization ... defines the polarization of an em pulse in\n",
       "        terms of its linear and circular degrees, the direction of the\n",
       "        polarization vector or some generalized polarization coefficients.\n",
       "\n",
       "    •    Pulse.PolarizationType ... defines the polarization of an\n",
       "        experimentally described light pulse as linear, left-circular, ..\n",
       "\n",
       "    •    Pulse.Shape ... defines a shape of a general em pulse as Gaussian,\n",
       "        SineSquared, etc.\n",
       "\n",
       "    •    Pulse.SineSquared ... a SinSquared light pulse that is used for\n",
       "        evaluating time-dependent statistical tensors.\n",
       "\n",
       "\u001b[1m  \u001b[36mData types for dealing wiht (time-dependent) statistical tensors\u001b[39m\u001b[22m\n",
       "\u001b[1m  ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\u001b[22m\n",
       "\n",
       "    •    Statistical.ResonanceR ... a resonance state in the continuum with\n",
       "        a well-defined bound-ionic core, one or several electrons in the\n",
       "        continuum, a widths as well as a loss rate due to \u001b[4madditional\u001b[24m decay\n",
       "        processes that cannot be accounted for explicitly.\n",
       "\n",
       "    •    Statistical.Tensor ... represents a statistical tensor of given\n",
       "        rank k, projection q and which generally depends upon two\n",
       "        resonances.\n",
       "\n",
       "\u001b[1m  \u001b[36mData types for advanced computations\u001b[39m\u001b[22m\n",
       "\u001b[1m  ––––––––––––––––––––––––––––––––––––––\u001b[22m\n",
       "\n",
       "    •    Atomic.CasComputation ... an individual or a series of\n",
       "        systematically enlarged SCF computations.\n",
       "\n",
       "    •    Atomic.CasStep ... single-step in an (systematically enlarged) SCF\n",
       "        calculation.\n",
       "\n",
       "    •    Atomic.CasSettings ... settings for CAS computation.\n",
       "\n",
       "    •    Cascade.Approach ... a particular (computational) approach in\n",
       "        which a cascade is considered.\n",
       "\n",
       "    •    Cascade.Block ... a block of configurations that are treatet\n",
       "        together within a given cascade. \n",
       "\n",
       "    •    Cascade.Data ... all transition data of a cascade as given by a\n",
       "        list of lines (of different type).\n",
       "\n",
       "    •    Cascade.Computation ... definition of an atomic exciation/decay\n",
       "        cascade from which the actual computations can be derived.\n",
       "\n",
       "    •    Cascade.Level (mutable) ... defines a level specification for\n",
       "        dealing with cascade transitions.\n",
       "\n",
       "    •    Cascade.LineIndex ... defines a line index with regard to the\n",
       "        various lineLists of data::Cascade.Data.\n",
       "\n",
       "    •    Cascade.Step ... an individual step of a Cascade.Computation that\n",
       "        generally combines two ionization states of ions.\n",
       "\n",
       "    •    Cascade.Simulation ... simulation of cascade data.\n",
       "\n",
       "    •    Cascade.SimulationSettings ... defines settings for performing the\n",
       "        simulation of some cascade (data).\n",
       "\n",
       "    •    Cascade.Settings ... settings for cascade computations (not yet)."
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Details.datatypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, however, this list is rather incomplete and no attempt is currently made to keep this list *up-dated*. The power of these data types lays not in their number but in the **consistency** of how they are defined and utilized internally. It is the aim of these tutorials to show the user how one can benefit from a proper set of such data types (`struct`s) without that one needs to know all of them nor the details how they are defined. Although the detailed definition of all data types is important to the work of JAC, their efficient use comes by using the help (\"?\") pages of some available examples files that can be adapted for the requested computations.\n",
    "\n",
    "For those users, which are not yet *convinced* about the advantages of Julia, we may ask also `? JAC.whyJulia`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\textbf{\\texttt{Why Julia ?}}\n",
       "\n",
       "Here, we recall a few remarks from the literature as well as some own experience why Julia is helpful for developing the JAC program.  Many of these arguments have been adapted from the paper by Bezanson et al. (2017) and by Post and Kendall (2004):\n",
       "\n",
       "\\begin{itemize}\n",
       "\\item Julia stands for the combination of productivity and performance through a careful language design and carefully chosen technologies;    it never forces the user to resort to C or Fortran for fast computations. – Julia's design allows for gradual learning of modern concepts    in scientific computing; from a manner familiar to many users and towards well-structured and high-performance code. In Julia, however,   it is sometimes beliefed that class-based methods are not scientifically powerful enough to express full abstraction in scientific computing.\n",
       "\n",
       "\n",
       "\\item \\texttt{High-level languages}: Most traditional high-level languages are hampered by the overhead from the interpretor and which typically results into                           more run-time processing that are strictly necessary. One of these hindrances is (missing) type information, and which                           then results in the request for supporting vectorization. Julia is a 'verb'-based language in contrast to most                            object-oriented 'noun'-based language, in which the generic functions play a more important role than the datatypes.\n",
       "\n",
       "\n",
       "\\item \\texttt{Code selection}: Julia name space allows the use of the same vocabulary in different circumstances, and which makes programs easier to read.                   In particular, it uses the same mechanism of code selection at the lowest and highest levels and is therefore able to select                   the right method, either already at compile time or later at run time.\n",
       "\n",
       "\n",
       "\\item \\texttt{Multiple dispatch}: refers to the dynamically selected implementation and to the concept of running the right code at the right time.                       This is achieved by overloading by multiple-argument function, a very powerful abstraction. Multiple dispatch makes                        it easier to structure the programs close to the underlying science. It also reduces the needs for argument checking                       at the begin of a function. The overloading of functions by multiple dispatch is also called ad-hoc polymophism.                       Instead of encapsulating methods inside classes, Julia's multiple dispatch is a paradigm in wich methods are defined on                       combinations of data types (classes). Julia shows that this is remarkably well-suited for numerical computing.\n",
       "\n",
       "\n",
       "\\item \\texttt{Code re-use}: In good language design, on should be able to write a general implementation and, as long as the necessary operations are                   available, the code should just work.\n",
       "\n",
       "\n",
       "\\item \\texttt{Type system}: Julia's expressive type system that allows opional type annotations; this type system supports an agressive code specializiation                   against run-time types. Over a large extent, however, Julia code can be used without any mentioning of types (in contrast to                   C and Fortran); this is achieved by data-flow interference.– User's own types are also first class in Julia, that is there                    is not meaningful distinction between built-in and user-defined types. There are mutable and (default: immutable)                    composite types.\n",
       "\n",
       "\n",
       "\\item \\texttt{Parallelization}: One of the central motivation to built Julia was the design of a parallel computing language. Therefore, Julia provides                       different facilities for parallelism. Two important concepts are 'remote calls'  and 'remote references'; cf.                       @parallel. In contrast, vectorization is in Julia NOT considered as a pre-requisite for performance.\n",
       "\n",
       "\n",
       "\\item \\texttt{Performance}: There are helpful macros, such as @timing function\\emph{call(parameters) or @benchmark function}call(parameters) to analyze the                   performance of the program and to find (and resolve) bottlenecks.\n",
       "\n",
       "\n",
       "\\item \\texttt{Code developers}: In numerical and scientific computing, people with special skills are sometimes called library or package writers, while                    many others just use these libraries and packages.\n",
       "\n",
       "\n",
       "\\item \\texttt{LAPACK}: All of LAPACK is available in Julia, not just the most common functions. LAPACK wrappers are fully implemented by 'ccall' and can           be called directly from the Julia promt.\n",
       "\n",
       "\n",
       "\\item \\texttt{Macros}: A macro is a function that runs at parse time. It takes symbolic expressions in and returns transformed expressions out, which are           inserted into the code for later compilation. The output of macros is often 'inlined' into the code.\n",
       "\n",
       "\n",
       "\\item \\texttt{Physical models}: However, better physics is more important than better computer science. It is recommended to use modern but well-proven                       computer-science techniques, and a 'physics code' should not be a computer-science research project. Instead, one should                       use best engineering practices to improve quality rather tha processes. Emphasis should be given to improvements of the                        physics capabilities. Do not use the latest computer-science features; let the new ideas mature first. Better physics is the                       most important product of the code.\n",
       "\n",
       "\n",
       "\\item The scale of code-development can be truly immense; a good overview/quantitative database about (previously) successful software projects is   required for good estimation for resources and schedules. It is easy to loose motivation on a project that last years and which has few   incremental deliveries.\n",
       "\n",
       "\n",
       "\\item \\texttt{Success criteria}: One of the important success criteria is the costumer focus. What do the user really need.\n",
       "\n",
       "\n",
       "\\item \\texttt{Visualization}: Visualization of large data sets is essential for debugging, problem generation and analysis of results.\n",
       "\n",
       "\n",
       "\\item \\texttt{Code evolution}: Continues replacement of code modules is recommended as better tools and techniques are developed. Every code development                   typically proceeds in steps: First develop a core capability (with a small team) and let this small core be tested by users                    and, if successful, add further capabilities (so-called incremental delivery).\n",
       "\n",
       "\n",
       "\\item \\texttt{Team work}: Good teams are more important than good processes; they are characterized by the ability to share ideas and to work informally               together. The chracks need to evolve into senior mentors and code architects who communicate their vision and expertise. –- Poor                performers not only do not complete their work, they also tend to impede and discourage others.\n",
       "\n",
       "\n",
       "\\item \\texttt{Code specification}: Some flexibility in the requirement specification phase is essential because it is difficult to predict when (or if) a                        new algorithm/approach will be available. There is a need to pursue multiple approaches for algorithms and modules near                        to the critical path. If one approach is not feasible, another one can be used.\n",
       "\n",
       "\n",
       "\\item \\texttt{Quality tests}: If a code is not verified and validated by proper examples, the users will not believe and see its connection to reality.                    Therefore, develop and execute a verification and validation program.\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "**`Why Julia ?`**\n",
       "\n",
       "Here, we recall a few remarks from the literature as well as some own experience why Julia is helpful for developing the JAC program.  Many of these arguments have been adapted from the paper by Bezanson et al. (2017) and by Post and Kendall (2004):\n",
       "\n",
       "  * Julia stands for the combination of productivity and performance through a careful language design and carefully chosen technologies;    it never forces the user to resort to C or Fortran for fast computations. – Julia's design allows for gradual learning of modern concepts    in scientific computing; from a manner familiar to many users and towards well-structured and high-performance code. In Julia, however,   it is sometimes beliefed that class-based methods are not scientifically powerful enough to express full abstraction in scientific computing.\n",
       "  * `High-level languages`: Most traditional high-level languages are hampered by the overhead from the interpretor and which typically results into                           more run-time processing that are strictly necessary. One of these hindrances is (missing) type information, and which                           then results in the request for supporting vectorization. Julia is a 'verb'-based language in contrast to most                            object-oriented 'noun'-based language, in which the generic functions play a more important role than the datatypes.\n",
       "  * `Code selection`: Julia name space allows the use of the same vocabulary in different circumstances, and which makes programs easier to read.                   In particular, it uses the same mechanism of code selection at the lowest and highest levels and is therefore able to select                   the right method, either already at compile time or later at run time.\n",
       "  * `Multiple dispatch`: refers to the dynamically selected implementation and to the concept of running the right code at the right time.                       This is achieved by overloading by multiple-argument function, a very powerful abstraction. Multiple dispatch makes                        it easier to structure the programs close to the underlying science. It also reduces the needs for argument checking                       at the begin of a function. The overloading of functions by multiple dispatch is also called ad-hoc polymophism.                       Instead of encapsulating methods inside classes, Julia's multiple dispatch is a paradigm in wich methods are defined on                       combinations of data types (classes). Julia shows that this is remarkably well-suited for numerical computing.\n",
       "  * `Code re-use`: In good language design, on should be able to write a general implementation and, as long as the necessary operations are                   available, the code should just work.\n",
       "  * `Type system`: Julia's expressive type system that allows opional type annotations; this type system supports an agressive code specializiation                   against run-time types. Over a large extent, however, Julia code can be used without any mentioning of types (in contrast to                   C and Fortran); this is achieved by data-flow interference.– User's own types are also first class in Julia, that is there                    is not meaningful distinction between built-in and user-defined types. There are mutable and (default: immutable)                    composite types.\n",
       "  * `Parallelization`: One of the central motivation to built Julia was the design of a parallel computing language. Therefore, Julia provides                       different facilities for parallelism. Two important concepts are 'remote calls'  and 'remote references'; cf.                       @parallel. In contrast, vectorization is in Julia NOT considered as a pre-requisite for performance.\n",
       "  * `Performance`: There are helpful macros, such as @timing function*call(parameters) or @benchmark function*call(parameters) to analyze the                   performance of the program and to find (and resolve) bottlenecks.\n",
       "  * `Code developers`: In numerical and scientific computing, people with special skills are sometimes called library or package writers, while                    many others just use these libraries and packages.\n",
       "  * `LAPACK`: All of LAPACK is available in Julia, not just the most common functions. LAPACK wrappers are fully implemented by 'ccall' and can           be called directly from the Julia promt.\n",
       "  * `Macros`: A macro is a function that runs at parse time. It takes symbolic expressions in and returns transformed expressions out, which are           inserted into the code for later compilation. The output of macros is often 'inlined' into the code.\n",
       "  * `Physical models`: However, better physics is more important than better computer science. It is recommended to use modern but well-proven                       computer-science techniques, and a 'physics code' should not be a computer-science research project. Instead, one should                       use best engineering practices to improve quality rather tha processes. Emphasis should be given to improvements of the                        physics capabilities. Do not use the latest computer-science features; let the new ideas mature first. Better physics is the                       most important product of the code.\n",
       "  * The scale of code-development can be truly immense; a good overview/quantitative database about (previously) successful software projects is   required for good estimation for resources and schedules. It is easy to loose motivation on a project that last years and which has few   incremental deliveries.\n",
       "  * `Success criteria`: One of the important success criteria is the costumer focus. What do the user really need.\n",
       "  * `Visualization`: Visualization of large data sets is essential for debugging, problem generation and analysis of results.\n",
       "  * `Code evolution`: Continues replacement of code modules is recommended as better tools and techniques are developed. Every code development                   typically proceeds in steps: First develop a core capability (with a small team) and let this small core be tested by users                    and, if successful, add further capabilities (so-called incremental delivery).\n",
       "  * `Team work`: Good teams are more important than good processes; they are characterized by the ability to share ideas and to work informally               together. The chracks need to evolve into senior mentors and code architects who communicate their vision and expertise. –- Poor                performers not only do not complete their work, they also tend to impede and discourage others.\n",
       "  * `Code specification`: Some flexibility in the requirement specification phase is essential because it is difficult to predict when (or if) a                        new algorithm/approach will be available. There is a need to pursue multiple approaches for algorithms and modules near                        to the critical path. If one approach is not feasible, another one can be used.\n",
       "  * `Quality tests`: If a code is not verified and validated by proper examples, the users will not believe and see its connection to reality.                    Therefore, develop and execute a verification and validation program.\n"
      ],
      "text/plain": [
       "  \u001b[1m\u001b[36mWhy Julia ?\u001b[39m\u001b[22m\n",
       "\n",
       "  Here, we recall a few remarks from the literature as well as some own\n",
       "  experience why Julia is helpful for developing the JAC program. Many of\n",
       "  these arguments have been adapted from the paper by Bezanson et al. (2017)\n",
       "  and by Post and Kendall (2004):\n",
       "\n",
       "    •    Julia stands for the combination of productivity and performance\n",
       "        through a careful language design and carefully chosen\n",
       "        technologies; it never forces the user to resort to C or Fortran\n",
       "        for fast computations. – Julia's design allows for gradual\n",
       "        learning of modern concepts in scientific computing; from a manner\n",
       "        familiar to many users and towards well-structured and\n",
       "        high-performance code. In Julia, however, it is sometimes beliefed\n",
       "        that class-based methods are not scientifically powerful enough to\n",
       "        express full abstraction in scientific computing.\n",
       "\n",
       "    •    \u001b[36mHigh-level languages\u001b[39m: Most traditional high-level languages are\n",
       "        hampered by the overhead from the interpretor and which typically\n",
       "        results into more run-time processing that are strictly necessary.\n",
       "        One of these hindrances is (missing) type information, and which\n",
       "        then results in the request for supporting vectorization. Julia is\n",
       "        a 'verb'-based language in contrast to most object-oriented\n",
       "        'noun'-based language, in which the generic functions play a more\n",
       "        important role than the datatypes.\n",
       "\n",
       "    •    \u001b[36mCode selection\u001b[39m: Julia name space allows the use of the same\n",
       "        vocabulary in different circumstances, and which makes programs\n",
       "        easier to read. In particular, it uses the same mechanism of code\n",
       "        selection at the lowest and highest levels and is therefore able\n",
       "        to select the right method, either already at compile time or\n",
       "        later at run time.\n",
       "\n",
       "    •    \u001b[36mMultiple dispatch\u001b[39m: refers to the dynamically selected\n",
       "        implementation and to the concept of running the right code at the\n",
       "        right time. This is achieved by overloading by multiple-argument\n",
       "        function, a very powerful abstraction. Multiple dispatch makes it\n",
       "        easier to structure the programs close to the underlying science.\n",
       "        It also reduces the needs for argument checking at the begin of a\n",
       "        function. The overloading of functions by multiple dispatch is\n",
       "        also called ad-hoc polymophism. Instead of encapsulating methods\n",
       "        inside classes, Julia's multiple dispatch is a paradigm in wich\n",
       "        methods are defined on combinations of data types (classes). Julia\n",
       "        shows that this is remarkably well-suited for numerical computing.\n",
       "\n",
       "    •    \u001b[36mCode re-use\u001b[39m: In good language design, on should be able to write a\n",
       "        general implementation and, as long as the necessary operations\n",
       "        are available, the code should just work.\n",
       "\n",
       "    •    \u001b[36mType system\u001b[39m: Julia's expressive type system that allows opional\n",
       "        type annotations; this type system supports an agressive code\n",
       "        specializiation against run-time types. Over a large extent,\n",
       "        however, Julia code can be used without any mentioning of types\n",
       "        (in contrast to C and Fortran); this is achieved by data-flow\n",
       "        interference.– User's own types are also first class in Julia,\n",
       "        that is there is not meaningful distinction between built-in and\n",
       "        user-defined types. There are mutable and (default: immutable)\n",
       "        composite types.\n",
       "\n",
       "    •    \u001b[36mParallelization\u001b[39m: One of the central motivation to built Julia was\n",
       "        the design of a parallel computing language. Therefore, Julia\n",
       "        provides different facilities for parallelism. Two important\n",
       "        concepts are 'remote calls' and 'remote references'; cf.\n",
       "        @parallel. In contrast, vectorization is in Julia NOT considered\n",
       "        as a pre-requisite for performance.\n",
       "\n",
       "    •    \u001b[36mPerformance\u001b[39m: There are helpful macros, such as @timing\n",
       "        function\u001b[4mcall(parameters) or @benchmark function\u001b[24mcall(parameters) to\n",
       "        analyze the performance of the program and to find (and resolve)\n",
       "        bottlenecks.\n",
       "\n",
       "    •    \u001b[36mCode developers\u001b[39m: In numerical and scientific computing, people\n",
       "        with special skills are sometimes called library or package\n",
       "        writers, while many others just use these libraries and packages.\n",
       "\n",
       "    •    \u001b[36mLAPACK\u001b[39m: All of LAPACK is available in Julia, not just the most\n",
       "        common functions. LAPACK wrappers are fully implemented by 'ccall'\n",
       "        and can be called directly from the Julia promt.\n",
       "\n",
       "    •    \u001b[36mMacros\u001b[39m: A macro is a function that runs at parse time. It takes\n",
       "        symbolic expressions in and returns transformed expressions out,\n",
       "        which are inserted into the code for later compilation. The output\n",
       "        of macros is often 'inlined' into the code.\n",
       "\n",
       "    •    \u001b[36mPhysical models\u001b[39m: However, better physics is more important than\n",
       "        better computer science. It is recommended to use modern but\n",
       "        well-proven computer-science techniques, and a 'physics code'\n",
       "        should not be a computer-science research project. Instead, one\n",
       "        should use best engineering practices to improve quality rather\n",
       "        tha processes. Emphasis should be given to improvements of the\n",
       "        physics capabilities. Do not use the latest computer-science\n",
       "        features; let the new ideas mature first. Better physics is the\n",
       "        most important product of the code.\n",
       "\n",
       "    •    The scale of code-development can be truly immense; a good\n",
       "        overview/quantitative database about (previously) successful\n",
       "        software projects is required for good estimation for resources\n",
       "        and schedules. It is easy to loose motivation on a project that\n",
       "        last years and which has few incremental deliveries.\n",
       "\n",
       "    •    \u001b[36mSuccess criteria\u001b[39m: One of the important success criteria is the\n",
       "        costumer focus. What do the user really need.\n",
       "\n",
       "    •    \u001b[36mVisualization\u001b[39m: Visualization of large data sets is essential for\n",
       "        debugging, problem generation and analysis of results.\n",
       "\n",
       "    •    \u001b[36mCode evolution\u001b[39m: Continues replacement of code modules is\n",
       "        recommended as better tools and techniques are developed. Every\n",
       "        code development typically proceeds in steps: First develop a core\n",
       "        capability (with a small team) and let this small core be tested\n",
       "        by users and, if successful, add further capabilities (so-called\n",
       "        incremental delivery).\n",
       "\n",
       "    •    \u001b[36mTeam work\u001b[39m: Good teams are more important than good processes; they\n",
       "        are characterized by the ability to share ideas and to work\n",
       "        informally together. The chracks need to evolve into senior\n",
       "        mentors and code architects who communicate their vision and\n",
       "        expertise. –- Poor performers not only do not complete their work,\n",
       "        they also tend to impede and discourage others.\n",
       "\n",
       "    •    \u001b[36mCode specification\u001b[39m: Some flexibility in the requirement\n",
       "        specification phase is essential because it is difficult to\n",
       "        predict when (or if) a new algorithm/approach will be available.\n",
       "        There is a need to pursue multiple approaches for algorithms and\n",
       "        modules near to the critical path. If one approach is not\n",
       "        feasible, another one can be used.\n",
       "\n",
       "    •    \u001b[36mQuality tests\u001b[39m: If a code is not verified and validated by proper\n",
       "        examples, the users will not believe and see its connection to\n",
       "        reality. Therefore, develop and execute a verification and\n",
       "        validation program."
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Details.whyJulia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This list gives further details why Julia (and JAC) is a very suitable and powerful framework for running -- many-electron -- atomic computations. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, there are many other features that make JAC as powerful as it is: For example, the user may pre-define and overwrite the **units** in which he wishes to communicate with JAC. These units determine how (most of) the input data are interpreted as well as output data are displayed in tabulations or to screen. The current defaults settings for the units can be seen by typing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current settings of the JAC module:  \n",
      "-----------------------------------  \n",
      "\n",
      "  + Framework:                              relativistic\n",
      "  + Energy unit:                            eV\n",
      "  + Rate and transition probability unit:   1/s\n",
      "  + Cross section unit:                     barn\n",
      "  + Time unit:                              sec\n",
      "\n",
      "  + A standard grid has been defined; cf. Defaults.getDefaults()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Basics.display(\"settings\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which show that energies are taken/printed in eV, rates in 1/s, etc. Apart from modifying these defaults directly in the source code, the can be *overwritten* by the user at any time of the program executation. This is done by means of the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\texttt{Defaults.setDefaults()}       ... (re-) defines some 'standard' settings which are common to all the computations with the JAC module, and which can          be 'overwritten' by the user. –- An improper setting of some variable may lead to an error message, if recognized         immediately. The following defaults apply if not specified otherwise by the user: the framework is 'relativistic',          energies are given in eV and cross sections in barn. Note that, internally, atomic units are used throughout for          all the computations within the program. nothing is returned if not indicated otherwise.\n",
       "\n",
       "\\subsection{+ \\texttt{(\"framework: relativistic\")}  or  \\texttt{(\"framework: non-relativistic\")}}\n",
       "\\subsection{... to define a relativistic or non-relativistic framework for all subsequent computations.}\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{(\"method: continuum, spherical Bessel\")}  or  \\texttt{(\"method: continuum, pure sine\")}  or   \\texttt{(\"method: continuum, asymptotic Coulomb\")}  or  \\texttt{(\"method: continuum, nonrelativistic Coulomb\")}  or   \\texttt{(\"method: continuum, Galerkin\")}     ... to define a a method for the generation of the continuum orbitals as (pure) spherical Bessel, pure sine,       asymptotic Coulomb, nonrelativistic Coulomb orbital or by means of the B-spline-Galerkin method.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"method: normalization, pure sine\")}  or  \\texttt{(\"method: normalization, pure Coulomb\")}  or  \\texttt{(\"method: normalization, Ong-Russek\")}      ... to define a method for the normalization of the continuum orbitals as asymptotically (pure) sine or Coulomb        functions, or following the procedure by Ong \\& Russek (1978).\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"QED model: Petersburg\")}  or  \\texttt{(\"QED model: Sydney\")}      ... to define a model for the computation of the QED corrections following the work by Shabaev et al. (2011; Petersburg)        or Flambaum and Ginges (2004; Syney).\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"unit: energy\", \"eV\")}  or  \\texttt{(\"unit: energy\", \"Kayser\")}  or  \\texttt{(\"unit: energy\", \"Hartree\")}  or   \\texttt{(\"unit: energy\", \"Hz\")}  or  \\texttt{(\"unit: energy\", \"Hz\")}     ... to (pre-) define the energy units for all further printouts and communications with the JAC module.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"unit: cross section\", \"a.u.\")}  or  \\texttt{(\"unit: cross section\", \"barn\")}  or  \\texttt{(\"unit: cross section\", \"Mbarn\")}     ... to (pre-) define the unit for the printout of cross sections.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"unit: rate\", \"a.u.\")}  or  \\texttt{(\"unit: rate\", \"1/s\")}  ... to (pre-) define the unit for the printout of rates.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"unit: time\", \"a.u.\")}  or  \\texttt{(\"unit: time\", \"sec\")}  or  \\texttt{(\"unit: time\", \"fs\")}  or  \\texttt{(\"unit: time\", \"as\")}     ... to (pre-) define the unit for the printout and communications of times with the JAC module.\n",
       "\n",
       "\\end{itemize}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{(\"relativistic subshell list\", subshells::Array\\{Subshell,1\\}; printout::Bool=true)}     ... to (pre-) define internally the standard relativistic subshell list on which the standard order of orbitals is based.\n",
       "\n",
       "\\end{itemize}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{(\"standard grid\", grid::Radial.Grid; printout::Bool=true)}     ... to (pre-) define internally the standard radial grid which is used to represent most orbitals.\n",
       "\n",
       "\\end{itemize}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{(\"QED: damped-hydrogenic\", Znuc::Float64, wa::Array\\{Float64,1\\})}     ... to (re-) define the lambda-C damped overlap integrals of the lowest kappa-orbitals        [ wa\\emph{1s}1/2, wa\\emph{2p}1/2, wa\\emph{2p}3/2, wa\\emph{3d}3/2, wa\\emph{3d}5/2 ] for the (new) nuclear charge Znuc;        nothing is returned.\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "`Defaults.setDefaults()`       ... (re-) defines some 'standard' settings which are common to all the computations with the JAC module, and which can          be 'overwritten' by the user. –- An improper setting of some variable may lead to an error message, if recognized         immediately. The following defaults apply if not specified otherwise by the user: the framework is 'relativistic',          energies are given in eV and cross sections in barn. Note that, internally, atomic units are used throughout for          all the computations within the program. nothing is returned if not indicated otherwise.\n",
       "\n",
       "## + `(\"framework: relativistic\")`  or  `(\"framework: non-relativistic\")`\n",
       "\n",
       "## ... to define a relativistic or non-relativistic framework for all subsequent computations.\n",
       "\n",
       "  * `(\"method: continuum, spherical Bessel\")`  or  `(\"method: continuum, pure sine\")`  or   `(\"method: continuum, asymptotic Coulomb\")`  or  `(\"method: continuum, nonrelativistic Coulomb\")`  or   `(\"method: continuum, Galerkin\")`     ... to define a a method for the generation of the continuum orbitals as (pure) spherical Bessel, pure sine,       asymptotic Coulomb, nonrelativistic Coulomb orbital or by means of the B-spline-Galerkin method.\n",
       "  * `(\"method: normalization, pure sine\")`  or  `(\"method: normalization, pure Coulomb\")`  or  `(\"method: normalization, Ong-Russek\")`      ... to define a method for the normalization of the continuum orbitals as asymptotically (pure) sine or Coulomb        functions, or following the procedure by Ong & Russek (1978).\n",
       "  * `(\"QED model: Petersburg\")`  or  `(\"QED model: Sydney\")`      ... to define a model for the computation of the QED corrections following the work by Shabaev et al. (2011; Petersburg)        or Flambaum and Ginges (2004; Syney).\n",
       "  * `(\"unit: energy\", \"eV\")`  or  `(\"unit: energy\", \"Kayser\")`  or  `(\"unit: energy\", \"Hartree\")`  or   `(\"unit: energy\", \"Hz\")`  or  `(\"unit: energy\", \"Hz\")`     ... to (pre-) define the energy units for all further printouts and communications with the JAC module.\n",
       "  * `(\"unit: cross section\", \"a.u.\")`  or  `(\"unit: cross section\", \"barn\")`  or  `(\"unit: cross section\", \"Mbarn\")`     ... to (pre-) define the unit for the printout of cross sections.\n",
       "  * `(\"unit: rate\", \"a.u.\")`  or  `(\"unit: rate\", \"1/s\")`  ... to (pre-) define the unit for the printout of rates.\n",
       "  * `(\"unit: time\", \"a.u.\")`  or  `(\"unit: time\", \"sec\")`  or  `(\"unit: time\", \"fs\")`  or  `(\"unit: time\", \"as\")`     ... to (pre-) define the unit for the printout and communications of times with the JAC module.\n",
       "\n",
       "---\n",
       "\n",
       "  * `(\"relativistic subshell list\", subshells::Array{Subshell,1}; printout::Bool=true)`     ... to (pre-) define internally the standard relativistic subshell list on which the standard order of orbitals is based.\n",
       "\n",
       "---\n",
       "\n",
       "  * `(\"standard grid\", grid::Radial.Grid; printout::Bool=true)`     ... to (pre-) define internally the standard radial grid which is used to represent most orbitals.\n",
       "\n",
       "---\n",
       "\n",
       "  * `(\"QED: damped-hydrogenic\", Znuc::Float64, wa::Array{Float64,1})`     ... to (re-) define the lambda-C damped overlap integrals of the lowest kappa-orbitals        [ wa*1s*1/2, wa*2p*1/2, wa*2p*3/2, wa*3d*3/2, wa*3d*5/2 ] for the (new) nuclear charge Znuc;        nothing is returned.\n"
      ],
      "text/plain": [
       "  \u001b[36mDefaults.setDefaults()\u001b[39m ... (re-) defines some 'standard' settings which are\n",
       "  common to all the computations with the JAC module, and which can be\n",
       "  'overwritten' by the user. –- An improper setting of some variable may lead\n",
       "  to an error message, if recognized immediately. The following defaults apply\n",
       "  if not specified otherwise by the user: the framework is 'relativistic',\n",
       "  energies are given in eV and cross sections in barn. Note that, internally,\n",
       "  atomic units are used throughout for all the computations within the\n",
       "  program. nothing is returned if not indicated otherwise.\n",
       "\n",
       "\u001b[1m  + \u001b[36m(\"framework: relativistic\")\u001b[39m or \u001b[36m(\"framework: non-relativistic\")\u001b[39m\u001b[22m\n",
       "\u001b[1m  ==================================================================\u001b[22m\n",
       "\n",
       "\u001b[1m  ... to define a relativistic or non-relativistic framework for all\u001b[22m\n",
       "\u001b[1m subsequent computations.\u001b[22m\n",
       "\u001b[1m  ==========================\u001b[22m\n",
       "\n",
       "    •    \u001b[36m(\"method: continuum, spherical Bessel\")\u001b[39m or \u001b[36m(\"method: continuum,\n",
       "        pure sine\")\u001b[39m or \u001b[36m(\"method: continuum, asymptotic Coulomb\")\u001b[39m or\n",
       "        \u001b[36m(\"method: continuum, nonrelativistic Coulomb\")\u001b[39m or \u001b[36m(\"method:\n",
       "        continuum, Galerkin\")\u001b[39m ... to define a a method for the generation\n",
       "        of the continuum orbitals as (pure) spherical Bessel, pure sine,\n",
       "        asymptotic Coulomb, nonrelativistic Coulomb orbital or by means of\n",
       "        the B-spline-Galerkin method.\n",
       "\n",
       "    •    \u001b[36m(\"method: normalization, pure sine\")\u001b[39m or \u001b[36m(\"method: normalization,\n",
       "        pure Coulomb\")\u001b[39m or \u001b[36m(\"method: normalization, Ong-Russek\")\u001b[39m ... to\n",
       "        define a method for the normalization of the continuum orbitals as\n",
       "        asymptotically (pure) sine or Coulomb functions, or following the\n",
       "        procedure by Ong & Russek (1978).\n",
       "\n",
       "    •    \u001b[36m(\"QED model: Petersburg\")\u001b[39m or \u001b[36m(\"QED model: Sydney\")\u001b[39m ... to define a\n",
       "        model for the computation of the QED corrections following the\n",
       "        work by Shabaev et al. (2011; Petersburg) or Flambaum and Ginges\n",
       "        (2004; Syney).\n",
       "\n",
       "    •    \u001b[36m(\"unit: energy\", \"eV\")\u001b[39m or \u001b[36m(\"unit: energy\", \"Kayser\")\u001b[39m or \u001b[36m(\"unit:\n",
       "        energy\", \"Hartree\")\u001b[39m or \u001b[36m(\"unit: energy\", \"Hz\")\u001b[39m or \u001b[36m(\"unit: energy\",\n",
       "        \"Hz\")\u001b[39m ... to (pre-) define the energy units for all further\n",
       "        printouts and communications with the JAC module.\n",
       "\n",
       "    •    \u001b[36m(\"unit: cross section\", \"a.u.\")\u001b[39m or \u001b[36m(\"unit: cross section\", \"barn\")\u001b[39m\n",
       "        or \u001b[36m(\"unit: cross section\", \"Mbarn\")\u001b[39m ... to (pre-) define the unit\n",
       "        for the printout of cross sections.\n",
       "\n",
       "    •    \u001b[36m(\"unit: rate\", \"a.u.\")\u001b[39m or \u001b[36m(\"unit: rate\", \"1/s\")\u001b[39m ... to (pre-)\n",
       "        define the unit for the printout of rates.\n",
       "\n",
       "    •    \u001b[36m(\"unit: time\", \"a.u.\")\u001b[39m or \u001b[36m(\"unit: time\", \"sec\")\u001b[39m or \u001b[36m(\"unit: time\",\n",
       "        \"fs\")\u001b[39m or \u001b[36m(\"unit: time\", \"as\")\u001b[39m ... to (pre-) define the unit for\n",
       "        the printout and communications of times with the JAC module.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "    •    \u001b[36m(\"relativistic subshell list\", subshells::Array{Subshell,1};\n",
       "        printout::Bool=true)\u001b[39m ... to (pre-) define internally the standard\n",
       "        relativistic subshell list on which the standard order of orbitals\n",
       "        is based.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "    •    \u001b[36m(\"standard grid\", grid::Radial.Grid; printout::Bool=true)\u001b[39m ... to\n",
       "        (pre-) define internally the standard radial grid which is used to\n",
       "        represent most orbitals.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "    •    \u001b[36m(\"QED: damped-hydrogenic\", Znuc::Float64, wa::Array{Float64,1})\u001b[39m\n",
       "        ... to (re-) define the lambda-C damped overlap integrals of the\n",
       "        lowest kappa-orbitals [ wa\u001b[4m1s\u001b[24m1/2, wa\u001b[4m2p\u001b[24m1/2, wa\u001b[4m2p\u001b[24m3/2, wa\u001b[4m3d\u001b[24m3/2,\n",
       "        wa\u001b[4m3d\u001b[24m5/2 ] for the (new) nuclear charge Znuc; nothing is returned."
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Defaults.setDefaults"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which enables one to re-define various **global values** of JAC. If we wish to enter/display energies in **Kaysers** or cross sections in atomic units, we can simply type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "Defaults.setDefaults(\"unit: energy\", \"Kayser\")\n",
    "Defaults.setDefaults(\"unit: cross section\", \"a.u.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, again `nothing` is returned but the corresponding global values are not changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current settings of the JAC module:  \n",
      "-----------------------------------  \n",
      "\n",
      "  + Framework:                              relativistic\n",
      "  + Energy unit:                            Kayser\n",
      "  + Rate and transition probability unit:   1/s\n",
      "  + Cross section unit:                     a.u.\n",
      "  + Time unit:                              sec\n",
      "\n",
      "  + A standard grid has been defined; cf. Defaults.getDefaults()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Basics.display(\"settings\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apart from the default units, one can similarly *overwrite* the method that is use for the generation and normalization of continuum orbitals and several others. Although call *global*, the corresponding values can be accesses just in two ways. (i) The **global constants**, such as the electron mass, the speed of light, the fine-structure constant $\\alpha$, etc., are accessed via the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\texttt{Defaults.getDefaults()}       ... gives/supplies different information about the (present) framework of the computation or about some          given data; cf. Defaults.setDefaults(). \n",
       "\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{(\"alpha\")}  or  \\texttt{(\"fine-structure constant alpha\")}      ... to get the (current) value::Float64 of the fine-structure constant alpha.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"electron mass: kg\")}  or  \\texttt{(\"electron mass: amu\")}     ... to get the (current) value::Float64 of the electron mass in the specified unit.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"framework\")}  ... to give the (current) setting::String  of the overall framework.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"electron rest energy\")}  or  \\texttt{(\"mc\\^{}2\")}  ... to get the electron rest energy.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"electron g-factor\")}  ... to give the electron g-factor g\\_s = 2.00232.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"unit: energy\")}  or  \\texttt{(\"unit: cross section\")}  or  \\texttt{(\"unit: rate\")}     ... to get the corresponding (user-defined) unit::String for the current computations.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"standard grid\")}     ... to get the (current standard) grid::Array\\{Float64,1\\} to which all radial orbital functions usually refer.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"speed of light: c\")}  ... to get the speed of light in atomic units.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"summary flag/stream\")}     ... to get the logical flag and stream for printing a summary file; a tupel (flag, iostream) is returned.\n",
       "\n",
       "\\end{itemize}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{(\"ordered shell list: non-relativistic\", n\\_max::Int64)}     ... to give an ordered list of non-relativistic shells::Array\\{Shell,1\\} up to the (maximum) principal number n\\_max.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"ordered subshell list: relativistic\", n\\_max::Int64)}      ... to give an ordered list of relativistic subshells::Array\\{Subshell,1\\} up to the (maximum) principal number n\\_max.\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "`Defaults.getDefaults()`       ... gives/supplies different information about the (present) framework of the computation or about some          given data; cf. Defaults.setDefaults(). \n",
       "\n",
       "  * `(\"alpha\")`  or  `(\"fine-structure constant alpha\")`      ... to get the (current) value::Float64 of the fine-structure constant alpha.\n",
       "  * `(\"electron mass: kg\")`  or  `(\"electron mass: amu\")`     ... to get the (current) value::Float64 of the electron mass in the specified unit.\n",
       "  * `(\"framework\")`  ... to give the (current) setting::String  of the overall framework.\n",
       "  * `(\"electron rest energy\")`  or  `(\"mc^2\")`  ... to get the electron rest energy.\n",
       "  * `(\"electron g-factor\")`  ... to give the electron g-factor g_s = 2.00232.\n",
       "  * `(\"unit: energy\")`  or  `(\"unit: cross section\")`  or  `(\"unit: rate\")`     ... to get the corresponding (user-defined) unit::String for the current computations.\n",
       "  * `(\"standard grid\")`     ... to get the (current standard) grid::Array{Float64,1} to which all radial orbital functions usually refer.\n",
       "  * `(\"speed of light: c\")`  ... to get the speed of light in atomic units.\n",
       "  * `(\"summary flag/stream\")`     ... to get the logical flag and stream for printing a summary file; a tupel (flag, iostream) is returned.\n",
       "\n",
       "---\n",
       "\n",
       "  * `(\"ordered shell list: non-relativistic\", n_max::Int64)`     ... to give an ordered list of non-relativistic shells::Array{Shell,1} up to the (maximum) principal number n_max.\n",
       "  * `(\"ordered subshell list: relativistic\", n_max::Int64)`      ... to give an ordered list of relativistic subshells::Array{Subshell,1} up to the (maximum) principal number n_max.\n"
      ],
      "text/plain": [
       "  \u001b[36mDefaults.getDefaults()\u001b[39m ... gives/supplies different information about the\n",
       "  (present) framework of the computation or about some given data; cf.\n",
       "  Defaults.setDefaults(). \n",
       "\n",
       "    •    \u001b[36m(\"alpha\")\u001b[39m or \u001b[36m(\"fine-structure constant alpha\")\u001b[39m ... to get the\n",
       "        (current) value::Float64 of the fine-structure constant alpha.\n",
       "\n",
       "    •    \u001b[36m(\"electron mass: kg\")\u001b[39m or \u001b[36m(\"electron mass: amu\")\u001b[39m ... to get the\n",
       "        (current) value::Float64 of the electron mass in the specified\n",
       "        unit.\n",
       "\n",
       "    •    \u001b[36m(\"framework\")\u001b[39m ... to give the (current) setting::String of the\n",
       "        overall framework.\n",
       "\n",
       "    •    \u001b[36m(\"electron rest energy\")\u001b[39m or \u001b[36m(\"mc^2\")\u001b[39m ... to get the electron rest\n",
       "        energy.\n",
       "\n",
       "    •    \u001b[36m(\"electron g-factor\")\u001b[39m ... to give the electron g-factor g_s =\n",
       "        2.00232.\n",
       "\n",
       "    •    \u001b[36m(\"unit: energy\")\u001b[39m or \u001b[36m(\"unit: cross section\")\u001b[39m or \u001b[36m(\"unit: rate\")\u001b[39m ...\n",
       "        to get the corresponding (user-defined) unit::String for the\n",
       "        current computations.\n",
       "\n",
       "    •    \u001b[36m(\"standard grid\")\u001b[39m ... to get the (current standard)\n",
       "        grid::Array{Float64,1} to which all radial orbital functions\n",
       "        usually refer.\n",
       "\n",
       "    •    \u001b[36m(\"speed of light: c\")\u001b[39m ... to get the speed of light in atomic\n",
       "        units.\n",
       "\n",
       "    •    \u001b[36m(\"summary flag/stream\")\u001b[39m ... to get the logical flag and stream for\n",
       "        printing a summary file; a tupel (flag, iostream) is returned.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "    •    \u001b[36m(\"ordered shell list: non-relativistic\", n_max::Int64)\u001b[39m ... to give\n",
       "        an ordered list of non-relativistic shells::Array{Shell,1} up to\n",
       "        the (maximum) principal number n_max.\n",
       "\n",
       "    •    \u001b[36m(\"ordered subshell list: relativistic\", n_max::Int64)\u001b[39m ... to give\n",
       "        an ordered list of relativistic subshells::Array{Subshell,1} up to\n",
       "        the (maximum) principal number n_max."
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Defaults.getDefaults"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0072973525664"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Defaults.getDefaults(\"alpha\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18778.865059792286"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Defaults.getDefaults(\"electron rest energy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Kayser\""
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Defaults.getDefaults(\"unit: energy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(ii) These **global values** are frequently applied in order to -- internally or externally -- convert physical numbers into units of the same dimension. This is done by the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\texttt{Defaults.convertUnits()}       ... converts some data from one format/unit into another one; cf. the supported keystrings and return values.\n",
       "\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{(\"cross section: from atomic to predefined unit\", value::Float64)}  or  \\texttt{(\"cross section: from atomic\", value::Float64)}     ... to convert an energy value from atomic to the predefined cross section unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"cross section: from atomic to barn\", value::Float64)}  or  \\texttt{(\"cross section: from atomic to Mbarn\", value::Float64)}  or \\texttt{(\"cross section: from atomic to Hz\", value::Float64)}  or  \\texttt{(\"energy: from atomic to Angstrom\", value::Float64)}    ... to convert an energy value from atomic to the speficied cross section unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"cross section: from predefined to atomic unit\", value::Float64)}  or  \\texttt{(\"cross section: to atomic\", value::Float64)}   ... to convert a cross section value from the predefined to the atomic cross section unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"einstein B: from atomic\", value::Float64)}     ... to convert a Einstein B coefficient from atomic to the speficied energy units; a Float64 is returned.or\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"energy: from atomic to eV\", value::Float64)}  or  \\texttt{(\"energy: from atomic to Kayser\", value::Float64)}  or \\texttt{(\"energy: from atomic to Hz\", value::Float64)}  or  \\texttt{(\"energy: from atomic to Angstrom\", value::Float64)}    ... to convert an energy value from atomic to the speficied energy unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"energy: from predefined to atomic unit\", value::Float64)}  or  \\texttt{(\"energy: to atomic\", value::Float64)}... to convert an energy value                                                from the predefined to the atomic energy unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"energy: from eV to atomic unit\", value::Float64)} ... to convert an energy value from eV to the atomic energy unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"energy: from wavelength [nm] to atomic\", value::Float64)} ... to convert a wavelength [nm] to the atomic energy unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"intensity: from W/cm\\^{}2 to atomic\", value::Float64)} ... to convert the intensity [in W/cm\\^{}2] to the atomic intensity unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"kinetic energy to wave number: atomic units\", value::Float64)}  ... to convert a kinetic energy value (in a.u.) into a wave number                                               k (a.u.); a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"kinetic energy to wavelength: atomic units\", value::Float64)}  ... to convert a kinetic energy value (in a.u.) into a wavelength (a.u.);                                                a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"length: from fm to atomic\", value::Float64)}  ... to convert a length value (in fm) into a.u.;  a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"length: from atomic to fm\", value::Float64)}  ... to convert a length value (in Bohr's a.u.) into fm;  a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"rate: from atomic to predefined unit\", value::Float64)}  or  (\"rate: from atomic\", value::Float64)  ... to convert a rate value                                            from atomic to the predefined rate unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"rate: from atomic to 1/s\", value::Float64)}  ... to convert an rate value from atomic to the speficied rate unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"rate: from predefined to atomic unit\", value::Float64)}  or  `(\"rate: to atomic\", value::Float64)'... to convert a                                               rate value from the predefined to the atomic rate unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"time: from atomic to predefined unit\", value::Float64)}  or  (\"time: from atomic\", value::Float64)  ... to convert an time value                                            from atomic to the predefined time unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"time: from atomic to sec\", value::Float64)}  or  \\texttt{(\"time: from atomic to fs\", value::Float64)'  or}(\"time: from atomic to as\", value::Float64)`  ... to convert a time value from atomic to the speficied time unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"time: from predefined to atomic unit\", value::Float64)}  or  `(\"time: to atomic\", value::Float64)'  ... to convert a                                           time value from the predefined to the atomic time unit; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"wave number to total electron energy: atomic units\", value::Float64)}  ... to convert a wavenumber (a.u.) into the total electron                                           energy, including the rest energy; a Float64 is returned.\n",
       "\n",
       "\n",
       "\\item \\texttt{(\"wave number to kinetic energy: atomic units\", value::Float64)}  ... to convert a wavenumber (a.u.) into the kinetic energy;                                            a Float64 is returned.\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "`Defaults.convertUnits()`       ... converts some data from one format/unit into another one; cf. the supported keystrings and return values.\n",
       "\n",
       "  * `(\"cross section: from atomic to predefined unit\", value::Float64)`  or  `(\"cross section: from atomic\", value::Float64)`     ... to convert an energy value from atomic to the predefined cross section unit; a Float64 is returned.\n",
       "  * `(\"cross section: from atomic to barn\", value::Float64)`  or  `(\"cross section: from atomic to Mbarn\", value::Float64)`  or `(\"cross section: from atomic to Hz\", value::Float64)`  or  `(\"energy: from atomic to Angstrom\", value::Float64)`    ... to convert an energy value from atomic to the speficied cross section unit; a Float64 is returned.\n",
       "  * `(\"cross section: from predefined to atomic unit\", value::Float64)`  or  `(\"cross section: to atomic\", value::Float64)`   ... to convert a cross section value from the predefined to the atomic cross section unit; a Float64 is returned.\n",
       "  * `(\"einstein B: from atomic\", value::Float64)`     ... to convert a Einstein B coefficient from atomic to the speficied energy units; a Float64 is returned.or\n",
       "  * `(\"energy: from atomic to eV\", value::Float64)`  or  `(\"energy: from atomic to Kayser\", value::Float64)`  or `(\"energy: from atomic to Hz\", value::Float64)`  or  `(\"energy: from atomic to Angstrom\", value::Float64)`    ... to convert an energy value from atomic to the speficied energy unit; a Float64 is returned.\n",
       "  * `(\"energy: from predefined to atomic unit\", value::Float64)`  or  `(\"energy: to atomic\", value::Float64)`... to convert an energy value                                                from the predefined to the atomic energy unit; a Float64 is returned.\n",
       "  * `(\"energy: from eV to atomic unit\", value::Float64)` ... to convert an energy value from eV to the atomic energy unit; a Float64 is returned.\n",
       "  * `(\"energy: from wavelength [nm] to atomic\", value::Float64)` ... to convert a wavelength [nm] to the atomic energy unit; a Float64 is returned.\n",
       "  * `(\"intensity: from W/cm^2 to atomic\", value::Float64)` ... to convert the intensity [in W/cm^2] to the atomic intensity unit; a Float64 is returned.\n",
       "  * `(\"kinetic energy to wave number: atomic units\", value::Float64)`  ... to convert a kinetic energy value (in a.u.) into a wave number                                               k (a.u.); a Float64 is returned.\n",
       "  * `(\"kinetic energy to wavelength: atomic units\", value::Float64)`  ... to convert a kinetic energy value (in a.u.) into a wavelength (a.u.);                                                a Float64 is returned.\n",
       "  * `(\"length: from fm to atomic\", value::Float64)`  ... to convert a length value (in fm) into a.u.;  a Float64 is returned.\n",
       "  * `(\"length: from atomic to fm\", value::Float64)`  ... to convert a length value (in Bohr's a.u.) into fm;  a Float64 is returned.\n",
       "  * `(\"rate: from atomic to predefined unit\", value::Float64)`  or  (\"rate: from atomic\", value::Float64)  ... to convert a rate value                                            from atomic to the predefined rate unit; a Float64 is returned.\n",
       "  * `(\"rate: from atomic to 1/s\", value::Float64)`  ... to convert an rate value from atomic to the speficied rate unit; a Float64 is returned.\n",
       "  * `(\"rate: from predefined to atomic unit\", value::Float64)`  or  `(\"rate: to atomic\", value::Float64)'... to convert a                                               rate value from the predefined to the atomic rate unit; a Float64 is returned.\n",
       "  * `(\"time: from atomic to predefined unit\", value::Float64)`  or  (\"time: from atomic\", value::Float64)  ... to convert an time value                                            from atomic to the predefined time unit; a Float64 is returned.\n",
       "  * `(\"time: from atomic to sec\", value::Float64)`  or  `(\"time: from atomic to fs\", value::Float64)'  or`(\"time: from atomic to as\", value::Float64)`  ... to convert a time value from atomic to the speficied time unit; a Float64 is returned.\n",
       "  * `(\"time: from predefined to atomic unit\", value::Float64)`  or  `(\"time: to atomic\", value::Float64)'  ... to convert a                                           time value from the predefined to the atomic time unit; a Float64 is returned.\n",
       "  * `(\"wave number to total electron energy: atomic units\", value::Float64)`  ... to convert a wavenumber (a.u.) into the total electron                                           energy, including the rest energy; a Float64 is returned.\n",
       "  * `(\"wave number to kinetic energy: atomic units\", value::Float64)`  ... to convert a wavenumber (a.u.) into the kinetic energy;                                            a Float64 is returned.\n"
      ],
      "text/plain": [
       "  \u001b[36mDefaults.convertUnits()\u001b[39m ... converts some data from one format/unit into\n",
       "  another one; cf. the supported keystrings and return values.\n",
       "\n",
       "    •    \u001b[36m(\"cross section: from atomic to predefined unit\", value::Float64)\u001b[39m\n",
       "        or \u001b[36m(\"cross section: from atomic\", value::Float64)\u001b[39m ... to convert\n",
       "        an energy value from atomic to the predefined cross section unit;\n",
       "        a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"cross section: from atomic to barn\", value::Float64)\u001b[39m or \u001b[36m(\"cross\n",
       "        section: from atomic to Mbarn\", value::Float64)\u001b[39m or \u001b[36m(\"cross\n",
       "        section: from atomic to Hz\", value::Float64)\u001b[39m or \u001b[36m(\"energy: from\n",
       "        atomic to Angstrom\", value::Float64)\u001b[39m ... to convert an energy\n",
       "        value from atomic to the speficied cross section unit; a Float64\n",
       "        is returned.\n",
       "\n",
       "    •    \u001b[36m(\"cross section: from predefined to atomic unit\", value::Float64)\u001b[39m\n",
       "        or \u001b[36m(\"cross section: to atomic\", value::Float64)\u001b[39m ... to convert a\n",
       "        cross section value from the predefined to the atomic cross\n",
       "        section unit; a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"einstein B: from atomic\", value::Float64)\u001b[39m ... to convert a\n",
       "        Einstein B coefficient from atomic to the speficied energy units;\n",
       "        a Float64 is returned.or\n",
       "\n",
       "    •    \u001b[36m(\"energy: from atomic to eV\", value::Float64)\u001b[39m or \u001b[36m(\"energy: from\n",
       "        atomic to Kayser\", value::Float64)\u001b[39m or \u001b[36m(\"energy: from atomic to\n",
       "        Hz\", value::Float64)\u001b[39m or \u001b[36m(\"energy: from atomic to Angstrom\",\n",
       "        value::Float64)\u001b[39m ... to convert an energy value from atomic to the\n",
       "        speficied energy unit; a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"energy: from predefined to atomic unit\", value::Float64)\u001b[39m or\n",
       "        \u001b[36m(\"energy: to atomic\", value::Float64)\u001b[39m... to convert an energy\n",
       "        value from the predefined to the atomic energy unit; a Float64 is\n",
       "        returned.\n",
       "\n",
       "    •    \u001b[36m(\"energy: from eV to atomic unit\", value::Float64)\u001b[39m ... to convert\n",
       "        an energy value from eV to the atomic energy unit; a Float64 is\n",
       "        returned.\n",
       "\n",
       "    •    \u001b[36m(\"energy: from wavelength [nm] to atomic\", value::Float64)\u001b[39m ... to\n",
       "        convert a wavelength [nm] to the atomic energy unit; a Float64 is\n",
       "        returned.\n",
       "\n",
       "    •    \u001b[36m(\"intensity: from W/cm^2 to atomic\", value::Float64)\u001b[39m ... to\n",
       "        convert the intensity [in W/cm^2] to the atomic intensity unit; a\n",
       "        Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"kinetic energy to wave number: atomic units\", value::Float64)\u001b[39m\n",
       "        ... to convert a kinetic energy value (in a.u.) into a wave number\n",
       "        k (a.u.); a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"kinetic energy to wavelength: atomic units\", value::Float64)\u001b[39m ...\n",
       "        to convert a kinetic energy value (in a.u.) into a wavelength\n",
       "        (a.u.); a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"length: from fm to atomic\", value::Float64)\u001b[39m ... to convert a\n",
       "        length value (in fm) into a.u.; a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"length: from atomic to fm\", value::Float64)\u001b[39m ... to convert a\n",
       "        length value (in Bohr's a.u.) into fm; a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"rate: from atomic to predefined unit\", value::Float64)\u001b[39m or\n",
       "        (\"rate: from atomic\", value::Float64) ... to convert a rate value\n",
       "        from atomic to the predefined rate unit; a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"rate: from atomic to 1/s\", value::Float64)\u001b[39m ... to convert an\n",
       "        rate value from atomic to the speficied rate unit; a Float64 is\n",
       "        returned.\n",
       "\n",
       "    •    \u001b[36m(\"rate: from predefined to atomic unit\", value::Float64)\u001b[39m or\n",
       "        `(\"rate: to atomic\", value::Float64)'... to convert a rate value\n",
       "        from the predefined to the atomic rate unit; a Float64 is\n",
       "        returned.\n",
       "\n",
       "    •    \u001b[36m(\"time: from atomic to predefined unit\", value::Float64)\u001b[39m or\n",
       "        (\"time: from atomic\", value::Float64) ... to convert an time value\n",
       "        from atomic to the predefined time unit; a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"time: from atomic to sec\", value::Float64)\u001b[39m or \u001b[36m(\"time: from\n",
       "        atomic to fs\", value::Float64)'  or\u001b[39m(\"time: from atomic to as\",\n",
       "        value::Float64)` ... to convert a time value from atomic to the\n",
       "        speficied time unit; a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"time: from predefined to atomic unit\", value::Float64)\u001b[39m or\n",
       "        `(\"time: to atomic\", value::Float64)' ... to convert a time value\n",
       "        from the predefined to the atomic time unit; a Float64 is\n",
       "        returned.\n",
       "\n",
       "    •    \u001b[36m(\"wave number to total electron energy: atomic units\",\n",
       "        value::Float64)\u001b[39m ... to convert a wavenumber (a.u.) into the total\n",
       "        electron energy, including the rest energy; a Float64 is returned.\n",
       "\n",
       "    •    \u001b[36m(\"wave number to kinetic energy: atomic units\", value::Float64)\u001b[39m\n",
       "        ... to convert a wavenumber (a.u.) into the kinetic energy; a\n",
       "        Float64 is returned."
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Defaults.convertUnits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function is called at many places within JAC to generate tables where all physical data are printed out in the pre-specified values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "219474.63068"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Defaults.convertUnits(\"energy: from atomic\", 1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the given user-selection, this is equivalent to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "219474.63068"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Defaults.convertUnits(\"energy: from atomic to Kayser\", 1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In JAC, the call of this function is often combined with some proper formatting of the results, such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"2.1947e+05\""
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Printf\n",
    "@sprintf(\"%.4e\", Defaults.convertUnits(\"energy: from atomic\", 1.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following tutorials, we wish to explain the user in further detail how such computations can be performed. In particular, we shall demonstrate that JAC already provides a good basis, although (much) further work has to be done to increase the power, efficiency and range of applications. We certainly wish to encourage the users to fork the code and to report improvements, failures, bugs, etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.4.2",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}