tutorial_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## hammurabiX tutorial 01\n",
    "\n",
    "### hammurabiX with given field models\n",
    "\n",
    "This tutorial describes the basic usage of the python wrapper which depends on an XML parameter file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import healpy as hp\n",
    "import os\n",
    "import sys\n",
    "import hampyx as hpx\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### hampyx, the hammurabiX python wrapper\n",
    "\n",
    "The Hampyx init function:\n",
    "\n",
    "```\n",
    "def __init__(self,\n",
    "             xml_path=None,\n",
    "             exe_path=None)\n",
    "```\n",
    "\n",
    "The path to the executable `exe_path` (upon the default input `None`) is searched automatically through the system environment (by taking the first executable target with key word `hamx` registered in `PATH`), while the path to the XML parameter file `xml_path` by default is searched automatically through the current working directory and the first match with `*.xml` will be taken.\n",
    "\n",
    "Users can store different sets of `hammuarbiX` parameters in different `XML` files.\n",
    "\n",
    "working directory is set as the same directory as this file, it relies on subprocess to fork `C++` routine and passing data through disk, and by doing so, it is not fast.\n",
    "\n",
    "Notice that `hammurabiX` uses `XML` input parameter file, which may look like:\n",
    "\n",
    "```\n",
    "<root>\n",
    "    ...\n",
    "    <key1 tag1='content1'>\n",
    "        ...\n",
    "        <key2 tag21='content21' tag22='content22'/>\n",
    "        ...\n",
    "    </key1>\n",
    "    ...\n",
    "</root>\n",
    "```\n",
    "We highly recommend users to read the template_params.xml first, where sufficient captions have been provided.\n",
    "\n",
    "methods/functions:\n",
    "\n",
    "- Import class\n",
    "\n",
    "```\n",
    "In []: import hampyx as hpx\n",
    "```\n",
    "\n",
    "- Initialize instance/object\n",
    "\n",
    "```\n",
    "In []: object = hpx.Hampyx (exe_path, xml_path)\n",
    "```\n",
    "\n",
    "- Modify parameter value from base xml file to temp `XML` file\n",
    "\n",
    "```\n",
    "In []: object.mod_par (keychain=['key1','key2',...], attrib={'tag':'content'})\n",
    "```\n",
    "\n",
    "- Add new parameter with or without attributes.\n",
    "\n",
    "```\n",
    "In []: object.add_par (keychain=['key1','key2',...], subkey='keyfinal', attrib={'tag':'content'})\n",
    "```\n",
    "\n",
    "The new parameter subkey, will be added at the path defined by keychain.\n",
    "\n",
    "- Delete parameter\n",
    "\n",
    "```\n",
    "In []: object.del_par (keychain=['key1','key2',...],opt='')\n",
    "```\n",
    "\n",
    "If additional argument opt='all', then all matching parameters will be deleted.\n",
    "\n",
    "The strings 'key1', 'key2', etc represent the path to the desired parameter, going through the `XML` file.\n",
    "\n",
    "The \"tag\" is the label for the parameter: eg. \"Value\" or \"cue\" or \"type\".\n",
    "\n",
    "The \"content\" is the content under the tag: eg. the string for the tag \"filename\"\n",
    "\n",
    "- Look through the parameter tree in python\n",
    "\n",
    "```\n",
    "In []: object.print_par(keychain=['key1','key2',...])\n",
    "```\n",
    "\n",
    "This will return the current value of the parameter in the `XML` associated with the path \"key1/key2/.../keyfinal/\".\n",
    "\n",
    "- Run the executable\n",
    "\n",
    "```\n",
    "In []: object(verbose=True/False)\n",
    "```\n",
    "\n",
    "If additional verbose=True (by default is False) hampyx_run.log and hampyx_err.log will be dumped to disk\n",
    "notice that dumping logs is not thread safe, use quiet mode in threading.\n",
    "\n",
    "After this main routine, object.sim_map will be filled with simulation outputs from hammurabiX\n",
    "the structure of object.sim_map contains arrays under entries:\n",
    "\n",
    "(we give up nested dict structure for the convenience of Bayesian analysis)\n",
    "\n",
    "```\n",
    "object.sim_map[('sync',str(freq),str(Nside),'I')] # synchrotron intensity map at 'frequency' \n",
    "object.sim_map[('sync',str(freq),str(Nside),'Q')] # synchrotron Q map at 'frequency' \n",
    "object.sim_map[('sync',str(freq),str(Nside),'U')] # synchrotron U map at 'frequency'\n",
    "object.sim_map[('fd','nan',str(Nside),'nan')] # Faraday depth map\n",
    "object.sim_map[('dm','nan',str(Nside),'nan')] # dispersion measure map\n",
    "```\n",
    "\n",
    "#### In the following we will present how to use above functions\n",
    "\n",
    "#### initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observable {}\n",
      "|-->  dm {'cue': '1', 'filename': 'dm.bin', 'nside': '8'}\n",
      "|-->  faraday {'cue': '1', 'filename': 'fd.bin', 'nside': '64'}\n",
      "|-->  sync {'cue': '1', 'freq': '30', 'filename': 'sync_30.bin', 'nside': '16'}\n",
      "|-->  sync {'cue': '1', 'freq': '1.4', 'filename': 'sync_1.4.bin', 'nside': '32'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "xmlpath = '../templates/params_template.xml'\n",
    "sim = hpx.Hampyx(xml_path=xmlpath)\n",
    "\n",
    "# print root->observable\n",
    "sim.print_par(['observable'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- once the `XML` parameter file is read in, the `XML` tree is deep copied and so the following modifications does not affect the external file, unless explicit write the tree to the disk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### use `del_par` to remove dust emission outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observable {}\n",
      "|-->  dm {'cue': '1', 'filename': 'dm.bin', 'nside': '8'}\n",
      "|-->  faraday {'cue': '1', 'filename': 'fd.bin', 'nside': '64'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.del_par(['observable','sync'],'all')\n",
    "sim.print_par(['observable'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### use `mod_par` to change synchrotron emission output resolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observable {}\n",
      "|-->  dm {'cue': '1', 'filename': 'dm.bin', 'nside': '8'}\n",
      "|-->  faraday {'cue': '1', 'filename': 'fd.bin', 'nside': '2'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.mod_par(['observable','faraday'],{'nside':'2'})\n",
    "sim.print_par(['observable'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### use `add_par` to add another synchrotron emission output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observable {}\n",
      "|-->  dm {'cue': '1', 'filename': 'dm.bin', 'nside': '8'}\n",
      "|-->  faraday {'cue': '1', 'filename': 'fd.bin', 'nside': '2'}\n",
      "|-->  sync {'cue': '1', 'freq': '10', 'filename': 'sync_10.bin', 'nside': '8'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.add_par(['observable'],'sync',{'cue':'1','freq':'10','filename':'sync_10.bin','nside':'8'})\n",
    "sim.print_par(['observable'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- upon adding an existed key with existed attributes, a ValueError will be raised"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### check field i/o settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fieldio {}\n",
      "|-->  breg {'read': '0', 'write': '0', 'filename': 'breg.bin'}\n",
      "|-->  brnd {'read': '0', 'write': '0', 'filename': 'brnd.bin'}\n",
      "|-->  tereg {'read': '0', 'write': '0', 'filename': 'tereg.bin'}\n",
      "|-->  ternd {'read': '0', 'write': '0', 'filename': 'ternd.bin'}\n",
      "|-->  cre {'read': '0', 'write': '0', 'filename': 'cre.bin'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.print_par(['fieldio'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### check grid settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "grid {}\n",
      "|-->  observer {}\n",
      "|-->  box_breg {}\n",
      "|-->  box_brnd {}\n",
      "|-->  box_tereg {}\n",
      "|-->  box_ternd {}\n",
      "|-->  box_cre {}\n",
      "|-->  shell {}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.print_par(['grid'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- grid->observer hosts the galactic-centric location of the observer (in kpc unit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observer {}\n",
      "|-->  x {'value': '-8.3'}\n",
      "|-->  y {'value': '0'}\n",
      "|-->  z {'value': '0.006'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.print_par(['grid','observer'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- shell hosts the LoS integral settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shell {}\n",
      "|-->  layer {'type': 'auto'}\n",
      "|-->  oc_r_min {'value': '0.0'}\n",
      "|-->  oc_r_max {'value': '30.0'}\n",
      "|-->  gc_r_min {'value': '0.0'}\n",
      "|-->  gc_r_max {'value': '20.0'}\n",
      "|-->  gc_z_min {'value': '-10.0'}\n",
      "|-->  gc_z_max {'value': '10.0'}\n",
      "|-->  oc_r_res {'value': '0.01'}\n",
      "\n",
      "layer {'type': 'auto'}\n",
      "|-->  auto {}\n",
      "|-->  manual {}\n",
      "\n",
      "auto {}\n",
      "|-->  shell_num {'value': '1'}\n",
      "|-->  nside_sim {'value': '32'}\n",
      "\n",
      "manual {}\n",
      "|-->  cut {'value': '0.5'}\n",
      "|-->  nside_sim {'value': '32'}\n",
      "|-->  nside_sim {'value': '64'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.print_par(['grid','shell'])\n",
    "print()\n",
    "sim.print_par(['grid','shell','layer'])\n",
    "print()\n",
    "sim.print_par(['grid','shell','layer','auto'])\n",
    "print()\n",
    "sim.print_par(['grid','shell','layer','manual'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### check magnetic field settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "magneticfield {}\n",
      "|-->  regular {'cue': '1', 'type': 'unif'}\n",
      "|-->  random {'cue': '0', 'type': 'local', 'seed': '0'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.print_par(['magneticfield'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### check thermal electron field settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "thermalelectron {}\n",
      "|-->  regular {'cue': '1', 'type': 'unif'}\n",
      "|-->  random {'cue': '0', 'type': 'global', 'seed': '0'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.print_par(['thermalelectron'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### check cosmic ray electron field settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cre {'cue': '1', 'type': 'unif'}\n",
      "|-->  analytic {}\n",
      "|-->  unif {}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.print_par(['cre'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### users are recommended to check all parameters to make sure they are set as expected, then we can start to run the simulation routine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- the optional input argument verbose=True/False determines whether the log of hammurabiX execution will be printed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- get the output entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('dm', 'nan', '8', 'nan')\n",
      "('fd', 'nan', '2', 'nan')\n",
      "('sync', '10', '8', 'I')\n",
      "('sync', '10', '8', 'Q')\n",
      "('sync', '10', '8', 'U')\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "for key in sim.sim_map.keys():\n",
    "    print (key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- illustrate simulated map behind one entry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x388.8 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "out_sync_Q = sim.sim_map[('sync', '10', '8', 'Q')]\n",
    "hp.mollview(out_sync_Q,norm='hist')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### play with mask map\n",
    "\n",
    "for simulating partial-sky maps and saving computing time, hammurabi X can read in a single mask map provided in HEALPix format, this external mask map once read in, will be applied to all simulation outputs.\n",
    "\n",
    "Notice that, the mask map resolution is read in as the pivot masking resolution, which means it DOES NOT defines the output resolution, so the output results will ONLY ensure that the un-masked area is included, sometimes, the masked area near the masking boudary will also be calculated due to the resolution difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "faction:  0.32902018229166663\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x388.8 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "# mask resolution\n",
    "mask_nside = 32\n",
    "\n",
    "def mask_map_prod(_nside,_clon,_clat,_sep,_external_mask=None):\n",
    "    _c = np.pi/180\n",
    "    def hav(_theta):\n",
    "        return 0.5-0.5*np.cos(_theta)\n",
    "    tmp = np.ones(hp.nside2npix(_nside),dtype=np.float64)\n",
    "    count = 0\n",
    "    for _ipix in range(len(tmp)):\n",
    "        lon,lat = hp.pix2ang(_nside,_ipix,lonlat=True)\n",
    "        # iso-angle separation\n",
    "        if((hav(np.fabs(_clat-lat)*_c)+np.cos(_clat*_c)*np.cos(lat*_c)*hav(np.fabs(_clon-lon)*_c))>hav(_sep*_c)):\n",
    "            count = count + 1\n",
    "            tmp[_ipix] = False\n",
    "    print ('faction: ', (1 - count/(12*_nside*_nside)))\n",
    "    return tmp\n",
    "\n",
    "# prepare mask\n",
    "cust_tmask = mask_map_prod(mask_nside, 30, 20, 70)\n",
    "hp.orthview(cust_tmask, rot=[0,90], min=0, max=1, title='mask')\n",
    "if os.path.isfile('mask_tutorial_01.bin'):\n",
    "    os.remove('mask_tutorial_01.bin')\n",
    "cust_tmask.tofile('mask_tutorial_01.bin')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**modify the mask entry**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mask {'cue': '1', 'filename': 'mask_tutorial_01.bin', 'nside': '32'}\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim.mod_par(['mask'],{'cue': '1', 'filename': 'mask_tutorial_01.bin'})\n",
    "sim.print_par(['mask'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**rerun the simulation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "sim()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**the masked pixels should have value 0.0**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x388.8 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#NBVAL_CHECK_OUTPUT\n",
    "\n",
    "out_sync_Q = sim.sim_map[('sync', '10', '8', 'Q')]\n",
    "absmax = np.max(out_sync_Q)\n",
    "hp.orthview(out_sync_Q, rot=[0,90], norm='hist',max=absmax,min=-absmax,cmap='coolwarm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "clean up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.path.isfile('mask_tutorial_01.bin'):\n",
    "    os.remove('mask_tutorial_01.bin')\n",
    "if os.path.isfile('err.log'):\n",
    "    os.remove('err.log')\n",
    "if os.path.isfile('run.log'):\n",
    "    os.remove('run.log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "end"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}