{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "41ae4865-445c-4832-9dbb-aef3f8ec088f",
   "metadata": {},
   "source": [
    "# Spectrum Overlay\n",
    "\n",
    "This Jupyter notebook is designed to plot calculated and experimental spectra of all sorts. It can plot harmonic and anharmonic IR, VCD, Raman, and UV-Vis spectra, and overlay these with experimental data from any format."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2533e9ca-8f09-44ee-92e9-d4774285c311",
   "metadata": {},
   "source": [
    "## Imports\n",
    "\n",
    "First we need to import a few things. If any of these fail, install them using `pip3` like so:\n",
    "\n",
    "`pip3 install --user <package>`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5b869f36-51bc-42d4-ba01-eac44ec8f45d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import webmo                    # for WebMO interfacing\n",
    "import numpy as np              # for vector math\n",
    "import math                     # for square root and log\n",
    "import matplotlib.pyplot as plt # to make plots at the end\n",
    "import scipy                    # to calculate line shapes\n",
    "import itertools                # for iterators\n",
    "import os                       # deal with files existing\n",
    "import datetime                 # to timestamp images in case of overwrites"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bda464d-faa0-4066-8067-62ab06b9dfe0",
   "metadata": {},
   "source": [
    "## User Input\n",
    "\n",
    "Set your user input, along with all the configurable parameters. You'll have to run the jobs to plot on \n",
    "your own, though! \n",
    "\n",
    "Setting any parameter to `None` will automatically set it to the default later on. Defaults are defined in the comments above each parameter, or you can find them all in the block of code at the end that check for each of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "aabacfb6-21b1-4e0c-be79-0d33fb23d2f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "## BOOKKEEPING PARAMETERS\n",
    "\n",
    "# the URL of your WebMO instance\n",
    "URL = \"https://server.university.edu/~webmo/cgi-bin/webmo/rest.cgi\"\n",
    "\n",
    "# your WebMO username\n",
    "uname = \"cbrzezinski\"\n",
    "\n",
    "# List of jobs to pull from. It takes 3-tuples of the form (job #, spectra type, label), where\n",
    "# spectra type is one of {\"IR\", \"VCD\", \"RAMAN\", \"IR_ANHARMONIC\", \"VCD_ANHARMONIC\", \"UV_VIS\"}. \n",
    "# Leave `label` as None to use the WebMO job title.\n",
    "jobs = [\n",
    "    # Example:\n",
    "    (56, \"IR\", \"Ab-Initio Calculation\")\n",
    "]\n",
    "\n",
    "# The output file to save the results to. If left as `None`, won't save image, just display it.\n",
    "# We highly recommend saving the image and viewing it that way as the inline Jupyter image display\n",
    "# is rather low resolution. This notebook WILL NOT overwrite your images; if you were to run the \n",
    "# same analysis again it will instead be to \"[name]_TIMESTAMP.[ext]\" instead so you don't accidentally\n",
    "# lose data.\n",
    "output_file = \"webmo_output.png\"\n",
    "\n",
    "# Graph ranges for the views. Values are required; no default given.\n",
    "xrange = (4000,0)\n",
    "yrange = (0,3)\n",
    "\n",
    "# Peak width, specified as a Full Width Half Max (FWHM). Default is 40.\n",
    "peak_width = 40\n",
    "\n",
    "# Resolution for the plot itself (or how many points are calculated for the predicted spectrum). Default is 4000.\n",
    "resolution = 8000\n",
    "\n",
    "# If you want a frequency scaling factor, which only applies to certain spectra types. \n",
    "# Default is 1.00. For B3LYP/6-31G(d) IR spectra, you would want 0.96.\n",
    "scaling_factor = None\n",
    "\n",
    "# The labels for the plot. Defaults are empty.\n",
    "xlabel = \"Wavenumber\"\n",
    "ylabel = \"Absorption\"\n",
    "\n",
    "# The title of the output. Default is no title.\n",
    "title = None\n",
    "\n",
    "# `True` if the generated plot should only be greyscale (e.g., for a publication)\n",
    "# `False` for color. Default is color.\n",
    "greyscale = None\n",
    "\n",
    "# The resolution to save or display the plot at in DPI. Default is 1200.\n",
    "DPI = None\n",
    "\n",
    "# Line width of the drawn spectra. Default is 0.5.\n",
    "plot_line_width = None\n",
    "\n",
    "# Line shape. Options are gaussian, lorentzian, and voigt (50/50 split). Default is voigt.\n",
    "lineshape = None\n",
    "\n",
    "## EXPERIMENTAL PARAMETERS\n",
    "\n",
    "# Gas Parameters\n",
    "# Pressure in torr. Default is 10.\n",
    "pressure = None\n",
    "\n",
    "# Sample cell pathlength in cm. Default is 10.\n",
    "clength = None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758e4da3-0a46-4f36-850b-1d8c0c3ac213",
   "metadata": {},
   "source": [
    "### Set up `REST` Session\n",
    "\n",
    "Set up the `REST` session and log into WebMO."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4648bccc-fadf-4469-9e3d-a374d925614b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter WebMO password for user cbrzezinski: ········\n"
     ]
    }
   ],
   "source": [
    "rest = webmo.WebMOREST(URL, username=uname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8d4902e-79db-4920-8981-24bea8cbace6",
   "metadata": {},
   "source": [
    "### Experimental Data (Optional)\n",
    "\n",
    "Here's how to overlay some experimental data. Using the cell below as scratch, use whatever method you need to get your experimental data into variables. Then load the variables into the `experimental_jobs` array in the form:\n",
    "```\n",
    "(<array of x values>, <array of y values>, \"label for the legend on the plot\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bbad56e0-7c87-40ba-954a-cbe2d8894b53",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example data in a CSV file of x,y with no headers:\n",
    "expt_x,expt_y = np.genfromtxt(\"../csv/data2.csv\", delimiter=\",\", dtype=float,\n",
    "                             missing_values=0.0, names=None).T\n",
    "\n",
    "experimental_curves = [\n",
    "    # format: (x_array, y_array, \"label\")\n",
    "    # This is how you would format given the above example:\n",
    "    (expt_x,expt_y,\"Experiment\"),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07c044da-af2a-4904-9e4f-fe168bef94c5",
   "metadata": {},
   "source": [
    "### Verification and Defaults\n",
    "\n",
    "Check that the input makes sense."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a07b8c9a-5410-48de-b35c-f00b2430c238",
   "metadata": {},
   "outputs": [],
   "source": [
    "if URL[:4] != \"http\":\n",
    "    print(\"Error: Check that your WebMO URL is in fact a URL\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21463c06-4828-4eb9-b95c-faba6afd2769",
   "metadata": {},
   "source": [
    "We'll also set any values left as `None` to their defaults here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ade70a0d-1b50-433d-8998-0900e06fcdf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "if peak_width == None:\n",
    "    peak_width = 40\n",
    "\n",
    "if resolution == None:\n",
    "    resolution = 4000\n",
    "\n",
    "if scaling_factor == None:\n",
    "    scaling_factor = 1\n",
    "\n",
    "if xlabel == None:\n",
    "    xlabel = \"\"\n",
    "\n",
    "if ylabel == None:\n",
    "    ylabel = \"\"\n",
    "\n",
    "if pressure == None:\n",
    "    pressure = 10\n",
    "\n",
    "if clength == None:\n",
    "    clength = 10\n",
    "\n",
    "if greyscale == None:\n",
    "    greyscale = False\n",
    "\n",
    "if plot_line_width == None:\n",
    "    plot_line_width = 0.5\n",
    "\n",
    "if greyscale:\n",
    "    plt.style.use('grayscale')\n",
    "\n",
    "if lineshape == None:\n",
    "    lineshape = \"voigt\"\n",
    "\n",
    "if DPI == None:\n",
    "    DPI = 1200"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55d1669e-a4f3-4a1d-83b7-61d6577fc229",
   "metadata": {},
   "source": [
    "## Job Fetching and Calculations (Recommended)\n",
    "\n",
    "Grab the data for each job and generate the curves from it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2478760a-bac3-4847-859e-66db7e525724",
   "metadata": {},
   "source": [
    "### Utility Functions\n",
    "\n",
    "These functions are the building blocks that do the work of a) downloading the correct values from WebMO, and b) calculating\n",
    "the curves to plot from those values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6bb8d9a8-eb11-4ce2-9a82-1f04189f7dab",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def get_frequencies(rest, job, type):\n",
    "    \"\"\"\n",
    "    Retrieve WebMO job information. Here lives all the magic to get the right peak positions and intensities.\n",
    "    \"\"\"\n",
    "    def deref(obj, l):\n",
    "        \"\"\"\n",
    "        Dereference a nested dictionary by a sequence of indices given in a list. Or in other words:\n",
    "        \n",
    "        deref(obj, ['a','b','c','d'])\n",
    "                 <=>\n",
    "        obj['a']['b']['c']['d']\n",
    "        \"\"\"\n",
    "        k = obj\n",
    "        for ac in l:\n",
    "            k = k[ac]\n",
    "\n",
    "        return k\n",
    "\n",
    "    # util functions\n",
    "    identity = lambda x: x\n",
    "    scale = lambda x: list(map(lambda y: y * scaling_factor,x))\n",
    "\n",
    "    # accessor shorthands\n",
    "    FREQ_ACCESSOR = [\"properties\", \"vibrations\"]\n",
    "    ANH_ACCESSOR = [\"properties\", \"anharmonic_vibrations\"]\n",
    "\n",
    "    # this looks scarier than it is. For each type of spectra, we have an accessor to the x values (called\n",
    "    # points), an accessor to the y values (called intensities), and a function to adjust both of those\n",
    "    # (called adjp and adji respectively). The correct functions get assigned to those names by tuple assignment\n",
    "    # through this dictionary, which acts like a switch statement.\n",
    "    (points, intensities, adjp, adji) = {\n",
    "        \"IR\": (\n",
    "            FREQ_ACCESSOR + [\"frequencies\"], \n",
    "            FREQ_ACCESSOR + [\"intensities\", \"IR\"],\n",
    "            scale,\n",
    "            lambda x: list(map(lambda Ee: (Ee * (10**5) * clength * pressure * (5.38E-8))/2.303,x))\n",
    "        ),\n",
    "        \"VCD\": (\n",
    "            FREQ_ACCESSOR + [\"frequencies\"],\n",
    "            FREQ_ACCESSOR + [\"intensities\", \"VCD\"],\n",
    "            scale, \n",
    "            identity\n",
    "        ),\n",
    "        \"RAMAN\": (\n",
    "            FREQ_ACCESSOR + [\"frequencies\"],\n",
    "            FREQ_ACCESSOR + [\"intensities\", \"raman\"],\n",
    "            identity, \n",
    "            identity\n",
    "        ),\n",
    "        \"IR_ANHARMONIC\": (\n",
    "            ANH_ACCESSOR + ['frequencies'],\n",
    "            ANH_ACCESSOR + [\"intensities\", \"IR\"],\n",
    "            identity,\n",
    "            lambda x: list(map(lambda Ee: (Ee * (10**5) * clength * pressure * (5.38E-8))/2.303,x))\n",
    "        ),\n",
    "        \"VCD_ANHARMONIC\": (\n",
    "            ANH_ACCESSOR + [\"frequencies\"],\n",
    "            ANH_ACCESSOR + [\"intensities\", \"VCD\"],\n",
    "            identity,\n",
    "            identity\n",
    "        ),\n",
    "        \"UV-VIS\": (\n",
    "            ['properties', 'excited_states', 'transition_energies'],\n",
    "            ['properties', 'excited_states', 'intensities'],\n",
    "            identity,\n",
    "            identity\n",
    "        )\n",
    "    }[type.upper()]\n",
    "    a = rest.get_job_results(job)\n",
    "    pts = adjp(deref(a,points))\n",
    "    ints = adji(deref(a,intensities))\n",
    "    return (pts,ints)\n",
    "\n",
    "def arb_gaussian(center, intensity):\n",
    "    \"\"\"\n",
    "    Return a gaussian with an arbitrary height and intensity, with sigma being determined by calculating\n",
    "    it from our FWHM peak width.\n",
    "    \"\"\"\n",
    "    sigma = (peak_width / (2 * math.sqrt(2 * math.log(2))))\n",
    "    l = lambda x: intensity * (1/sigma*math.sqrt(2*math.pi)) * math.exp(-((x-center)**2/(2*sigma**2)))\n",
    "    \n",
    "    return l\n",
    "\n",
    "def arb_lorentz(center, intensity):\n",
    "    \"\"\"\n",
    "    Return a lorentzian with an arbitrary height and intensity, with gamma being calculated from our\n",
    "    FWHM peak width.\n",
    "    \"\"\"\n",
    "    gamma = (peak_width / 2)\n",
    "    l = lambda x: (intensity/math.pi) * (gamma/((x-(center))**2 + gamma**2))\n",
    "    \n",
    "    return l\n",
    "    \n",
    "def arb_voigt(center, intensity):\n",
    "    \"\"\"\n",
    "    Use the Faddeeva function to calculate a 50/50 voigt line shape. See\n",
    "    https://en.wikipedia.org/wiki/Voigt_profile#The_uncentered_Voigt_profile and\n",
    "    https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.wofz.html\n",
    "    \"\"\"\n",
    "    def voigt_decoder(q, k):\n",
    "        \"\"\"\n",
    "        Takes the FWHM (k) and a ratio (q) and determines the values of gamma␣\n",
    "        ↪and sigma.\n",
    "        Accurate to within around 1.2%.\n",
    "        \"\"\"\n",
    "        f_l = (-k*(q**2) + (-1 + q)**2 * np.sqrt(((k**2)*(q**2) * (4 - 8 * q + 5 * (q**2)))/(-1 + q)**4))/(2 * (-1 + q)**2)\n",
    "        f_g = (k * (q**2) - (-1 + q)**2 * np.sqrt(((k**2) * (q**2) * (4 - 8 * q + 5 * (q**2)))/(-1 + q)**4))/(2 * (-1 + q) * q)\n",
    "        \n",
    "        gamma = f_l/2 # because gamma = FWHM/2\n",
    "        sigma = f_g / (2 * np.sqrt(2*np.log(2)))\n",
    "        \n",
    "        return(gamma,sigma)\n",
    "        \n",
    "    gamma, sigma = voigt_decoder(0.3, peak_width)\n",
    "    denom = sigma * math.sqrt(2 * math.pi) # denomonator\n",
    "    z = lambda x: scipy.special.wofz((x - center + gamma*1j)/(math.sqrt(2) * sigma)) # Define z(x) as numerator, more or less\n",
    "    l = lambda x: intensity * ((z(x).real)/denom) # define the actual voigt function\n",
    "    return l\n",
    "\n",
    "def generate_curve(rest, job, type, axis):\n",
    "    \"\"\"\n",
    "    Given a job, spectra type, and axis to calculate on, calculates the resultant y data.\n",
    "    \"\"\"\n",
    "    (freq, intensity) = get_frequencies(rest, job, type)\n",
    "    \n",
    "    arb_curve = {\n",
    "        \"VOIGT\": arb_voigt,\n",
    "        \"CAUCHY\": arb_lorentz,\n",
    "        \"GAUSSIAN\": arb_gaussian,\n",
    "    }[lineshape.upper()]\n",
    "\n",
    "    # create our y array of zeroes\n",
    "    y = np.zeros(axis.shape)\n",
    "\n",
    "    # loop over the peaks, adding each peak to our y\n",
    "    for x in range(0, len(freq)):\n",
    "        # vectorize is faster than looping through axis manually\n",
    "        vfunc = np.vectorize(arb_curve(freq[x],intensity[x]))\n",
    "        y += vfunc(axis)\n",
    "\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51b4bebd-a4ab-46b3-96ff-45e03e68c912",
   "metadata": {},
   "source": [
    "### Calculate the Predicted Curves\n",
    "\n",
    "Generate the curves by setting up the numpy arrays and then looping over all of the jobs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8df45f6f-a79c-4aaa-ad9b-07a74af3627f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# numpy can't deal with inverse ranges\n",
    "start = min(xrange[0],xrange[1])\n",
    "end = max(xrange[0],xrange[1])\n",
    "res = (end-start)/resolution\n",
    "\n",
    "# set up np x array as a vector\n",
    "x = np.arange(start,end,res)\n",
    "\n",
    "# generate our calculated curves\n",
    "calc_curves = []\n",
    "for i in range(0, len(jobs)):\n",
    "    # jobs[i][0] = job #\n",
    "    # jobs[i][1] = spectra type\n",
    "    # jobs[i][2] = label\n",
    "    y = generate_curve(rest, jobs[i][0], jobs[i][1], x)\n",
    "    if (jobs[i][2] == None):\n",
    "        name = rest.get_job_info(jobs[i][0])['properties']['jobName']\n",
    "    else:\n",
    "        name = jobs[i][2]\n",
    "    calc_curves.append((x, y, name))\n",
    "\n",
    "curves_to_plot = calc_curves + experimental_curves\n",
    "\n",
    "if not isinstance(curves_to_plot, list):\n",
    "    raise ValueError(\"Check that you actually provided a list of plots\")\n",
    "elif curves_to_plot == []:\n",
    "    raise ValueError(\"Check that you actually provided a list of plots\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef766c3-58f3-418a-bfe9-085db1f30ceb",
   "metadata": {},
   "source": [
    "## Display All Curves\n",
    "\n",
    "Finally, we can display our final image and save it to a file if requested."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "46d17497-b331-497f-aaef-48a90955d1f1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot *all* the things!\n",
    "styles = itertools.cycle(['-', '-.', ':', '--'])\n",
    "fig,ax = plt.subplots() # define here to make greyscale work\n",
    "for (x,y,label) in curves_to_plot:\n",
    "    if greyscale:\n",
    "        ax.plot(x,y, next(styles),\n",
    "                label=label, \n",
    "                linewidth=plot_line_width)\n",
    "    else:\n",
    "        ax.plot(x,y, \n",
    "                label=label, \n",
    "                linewidth=plot_line_width)\n",
    "\n",
    "# set misc plot options\n",
    "plt.xlabel(xlabel)\n",
    "plt.ylabel(ylabel)\n",
    "plt.axis([xrange[0],xrange[1],yrange[0],yrange[1]])\n",
    "if title != None:\n",
    "    plt.title(title)\n",
    "plt.figure(DPI)\n",
    "ax.legend()\n",
    "\n",
    "if output_file != None:\n",
    "    # check if there's already one\n",
    "    if os.path.isfile(output_file):\n",
    "        ext = output_file[-4:]\n",
    "        name = output_file[:-4]\n",
    "        new_name = name + \"_{:%y%m%d%H%M%S}\".format(datetime.datetime.now()) + ext\n",
    "        fig.savefig(new_name,dpi=DPI)\n",
    "    else:\n",
    "        fig.savefig(output_file,dpi=DPI)\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}