diff --git a/.gitignore b/.gitignore
index 13204b6f816513d708cfecfb7f4ebce19873f22a..c52417628ad5a75f1c3c46fc492245f4282c2154 100644
--- a/.gitignore
+++ b/.gitignore
@@ -32,3 +32,4 @@ parser.osio.log
 gui/src/metainfo.json
 gui/src/searchQuantities.json
 gui/src/parserMetadata.json
+examples/workdir/
diff --git a/examples/dos_analyzer.ipynb b/examples/dos_analyzer.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..efeb3136b8384897b282bb39c7ec05fb9ff3e1f4
--- /dev/null
+++ b/examples/dos_analyzer.ipynb
@@ -0,0 +1,1053 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Dos Analyser\n",
+    "  \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Changelog\n",
+    "- Removed external dependencies (input files) by downloading calculations on demand, <br>\n",
+    "  via `requests` module, from NOMAD's Archive & Repository.\n",
+    "- All downloads or figure files are saved to `./workdir/`, which is listed in a `.gitignore`\n",
+    "\n",
+    "# Notes\n",
+    "This notebook makes large use of python's `requests` module to download data from [NOMAD's Archive & Repository (link).](https://repository.nomad-coe.eu/app/api/)\n",
+    "\n",
+    "- **Note on encodings:**\n",
+    " \"_HTML and XML have the ability to specify their encoding in their body. In situations like this, you should use `r.content` to find the encoding, and then set `r.encoding`. This will let you use `r.text`_ \"[Ref: (requests quickstart)](https://requests.readthedocs.io/en/master/user/quickstart/)\n",
+    " \n",
+    " \n",
+    "- **root | tree** : \"`ElementTree.fromstring()` _parses XML from a string directly into an `Element`, which is the root element of the parsed tree_ [hence we name the returned object as `root`]. _Other parsing functions may create an_ `ElementTree` [and their returned object would be conveniently named as `tree`]\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Input Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Try to keep all calculation parameters in this cell\n",
+    "\n",
+    "case = {}\n",
+    "case['upload_id'] = 'pT4cDgonSeK_RTagfGnz2g'\n",
+    "case['calc_id'] = 'PMtdh8FOg02FedbM5PRIf62yimVm'\n",
+    "case['calc_url'] = 'https://repository.nomad-coe.eu/app/gui/entry/id/pT4cDgonSeK_RTagfGnz2g/PMtdh8FOg02FedbM5PRIf62yimVm'\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import all required modules, except for plotting\n",
+    "import json\n",
+    "import requests\n",
+    "import os.path\n",
+    "import numpy as np\n",
+    "import xml.etree.ElementTree as ET\n",
+    "\n",
+    "# Unit Conversion Factors\n",
+    "from nomad.units import ureg\n",
+    "Ha2eV = (1.0 * ureg.a_u_energy).to(ureg.eV).magnitude # Hartree to eV\n",
+    "J2eV = (1.0 * ureg.J).to(ureg.eV).magnitude # Joules to eV\n",
+    "\n",
+    "# URLs to NOMAD's Archive & Repo\n",
+    "nomad_rae = 'http://nomad-lab.eu/prod/rae/api/raw' # bundle, ZIP\n",
+    "\n",
+    "nomad_app = 'https://repository.nomad-coe.eu/app/api/' # single file\n",
+    "nomad_arx = nomad_app + 'archive/' # processed calc's\n",
+    "nomad_rep = nomad_app + 'repo/'    # calc's metadata\n",
+    "nomad_raw = nomad_app + 'raw/'     # unprocessed calc's\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# FUNCTIONS\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def url_fetch_file(case, fname, verbose=False):\n",
+    "    '''\n",
+    "    fetch file `fname` from NOMAD's archive, via requests\n",
+    "    '''\n",
+    "    upload_id = case['upload_id']\n",
+    "    calc_id = case['calc_id']\n",
+    "    \n",
+    "    # Fetch the calculation metadata \n",
+    "    url = nomad_rep + upload_id + '/' + calc_id \n",
+    "    metadata = requests.get(url).json()\n",
+    "\n",
+    "    # pick up filename path from metadata\n",
+    "    calc_path = os.path.dirname(metadata['mainfile'] ) \n",
+    "    fname_full = calc_path + '/' + fname\n",
+    "\n",
+    "    # download fname as 'response' object\n",
+    "    url = nomad_raw + upload_id + '/' + fname_full\n",
+    "    response = requests.get(url)\n",
+    "    \n",
+    "    if verbose:\n",
+    "        print('type(response): ', type(response))\n",
+    "        print('Received encoding:', response.encoding) # see note below\n",
+    "    return response\n",
+    "# ------\n",
+    "\n",
+    "def xml_find_dos(root, verbose=False):\n",
+    "    '''\n",
+    "    root: an xml root object\n",
+    "    returns: a tuple (True|False, level), where `level` is the depth\n",
+    "    at which `totaldos` was found\n",
+    "    '''\n",
+    "    if verbose:\n",
+    "        print('[TAG] \\t\\tATTRIBUTE')\n",
+    "    level = 0\n",
+    "    for child in root:\n",
+    "        if verbose:\n",
+    "            print('[{:10s}]\\t{}'.format(child.tag, child.attrib) )\n",
+    "        if child.tag == 'totaldos':\n",
+    "            print('`totaldos` found at level {}'.format(level))\n",
+    "            return (True, level)\n",
+    "        level += 1\n",
+    "# - - -        \n",
+    "\n",
+    "\n",
+    "def xml_dos_dimensions(root, verbose=False):\n",
+    "    '''\n",
+    "    Determine spin_count and energy_points  \n",
+    "    root: a xml root object\n",
+    "    '''\n",
+    "    spin_count = 0\n",
+    "    energy_points = 0\n",
+    "    \n",
+    "    # There is one 'diagram' per spin\n",
+    "    # root.iter() does deep search\n",
+    "    for diag in root.iter('diagram'):\n",
+    "        spin_count += 1\n",
+    "        \n",
+    "        if energy_points ==0:\n",
+    "            energy_points = len(diag.findall('point') )\n",
+    "        else:\n",
+    "            # paranoic check: both spins have same num ene points\n",
+    "            assert energy_points ==len(diag.findall('point') )\n",
+    "            \n",
+    "        if verbose:\n",
+    "            print('nspin: {}, size:{} ' .format(spin_count, energy_points))\n",
+    "    return (spin_count, energy_points )  \n",
+    "# ---\n",
+    "\n",
+    "def fetch_dos_section(sscc, dos_type, verbose=False):\n",
+    "    '''\n",
+    "    Finds and returns `dos_energies` and `dos_values` from a \n",
+    "    given `sscc` list. The later comes from a \n",
+    "    NOMAD's json output. \n",
+    "    '''\n",
+    "    \n",
+    "    item_count = 0\n",
+    "    assert (dos_type in ['raw', 'normalized'])\n",
+    "    \n",
+    "    def set_keynames(dos_type, dos_dict):\n",
+    "        ''' \n",
+    "        Set key names (strings). Handles cases where \n",
+    "        normalized data is requested but \n",
+    "        `dos_energies_normalized` is absent\n",
+    "        '''\n",
+    "        if dos_type == 'raw':\n",
+    "            dos_ene = 'dos_energies'\n",
+    "            dos_vals = 'dos_values'\n",
+    "        # 'raw' type always contains previous key names\n",
+    "        # however, 'normalized' type might have or not the '_normalized'\n",
+    "        # appendix, or don't have the energies array. Hence, a few checks\n",
+    "        # are in place\n",
+    "        elif dos_type == 'normalized': \n",
+    "            dos_vals = 'dos_values_normalized'\n",
+    "            \n",
+    "            # there're two alternatives for the energy counterpart\n",
+    "            if 'dos_energies_normalized' in dos_dict:\n",
+    "                dos_ene = 'dos_energies_normalized'\n",
+    "            elif 'dos_energies' in dos_dict:\n",
+    "                # fall back\n",
+    "                dos_ene = 'dos_energies'\n",
+    "            else:\n",
+    "                dos_ene = None\n",
+    "        # ---\n",
+    "        return dos_ene, dos_vals        \n",
+    "    # ---\n",
+    "\n",
+    "    # sscc: list of dictionaries\n",
+    "    for item in sscc:\n",
+    "        if verbose:\n",
+    "            print('item_count:', item_count)\n",
+    "            \n",
+    "        if 'section_dos' in item:\n",
+    "            dos_dict = item['section_dos'][0]\n",
+    "            \n",
+    "            if 'gw_self_energy_c' not in item:\n",
+    "                print('sscc no. {}: section_dos found' .format(item_count))\n",
+    "                dos_ene, dos_vals = set_keynames(dos_type, dos_dict)\n",
+    "                \n",
+    "                ########\n",
+    "                energy_pts = len(dos_dict[dos_ene])\n",
+    "                spin_count = len(dos_dict[dos_vals])\n",
+    "                \n",
+    "                dos_energies = np.zeros((energy_pts))\n",
+    "                dos_values = np.zeros((energy_pts, spin_count))\n",
+    "                \n",
+    "                # store data                \n",
+    "                dos_energies[:] = dos_dict[dos_ene]  \n",
+    "                for spin in range(spin_count):\n",
+    "                    dos_values[:,spin] = dos_dict[dos_vals][spin] \n",
+    "                    \n",
+    "            elif 'gw_self_energy_c' in item:  \n",
+    "                # This `elif` branch might become unnecessary if we can confirm \n",
+    "                # that GW SSCC shouldn't contain any dos_section.\n",
+    "                pass\n",
+    "                \n",
+    "        else:\n",
+    "            print('sscc no. {}: section_dos absent' .format(item_count))\n",
+    "        item_count += 1\n",
+    "\n",
+    "    return (dos_energies, dos_values )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# 1. RAW DFT\n",
+    "Download a DOS calculation, verbatim, as produced by the DFT code.\n",
+    "\n",
+    "We only download the DOS data file."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "type(response):  <class 'requests.models.Response'>\n",
+      "Received encoding: utf-8\n",
+      "spin_count:    1\n",
+      "energy_points: 500\n"
+     ]
+    }
+   ],
+   "source": [
+    "# WARNING: This cell downloads an exciting DOS file (XML format).\n",
+    "#          Other DFT codes might use other file formats.          \n",
+    "\n",
+    "# fetch the DOS data file\n",
+    "dos_datafile = 'dos.xml' # an exciting dos file\n",
+    "\n",
+    "# next line is dft-code independent\n",
+    "response_dos = url_fetch_file(case, dos_datafile, verbose=True)\n",
+    "\n",
+    "# Use the 'ElementTree XML API'\n",
+    "root = ET.fromstring(response_dos.content)\n",
+    "\n",
+    "spin_count, energy_points = xml_dos_dimensions(root)\n",
+    "print('spin_count:   ', spin_count)\n",
+    "print('energy_points:', energy_points)\n",
+    "\n",
+    "# create arrays\n",
+    "dos_energies_raw = np.zeros((energy_points))\n",
+    "dos_values_raw = np.zeros((energy_points, spin_count))\n",
+    "\n",
+    "# fill in arrays\n",
+    "for td in root.findall('totaldos'):\n",
+    "    for diag in td.findall('diagram'):\n",
+    "        # nspin is the spin index, not spin_count\n",
+    "        # also, 1<= nspin <= spin_count <=2\n",
+    "        nspin = int(diag.get('nspin'))\n",
+    "        for pt in range(energy_points):\n",
+    "            point = diag[pt]\n",
+    "            dos_energies_raw[pt] = point.get('e')\n",
+    "            dos_values_raw[pt, nspin-1] = point.get('dos')\n",
+    "            \n",
+    "\n",
+    "# unit conversion\n",
+    "dos_energies_raw *= Ha2eV \n",
+    "dos_values_raw /= Ha2eV\n",
+    "\n",
+    "# ALERT: exciting code reports DOS values shifted by Fermi energy."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2. Archive \n",
+    "## Fetch (parsed) Metainfo from Archive\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "url: https://repository.nomad-coe.eu/app/api/archive/pT4cDgonSeK_RTagfGnz2g/PMtdh8FOg02FedbM5PRIf62yimVm\n",
+      "\n",
+      "sscc no. 0: section_dos found\n",
+      "sscc no. 2: section_dos absent\n"
+     ]
+    }
+   ],
+   "source": [
+    "# WARNING: This cell is DFT-code independent (any calc in NOMAD's archive)\n",
+    "\n",
+    "# fetch metadata\n",
+    "upload_id = case['upload_id']\n",
+    "calc_id = case['calc_id']\n",
+    "url = nomad_arx + upload_id +'/' + calc_id\n",
+    "print('url: {}\\n' .format(url))\n",
+    "\n",
+    "metadata = requests.get(url).json()\n",
+    "\n",
+    "sscc_str = 'section_single_configuration_calculation'\n",
+    "sscc_list = metadata['section_run'][0][sscc_str]   \n",
+    "\n",
+    "dos_type = ['raw', 'normalized'][0]   \n",
+    "dos_sec = fetch_dos_section(sscc_list, dos_type, verbose=False)\n",
+    "\n",
+    "dos_energies_arx, dos_values_arx = dos_sec\n",
+    "\n",
+    "# unit conversion    \n",
+    "dos_energies_arx *= J2eV\n",
+    "dos_values_arx /= J2eV"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Parse programatically \n",
+    "### 1. Download calculation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving file:  ./workdir/INFO.OUT\n",
+      "Saving file:  ./workdir/dos.xml\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "from nomad.cli.parse import parse, normalize_all\n",
+    "\n",
+    "code='exciting'\n",
+    "if code=='exciting':\n",
+    "    fnames = ['INFO.OUT', 'dos.xml']\n",
+    "    \n",
+    "outdir = './workdir/'\n",
+    "for fname in fnames:   \n",
+    "    response = url_fetch_file(case, fname, verbose=False)\n",
+    "    outfile = outdir + fname\n",
+    "    with open(outfile, 'w') as fh:\n",
+    "        print('Saving file: ', outfile)\n",
+    "        fh.write(response.text)\n",
+    "# - - -\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. Parse downloaded calculation\n",
+    "\n",
+    "see the [documentation](https://nomad-lab.eu/prod/rae/docs/client/parsers.html)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "mainfile: ./workdir/INFO.OUT\n"
+     ]
+    }
+   ],
+   "source": [
+    "mainfile = outdir + fnames[0]   \n",
+    "print(f'mainfile: {mainfile}')\n",
+    "\n",
+    "# match and run the parser\n",
+    "archive = parse(mainfile)\n",
+    "\n",
+    "normalize_all(archive)\n",
+    "\n",
+    "# get the 'main section' section_run as a metainfo object\n",
+    "section_run = archive.section_run[0]\n",
+    "\n",
+    "# get the same data as JSON serializable Python dict\n",
+    "python_dict = section_run.m_to_dict()   \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. Pick-up dos data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sscc no. 0: section_dos found\n"
+     ]
+    }
+   ],
+   "source": [
+    "sscc_str = 'section_single_configuration_calculation'\n",
+    "sscc_list = python_dict[sscc_str]\n",
+    "\n",
+    "dos_type = ['raw', 'normalized'][0]   \n",
+    "dos_sec = fetch_dos_section(sscc_list, dos_type, verbose=False)\n",
+    "\n",
+    "dos_energies_now, dos_values_now = dos_sec\n",
+    "\n",
+    "# unit conversion    \n",
+    "dos_energies_now *= J2eV\n",
+    "dos_values_now /= J2eV"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PLOTS\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data arrays\n",
+    "```\n",
+    "- dos_energies_raw , dos_values_raw\n",
+    "- dos_energies_arx , dos_values_arx  \n",
+    "- dos_energies_now, dos_values_now\n",
+    "```\n",
+    "### Keys:\n",
+    "- `'raw'`:  raw-calc downloaded from repo\n",
+    "- `'now'`:  freshly parsed 'raw' (raw-calc downloaded from repo)\n",
+    "- `'arx'`:  parsed-calc downloaded from archive"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "key\t dos_energies \t dos_values\t dos_values.max\n",
+      "raw\t(500,)      \t(500, 1)\t3.191\n",
+      "arx\t(500,)      \t(500, 2)\t1.278e-28\n",
+      "now\t(500,)      \t(500, 2)\t1.278e-28\n",
+      "-----\n",
+      "\n",
+      "Remove cell normalization from `raw`:\n",
+      "key\t dos_energies \t dos_values\t dos_values.max\n",
+      "raw\t(500,)      \t(500, 1)\t1.278e-28\n",
+      "arx\t(500,)      \t(500, 2)\t1.278e-28\n",
+      "now\t(500,)      \t(500, 2)\t1.278e-28\n"
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib as mpl\n",
+    "mpl.rcParams['figure.figsize']= [9.0, 6.0]\n",
+    "\n",
+    "# Data Structures\n",
+    "dosene={}\n",
+    "dosene['raw'] = dos_energies_raw\n",
+    "dosene['arx'] = dos_energies_arx\n",
+    "dosene['now'] = dos_energies_now\n",
+    "\n",
+    "dosvals={}\n",
+    "dosvals['raw'] = dos_values_raw\n",
+    "dosvals['arx'] = dos_values_arx\n",
+    "dosvals['now'] = dos_values_now\n",
+    "\n",
+    "print('key\\t dos_energies \\t dos_values\\t dos_values.max')\n",
+    "for key in dosene.keys():\n",
+    "    print('{}\\t{:12s}\\t{}\\t{:.4g}' .format(key, str(dosene[key].shape), dosvals[key].shape,\n",
+    "                                           dosvals[key].max()))\n",
+    "    assert (dosene[key].max() > 0.0)\n",
+    "    assert (dosene[key].max() > 0.0)\n",
+    "\n",
+    "print('-----')\n",
+    "print('\\nRemove cell normalization from `raw`:')\n",
+    "x_exciting_unit_cell_volume = 4.004791738111699e-29\n",
+    "dosvals['raw'] = dosvals['raw'] * x_exciting_unit_cell_volume\n",
+    "print('key\\t dos_energies \\t dos_values\\t dos_values.max')\n",
+    "for key in dosene.keys():\n",
+    "    print('{}\\t{:12s}\\t{}\\t{:.4g}' .format(key, str(dosene[key].shape), dosvals[key].shape, \n",
+    "                                           dosvals[key].max()))\n",
+    "    assert (dosene[key].max() > 0.0)\n",
+    "    assert (dosene[key].max() > 0.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "code='exciting'\n",
+    "fermi_eV ={}\n",
+    "fermi_eV[code] = 0.19731006767 * Ha2eV\n",
+    "\n",
+    "def plot_all(dosene, dosvals, material, code, save_plot=False):\n",
+    "    \n",
+    "    for zoom in [False]: # FIXME: [False, True], fix yrange\n",
+    "        delta = 0\n",
+    "        \n",
+    "        plt.figure()\n",
+    "        for source in [ 'arx', 'now', 'raw']:\n",
+    "            if code == 'exciting':\n",
+    "                lbl = '(unshifted)'\n",
+    "            else:\n",
+    "                lbl = ''\n",
+    "            factor = 1.0\n",
+    "            if source == 'raw':\n",
+    "                line = '-'\n",
+    "                lbl = 'raw DFT'\n",
+    "            elif source == 'arx':\n",
+    "                line = '--'\n",
+    "                lbl = 'archive '\n",
+    "            elif source == 'now':\n",
+    "                line = ':'   \n",
+    "                lbl = 'fresh'\n",
+    "                factor = 1.0\n",
+    "                #dosene['par'] -= fermi_eV[code]\n",
+    "                \n",
+    "            plt.plot(dosene[source][:], \n",
+    "                     dosvals[source][:,0] * factor, line,\n",
+    "                    label=r'{:10s}'.format(lbl))      \n",
+    "        \n",
+    "        if zoom:\n",
+    "            plt.xlim(-2,2)\n",
+    "            ymax = max(0, dosvals['raw'].max())\n",
+    "            plt.ylim(0, 1.3e-28)\n",
+    "            title_appendix = 'ZOOM IN'\n",
+    "        else:  \n",
+    "            plt.xlim(-10,10)\n",
+    "            title_appendix = ''\n",
+    "        # - - -\n",
+    "        \n",
+    "        ttl = 'DOS. Material: {}. Fermi Energy: {:.2f} eV' .format(material, fermi_eV[code], title_appendix)\n",
+    "        plt.title(ttl)\n",
+    "        plt.xlabel('Energy (eV)', size=12)\n",
+    "        plt.ylabel('DOS (states / eV)', color='k', size=12)\n",
+    "        \n",
+    "        plt.legend(title='Code: {}' .format(code))\n",
+    "      \n",
+    "        if save_plot:\n",
+    "            # goes before show()\n",
+    "            filename =  BASE+'outplots/dos_rawdft_{}.png' .format('ALL_ZOOM')\n",
+    "            plt.savefig( filename , bbox_inches='tight')\n",
+    "        plt.show()\n",
+    "# -------\n",
+    "\n",
+    "material = 'Si2'\n",
+    "code = 'exciting'\n",
+    "plot_all(dosene, dosvals, material, code)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Quick Checks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Only Archive vs Parsed\n",
+    "\n",
+    "if 1==0:\n",
+    "    plt.figure()\n",
+    "    plt.plot(dos_energies_arch , dos_values_arch)\n",
+    "\n",
+    "    # new figure\n",
+    "    plt.figure() #dosene['par'] -= fermi_eV[code]\n",
+    "    plt.plot(dos_energies_parsed - fermi_eV[code], \n",
+    "             dos_values_parsed )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "---\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DIFFERENT CODES &<br> SIMILAR CALCULATIONS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_all(dos_dft, material, source, save_plot):\n",
+    "    '''\n",
+    "    Plots DOS for different DFT codes\n",
+    "    This example iterates over ['aims', 'exciting', 'vasp']'\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    dos_dft : dictionary\n",
+    "        dos data.\n",
+    "    material : string\n",
+    "        Label for plot's title.\n",
+    "    save_plot : boolean\n",
+    "        Specify if a figure .\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    None.\n",
+    "    '''\n",
+    "    \n",
+    "    for zoom in [False]: #, True]:\n",
+    "        delta = 0\n",
+    "        \n",
+    "        plt.figure()\n",
+    "        for code in ['aims', 'exciting', 'vasp']:\n",
+    "            if code == 'exciting':\n",
+    "                lbl = '(unshifted)'\n",
+    "            else:\n",
+    "                lbl = ''\n",
+    "        \n",
+    "        \n",
+    "            plt.plot(dos_dft[code][:,0],\n",
+    "                     dos_dft[code][:,1],\n",
+    "                    label=r'{:10s} {}'.format(code, lbl))\n",
+    "        \n",
+    "            #txt = '{} EFermi {:.2f} eV' .format(code, fermi_eV[code])\n",
+    "            #plt.text(0.5, 0.4-delta, txt)\n",
+    "           # delta -= 0.03\n",
+    "        \n",
+    "        if zoom:\n",
+    "            plt.xlim(-1,1)\n",
+    "            plt.ylim(-.02, .5)\n",
+    "            title_appendix = 'ZOOM IN'\n",
+    "        else:  \n",
+    "            plt.xlim(-10,10)\n",
+    "            title_appendix = ''\n",
+    "        # - - -\n",
+    "        \n",
+    "        plt.title('Source: {}. Material: {}. {}' .format(source, material, title_appendix))\n",
+    "        plt.xlabel('Energy (eV)', size=12)\n",
+    "        plt.ylabel('DOS (states / eV)', color='k', size=12)\n",
+    "        \n",
+    "        plt.legend(title='Code')\n",
+    "      \n",
+    "        if save_plot:\n",
+    "            # goes before show()\n",
+    "            filename =  BASE+'outplots/dos_rawdft_{}.png' .format('ALL_ZOOM')\n",
+    "            plt.savefig( filename , bbox_inches='tight')\n",
+    "        plt.show()\n",
+    "# -------\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fetch from Archive: 3 codes\n",
+    "## Fetch (parsed) Metainfo from Archive\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def archive_fetch_calc(case, normalized=False, verbose=False):\n",
+    "    '''\n",
+    "    Fetch processed calculation from NOMAD's archive\n",
+    "    Avoid unit conversions, since these depend on the DFT code\n",
+    "    '''\n",
+    "    upload_id = case['upload_id']\n",
+    "    calc_id = case['calc_id']\n",
+    "    \n",
+    "    # fetch metadata\n",
+    "    url = nomad_app + 'archive/' + upload_id +'/' + calc_id\n",
+    "    metadata = requests.get(url).json()\n",
+    "\n",
+    "    if verbose:\n",
+    "        print('\\n', url)\n",
+    "        \n",
+    "    sscc_str = 'section_single_configuration_calculation'\n",
+    "    sscc_list = metadata['section_run'][0][sscc_str]\n",
+    "\n",
+    "    # print(type(sscc_list))    \n",
+    "\n",
+    "    # dos_type = ['raw', 'normalized'][0] \n",
+    "    if normalized:\n",
+    "        dos_type = 'normalized'\n",
+    "    else:\n",
+    "        dos_type = 'raw'\n",
+    "            \n",
+    "    dos_energies, dos_values = fetch_dos_section(sscc_list, dos_type)\n",
+    "\n",
+    "    # unit conversion (archive is always in SI units)   \n",
+    "    dos_energies *= J2eV\n",
+    "    dos_values /= J2eV\n",
+    "\n",
+    "    # dos.shape = {(n,2) or (n,3)}\n",
+    "    # col 1: energies, cols 2-3: dos_values \n",
+    "    dos = np.vstack((dos_energies, dos_values.T)).T\n",
+    "    return dos\n",
+    "#-------\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sscc no. 0: section_dos found\n",
+      "sscc no. 2: section_dos absent\n",
+      "sscc no. 0: section_dos found\n",
+      "sscc no. 2: section_dos absent\n",
+      "sscc no. 0: section_dos found\n",
+      "sscc no. 0: section_dos found\n",
+      "sscc no. 0: section_dos found\n",
+      "sscc no. 0: section_dos found\n",
+      "\n",
+      "RAW DOS\n",
+      "\t\tShape\t dos.max()\n",
+      "aims       ene: (1000,)\t 10.0\n",
+      "aims       dos: (1000,)\t 6.666676298687467e-29\n",
+      "\n",
+      "exciting   ene: (500,)\t 18.92035087549528\n",
+      "exciting   dos: (500,)\t 1.277912681175228e-28\n",
+      "\n",
+      "vasp       ene: (301,)\t 17.5918\n",
+      "vasp       dos: (301,)\t 9.303976673342951e-29\n",
+      "\n",
+      "\n",
+      "NORMALIZED DOS\n",
+      "\t\tShape\t dos.max()\n",
+      "aims       ene: (1000,)\t 15.7957958\n",
+      "aims       dos: (1000,)\t 0.739372055\n",
+      "\n",
+      "exciting   ene: (500,)\t 13.768961440470166\n",
+      "exciting   dos: (500,)\t 1.5954795713984835\n",
+      "\n",
+      "vasp       ene: (301,)\t 11.9561\n",
+      "vasp       dos: (301,)\t 1.1402\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "#########\n",
+    "# Data Structures\n",
+    "#########\n",
+    "dos_arch_raw={}\n",
+    "dos_arch_norm={}\n",
+    "\n",
+    "\n",
+    "#########\n",
+    "# exciting\n",
+    "#########\n",
+    "case = {}\n",
+    "case['upload_id'] = 'pT4cDgonSeK_RTagfGnz2g'\n",
+    "case['calc_id'] = 'PMtdh8FOg02FedbM5PRIf62yimVm'\n",
+    "case['calc_url'] = 'https://repository.nomad-coe.eu/app/gui/entry/id/pT4cDgonSeK_RTagfGnz2g/PMtdh8FOg02FedbM5PRIf62yimVm'\n",
+    "\n",
+    "dos_arch_raw['exciting'] = archive_fetch_calc(case, normalized=False)\n",
+    "dos_arch_norm['exciting'] = archive_fetch_calc(case, normalized=True)\n",
+    "\n",
+    "#########\n",
+    "# FHI-AIMS\n",
+    "#########\n",
+    "case = {}\n",
+    "case['upload_id'] = 'uCSlNMEWQfOS5TMvsQXz1A'\n",
+    "case['calc_id'] = 'hpUk30zGCNI6gYMRAYIr-j0MII0d'\n",
+    "case['calc_url'] = 'https://repository.nomad-coe.eu/app/gui/entry/id/uCSlNMEWQfOS5TMvsQXz1A/hpUk30zGCNI6gYMRAYIr-j0MII0d'\n",
+    "\n",
+    "dos_arch_raw['aims'] =  archive_fetch_calc(case, normalized=False)\n",
+    "dos_arch_norm['aims'] =  archive_fetch_calc(case, normalized=True)\n",
+    "\n",
+    "cell_volume_aims = 1.8033346685485985e-28\n",
+    "#dos_arch[code][:,1 ] /= cell_volume_aims\n",
+    "\n",
+    "\n",
+    "#########\n",
+    "# VASP\n",
+    "#########\n",
+    "case = {}\n",
+    "case['upload_id'] = 'IxN_SXI0QlqRv6sdGLULfA'\n",
+    "case['calc_id'] = '7UCmdvcWkQ9GSqeciDJ0kpK3u6W3'\n",
+    "case['calc_url'] = 'https://repository.nomad-coe.eu/v0.8/gui/entry/id/IxN_SXI0QlqRv6sdGLULfA/7UCmdvcWkQ9GSqeciDJ0kpK3u6W3'\n",
+    "\n",
+    "dos_arch_raw['vasp']  = archive_fetch_calc(case, normalized=False)\n",
+    "dos_arch_norm['vasp'] = archive_fetch_calc(case, normalized=True)\n",
+    "\n",
+    "# quick checks\n",
+    "if 1==1:\n",
+    "    print('\\nRAW DOS')\n",
+    "    print('\\t\\tShape\\t dos.max()')\n",
+    "    for code in ['aims', 'exciting', 'vasp']:\n",
+    "        ene = dos_arch_raw[code][:,0]\n",
+    "        dos = dos_arch_raw[code][:,1]\n",
+    "        print('{:10s} ene: {}\\t {}' .format(code, ene.shape, ene.max()))\n",
+    "        print('{:10s} dos: {}\\t {}' .format(code, dos.shape, dos.max()))\n",
+    "        print('')\n",
+    "    #------\n",
+    "    print('\\nNORMALIZED DOS')\n",
+    "    print('\\t\\tShape\\t dos.max()')\n",
+    "    for code in ['aims', 'exciting', 'vasp']:\n",
+    "        ene = dos_arch_norm[code][:,0]\n",
+    "        dos = dos_arch_norm[code][:,1]\n",
+    "        print('{:10s} ene: {}\\t {}' .format(code, ene.shape, ene.max()))\n",
+    "        print('{:10s} dos: {}\\t {}' .format(code, dos.shape, dos.max()))\n",
+    "        print('')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Plot Raw (unnormalized) DOS \n",
+    "### Separate plots, since different DFT codes might output results<br> in different units and/or normalizations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for code in ['aims', 'exciting', 'vasp']:\n",
+    "    ene = dos_arch_raw[code][:,0]\n",
+    "    dos = dos_arch_raw[code][:,1]\n",
+    "    plt.figure()\n",
+    "    plt.title('Code: {:15s} {}' .format(code, 'Source: (unnormalized) NOMAD`s archive'))\n",
+    "    plt.plot(ene, dos)\n",
+    "    plt.xlabel('Energy (eV)')\n",
+    "    plt.ylabel(r'DOS (states / eV)')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Plot Normalized DOS\n",
+    "### One figure frame, since data ranges should lie on similar ranges\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "material='Si2'\n",
+    "source='(normalized) NOMAD`s archive'\n",
+    "plot_all(dos_arch_norm, material, source, save_plot=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  }
+ ],
+ "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.7.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}