test/test_set_1/Analysis_MS_figures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis of Test Set 1 to Make Figures for MS\n",
    "This notebook allows for the analysis and reproduction of the figures associated with the scientific publication of this work.\n",
    "Upon running this notebook, the figures will be produced and saved under `figures`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: resetting values of constants to default. Make sure this is really what you want!\n"
     ]
    }
   ],
   "source": [
    "import statistics\n",
    "# import analysis functions\n",
    "%run ../../tools/analysis/functions_for_notebooks.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Collect paths to all the sdf files of test set 1 in 'pathnames' variable.\n",
    "pathnames = sorted(glob.glob('*/*_out.sdf'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of AF Candidates = 30\n"
     ]
    }
   ],
   "source": [
    "# store paths to catalyst groups (AF) in separate variables\n",
    "H0_paths = []; HI_paths = []; HIIprime_paths = []; HII_paths = []; HC1Ph_paths = []\n",
    "for pathname in pathnames:\n",
    "    if \"H0-\" in pathname:\n",
    "        H0_paths.append(pathname)\n",
    "    if \"HI-\" in pathname:\n",
    "        HI_paths.append(pathname)    \n",
    "    if \"HIIprime-\" in pathname:\n",
    "        HIIprime_paths.append(pathname)\n",
    "    if \"HII-\" in pathname:\n",
    "        HII_paths.append(pathname)\n",
    "    if \"HC1Ph-\" in pathname:\n",
    "        HC1Ph_paths.append(pathname)\n",
    "        \n",
    "print(\"Total number of AF Candidates = \" + str(len(H0_paths + HI_paths + HIIprime_paths + HII_paths + HC1Ph_paths)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: Missing property 'G_PCy3' in 'H0-0/H0-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'H0-0/H0-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'H0-1/H0-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'H0-1/H0-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'H0-2/H0-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'H0-2/H0-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'H0-3/H0-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'H0-3/H0-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'H0-4/H0-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'H0-4/H0-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'H0-5/H0-5_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'H0-5/H0-5_out.sdf'. Using default value.\n",
      "Fitness: 0.0 (St.dev: 0.0)\n",
      "candidate: H0\n",
      "D1: 0.0\n",
      "D2: 1.47\n",
      "D3: 2.66\n",
      "w1: 1.0\n",
      "w2: 0.0\n",
      "w3: 0.04\n",
      "w4: 1.0\n",
      "WARNING: Missing property 'G_PCy3' in 'HI-0/HI-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HI-0/HI-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HI-1/HI-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HI-1/HI-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HI-2/HI-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HI-2/HI-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HI-3/HI-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HI-3/HI-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HI-4/HI-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HI-4/HI-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HI-5/HI-5_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HI-5/HI-5_out.sdf'. Using default value.\n",
      "Fitness: 3.45 (St.dev: 1.71)\n",
      "candidate: HI\n",
      "D1: 0.0\n",
      "D2: 5.17\n",
      "D3: 0.21\n",
      "w1: 1.0\n",
      "w2: 0.69\n",
      "w3: 0.9\n",
      "w4: 1.0\n",
      "WARNING: Missing property 'G_PCy3' in 'HIIprime-0/HIIprime-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HIIprime-0/HIIprime-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HIIprime-1/HIIprime-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HIIprime-1/HIIprime-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HIIprime-2/HIIprime-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HIIprime-2/HIIprime-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HIIprime-3/HIIprime-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HIIprime-3/HIIprime-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HIIprime-4/HIIprime-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HIIprime-4/HIIprime-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HIIprime-5/HIIprime-5_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HIIprime-5/HIIprime-5_out.sdf'. Using default value.\n",
      "Fitness: 13.66 (St.dev: 0.01)\n",
      "candidate: HIIprime\n",
      "D1: 0.23\n",
      "D2: 13.05\n",
      "D3: 0.38\n",
      "w1: 1.0\n",
      "w2: 1.0\n",
      "w3: 1.0\n",
      "w4: 1.0\n",
      "WARNING: Missing property 'G_PCy3' in 'HII-0/HII-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HII-0/HII-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HII-1/HII-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HII-1/HII-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HII-2/HII-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HII-2/HII-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HII-3/HII-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HII-3/HII-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HII-4/HII-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HII-4/HII-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HII-5/HII-5_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HII-5/HII-5_out.sdf'. Using default value.\n",
      "Fitness: 14.95 (St.dev: 0.02)\n",
      "candidate: HII\n",
      "D1: 1.0\n",
      "D2: 13.95\n",
      "D3: 0.0\n",
      "w1: 1.0\n",
      "w2: 1.0\n",
      "w3: 1.0\n",
      "w4: 1.0\n",
      "WARNING: Missing property 'G_PCy3' in 'HC1Ph-0/HC1Ph-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HC1Ph-0/HC1Ph-0_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HC1Ph-1/HC1Ph-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HC1Ph-1/HC1Ph-1_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HC1Ph-2/HC1Ph-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HC1Ph-2/HC1Ph-2_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HC1Ph-3/HC1Ph-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HC1Ph-3/HC1Ph-3_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HC1Ph-4/HC1Ph-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HC1Ph-4/HC1Ph-4_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_PCy3' in 'HC1Ph-5/HC1Ph-5_out.sdf'. Using default value.\n",
      "WARNING: Missing property 'G_HI_precursor' in 'HC1Ph-5/HC1Ph-5_out.sdf'. Using default value.\n",
      "Fitness: 19.91 (St.dev: 6.86)\n",
      "candidate: HC1Ph\n",
      "D1: 5.87\n",
      "D2: 14.54\n",
      "D3: 0.0\n",
      "w1: 0.98\n",
      "w2: 1.0\n",
      "w3: 1.0\n",
      "w4: 1.0\n"
     ]
    }
   ],
   "source": [
    "# Now we calculate the mean of selected sdf properties (energies, descriptor, weights etc.) within each catalyst group.\n",
    "# The mean values are then stored in separate arrays for further use bellow.\n",
    "# Finally, we print a simple overview of the fitness, descriptors and weights.\n",
    "\n",
    "# define arrays containing catalyst groups paths and names.\n",
    "catalyst_groups = [H0_paths, HI_paths, HIIprime_paths, HII_paths, HC1Ph_paths]\n",
    "catalyst_name = ['H0', 'HI', 'HIIprime', 'HII', 'HC1Ph']\n",
    "# All arrays that contains values derived from the set complete of catalyst (test set 1) \n",
    "# will adhear to the index above (arr[0] = H0 value, arr[1] = HI value ... ) \n",
    "\n",
    "# define arrays containing desired properties (averages).\n",
    "fitnesses = []; d1s = []; d2s = []; d3s = []; w1s = []; w2s = []; w3s = []; w4s = []\n",
    "AFenergyA = []; AFenergyE = []; AFenergyF = []; AFenergyC = []; AFenergyD = []; AFenergyX = []; AFenergyZ = []; AFenergyL = []\n",
    "\n",
    "# define array containing desired properties (standard deviations).\n",
    "fitnessStds = []; d1Stds = []; d2Stds = []; d3Stds = []; w1Stds = []; w2Stds = []; w3Stds = []; w4Stds = []\n",
    "AFenergyA_std = []; AFenergyD_std = []; AFenergyX_std = []; AFenergyZ_std = []\n",
    "\n",
    "# Loop over each catalyst group to extract mean values and standardard deviations. \n",
    "i = 0\n",
    "for group in catalyst_groups:\n",
    "    rows = []\n",
    "    for candidate in group:\n",
    "        rows.append(extract_properties_from_sdf(candidate))\n",
    "        \n",
    "    # Definte pandas datafram with all extracted properties, from all candidates.\n",
    "    df = pd.DataFrame(rows)\n",
    "\n",
    "    # colelct mean values from descriptors and weights.\n",
    "    fitness = str(df.agg({'FITNESS': ['mean']})).split()[2]; fitnesses.append(float(fitness))\n",
    "    fitnessStd = str(df.agg({'FITNESS': ['std']})).split()[2]\n",
    "    print('Fitness: ' + str(round(float(fitness), 2)) + ' (St.dev: ' + str(round(float(fitnessStd), 2)) + ')')\n",
    "    d1 = str(df.agg({'DESCRIPTOR_1': ['mean']})).split()[2]; d1s.append(float(d1))\n",
    "    d2 = str(df.agg({'DESCRIPTOR_2': ['mean']})).split()[2]; d2s.append(float(d2))\n",
    "    d3 = str(df.agg({'DESCRIPTOR_3': ['mean']})).split()[2]; d3s.append(float(d3))\n",
    "    w1 = str(df.agg({'WEIGHT_1': ['mean']})).split()[2]; w1s.append(float(w1))\n",
    "    w2 = str(df.agg({'WEIGHT_2': ['mean']})).split()[2]; w2s.append(float(w2))\n",
    "    w3 = str(df.agg({'WEIGHT_3': ['mean']})).split()[2]; w3s.append(float(w3))\n",
    "    w4 = str(df.agg({'WEIGHT_4': ['mean']})).split()[2]; w4s.append(float(w4))\n",
    "\n",
    "    #collect standard deviations from descriptors and weights.\n",
    "    d1Stds.append(float(str(df.agg({'DESCRIPTOR_1': ['std']})).split()[2]))\n",
    "    d2Stds.append(float(str(df.agg({'DESCRIPTOR_2': ['std']})).split()[2]))\n",
    "    d3Stds.append(float(str(df.agg({'DESCRIPTOR_3': ['std']})).split()[2]))\n",
    "    w1Stds.append(float(str(df.agg({'WEIGHT_1': ['std']})).split()[2]))\n",
    "    w2Stds.append(float(str(df.agg({'WEIGHT_2': ['std']})).split()[2]))\n",
    "    w3Stds.append(float(str(df.agg({'WEIGHT_3': ['std']})).split()[2]))\n",
    "    w4Stds.append(float(str(df.agg({'WEIGHT_4': ['std']})).split()[2]))\n",
    "    fitnessStds.append(float(str(df.agg({'FITNESS': ['std']})).split()[2]))\n",
    "\n",
    "    #collect mean values from potential energies.\n",
    "    AFenergyA.append(float(str(df.agg({'freeEnergyA': ['mean']})).split()[2]))\n",
    "    AFenergyE.append(float(str(df.agg({'freeEnergyE': ['mean']})).split()[2]))\n",
    "    AFenergyF.append(float(str(df.agg({'freeEnergyF': ['mean']})).split()[2]))\n",
    "    AFenergyC.append(float(str(df.agg({'freeEnergyC': ['mean']})).split()[2]))\n",
    "    AFenergyD.append(float(str(df.agg({'freeEnergyD': ['mean']})).split()[2]))\n",
    "    AFenergyX.append(float(str(df.agg({'freeEnergyX': ['mean']})).split()[2]))\n",
    "    AFenergyZ.append(float(str(df.agg({'freeEnergyZ': ['mean']})).split()[2]))\n",
    "    AFenergyL.append(float(str(df.agg({'freeEnergyL': ['mean']})).split()[2]))\n",
    "\n",
    "    AFenergyD_std.append(float(str(df.agg({'freeEnergyA': ['std']})).split()[2]))\n",
    "    AFenergyA_std.append(float(str(df.agg({'freeEnergyA': ['std']})).split()[2]))\n",
    "    AFenergyX_std.append(float(str(df.agg({'freeEnergyA': ['std']})).split()[2]))\n",
    "    AFenergyZ_std.append(float(str(df.agg({'freeEnergyA': ['std']})).split()[2]))\n",
    "\n",
    "    \n",
    "    # print overview.\n",
    "    print(f\"candidate: {catalyst_name[i]}\")\n",
    "    print('D1: ' + str(round(float(d1), 2)))\n",
    "    print('D2: ' + str(round(float(d2), 2)))\n",
    "    print('D3: ' + str(round(float(d3), 2)))\n",
    "    print('w1: ' + str(round(float(w1), 2)))\n",
    "    print('w2: ' + str(round(float(w2), 2)))\n",
    "    print('w3: ' + str(round(float(w3), 2)))\n",
    "    print('w4: ' + str(round(float(w4), 2)))\n",
    "\n",
    "    i = i + 1\n",
    "\n",
    "    \n",
    "# Exract individual energies from each catalyst group\n",
    "patterns = [\"> <freeEnergyA>\", \"> <freeEnergyF>\", \"> <freeEnergyE>\", \"> <freeEnergyC>\", \"> <freeEnergyD>\",\"> <freeEnergyL>\", \"> <freeEnergyX>\", \"> <freeEnergyZ>\"]\n",
    "AF_EnergyA = []; AF_EnergyF = []; AF_EnergyE = []; AF_EnergyC = []; AF_EnergyD = []; AF_EnergyL = []; AF_EnergyX = []; AF_EnergyZ = []\n",
    "AF_Energies = [AF_EnergyA, AF_EnergyF, AF_EnergyE, AF_EnergyC, AF_EnergyD, AF_EnergyL, AF_EnergyX, AF_EnergyZ]\n",
    "\n",
    "for group in catalyst_groups:\n",
    "    for pathname in group:\n",
    "        i = 0\n",
    "        with open(pathname, \"r\") as input_file:\n",
    "            lines = input_file.readlines()\n",
    "            for pattern in patterns:\n",
    "                for index, line in enumerate(lines):\n",
    "                #for pattern in patterns:\n",
    "                    pattern = re.compile(pattern)\n",
    "                    if pattern.match(line):\n",
    "                        property_name = re.split('<|>', line)[2]\n",
    "                        value_str = lines[index + 1].rstrip()\n",
    "                        if is_float(value_str):\n",
    "                            AF_Energies[i].append(float(value_str))\n",
    "                            i = i + 1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average AF Energy descriptor values (kcal/mol)\n",
      "DE BH: [-8.380191386791203, 5.739066299219215, 11.477505103550842, 13.848179986169649, 17.802651428888517]\n",
      "DE cat: [-9.849884440476457, 0.5652721776431471, -1.570092201742722, -0.10175466186594773, 3.265381764959281]\n",
      "DDE: [1.469693053685253, 5.173794121576067, 13.047597305293564, 13.949934648035597, 14.537269663929235]\n",
      "DE stab: [18.579772962393587, 7.392170398748112, -3.2959464030189753, -3.277749057556617, -3.870104030838862]\n",
      "DE synt: [3.370273900121769, 0.0, -12.510361338895992, -15.18160617094229, -19.46990478093084]\n",
      "DE stereo: [11.611161469236485, 13.226332762872655, 9.805859288864827, 9.726167464964021, 13.070714083540523]\n"
     ]
    }
   ],
   "source": [
    "# Calculate barriers from AF values\n",
    "\n",
    "# Constant energies\n",
    "E_propene=-117.738020895\n",
    "E_ethene=-78.4716324751\n",
    "E_Hoveyda=-502.204109499\n",
    "hartree_to_kcalmol=627.49467516\n",
    "\n",
    "AF_BarriersBHE_from_precursor = [] # Barriers to B-HE with respect to the precursor \n",
    "AF_BarriersMetathesis_from_precursor = [] # Barriers to metathesis with respect to the precursor\n",
    "AF_BarriersBHE_from_MCB = [] # Barriers to B-HE with respect to the MCB \n",
    "AF_BarriersMetathesis_from_MCB = [] # Barriers to metathesis with respect to the MCB\n",
    "\n",
    "i = 0\n",
    "while i < len(AFenergyA):\n",
    "\n",
    "    # Calculate barriers to B-H elimination wrt. MCB:\n",
    "    AF_BHE_MCB = (AFenergyZ[i] - AFenergyD[i]) * hartree_to_kcalmol\n",
    "    AF_BarriersBHE_from_MCB.append(AF_BHE_MCB)\n",
    "        \n",
    "    # Calculate barriers to metathesis wrt. MCB:\n",
    "    AF_Metathesis_MCB = (AFenergyX[i] + (2 * E_ethene) - AFenergyD[i] - (2 * E_propene)) * hartree_to_kcalmol\n",
    "    AF_BarriersMetathesis_from_MCB.append(AF_Metathesis_MCB)\n",
    "    i = i + 1\n",
    "\n",
    "# Calculate metathesis/B-H elim. barriers from AF energy values for each candidate\n",
    "AF_H0_BH_bar=[]; AF_HI_BH_bar=[]; AF_HIIprime_BH_bar=[]; AF_HII_BH_bar=[]; AF_HC1Ph_BH_bar=[]\n",
    "AF_H0_met_bar=[]; AF_HI_met_bar=[]; AF_HIIprime_met_bar=[]; AF_HII_met_bar=[]; AF_HC1Ph_met_bar=[]\n",
    "\n",
    "i = 0\n",
    "while i < 6:\n",
    "    # Calculate barriers to B-H elimination wrt. MCB:\n",
    "    BH_bar = (AF_EnergyZ[i] - AF_EnergyD[i]) * hartree_to_kcalmol\n",
    "    AF_H0_BH_bar.append(BH_bar)\n",
    "    # Calculate barriers to metathesis wrt. MCB:\n",
    "    met_bar = (AF_EnergyX[i] + (2 * E_ethene) - AF_EnergyD[i] - (2 * E_propene)) * hartree_to_kcalmol\n",
    "    AF_H0_met_bar.append(met_bar)\n",
    "    i = i + 1\n",
    "\n",
    "while i < 12:\n",
    "    # Calculate barriers to B-H elimination wrt. MCB:\n",
    "    BH_bar = (AF_EnergyZ[i] - AF_EnergyD[i]) * hartree_to_kcalmol\n",
    "    AF_HI_BH_bar.append(BH_bar)\n",
    "    # Calculate barriers to metathesis wrt. MCB:\n",
    "    met_bar = (AF_EnergyX[i] + (2 * E_ethene) - AF_EnergyD[i] - (2 * E_propene)) * hartree_to_kcalmol\n",
    "    AF_HI_met_bar.append(met_bar)\n",
    "    i = i + 1\n",
    "\n",
    "while i < 18:\n",
    "    # Calculate barriers to B-H elimination wrt. MCB:\n",
    "    BH_bar = (AF_EnergyZ[i] - AF_EnergyD[i]) * hartree_to_kcalmol\n",
    "    AF_HIIprime_BH_bar.append(BH_bar)\n",
    "    # Calculate barriers to metathesis wrt. MCB:\n",
    "    met_bar = (AF_EnergyX[i] + (2 * E_ethene) - AF_EnergyD[i] - (2 * E_propene)) * hartree_to_kcalmol\n",
    "    AF_HIIprime_met_bar.append(met_bar)\n",
    "    i = i + 1\n",
    "\n",
    "while i < 24:\n",
    "    # Calculate barriers to B-H elimination wrt. MCB:\n",
    "    BH_bar = (AF_EnergyZ[i] - AF_EnergyD[i]) * hartree_to_kcalmol\n",
    "    AF_HII_BH_bar.append(BH_bar)\n",
    "    # Calculate barriers to metathesis wrt. MCB:\n",
    "    met_bar = (AF_EnergyX[i] + (2 * E_ethene) - AF_EnergyD[i] - (2 * E_propene)) * hartree_to_kcalmol\n",
    "    AF_HII_met_bar.append(met_bar)\n",
    "    i = i + 1\n",
    "\n",
    "while i < 30:\n",
    "    # Calculate barriers to B-H elimination wrt. MCB:\n",
    "    BH_bar = (AF_EnergyZ[i] - AF_EnergyD[i]) * hartree_to_kcalmol\n",
    "    AF_HC1Ph_BH_bar.append(BH_bar)\n",
    "    # Calculate barriers to metathesis wrt. MCB:\n",
    "    met_bar = (AF_EnergyX[i] + (2 * E_ethene) - AF_EnergyD[i] - (2 * E_propene)) * hartree_to_kcalmol\n",
    "    AF_HC1Ph_met_bar.append(met_bar)\n",
    "    i = i + 1 \n",
    "    \n",
    "DE_BHs, DE_cats, DDEs, stabs, synts, stereos = [], [], [], [], [], []\n",
    "i = 0\n",
    "while i < 5:\n",
    "    #Calculate the energy descriptors:\n",
    "    DE_BH = ( AFenergyZ[i] - AFenergyC[i] ) * hartree_to_kcalmol\n",
    "    DE_BHs.append(DE_BH)\n",
    "    DE_cat = ( AFenergyX[i] + 2*E_ethene - AFenergyC[i] - 2*E_propene ) * hartree_to_kcalmol\n",
    "    DE_cats.append(DE_cat)\n",
    "    DDE = DE_BH - DE_cat\n",
    "    DDEs.append(DDE)\n",
    "    DE_stab = ( AFenergyC[i] + E_Hoveyda - AFenergyA[i] - 2*E_ethene ) * hartree_to_kcalmol\n",
    "    stabs.append(DE_stab)\n",
    "    DE_synt = ( AFenergyA[i] + AFenergyL[1] - AFenergyA[1] - AFenergyL[i] ) * hartree_to_kcalmol\n",
    "    synts.append(DE_synt)\n",
    "    DE_stereo = ( AFenergyF[i] - AFenergyA[i] ) * hartree_to_kcalmol\n",
    "    stereos.append(DE_stereo)\n",
    "    i = i + 1\n",
    "\n",
    "print('average AF Energy descriptor values (kcal/mol)')\n",
    "print('DE BH:', DE_BHs)\n",
    "print('DE cat:', DE_cats)\n",
    "print('DDE:', DDEs)\n",
    "print('DE stab:', stabs)\n",
    "print('DE synt:', synts)\n",
    "print('DE stereo:', stereos)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract energies from HQF.\n",
    "\n",
    "HQF_paths = []\n",
    "sorted_HQF_names = ['H0HQF', 'HIHQF', 'HIIprimeHQF', 'HIIHQF', 'HC1PhHQF']\n",
    "sorted_HQF_paths = []\n",
    "\n",
    "for pathname in pathnames:\n",
    "    for name in sorted_HQF_names:\n",
    "        if pathname in name or name in pathname:\n",
    "            HQF_paths.append(pathname)\n",
    "for name in sorted_HQF_names:\n",
    "    for path in HQF_paths:\n",
    "        if name in path:\n",
    "            sorted_HQF_paths.append(path) \n",
    "\n",
    "patterns = [\"> <freeEnergyA>\", \"> <freeEnergyF>\", \"> <freeEnergyE>\", \"> <freeEnergyC>\",\"> <freeEnergyL>\", \"> <freeEnergyX>\", \"> <freeEnergyZ>\"]\n",
    "HQFfreeEnergyA, HQFfreeEnergyF, HQFfreeEnergyE, HQFfreeEnergyC, HQFfreeEnergyL, HQFfreeEnergyX, HQFfreeEnergyZ = [], [], [], [], [], [], []\n",
    "HQFfreeEnergies= [HQFfreeEnergyA, HQFfreeEnergyF, HQFfreeEnergyE, HQFfreeEnergyC, HQFfreeEnergyL, HQFfreeEnergyX, HQFfreeEnergyZ]\n",
    "\n",
    "for pathname in sorted_HQF_paths:\n",
    "    i = 0\n",
    "    with open(pathname, \"r\") as input_file:\n",
    "            lines = input_file.readlines()\n",
    "            for index, line in enumerate(lines):\n",
    "                for pattern in patterns:\n",
    "                    pattern = re.compile(pattern)\n",
    "                    if pattern.match(line):\n",
    "                        property_name = re.split('<|>', line)[2]\n",
    "                        value_str = lines[index + 1].rstrip()\n",
    "                        if is_float(value_str):\n",
    "                            HQFfreeEnergies[i].append(float(value_str))\n",
    "                            i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DE cat: [12.230885251121038, 14.225153060511133, 14.876375819376996, 15.40644316138325, 16.247708957529827]\n",
      "DDE: [4.4171458568846305, 4.833002265496361, 11.103985761231115, 12.031650671701689, 13.616375923902666]\n",
      "DE stab: [20.63851007775288, 13.654747223394013, 7.207525573340769, 6.285048788480383, 8.321249557299195]\n",
      "DE synt: [1.2457896512081996, 1.426757706212811e-10, -9.290566937013107, -10.175460555260043, -15.119652994788716]\n",
      "DE stereo: [12.41970216377184, 11.477163747079588, 10.494395391759488, 9.994675574527829, 9.003057034307652]\n",
      "\n",
      "property  H0   HI   HII' HII  HC1Ph\n",
      "d1:      [0.0, 0.0, 0.2, 1.0, 12.8]\n",
      "d2:      [4.4, 4.8, 11.1, 12.0, 13.6]\n",
      "d3:      [3.2, 1.2, 0.5, 0.0, 0.0]\n",
      "w1:      [1.0, 1.0, 1.0, 1.0, 1.0]\n",
      "w2:      [0.0, 0.9, 1.0, 1.0, 1.0]\n",
      "w3:      [0.6, 0.9, 1.0, 1.0, 1.0]\n",
      "w4:      [1.0, 1.0, 1.0, 1.0, 1.0]\n",
      "Fitness: [0.0, 5.0, 11.9, 13.0, 26.4]\n"
     ]
    }
   ],
   "source": [
    "# Calculating barriers from HQF energies, then calculate the descriptors, weights and overall fitness.\n",
    "\n",
    "# Defining variables\n",
    "BarriersBHE_from_precursor = [] # Barriers to B-HE with respect to the precursor \n",
    "BarriersMetathesis_from_precursor = [] # Barriers to metathesis with respect to the precursor\n",
    "BarriersBHE_from_MCB = [] # Barriers to B-HE with respect to the MCB \n",
    "BarriersMetathesis_from_MCB = [] # Barriers to metathesis with respect to the MCB\n",
    "HQF_fitnesses = []; HQFd1s = []; HQFd2s = []; HQFd3s = []; HQFw1s = []; HQFw2s = []; HQFw3s = []; HQFw4s = []\n",
    "ddE_stability_HI = hartree_to_kcalmol * math.fabs(HQFfreeEnergyC[3] - HQFfreeEnergyA[3] - HQFfreeEnergyC[1] + HQFfreeEnergyA[1])\n",
    "# Defining constants (free energies [hartree] of substrates, conversion factors etc.)\n",
    "G_ethene = -78.477866552\n",
    "G_propene = -117.734910132\n",
    "G_Hoveyda = -502.210801644\n",
    "hartree_to_kcalmol = 627.4946752\n",
    "kT = 0.622308995 # NB: in Kcal/mol\n",
    "epsilon = 5.73163236\n",
    "delta = 1.43290809\n",
    "Lambda = 1.43290809\n",
    "sigma = 2.86581618\n",
    "\n",
    "i = 0\n",
    "# Check for inconsistancies in the data set\n",
    "if not len(HQFfreeEnergyA) == len(HQFfreeEnergyF) == len(HQFfreeEnergyE) == len(HQFfreeEnergyC) == len(HQFfreeEnergyX) == len(HQFfreeEnergyZ) == len(HQFfreeEnergyL):\n",
    "    print('Error: inconsistant number of energy values')\n",
    "    quit(1)\n",
    "else:\n",
    "    while i < len(HQFfreeEnergyA):\n",
    "        # Calculate barriers to B-H elimination wrt. precursor:\n",
    "        BHE_P = ((HQFfreeEnergyZ[i] + G_Hoveyda) - (HQFfreeEnergyA[i] + (2 * G_ethene))) * hartree_to_kcalmol\n",
    "        BarriersBHE_from_precursor.append(BHE_P)\n",
    "        \n",
    "        # Calculate barriers to metathesis wrt. precursor:\n",
    "        Metathesis_P = ((HQFfreeEnergyX[i] + G_Hoveyda) - (HQFfreeEnergyA[i] + (2 * G_propene))) * hartree_to_kcalmol\n",
    "        BarriersMetathesis_from_precursor.append(Metathesis_P)\n",
    "\n",
    "        # Calculate barriers to B-H elimination wrt. MCB:\n",
    "        BHE_MCB = (HQFfreeEnergyZ[i] - HQFfreeEnergyC[i]) * hartree_to_kcalmol\n",
    "        BarriersBHE_from_MCB.append(BHE_MCB)\n",
    "        \n",
    "        # Calculate barriers to metathesis wrt. MCB:\n",
    "        Metathesis_MCB = (HQFfreeEnergyX[i] + (2 * G_ethene) - HQFfreeEnergyC[i] - (2 * G_propene)) * hartree_to_kcalmol\n",
    "        BarriersMetathesis_from_MCB.append(Metathesis_MCB)\n",
    "        i = i + 1\n",
    "\n",
    "HQF_DDEs, HQF_DE_cats, HQF_stabs, HQF_synts, HQF_stereos = [], [], [], [], []\n",
    "\n",
    "i = 0        \n",
    "while i < len(HQFfreeEnergyA):\n",
    "    # Calculate descriptor 1 (d1) values:\n",
    "    HQFd1 = math.exp((( BarriersBHE_from_MCB[i] - BarriersMetathesis_from_MCB[i] ) - ( BarriersBHE_from_MCB[3] - BarriersMetathesis_from_MCB[3] )) / kT )\n",
    "    HQFd1s.append(HQFd1)\n",
    "\n",
    "    # Calculate descriptor 2 (d2) values:\n",
    "    HQFd2 = BarriersBHE_from_MCB[i] - BarriersMetathesis_from_MCB[i]\n",
    "    HQFd2s.append(HQFd2)\n",
    "\n",
    "    # Calculate descriptor 3 (d3) values:\n",
    "    if BarriersMetathesis_from_MCB[3] - BarriersMetathesis_from_MCB[i] > 0:\n",
    "        HQFd3 = BarriersMetathesis_from_MCB[3] - BarriersMetathesis_from_MCB[i]\n",
    "        HQFd3s.append(HQFd3)\n",
    "    else:\n",
    "        HQFd3 = 0.0\n",
    "        HQFd3s.append(HQFd3)\n",
    "\n",
    "    # calculate weight 1 (w1) values:\n",
    "    HQFw1 = 1 / (1 + math.exp((BarriersMetathesis_from_MCB[i] - (BarriersMetathesis_from_MCB[3] + epsilon) ) / kT))\n",
    "    HQFw1s.append(HQFw1)\n",
    "\n",
    "    # calculate weight 2 (w2) values:\n",
    "    HQFw2 = 1 / (1 + math.exp(((hartree_to_kcalmol * (math.fabs(HQFfreeEnergyC[3] - HQFfreeEnergyA[3] - HQFfreeEnergyC[i] + HQFfreeEnergyA[i])) - (ddE_stability_HI + delta)) / kT)))\n",
    "    HQFw2s.append(HQFw2)\n",
    "\n",
    "    # calculate weight 3 (w3) values:\n",
    "    dE_synt = hartree_to_kcalmol * (HQFfreeEnergyA[i] + HQFfreeEnergyL[1] - HQFfreeEnergyA[1] - HQFfreeEnergyL[i])\n",
    "    HQFw3 = 1 / (1 + math.exp((dE_synt - Lambda) / kT))\n",
    "    HQFw3s.append(HQFw3)\n",
    "\n",
    "    # calculate weight 4 (w4) values:\n",
    "    dE_stereo = hartree_to_kcalmol * (HQFfreeEnergyF[i] - HQFfreeEnergyA[i])\n",
    "    HQFw4 = 1 / (1 + math.exp((sigma - dE_stereo) / kT))\n",
    "    HQFw4s.append(HQFw4)\n",
    "\n",
    "    HQF_fitness = (HQFd1 + HQFd2 + HQFd3) * HQFw1 * HQFw2 * HQFw3 * HQFw4\n",
    "    HQF_fitnesses.append(HQF_fitness)\n",
    "\n",
    "    #Calculate the energy descriptors:\n",
    "    HQF_DE_cat = BarriersMetathesis_from_MCB[i]\n",
    "    HQF_DE_cats.append(HQF_DE_cat)\n",
    "    HQF_DDE = BarriersBHE_from_MCB[i] - BarriersMetathesis_from_MCB[i]\n",
    "    HQF_DDEs.append(HQF_DDE)\n",
    "    HQF_DE_stab = ( HQFfreeEnergyC[i] + G_Hoveyda - HQFfreeEnergyA[i] - 2*G_ethene ) * hartree_to_kcalmol\n",
    "    HQF_stabs.append(HQF_DE_stab)\n",
    "    HQF_DE_synt = ( HQFfreeEnergyA[i] + HQFfreeEnergyL[1] - HQFfreeEnergyA[1] - HQFfreeEnergyL[i] ) * hartree_to_kcalmol\n",
    "    HQF_synts.append(HQF_DE_synt)\n",
    "    HQF_DE_stereo = ( HQFfreeEnergyF[i] - HQFfreeEnergyA[i] ) * hartree_to_kcalmol\n",
    "    HQF_stereos.append(HQF_DE_stereo)\n",
    "                 \n",
    "    i = i + 1\n",
    "\n",
    "print('DE cat:', HQF_DE_cats)\n",
    "print('DDE:', HQF_DDEs)\n",
    "print('DE stab:', HQF_stabs)\n",
    "print('DE synt:', HQF_synts)\n",
    "print('DE stereo:', HQF_stereos)\n",
    "print('')\n",
    "\n",
    "HQF_descriptors = [HQFd1s, HQFd2s, HQFd3s, HQFw1s, HQFw2s, HQFw3s, HQFw4s, HQF_fitnesses]\n",
    "r_HQFd1s='';r_HQFd2s='';r_HQFd3s='';r_HQFw1s='';r_HQFw2s='';r_HQFw3s='';r_HQFw4s='';r_HQF_fitnesses=''\n",
    "rounded_HQF_descriptors = [r_HQFd1s, r_HQFd2s, r_HQFd3s, r_HQFw1s, r_HQFw2s, r_HQFw3s, r_HQFw4s, r_HQF_fitnesses]\n",
    "i = 0\n",
    "for desc in HQF_descriptors:\n",
    "    rounded_HQF_descriptors[i] = [ round(elem, 1) for elem in desc ]; i = i + 1\n",
    "\n",
    "# Printing HQF descriptor/weights overview.\n",
    "print('property  H0   HI   HII\\' HII  HC1Ph')\n",
    "print('d1:      '+str(rounded_HQF_descriptors[0]))\n",
    "print('d2:      '+str(rounded_HQF_descriptors[1]))\n",
    "print('d3:      '+str(rounded_HQF_descriptors[2]))\n",
    "print('w1:      '+str(rounded_HQF_descriptors[3]))\n",
    "print('w2:      '+str(rounded_HQF_descriptors[4]))\n",
    "print('w3:      '+str(rounded_HQF_descriptors[5]))\n",
    "print('w4:      '+str(rounded_HQF_descriptors[6]))\n",
    "print('Fitness: '+str(rounded_HQF_descriptors[7]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we plot the two barriers to metathesis and to decomposition together with the HQ fitness to demonstrate that the barriers by themselves cannot reproduce the ranks expected from literature, and observed in lab experiments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we decompose the HQF fitness into descriptors and weights for a closer inspection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comparison of high-quality fitness (HQF) scores and barriers\n",
      "to propene self-metathesis and decomposition via b-HE as calculated\n",
      "relative to Ru-P for the test-set catalysts.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU8AAADXCAYAAACaj9NoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGlklEQVR4nO2de1zN9x/HX6e7Sg2RImUVisplyYxJzKV+bK4zMpfF2mxDFiq0wmIuM4yMTZg7uW+5M9usIhFRM93IpZRSup7z/v3x0dHR6XbOqXM6fZ6Px+fROd/P5/v5vr/n9H2dz/X9FhARgcPhcDi1QkPZBnA4HE5DhIsnh8PhyAAXTw6Hw5EBLp4cDocjA1w8ORwORwa4eHI4HI4McPHkcDgcGeDiyeFwODLAxZPD4XBkgIsnh8NRTfz8ADs7wN4eWL2aHTtzBnB0BGxtgYAAQIkbJLWUdmUOh8OpjN9+A/76C4iLA4qLgc6dgQEDgClTgAsXAEtLwMMDOH4cGDZMKSY2CvEsLS3FtWvXYGpqCg0N3tjmcOobkUiEx6mp6GZvDy2tcrKjq8vS67i7A++9B2hpAQ8eAEIh8OwZa3FaW7Mynp7AgQNcPOuSa9euoWfPnso2g8Np9KQBaFv+QGAg8M030gtrawMLFrAu+9ixQHo6YG7+Kt/MDHj4sO6MrYZGIZ6mpqYAgKioKJiZmSnZGg6n8fHw4UP07NkTops3AQuLVxnSWp3lWbIE8PcHhg8HEhMBgeBVHhGgxJ5koxDPsq66mZkZ2rZtW01pDodTV2gYGwNGRtUXvHULEIkABwdAXx8YMYJ10TU1X5V59EiyJVrP8AFADoejety+DXh7s8mioiIgPJxNFt25w1qgQiHw66/A0KFKM7FRtDw5HE4DY/RoICYG6NqVtTbHjgU+/hho0wYYMwYoKGCz7aNHK81EQWPwJH///n1YWFggLS2Nd9s5HCWgjs8g77ZzOByODHDx5HA4HBng4snhcDgywMWTw+FwZICLJ4fD4ciASovn119/jcmTJwMAzpw5A0dHR9ja2iIgIACNYJEAh8NRYVRWPM+ePYtt27YBAAoKCjBlyhQcOnQIt2/fxpUrV3D8+HElW8jhcBozKimeWVlZCAgIgL+/PwC2J93W1hbW1tbQ0tKCp6cnDhw4oGQrOa+zd+9eODg4oFu3bpg3b16F/OTkZFhZWVU4bmVlheTkZCQnJ0NHRwddu3aVSMuWLasH66UTHh4OJycnNGnSBE5OTggPD1eaLRzVQiV3GH366adYunQp0tLSAADp6ekwL7eH1czMDA+r8KZSVFSEoqIi8fvnz5/XnbEcAMC9e/cwe/ZsREdHw9zcHI6Ojvjiiy9gUd4JRA0wNzdHbGyszHbk5+dXmqepqQk9Pb0aldXQ0MDvv/+OUaNGQSAQgIgQFxeHUaNGYefOnXj//fclyjZp0kT8/sWLF5UOKwkEAujr69fmljgqisqJ55YtW2BhYYEBAwYgLCwMAPMFKCjnTYWIqvTLGRISgqCgoLo2lVOOffv24eOPP0abNm0QFRWF0tJStGzZst7tMDQ0rDTP3d0dJ06cEL9v1aoVXrx4IbVsv379kJ2dLRZOAOK/EyZMkCj71ltvITo6Wvze3t4eKSkpUuu1t7fHrVu3anYzqkxqKpCZWfG4iQnQrl3926MEVE489+7di4cPH6Jr167IyspCXl4eUlJSoFnOm8qjR48kWqKv4+fnBx8fH/H7Bw8ewN7evk7tbuxcvHgRPj4+6N27NxITE3Hp0iWJVl4Z6enp6Nq1a4VjVeVv2LABvXv3rguzqyQxMZFPTEojNRXo2BEoLKyYp6cHJCQ0CgFVOfE8ffq0+HVYWBguXLiA0NBQ2NjYIDExEdbW1vj111/h5eVVaR26urrQLecnMDc3t05tbuwQEaKiotCzZ0/8/fff2LFjBxYuXCh1XFpat7z8OKi83fa8vLxK88r/AAPAkydPKi2roaGBXr16IS4uTkJABQIBunTpgsuXL0uULU98fHyV3fYGT2amdOEE2PHMTC6eqoKenh62bduGMWPGoKCgAB4eHhitRG8qHEkSExOhqakJY2NjAMCYMWPg6+uLRYsW4ejRowCA4OBgODo61rktBgYGCisbGBgoMeZZ9jcoKKjKc/mYZiOBGgFpaWkEgNLS0pRtilqybds20tLSovj4eCIi2rx5M40cObJCuaSkJLK0tKxw3NLSkpKSkirNVyYHDx4kJycn0tPTIycnJwoPD1e2Scrn6lUi5sdderp6tcIp6vgMNoiWJ0e1+eeff7BgwQJMnz4dRUVFaNGiBX755ReZ6pI25tmtWzds3bpVAZbWnpEjR2LkyJFKuTZHteHiyZGbyMhIbN++HYGBgVWWK1vP+TrljxUXFyvYOg6nblDJRfKchkNBQQFSUlJgZ2enbFM49UVpaeV5enpsuVIjgLc8OXLRpEkTZEpb78dRT4RCwM8P0NEBtm9ncdTLw9d5cjgcjhRWrADOnQPWrwc+/LBur7V6NfDzzyy8sLMzEBrK4rzv3g288QYrM20aMGNG3dpRCVw8ORxOzYiKAhYuBIYNAz7/vO6vtXUr+6uvz4K//fgje3/oENCtW91evwbwMU8Oh1M9z58D48cDLVsCv/wCCASyOU15/hzIzX2VyvmgkKBZM9a6NTAABALAyYntbLp2jbU+HR2BmTMrP78e4OLJ4XCqZ8YM4N49YMcOwMQE4eHhGDVqFOLi4lBYWCh2mlKdgBrZ2wPGxq9SSIj0gra2QL9+7PWTJ0xIe/cG3n4bWLmShSXOzgaWLlXwjdYCZS80rQ/UcYEuh1Nv/PorW/w+d674kKOjIwkEAgIgTgKBgJycnKRWIX4G4+OJcnJepcLCqq+dlERkb0+0ZEnFvGvXiLp1k/m25IW3PDkcTuXcuwd89hnw1lvA4sUAmMu9W7duVdi/T0RISEiour6mTQEjo1epnA+KCsTGAu+8A3h7AwEBwN27bIa/DKEQ0FLetA0XTw6HI52SEjbOKRKxGW4dHVy8eBFOTk4QCoUVigsEAnTs2FEx187IAIYMAdatA778kh3T1QXmzGFjn0Qsb8QIxVxPBrh4qinJyckQCASYOnWqxPHHjx9DS0sL33zzTaXnbt68Gbt3766y/qioKLG3+LCwMHGsKXkIDQ1FaGio3PUomjNnzsDe3h5nzpxRtin1S1AQEBnJZrltbLBo0SK4urqiqKgIAQEBAF55iSpzmlLdLrMas2YNm1AKDga6dmUpNJQJprs7c4mnocHEVEnwpUovCQ8PR1BQEBITE9GhQwcEBgY2+D3NJiYmiIiIQElJCbS1tQEwp8UtWrSo8ry//voLrq6uVZaJj4/H48ePFWUqAMDb21vuOhTpSb5JkyYgIvj7++P27duYN28eLl68WMGtnFp6kr9wAfj2W+Cjj0ATJ0IAoHv37vjss8+wbNkyGBkZoXv37ggODkZCQgI6duyIwMBAjFBUS3Dp0song8aNU8w15EVpo631SHUTRgcPHhQPeJf/e/DgwXq2VHGUeSgaOXIkHT9+XHy8b9++5O3tTYGBgRQTE0PvvvsudevWjfr370+3b9+miIgIatasGVlYWNCJEycoLi6OXF1dydnZmaysrGjDhg2UmZlJFhYW1KxZMwoKCqKtW7dSnz59yNXVlWxsbGjkyJFUVFRERES7du2iHj16kJOTE40fP55yc3NJKBSSt7c3OTo6kp2dHQUGBhIRUWBgIAUGBlaaXxNQbgLj9eTu7i5RVl9fv9Ky/fr1IyKiiIiIKusEQG+99ZZEvZaWlpWWtbe3r/2XWd88fUrUpg2VtmtH3h99ROvWrZO7SnWctOXddgBBQUEVwi0IBAIEBwcr2TL5+fDDD7Fv3z4AQGpqKpo0aQJTU1OUlJRg6tSp2L59O2JiYrB48WJMnDgRgwcPxvDhwxEcHAx3d3ds2bIF/v7+iIqKwoULFzB37ly0aNECwcHBGD58OBYtWgSADRPs378fCQkJSE1NxenTp3Hnzh1s2LABf/75J2JjY2Fvb4/g4GDcvHkTkZGRuH79OqKjoxEfH4/Ccs51q8uvL4gICxcurOBEWa0hAry8IHr4EMOfP8dPe/dW6TS6McO77ZAeboFqMnPYAPjf//4HHx8fFBcXY8+ePRg3bhxSUlKQkJCAxMREiUBmGRkZFbwarVy5Er/99htCQkJw/fr1Sj21v/vuuzB56RDC3t4emZmZSEpKQmJiInr16gUAKCkpgbW1NWxsbFBSUoJ3330X7u7u+O677yS609XlV4UiPcmfOnVKIjZRGYcPH8bAgQMlypanIXuSz125EkaHDmERgGQzM/z9++9wcXFRtlkqCRdPAB06dKgQbgFgwcTy8/Nr5Z1c1dDX10ffvn1x6tQpHDp0CBEREfj+++8hFArx5ptvikNeEBEePHgAHR0difPHjBmDFi1aYNiwYRg3bhz27t0r9TplY6rAq8kDoVCIsWPHYt26dQDYGGNRURH09fVx7do1nD9/HidPnsTbb7+NixcvStgsLb9Dhw7V3q+iPMmXtTo1NDQgEonExzU0NLB06VIMHz68UiFsEGOa0oiPh/6CBfgDgGZAAGIWLpQIZ8ORhHfbwcItlHXVgVetg8zMTDg5OSEyMlKZ5snNuHHjEBISAnNzc3GojE6dOiE7OxsXLlwAAOzatQvDhg0DAGhpaaH0pduxs2fPIigoCO+//z5OnjwJABAKhRJlKsPV1RWHDh3Co0ePAACzZ8/G4sWL8eeff2LIkCFwc3PDypUrYW9vL9HKry6/PiguLkZqaqqEcAIskmtaWppa+R29f/8+LkREAB99BE0DA1hcvIigJUu4cFYDb3mCeQs/ePBghZlDfX19fPbZZ9BS4kJcRTBkyBBMmjQJs2fPFh/T1dXF/v37MWvWLBQUFMDAwAA7d+4EAAwePBhz585F06ZN8c0338DZ2RnGxsZwcnJC+/btce/ePfTq1QtBQUHw9fVF586dpV7XyckJQUFBGDhwIIgIdnZ2WL16NQwMDGBnZ4cuXbqgSZMm6N69O4YOHYqrV68CAN555x2p+fWJrq4uoqOjkZGRUSGvVatWaiEsRITNmzfD19cXq4RCuObnQ3DgANq/+66yTWsQCKiywRk14v79+7CwsEBaWhratm1bq3NLS0vF4rlq1Sr06tUL77zzTl2YyeHUG/fu3YOXlxfOnz+POXZ2WHn7NnPv9tNPdXI9eZ5BVYV326uhTDjz8vKwdu1a9O3bF3PmzEFBQYGSLeNwZCM2NhYODg6IjIzE5uBgrMjMBDp1Ar7/XtmmNSi4eNYQQ0NDXL9+HZMmTcLq1avRtWtXidjdHI6qUzZO6+DggE8//RRx16/D688/IcjJYdsvG/DEqDLg4lkL3njjDWzduhXHjx/H8+fP0bdvXyQlJSnbLA6nSkpKShASEgI7Ozs8e/YMmpqaWL16Nd48cgQ4dQpYvpxtf+TUCi6eMuDh4YFbt24hLCwM7du3BwCFb1XkcBRBbGwsXFxc4O/vDzs7OxSVOQ++epXFIho6lDkV5tQaLp4y0qxZM3h6egIAbty4ASsrK8yfP18pO2E4nNcpLi7GggUL4OzsjNTUVPz66684duwYTE1Ngbw84KOPgObNgbAw5qmdU2sa9hocFaFt27YYNWoUli9fjmPHjiEsLAzOzs7KNosjL6mpgLTIoA0kQuTRo0cxcuRIrFu3Dq1atXqVMXMm8O+/QEQEUP44p3YoYT99vVNfTgkOHz5MpqampKmpSX5+fiQUCuv0evVBUlISaWtrk5OTk0Ras2YNbdy4kYiIJk+eTMnJyUq2VMGkpBDp6TEP6q8nPT2Wr2Lk5+fT4sWLKT8/n4iInj17VrHQ3r3sHnx86tU2dXQMwlueCuT9999Hnz598OWXXyIlJaXCnueGirm5uXgbpzTOnz+vOD+OskIEvHihuPrS0oDKhmAKC1l+Na79aoy+vtxd5wsXLsDLywv//fcfbGxsMG7cOPFuMjEpKcD06Szy5LffynU9DhTX8szKyqIrV67QtWvXpP/i1ZL58+dTp06dyM7OjlatWiU+ZmlpKW79rF+/vkZ1KeNXr7i4mIiI/vvvPwoMDBS7aGtolLm2e50y93FLliwhbW1tsrOzo8ePH5OlpSUtXLiQXFxcyMbGhn7//XciIsrIyKBRo0ZRjx49qHv37nT06FEiIrp8+TI5OzuTg4MD9e7dmxISEmRzSZeXJ72V2BBSXp7M309OTg55e3sTAGrXrh1FRERIL1hSQvTOO0T6+kR37sh8PVlRx5an3OJ54sQJ6tOnD5mYmFC3bt3I2dmZzMzMyM3NTfzgyFJn3759qaSkhPLz88nKyoru3LlDbm5uFBMTU+v6lPnFLV26lACQo6OjTLYrG2nd9qCgILF4EjH/lUlJSeLXK1euJCKi8PBw6t69OxERTZgwgQ4dOkRETEitra3p8ePHNGLECDpy5AgREW3dupW2bdtG169fp24vA3vl5eXRmDFjqKCgoGpDG6l49u/fnwDQ559/Trm5uZUX/OYbdq0tW2S+ljyojHhmZRFducKCx8nZyJNLPKdMmUK+vr5048aNCnlxcXE0a9Ys8vT0lKnuspZbcnIyWVhYUGpqKjVr1oyGDRtGDg4O9NVXX1FhdZH3XqLsL27fvn1kYmJCWlpaDa4VWl3Lk6iieN6+fZuIiO7du0dWVlZERNSiRQtydHQUC3C7du3o4sWLFBYWRq1atSIvLy86dOgQlZaWUn5+PnXp0oX69u1LISEh4rqrRCRiIqSo9OefVQven38q7loiUa2+k6dPn4r/h/7880+6ePFi1SdcukSkoUE0enStr6UoZHoGV61ikTO7dCGaMoWoqIjo9GkiBwciGxsif/+a38+JE0R9+hCZmLCIm87ORGZmRG5uRDI28uQSz5p8EClyDKwHBARQkyZNaNKkSfTkyRNyd3enhIQEKikpoYkTJ9LChQulnldYWEg5OTniFB8fr/RfvcePH9OoUaMIAM2cOVNpdtQWWcSz7HX5c9944w3KzMwUn5+enk4lJSVExP5HNmzYQO+++y55eXkREVFJSQmdOnWK5syZQ61bt6aEhIQ6ub9KuXq1avG8erV+7XnJgQMHyNTUlIKCgmp2QlYWUbt2LGVl1a1xVVBr8YyMZKJZ9uPi6Un07bdEbdsS3b3LhiEGDSJ6OfxTJVOmEPn6Eklp5NHNm0SzZrH6a4lc4unq6kr9+/evkMqOK4L8/HwaMGAAbdq0SeL4tWvXxF271wkMDCSgYggEZXcZRCIR7dmzh+7fv09ERNnZ2eIWtqpSE/G0tramf//9l4gqF8+RI0fSN998Q0REiYmJ1KxZM3r8+DENHTqUTp48SUREFy9epO7du9OlS5dowIABVFpaSkREbm5u4jHSekPFZtsfPXok/vHt3LkzRUVFVX+SSEQ0dixrdf7xR90bWQW1jtuemEh04cKr9ytWELm6EpXXle3biT7+uPqL1+TeZfg+5ZptryoCozzcunULIpEIDg4O0NfXx4gRI3D06FHo6enh448/BvDKp6Q0/Pz84OPjI37/4MED2Nvb14mttUEgEODDDz8EABARJk2ahLS0NGzbtg0ODg5Ktk523n//fbi7u+O3336rtMy6devw6aefwsHBAUSEn3/+Ga1atUJgYCA+//xzzJ8/H9ra2li9erVKuKRDu3ZAQoJKrPMMDw/HtGnTkJubi0WLFsHf379mLvG2bgX27QMWLQL69q17Q2uA0evPYWAgIE1HbG1ZAoAnT4D164GQEODEiVdlzMyAhw+rv+i8ecDff7PX330HzJ1bsYws32et5VYKIpGINmzYQKNGjaLhw4fTqlWrxF0yWdi/fz/17t2bioqKqLCwkNzc3CgsLIxMTEwoJSWFRCIRTZo0ib799tsa1afsMU9piEQi2rVrFzVv3py0tbVpyZIlcn1mHPXlyJEj1KNHD4qNja35SXfusJn1d95hXVwlU+uWZxlJSWzcc8kSol9/lexenzpFNHhw9Rfv1evV67fflsl+aShknefcuXPx77//YurUqSAibN26FcnJyVi7dq1M9Y0ePRoxMTHo2rUrNDU1MXbsWEyaNAm6urpwd3dHcXEx+vTpgzlKjNksLwKBAB999BH69+8Pb29vLFiwAIcOHcLOnTvRsWNHZZvHUSIikQibN2+GQCDA9OnTMXz4cHh4eNQ8EF1REdt+qa0N7NwJqJIz76ZNASOjmpWNjQU8PID584EvvwQuXpRsaT56BJibV19P+TW0inRfrAgFdnR0lNhNU1JSQp06dVJE1QpBFVue5RGJRLRjxw5q06YNJSYmKtscjhIpKCggV1dXAkCDBg0ikSyz43PmsLHZPXsUb6CM1PoZfPKEyNSUqHz474ICojZtiBISiEpL2YTRvn3V11VHLU+FbIEpLS1FSUmJ+H1JSUnjCtcqJwKBAJ6enrh37x5sX47zLFu2DPHx8Uq2jFNfEBEeP36MK1euICoqCmvXrsXvv/9e+2ibJ08Cq1YBU6YAL8fXGyRr1gC5uUBwMHOX17UrsHgxsG0bMGYMYGcH2NsDo0dXX1dCAtC+PTBhAvD4MfMopQAHPgoJw7F8+XIcOnQI48ePh0AgwM6dOzF8+HD4+/vLbaAiaGghAB4+fAh7e3sUFBQgODgYc+bM4T9Gas6zZ89w9+5d3L9/XxwrqtY8eQI4OrJucUwMYGioeENlROnP4N27QHQ0EBXF/t64AVhYMFF+GburtigshlFERATOnTsHoVAINzc3eHh4KKJahaD0L04GHjx4gOnTp+O3336Di4sLwsLC0KlTJ2WbxZGT7OxspKeno7CwEHp6emjRogVat24NIkJGRgZatmwpW2x3IuB//wNOnwYuXwZ69FC88XKgcs+gUAjExQFXrgBeXrLVobABABVG1cc8K0MkEtEvv/xCRkZGZGhoSE+fPlW2SRw5OHjwIAEggUAgsf44LCxM/sp/+IGNc65YIX9ddYDSn8GMDKK1a5k3qVWrFLJOVyEtz8ePH2Pfvn3Izs6WOL5o0SJ5q1YIKverV0vS0tJw6dIljB8/HgDw9OlTtFCURx+OQiEi5OfnIzMzExkZGcjMzESPHj3QqlUrdOzYEYmJiRLlBQIBHB0dq/RaVS3XrwM9ewL9+jEfnSrozUupz2BcHDB4MEtWVsB//7HPyc8PGD4cOHeORQ6tJQpZw+Du7g4HBwfZxmk41WJhYSEWzkuXLmHIkCFYsmQJvvrqKz4WWscUFhZCR0cHGhoaSEpKQmRkJDIzMyXSkiVLYGNjgwMHDsDT0/NVqIuXHD58GO+//z6Sk5Mr1E9ESEhIkN3AFy+AcePYOOe2bSopnErH1xfYswcoH48+I4N9bps2AVVs7qgKhYinQCBAWFiYIqriVIOlpSXeeecd+Pj44ODBg9i6dat4hl5dCQ8PR1BQEBITE9GhQwcEBgZi5MiRta6ntLQUT58+rSB+U6dOhba2Nvbt24etW7dK5OXl5SExMRG2trY4efIkPvvsM3F9BgYGMDExQWZmJmxsbGBrawtvb2+YmJhIJEdHRwBAp06dEBcXh/KdPYFAIN+6Xh8f4M4d4PhxtuOGU5GcHEnhBABjY6C0lEUMffNN2eqVu+NPREuWLKHNmzfTf//9RykpKeKkKih9vEXBiEQi2rRpExkaGlKTJk1o7dq1yjapznh9nLDs7/79++np06d07949cdnTp0/T8uXLydfXl6ZMmULDhg2jPn36iNdKfvnll1J9Hjx48ICIiDZt2kSOjo7k5uZGY8eOpc8//5wWLVpEDx8+JCK2vzwmJoZSU1PpxYsXCruX8PBwWT8cNs755ZeynV+PKPUZdHAgej2qQ3o6+/ycnWWuViHi6evrSwYGBmRlZSVO7du3V0TVCqGmX9zp06fJzs6OTp8+XU+WyUdycjK5ubnRlw3g4akJt27dojNnztC+ffsoNDSUQkJCyMzMrMIES/n0xhtviM+fOnUqASANDQ1q2bIl2dnZUd++fcVCd/bsWVq1ahVt27aNTpw4QZGRkfTff//V67bYgwcPkpOTE+np6ZGTk5PswpmaStSsGZGjI1s8ruIoVTw/+4xNEr1OdjbbviojCpkwsrW1xfXr16Gvry9vVXVCTQariQguLi6Ijo6Gs7MzIiMjZVsyUs+IRCKUlJRAV1cX169fxx9//IEZM2YoJQRIZmYmsrKykJWVhezsbGRlZaFFixYYMmQIAGDWrFm4e/euuExWVhbs7e1x4cIFAECvXr0QGRlZo2tpampi6dKlaNmyJaZMmQKBQIDMzExoaGjgjTfeUJsQKFIRCoEBA4DISLbgWwWc3lSHUieMnj8H3n6bTapNmwZYWrJ1n3PnAp9+yjYUyIBCxjw7deqE7OxslRXPmnDq1ClER0cDAKKjo3Hq1CkMHjxYyVZVj4aGhtjDzubNm/Hjjz/i4MGD+PDDDxEaGlrrccKCggIJcWvdujU6duyIkpISfPPNNxJ5WVlZGDRoEEJCQgAA1tbWyM3Nlahv0KBBYvGMi4vD48eP0bx5c3Tq1En8t4zvvvsORUVFaN68OZo1a4bmzZujX79+UscJu3Tpgnnz5klcy8TERLYPsaGxbBnb571xY4MQTqXTtClbz7l0KTB1KpCezrwozZkDTJ4sc7UKaXkOGDAA0dHRcHR0hI6Ojvj4uXPn5K1aIVT3q1fW6oyJiYFQKAQAODk54dq1aw2i9VmGSCTCxo0b4ePjg+LiYvFxgUAAIsL06dNhaWkpIX7jx4/H2LFj8fDhQ7z55psV4s7PnDkTa9asARFBR0cH+vr6aN68uVjghgwZgq+//hoAsGnTJmhra4uFr3nz5mjVqhWLFS4j4eHhGDVqlPgeyv6Gh4djxIgRMtfbYLl8mbmXGzYMCA9vMDHXldryPHcOeOutmjskqSFyiWfZP/PFixel5vfr109mwxRJdV/cyZMnxa2j8gQGBtaZz9K6pFOnThWWv5SJDsC6vGXiNnv2bHz66acoLCzEvHnzxMfLkq2tLWxsbACw2erKfKjWJeHh4QgODkZCQgI6duyIwMDAximcOTlsO2FJCVvb2YDW+ipVPN96C7h5k63xdHZmqWdP9lnq6cler8yjpUTUp08fGj9+PO3YsYMyMjLkqapOqWqwWiQSkbOzM2loaEidkPjiiy+qDz6mYujp6Um9F11dXcrJyZHNUw9HuYhEROPHEwkEROfOKduaWqP0FS/5+exza9qUaMwYImtrIm1tIicnmauUqxlx6dIlpKam4sSJE/jkk0+Ql5eHfv36wd3dHW+99ZY8VdcbxcXFSE1NhUgkqpDXpEkTrF+/HqNGjYKrq2v9GycjHTp0kDpO2KlTJxgpuOvCqSd+/RXYtQvw9wf691e2NQ0PfX32uRkYMO/6APPaJMfOLoU5BgGYEJ0/fx6//fYbrl69ij///FNRVctFdV2GtLQ0ZGRkVDjeqlUrZGdni0Nk3L59G506dVL5cVA+Tqhm3L0LdOsGdO4MXLrEnBw3MFRmi7S5OZswUgBytTz79+8vVUiICNoN6Au2sLCAhYWF1LyyL/rWrVvo1q0bxowZg40bN6p0C27kyJE4ePAgHydUB4qLgfHj2cTQrl0NUjiVTnY20KyZwqutswBwqt46qy0dOnSAr68vQkJCEBkZid27d8PZ2VnZZlXKyJEjZdrCyFExAgOZ/8lff5V9G2Fjx9ISaNMG6N0bKCgArl1jrfhyK4NkQa6VxP369UO/fv3g4uKCrKwspKamIiUlBffu3cPp06flMkzV0NbWxtKlS3H69Gnk5+ejd+/eWLlyJRQ46sHhSHLuHLB8OeDpybygc2QjJwfYvx/o04c5A5k2ja1U6NaNrfuUEYWsOxk/fjxyc3ORkJCAvn374sKFC+jTp48iqlY5BgwYgOvXr2Py5Mm4du2ass3hqCuZmUw027cHfvxR2dY0bAQCoEsXlsp2ExUVscmilxtjZEEhe9ji4uJw5swZfPDBB5g7dy7++usvJCUlKaJqlaRVq1Y4fvw4fv75ZwgEAiQnJ+PMmTPKNoujLhABn3zC3Kbt3q3wxd0NhufPAQcHoMyVn58fW6tZFtOopj8q+fkVj+nqAi4uwBdfVF6mGhQinq1atQIA2NnZIS4uDu3bt0e+DMY0JDQ0NKD3coFtQEAABg0aBD8/P4lAeByOTGzcCBw9yoKf9eypbGuUQ2Qk20lVfrNHVBRw6BBrMcbGAjNm1Kyujz9mQvvsWcW83Fzghx9kGhZRSLe9c+fOmDFjBry9veHp6Yn79++rt2OG1wgNDYWmpiaWLVuG8+fPY/fu3dwxNEc2bt5ke67792eOK9SN58+ZYJWhq8vS64SGAuvWARMnsvdEbKInMJC1RPv3B777Tvq5r7N/P3N67OLCWvHt2rHJonv32HjorFnAwYO1vxcFrN2n0tJS+uOPP4iI6NChQ/TVV19RXFycIqpWCPW1u2Hbtm1kYGBARkZGdObMmTq9FkcNefGCqEsXoubNie7fV7Y1CqXsGcxhMvgqBQZWfaKlJVFSEotB5O7OYraXlBBNnEi0cGHtDYmNJdq/n/nyvHFDhjt5hcICwCUnJxMR0fPnz+mGnEYpmvrcGpaQkECDBg0SO9jlcGrMjBlMUA4fVrYlCkf8DMbHE+XkvEqFhVWfWCaer3PtGlG3bnVgac1RSN96xYoV+PDDDwGw4GQTJkzAhg0bFFF1g6NDhw44efIkzM3NQUSYM2cObty4oWyzOKrOsWNsXO6zz4D331e2NXVH06as61yWatLtBtguq+3bX70XCgElOKkpj0LEc9u2bWLPSpaWloiKisLGjRsVUXWDJiUlBdu3b0fPnj2xYcMGviaUI530dLaExt4eWLlS2daoJrq6bCw4NZV1+NetA+TdMfea79naohDxLC0tlZgg0tTUVLsdRrJgZWWF69evo3fv3pgxYwZGjRqFrKwsZZvFUSVEIjYbnJfHIjw2YIfidYqFBRNMd3egY0cWJXTOnNrVcewYm4TLywPs7NiOLTl6yApp944dOxYDBgzA2LFjIRAIcPDgQb418CXm5uY4ffo0li1bhsDAQPTu3Rs3b95Uil9MjgqyciVw9iwThpcOaDjlKB+uedw4lmRlwQIWnnnPHubTc8MGwNUV+PxzmapTyBMcHByMI0eO4OzZs9DS0sKsWbMwfPhwuer08/PD4cOHIRAI4OXlBR8fH5w5cwY+Pj4oKCjA2LFjsWTJkgbRwtXU1ERAQABcXV2RlpYmFk566fGI00hITWU7h8q4dYu5mBswoOZrFjmyo6XFFtcvWQJ8+CFgaMgcS8uKImad8vLyKhz7+++/Za7vxIkT1LdvXyopKaH8/HyysrKi2NhYatu2Ld29e5dKSkpo0KBBdPTo0RrVp3RHrFIIDw+n/v370301W5LCqYSUFCI9PcllOmVJV5flqzEq8Qy+9x7RnDlEZmZEz58TLVhANGiQzNUpZMxz8ODB4h1FeXl5mDFjBsaOHStzfe7u7uJWbEZGBoRCIZ49ewZbW1tYW1tDS0sLnp6eOHDggCLMVwq5ubm4fPkynJyccPz4cWWbw6lrMjOB1+JDiSkqkmyRcuqG3buZh6VTp1ir09CQufmTEYWI54QJEzB48GDs27cPXbp0AQDcvHlTrjq1tbWxYMEC2NnZwc3NDenp6TA3Nxfnm5mZ4eHDh1LPLSoqQm5urjg9f/5cLlvqgkmTJiE6OhqmpqYYNmwYZs6ciaKiImWbxakr8vKUbQGnRQvgyy+ZgxCALQuTIw6UQsY8P/vsMxgaGmLixIk4cuSI1GBqsrBkyRL4+/tj+PDhSExMlBgfJKJKt4CGhIQgKChIITbUJV26dEF0dDRmz56NtWvXokOHDpjBx74aHkSs5ZiSIpmSk1+9lravmlO/HDvGPPEvWsQmjDIymP8AZUwYlfckT0QwMjLC559/DisrKwCyhx6+desWRCIRHBwcoK+vjxEjRuDAgQPQ1NQUl3n06JFES7Q8fn5+8PHxEb9/8OAB7FU0vrW+vj42bdqE0aNHo//L2DQZGRkwMTHhk0mqgkgEPHwoKYavpxcvJM/R1WV7qC0tWfRGbW22X5ujPFRptn3OnDlo2rRplWXy8/NhYGBQq3pv376N77//HufPnxfH3pkyZQr8/f2RmJgIa2tr/Prrr/Dy8pJ6vq6uLnTL7VzIlXMxbH3w3nvvAQCePXsGZ2dn9OnTBxs3bqz28+UogOJi4P596S3GlBQgLa3irKyhIRPGN99kTiosLSWTqSlbi1hGTAwXT2Wj4Nl2ucRz69atcHNzw4QJE/DGG29I5OXm5uKHH37A+fPncfjw4VrVO3r0aMTExKBr167Q1NTE2LFj8fHHH6NNmzYYM2YMCgoK4OHhgdGjR8tjvkpiYGCA8ePHY9myZfjnn3+wZ8+eBhOJtE54fXlPGSYmrGVXE168kN5aLBPJ9HTW9S5PixZMBJ2cgOHDmR/J8uLYrBlzsltTTExYjHBpk0Z6eiyfU7e0aAF8/TXw119AWBiwcCHQurXM1ckVPVMkEmHTpk1Ys2YNjIyM0K5dO+jo6ODevXvIycnBrFmzMG3aNInutjJQmch9teDs2bPw9PTE06dPERISgtmzZzcqN38AmHB27Fi54CQkMAF99qzyVmNKChvbeh1z84qtRUtLJpLt2rFWSV3cj7w/BA0UlXgGnz5ls+tubiyG0fLlgJeXzJNGCgs9fP36dfz777/Q0NCAra2tOFyvKqASX5wMZGRkYPLkyUhKSsKVK1eg39i27sXEAD16VJ5vYwM8eVJxj7KWFtC27SsxfF0gLSxq7pCCoxBU4hkUidjQye3bQEgIsHUr25wgY6NEYXsEnZyc4OTkpKjqOABatmyJY8eOITMzE/r6+igqKkJ0dLTaxoeqNSYmr8Yby4ukuTmg5N4ORwWZPZv1Yi5dYsM0v/8O3Lkjc4wovsFaxdHQ0BCHOfnuu+8QGBiIefPmITg4GNrqHsP7yZOq83/8EejevX5s4TR8/viDeaPv1o25xjt2TC5/Ao1sEK1hM3PmTPFk0rvvvovk8k4T1I0jR+RzAsHhvI6mJmtxlk30FRTI3GUHuHg2KIyMjLBjxw6EhYUhLi4OXbt2xZEjR5RtlmJ58QLw9gY++IDPQHMUy4QJwNixbOLo++9ZHPfx42WurlbiuWXLFqmvOfWHQCDApEmTcPXqVdjY2MCwLmaFlUVsLJsg2rSJhYT97Tc2qy4NvryHU1tmz2Y/zGPHsnW9S5cyr1YyUuMxz507d+LYsWPQ19cHEYlfj5dDuTmy07FjR0RFRYmXL23btg3du3dXqVUONUYkAtasYXG5jY2B48cBDw+Wl5DQaJf3cBTMs2dsgsjIiHXfr15ladEimaqrsXiWlpZCKBSitLQURCR+zVEeZcKZn58PPz8/ZGdnY/Xq1fD29m44WzsfPgQmT2aeboYMYctHyi9cbteOiyRHMXz4IdCkCdtlpIjnozb+60JDQ6W+VnVUwpdgHXP//n1ydXUlADRy5EjKysqi06dPk52dHZ0+fVrZ5knn2DEiExMiHR2i778nEgqVbRGnjpDpGczNZaGYy6Jnnj5N5OBAZGND5O9PJBLVzgh7+9qVrwa5nSHHxsZSdHQ0ERGlp6fLbVBd0BjEk4iotLSUFi9eTBoaGtS2bVvq2rUrASBnZ2cS1fYfrS558eJVmF17exZLm6PW1PoZ/OcfIicnIm1tJp4vXhC1bUt09y6L2z5oEFENnaGLGTWKSIHOx+WabT9w4ADee+898ZKZnj17wtzcHKNGjVLvZTQqiqamJhYsWIA//vgDb7/9NmJjYwEA0dHROHXqlHKNK+PGDebRpizMbnQ02z/OaRw8f852hJWlynzYhoayuE5lntOiogBbW8Damu0g8/QEausMPSeHBX7r3Ztt0SxLMiLXIvlly5bh77//ho2NDQCgTZs22Lp1K37++WesWbMGa9askad6joz07t0bs2fPhqamJoRCIQQCAQICAjBo0CDljYWWhYudO5ftGz9yhDnc4DQqjF53DRkYCHzzTcWCW7dKvk9PfyWkAGBmxsbLa8OCBRWPyfE8yCWeGhoaYuFkdghgZ2eH4OBguLq6ylM1Rw5OnTqF6Oho8XsiwtWrVxEeHo5Ro0bVv0GPH7O45L//DgwcyHwqVuKLlaPe5MbHw6hNm1cHaupjQCSSFDqi2i9w//574HUPb/36ARcv1q6el8glnkKhEMXFxdDR0QHAomgCzMFvo/MApCIQERYuXAgNDQ2IRCKJPE9PT3Tt2hXW1tb1Z9BvvzHhzM5mYXZnz5ZrVwengdO0KVsqVFvatpVsaT56VPMf4JEj2Rri9HTmf7WM0lLmE0FG5Povdnd3x6Jya6TKHPoWFBQgj8dsUQrFxcVITU2tIJwAi+3k4uKCK1eu1L0hhYXAzJlsvWazZkBkJDBnDhdOjmy4uLA1momJgFAI/PorMHRozc4NCwPOnWO9nvPnX6XLl4ELF2Q2Sa6W58KFC+Hh4YHBgwfDy8sLHTt2RFZWFlasWCF33HaObOjq6iI6OhoZUnxYZmdnY/HixXXvEuzmTbbtLS4OmD4dWL0aqGU0AQ5HAj09NtwzZgzbk+7hAdTUGbqREUsKjlIrtz9PIsLPP/+MXbt24b///kOzZs3w0UcfwdfXV2W67irhS1DFEIlE2L9/P8aOHau4SSQiNovu6wvo6wNbtgAjRiimbk6DRqnP4PTpwE8/MfeF0v7XZYy1JrdLOoFAAC8vL4l4QkKhEEePHsUHH3wgb/WcOmLv3r0YP348jhw5gl9++QV6le0hrykZGcDUqezX3c0N2L4dKD8xwOEoi2nT2F9ps/ryoLAVo0R0584dmjt3LpmampKGhoYiq5aLxrJIvjaIRCJatGgRAaDevXvT48ePZa/s5Emi1q2JtLSIli/nO4U4FVDqM9it26vXixcrrFq5+9UvXrxAWFgY+vTpg969eyM/Px/Hjh1DO74fWaURCAQICgrCjh07cOXKFbi4uCA+Pr52lRQVAT4+wODBbBb18mW2jlNFhms4HACSwf3CwxVWrVzd9unTp2P//v3o1asXvvzyS3zwwQfikL8NxjFFI8fT0xNWVlYYMWIEbty4UfP49rdvAx99BFy/DnzyCfOKpE7u8TjqiWJCtgGQUzx3796NLl26wNvbG//73/+UHiWTIxt9+vTB3bt3YWxsDABISUmBpaWl9MJEzN+mjw9b4Lx/f81nPTkcZVC+IafARp1c/auHDx/ik08+wbJly2Bubg4fHx/ExcUpyjZOPVImnLdv34a9vT1mz54NoVAoWSgzk82ef/YZ0LMn26fOhZOj6ty6xRbHv/mm5Ov27SUXzdcSuVqehoaG4pn2W7du4ZdffsHAgQPRpk0bPH36VJ6qOUrCxsYGEyZMwJo1a3D37l3s2rULTZs2Bc6cAT7+mM2qL10KzJvHI1RyGgaJiXVTr8Kmnl5SUlJC+/fvp6FDhyq6apnhs+21QyQS0cqVK0kgEFAPBwfK+fRT5j7O2pooMlLZ5nEaIOr4DMq9SL4hwBfJy8bZDRvQ/Isv0I2IeXtfu5bNqnM4tUQdn0Eet51TESLg558xwNcXQkNDFKxdiyaTJ0MoFIJ31DkcBl+Qx5EkK4tNAk2bBnTvDs24ODSZPBnFxcUYOHAgli9fjkbQWeFwqkVlxXP16tXo3LkzHBwcMHXqVBQXF8PPzw9WVlbo2rUrunbtih9//FHZZqoX588Djo7MUfHixczjzMslS6WlpTA2Nsb8+fPh5eWF4uJi5drK4SgbJY+5SiUyMpK6dOlCeXl5JBKJyNPTk1avXk1ubm4UExNT6/rUcbBaoRQVEc2fTyQQELVvT/T331KLlZaW0tdff00AqH///pSVlVXPhnIaKur4DKpky7NZs2ZYv349DAwMIBAI4OTkhNTUVFy7dg2BgYFwdHTEzJkzUVRZ/BNOzfn3X+Cdd4Bly4AJE5jT2LffllpUU1MTK1aswE8//YRLly5hyJAhvAvPabSopHja2tqiX79+AIAnT55g/fr16N27N95++22sXLkSMTExyM7OxtKlS6WeX1RUhNzcXHF6/vx5fZrfMCACfvkF6NYNSEhgzmV37KiRl+9p06YhIiICS5cu5dtwOY0XZTd9qyIpKYns7e1pyZIlFfKuXbtG3cp7SylHYGAgAaiQ1KnLIBdZWURjxrC1m2+/TXTvnlzVbd68mcLCwhRkHEcd4d32eiQ2NhbvvPMOvL29ERAQgLt372L79u3ifKFQCC0t6Sut/Pz8kJOTI0619hakzvzxBwv1e/Agi1z4xx9sm5qMiEQi7Ny5E5MnT0ZAQIDU8B8c9eXMmTOwt7fHmTNnlG1K/aNs9ZbGkydPyNTUlA4ePCg+lpqaSiYmJpSSkkIikYgmTZpE3377bY3qU8dfvSpJSSG6elUyRUYSffEFmxSytCS6dElhlyssLCRPT08CQKNHj6YXL14orG6O6iISieitt94iAOTs7EwikajSsur4DKqkePr7+1OTJk3IyclJnPz9/Wn37t3UuXNnsrW1pSlTplBRUVGN6lPHL65SUlKI9PRYl1xaGjaMKDtb4ZcViUQUHBxMAKhnz56Um5ur8GtwVIecnBzy9vaWGBaLiIiotLxMz+C4cUS2tkROTiyFh8tttyLh2zPVjZgYoEePyvOvXKk6X0727NmDCxcuYOPGjXwySQ0pLS2FlpYWbty4AScnJ/FxTU1NdO/eHZGRkVK/d5meQVtbFnW1eXNFma9QVHbMk1NH1LGgjRs3DqGhoRAIBEhNTUVERESdXo9T95SWliI8PBxubm6YMWMGAOaOsjxCoRDR0dE4depU1ZU9fw7k5r5KlS03zMpiHrw++oht3AgKUqgjY0XAxVPdkBJyWFnMnTsXHh4eWLdunbJN4cjAkydPsHTpUrRv3x6jRo3CnTt3YGNjAyLCwoULK0TH1dDQwMKFC6tc+2tkbw8YG79KISHSCz56BAwYwMIN//MPcOkSsHWrIm9PfpQ7alA/NIoxz4wMIl9fIl3dysc7ATZ5VE88e/aMBg0aRABoxowZVFJSUm/X5sjPBx98QACob9++tHfvXiouLiYiNkFoamoqdTlg69atqbCwsEJd4mcwPp4oJ+dVklJWKocOEY0YocC7kx/uVamhk5MDrF4NfP896xINHMgcF6sAxsbGOHHiBGbOnIkff/wR//33H/bu3QujGizE59QvhYWF2Lt3L0JDQ3Hw4EGYm5sjODgYQUFBcHR0lCirq6uL6OhoZEjp5bRq1Uocx0wqTZvWaCMGrlwB0tOB4cPZe6EQqGRporJQLWs4NScvD1i3DlixAsjOBv73PyA4GGjRAujYESgsrHiOnh5gYlKvZmppaWH9+vXo2LEjVq5cidzcXC6eKkRKSgpCQ0OxefNmPH36FNbW1khJSYG5uTkcHBwqPc/CwgIWFhZ1Z5hQCMycCfTrB+jrA6GhwNSpdXc9GeDi2dAoLGT/SCEhwJMnrKW5eDHQq9erMgkJLN7Q65iYAEoICS0QCPDVV1/hk08+gYGBAYgI//77Lzp06FDvtnBekZCQAHt7exARhg4dii+++AKDBw+uMJapFFxcmHj26gWUlgKjRrHJI1VC2eMG9YFajHkWFRFt3EjUpg0bu+zdm+j8eWVbJROrV68mXV1d2rNnj7JNaVTk5OTQunXraNWqVUTE1uauWLGC/v333zq/tlo8g6/BxVPVKSkhCgtjruIAoh49iH7/naiK3RyqTnp6Ojk7OxMAWrx4cZU7UzjyEx8fTzNmzCBDQ0MCQK6urvX+mTfoZ7ASVKB9zpGKSATs3Qt06cLiB+nrA+HhQHQ0MGRIna/XrEvMzMxw4cIFjB49GgsXLsSkSZO4e8E6Yt68ebC3t8emTZvg4eGBS5cu4dy5c3wDgwLg4qlqEAFHjzJXcePGMRHdtQu4fp3FTFeTf3p9fX3s3bsXfn5+2LFjB06ePKlsk9SCjIwMhISEICsrCwDg5uaGwMBApKSkYM+ePejTpw8XTkWh7KZvfdAgugwiEdHJk0TOzqx73q4d0c8/s267mnPlyhXx65r6K+BIEhUVRR9//DHp6OgQANq+fbuyTZKgQTyDtYS3PFWBS5fYkozBg4H794EffwQSE9nSDBVb21YX9Hi51/7mzZvo0KEDzp07p2SLGg5PnjyBi4sLevbsiX379mHixImIiYnBxIkTlW2a2sPFU5lERTHBfPdd4PZtYOVK4O5d4PPPgaoWGqspurq60NHRweDBg7FlyxZlm6OypKamiv1ntmzZEi1atMCKFSvw4MEDbNmyBd26dVOyhY0EZTd96wOV6zJcv040fDjrnhsbEy1ZQsRduBER0dOnT6lfv34EgHx9fUkoFCrbJJVAJBLR2bNnacSIEaShoUGtW7duUNtdVe4ZVAC85Vmf3LnDJoGcnICzZ4GAACApif1t2lTZ1qkEzZs3x6lTpzB58mSsWLFCHKeqMXssP3ToEDp37owBAwbg7Nmz+Oqrr3Dx4sVKIylw6gf+6dcHSUls6+T27YCODjBnDjBvHtCypbItU0l0dHTwyy+/wMXFBR9++CGICP7+/rh9+zb8/f0xYMAAtZ8xvnPnDtq2bQtDQ0Pk5eVBU1MToaGhmDBhAgwNDZVtHgfg3fY6vjCRtzeRlhaRtjbR558T3b9fvzaoASdOnJDw3BMYGEjnz5+nlJQUcZkyjz8NmdLSUjp8+DANHDiQANDGjRvFxxv6RgJ17LZz8awLHj8mmj2buYfT0CCaMoUoKal+rq1miEQicnBwkOr+bN68eUTEXKQBoCZNmlDr1q2pY8eO5OzsTCEhIeJ6FixYQIGBgbR69WrasmUL7d+/n6Kjo8X5GRkZlJ+fXy8idfr0abKzs6PTp08TEVFBQQEtW7aMLC0tCQC1atWKFixYoFZCo47iybvtiiQri82Yr10LvHjBxjcDA5mXI45MnDp1CnFxcRWOL168GCNHjgTAIngGBASIo6Xm5uYiJydHovwPP/yA58+fSxwbNmwYjh49CgBwcXHBvXv3oKWlBSMjIxgbG8PFxQW7d+8GACxduhTp6ekwNjaGsbExjIyM0Lp1a4wYMQIAkJaWBpFIBGNjYzRt2hSamppS74fKDUHMnTsXV69ehba2NjZu3Ahzc3MsXboUo0ePrtqtG0cl4DGMFEFuLvDDD0w4c3OBDz5gY5xVuPTiVA8RwcXFBVevXpUIaayhoYEePXpUGi+nMgoLCyVCUuvr66Nz584AgM2bN+Phw4di4c3JyYGVlRW+++47AMDgwYPx999/Iy8vT1yftbU17t69C4AJ8fHjx8V5hoaGMDU1Fef/+OOP+OOPP5CbmysRmuTEiRNwd3fH06dP0aJFCxk+pYaBOsYR4y1PeXjxgi1oX74cePqU7TkPDgacnZVtmVpQXFyM1NTUCrHgRSIR0tLSUFxcXKsWmp6eHvT09GBqalohb9q0aVWeW7Z9VCgUIjc3F7m5uSguLhbnz5w5E+7u7hKt3/J2379/H5GRkbh//774mEAgwKJFizB06FC1Fk51hbc8ZaGoCNi8GVi6lMVaefddYMkSoG9f+evmSJCWllapx/KG1oI5efIkhgwZUuF4REQEBg8erASL6g/e8mzslJSwgFTBwUBaGtCzJ7BjBwtUpeZLZ5RFnXssryeoXNC014cgFi5ciEGDBqn98it1gy+SrwlCIbBzJ2BvD0ybxuJIHz3KovoNHMiFk1MtNRmC4DQseMsTAFJTpYetaN4cuHoVWLQIiI8HOnUC9u1jIQFUIVQBp8EgV9A0jkrCxTM1tfKAaQIB86/Zvj3rrk+YAFSyBIXDqQ51GYKoN3btYnMJJSUsntEXXyjbIgm4eGZmShdOgAlnQABbq6mtXb92cTiNmQcPAD8/ICaGRX3t3Zu5bVSh5X+871kdI0dy4eRwFMXz52wtdFmqLPzKmTNsIrZFC8DAABg9GjhwoH5trQYunhwOp94wsrcHjI1fpZAQ6QXT0wFz81fvzcyAhw/rx8gaorLiuXr1anTu3BkODg6YOnUqiouLcebMGTg6OsLW1hYBAQFoBEtUORy1Ijc+HsjJeZX8/KQXFIkkV7EQqdwkrWpZ85KoqChs3boVUVFRuHHjBkpKSrBq1SpMmTIFhw4dwu3bt3HlyhWJ7XAcDqcB0LQpYGT0KlW2yqBtW8mW5qNHki1RFUAlxbNZs2ZYv349DAwMIBAI4OTkhFOnTsHW1hbW1tbQ0tKCp6cnDihiDMTEhA1IS0NPj+VzOJz6ZeBANu755AmQnw/s38+2P6sQKjnbbmtrC1tbWwAswNX69esREhKCEydOiMuYmZnhYSVjIEVFRRJxwMs87Egtr6EBwYULELwM1Voeat4cpKHBgrJxOByZKXv2Xt8kUClt2gDffgv078+WKnl5sR19KoRKimcZycnJ8PDwwLRp0yASiSS2rxERNCoZAwkJCUFQUFCF4z1V7MPncBobjx8/Rrt27WpWePx4llQUlRXP2NhYeHh4YP78+fjyyy9x8eJFiZbjo0ePYF7JGIifnx98fHzE70tLS3H79m1YWFhUKrgA8Pz5c9jb2yM+Ph5N1SCmkDrdD78X1aSm9yISifD48WP1iuypNDfMVfDkyRMyNTWlgwcPio8VFBRQmzZtKCEhgUpLS2nQoEG0b98+hV43JyeHAFBOTo5C61UW6nQ//F5UE3W6l9qiki3PNWvWIDc3F8HBwQgODgYAeHh4YNu2bRgzZgwKCgrg4eGB0aNHK9lSDofTWGkU/jxrSm5uLoyNjZGTkwMjIyNlmyM36nQ//F5UE3W6l9qikkuVlIWuri4CAwPVxsONOt0PvxfVRJ3upbbwlieHw+HIAG95cjgcjgxw8eRwOBwZ4OLJ4XA4MsDFk8PhcGSAiyeHw+HIABdPDodTJ4SFhcHQ0BCdOnVCq1atEBoaim+++Qbe3t7KNk0hcPHkcDh1Rp8+fXDnzh34+/tj48aNAIB//vkHjo6O6NmzJwoKCpRsoexw8eRwOHXGn3/+iU6dOmHTpk1YsGABAMDS0hKxsbFITk7GrVu3lGyh7Kjk3nYOh6Me9OnTBxEREeL3t27dgpmZGTQ0NKCvr4/S0lIlWicfvOXJ4XA4sqBcp04cDkfZJCUlEQD6/vvvxce2bt1KAOjatWtERJSdnU1eXl5kYmJCTZs2pf79+9OVK1ck6klMTCQdHR2JetSZRtvyTE5OhkAgwJo1a8THwsLCIBAIEBsbCwDYvXs32rVrB1NTU3z33XfKMbQWVHdPFy5cgEAgwOHDh5VmY2XUxvbyr3NycqCpqYlp06Ypz/hKkPWeVA0iwtChQxEeHo6goCD89NNPSEtLg5ubGx49egQAOHv2LAYMGIDi4mIlW1t/8DHPSrh//z4mTZqEiRMnwtTUFPPmzUO/fv3g4uKibNM45YiLi4NIJEK/fv2UbUqDp7S0FIWFhQCAkpIS8fGzZ8/in3/+webNm+Hl5QUA6NChA/766y9oaGggJycHgwYNgqenJ7Zv364U25VBoxfPqv5hSkpKMHfuXFhaWmLZsmWIiIhoEOJZ2T01BGpru5aWFjp06IARI0bUtWky01C+D19fX/j6+lY4fu3aNQCQ+N/v3r07unfvDgAoLi5GfHw8dHV1G5V4Ntpuexm+vr5o0qQJmjRpgunTp4uPP3jwAADQokUL6OnpQV9fH+np6coys1ZUdk8Ngdra3qtXLyQkJMDAwKAerJONhvJ9zJo1C5cvX8bly5fFy4qA6iNe6ujooGPHjnVtnsrR6MWzsn8YeunmtCxiJzUgt6eV3VNDoCHbXhkN5Z4sLS3Rq1cv9OrVC9bW1uLjjo6OAIArV66Ijx06dAiurq6Ij4+vdztVhUbfbS/7hwGAO3fuiI+bmZkBAJ4+fQoDAwMUFBRUGq1T1ajsnhoCDdn2ymjo9zRo0CD06NED8+bNQ0lJCfT19TF//nyIRKKahxFWQxq9eFZG//79oampiRUrVqBVq1biGUcOp7GhqamJiIgI+Pj4YN68eRAKhejVqxfWrFkDQ0NDZZunNLh4VkL79u0RFhaGgIAAFBQUYPny5ejZs6eyzeJwFI6VlVWFYanJkydj8uTJ4vcmJibVTgZJq0ed4TGMOBwORwYa/YQRh8PhyAIXTw6Hw5EBLp4cDocjA1w8ORwORwa4eHI4HI4McPHkcDgcGeDiyeFwODLAxZPD4XBkgIsnh8PhyAAXTw6Hw5GB/wNCvv0A6xS9zAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 318x220 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.font_manager import FontProperties\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# Font settings\n",
    "fontSize = 8\n",
    "axisTitleFontSize = fontSize\n",
    "plt.rcParams['font.size'] = fontSize\n",
    "plt.rcParams['font.family'] = 'Arial'\n",
    "plt.rcParams['mathtext.fontset'] = 'custom'\n",
    "plt.rcParams['mathtext.it'] = 'Arial:italic'\n",
    "plt.rcParams['mathtext.bf'] = 'Arial:bold'\n",
    "\n",
    "# Size of markers and caps in plots\n",
    "mSize = 4\n",
    "cSize = mSize * 0.75\n",
    "\n",
    "# General line width for series\n",
    "seriesLineWidth = 1.1\n",
    "# and error bars\n",
    "ebLineWidth = seriesLineWidth*0.85\n",
    "# and grid\n",
    "gridLineWidth = seriesLineWidth*0.33\n",
    "\n",
    "catalyst = [\"$\\mathbf{H0}$\", \"$\\mathbf{HI}$\",  \"$\\mathbf{HII\\prime}$\", \"$\\mathbf{HII}$\", \"$\\mathbf{HC1^{Ph}}$\"]\n",
    "fig = plt.figure(figsize=(3.18, 2.2))\n",
    "ax = fig.add_subplot(axes_class=axisartist.Axes)\n",
    "\n",
    "# Plotting on the primary y-axis\n",
    "ax.plot(catalyst, BarriersBHE_from_precursor, linestyle='dashed', linewidth=seriesLineWidth, marker='o',  markersize=mSize, color='black', label='$\\\\beta$-HE')\n",
    "ax.plot(catalyst, BarriersMetathesis_from_precursor, linestyle='dashed', linewidth=seriesLineWidth, marker='^',  markersize=mSize, markerfacecolor='black', color='black', label='Metathesis')\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel(\"$\\Delta G^{\\u2021}$ (kcal/mol)\", fontsize=axisTitleFontSize)\n",
    "\n",
    "# Adjusting tick marks\n",
    "ax.axis[\"top\",\"right\"].toggle(all=False)\n",
    "ax.axis[:].major_ticks.set_tick_out(True)\n",
    "\n",
    "# set -y-axis limits for the first axis\n",
    "ax.set_ylim(20, 42)\n",
    "\n",
    "# Creating a secondary y-axis\n",
    "ax = ax.twinx()\n",
    "ax.plot(catalyst[0:], HQF_fitnesses[0:], color='red', label='HQF_fitnesses', linewidth=seriesLineWidth, marker='s', markersize=mSize, markerfacecolor='red')\n",
    "ax.set_ylabel('Fitness ($\\mathit{HQF}$)', color='red')\n",
    "\n",
    "handels = [\n",
    "    Line2D([0], [0], linestyle='dashed', marker='o', markersize=mSize, markerfacecolor='black', color='black'),\n",
    "    Line2D([0], [0], linestyle='dashed', marker='^', markersize=mSize, markerfacecolor='black', color='black'),\n",
    "    Line2D([0], [0], linestyle='solid', marker='s', markersize=mSize, markerfacecolor='red', color='red')\n",
    "]\n",
    "\n",
    "labels = [\n",
    "    '$\\\\beta$-HE',\n",
    "    'Metathesis',\n",
    "    'Fitness'\n",
    "]\n",
    "\n",
    "# Adjust legend\n",
    "box = ax.get_position()\n",
    "ax.set_position([box.x0, box.y0 + box.height * 0.1, box.width, box.height])\n",
    "leg = ax.legend(handels, labels, handlelength=4, markerfirst=False, loc='upper center', ncol=1)\n",
    "leg.get_frame().set_linewidth(0.0)\n",
    "\n",
    "# Set y-axis limits for the secondary axis\n",
    "ax.set_ylim(-1, 30)\n",
    "\n",
    "# Set the color of the y-axis ticks for the secondary axis\n",
    "ax.tick_params(axis='y', colors='red')\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"figures/Fitness_vs_barriers.svg\", format=\"svg\", bbox_inches=\"tight\")\n",
    "print('Comparison of high-quality fitness (HQF) scores and barriers\\nto propene self-metathesis and decomposition via b-HE as calculated\\nrelative to Ru-P for the test-set catalysts.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 318x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overall fitness (HQF) and its individual components (weights and descriptors):\n",
      "D1, reward for high catalyst productivity; D2, resolution of low catalyst productivity;\n",
      "D3, reward for high catalyst activity; w1, threshold against low catalyst activity;\n",
      "w2, initiation-based catalyst elimination; w3, synthetic accessibility-based catalyst elimination;\n",
      "w4, stereochemistry-based catalyst elimination.\n"
     ]
    }
   ],
   "source": [
    "# Create a figure with two subplots in a 2:1 ratio\n",
    "fig = plt.figure(figsize=(3.18, 3))\n",
    "gs = fig.add_gridspec(2, 1, height_ratios=[2, 1])\n",
    "\n",
    "# Specify axis type for the first subplot\n",
    "ax1 = host_subplot(gs[0], axes_class=axisartist.Axes)\n",
    "fig.add_axes(ax1)\n",
    "\n",
    "# Specify axis type for the second subplot\n",
    "ax2 = host_subplot(gs[1], axes_class=axisartist.Axes)\n",
    "fig.add_axes(ax2)\n",
    "\n",
    "catLabel = catalyst\n",
    "\n",
    "# Plotting on the primary y-axis\n",
    "ax1.plot(catLabel, HQFd1s, linestyle='dashed', linewidth=seriesLineWidth, marker='s', markersize=mSize, markerfacecolor='green', color='green', label=\"$\\mathit{D_{1}}$\")\n",
    "ax1.plot(catLabel, HQFd2s, linestyle='dashed', linewidth=seriesLineWidth, marker='d', markersize=mSize, markerfacecolor='blue', color='Blue', label=\"$\\mathit{D_{2}}$\")\n",
    "ax1.plot(catLabel, HQFd3s, linestyle='dashed', linewidth=seriesLineWidth, marker='^', markersize=mSize, markerfacecolor='orange', color='orange', label=\"$\\mathit{D_{3}}$\")\n",
    "ax1.plot(catLabel, HQF_fitnesses, linestyle='solid', linewidth=seriesLineWidth, marker='s', markersize=mSize, markerfacecolor='red', color='red', label=\"HQF\")\n",
    "\n",
    "# Set labels\n",
    "ax1.set_xlabel('')\n",
    "ax1.set_ylabel(\"Descriptor Value\", fontsize=axisTitleFontSize)\n",
    "\n",
    "# Create a custom legend with the desired order\n",
    "handles = [\n",
    "    Line2D([0], [0], linestyle='dashed', marker='D', markerfacecolor='green', color='green'),\n",
    "    Line2D([0], [0], linestyle='dashed', marker='v', markerfacecolor='blue', color='Blue'),\n",
    "    Line2D([0], [0], linestyle='dashed', marker='o', markerfacecolor='orange', color='orange'),\n",
    "    Line2D([0], [0], linestyle='solid', marker='s', markerfacecolor='red', color='red')\n",
    "]\n",
    "\n",
    "labels = [\n",
    "    \"$\\mathit{D_{1}}$\",\n",
    "    \"$\\mathit{D_{2}}$\",\n",
    "    \"$\\mathit{D_{3}}$\",\n",
    "    \"HQF\"\n",
    "]\n",
    "\n",
    "# Set custom legend\n",
    "leg = ax1.legend(markerfirst=False, loc='best', ncol=1, frameon=True, framealpha=0.9)\n",
    "leg.get_frame().set_linewidth(gridLineWidth)\n",
    "plt.grid(color='gray',linestyle='--',linewidth=gridLineWidth)\n",
    "\n",
    "# Adjust grid and tick marks/labels\n",
    "ax1.grid(color='gray',linestyle='--',linewidth=gridLineWidth)\n",
    "ax2.grid(color='gray',linestyle='--',linewidth=gridLineWidth)\n",
    "\n",
    "# Hides x-axis tick marks and labels\n",
    "ax1.axis[\"top\",\"bottom\",\"right\"].toggle(all=False)\n",
    "ax2.axis[\"top\",\"right\"].toggle(all=False)\n",
    "ax1.axis[:].major_ticks.set_tick_out(True)\n",
    "ax2.axis[:].major_ticks.set_tick_out(True)\n",
    "\n",
    "# set -y-axis limits for the first axis\n",
    "ax1.set_ylim(-1, 28)\n",
    "\n",
    "color1 = 'cyan'; color2 = 'brown'; color3 = 'magenta'; color4 = 'black'\n",
    "\n",
    "# Plotting on the primary y-axis\n",
    "ax2.plot(catLabel, HQFw1s, linestyle=':', linewidth=seriesLineWidth, marker='D', markerfacecolor=color1, markersize=mSize*0.80, color=color1, label=\"$\\mathit{w_{1}}$\")\n",
    "ax2.plot(catLabel, HQFw2s, linestyle=':', linewidth=seriesLineWidth, marker='v', markerfacecolor=color2, markersize=mSize, color=color2, label=\"$\\mathit{w_{2}}$\")\n",
    "ax2.plot(catLabel, HQFw3s, linestyle=':', linewidth=seriesLineWidth, marker='o', markerfacecolor=color3, markersize=mSize, color=color3, label=\"$\\mathit{w_{3}}$\")\n",
    "ax2.plot(catLabel, HQFw4s, linestyle=':', linewidth=seriesLineWidth, marker='x', markerfacecolor=color4, markersize=mSize, color=color4, label=\"$\\mathit{w_{4}}$\")\n",
    "\n",
    "ax2.set_xlabel('')\n",
    "ax2.set_ylabel(\"Weight Value\", fontsize=axisTitleFontSize)\n",
    "\n",
    "# Adjust legend\n",
    "box = ax2.get_position()\n",
    "leg = ax2.legend(markerfirst=False, loc='lower right', ncol=2, frameon=True, framealpha=0.9)\n",
    "leg.get_frame().set_linewidth(0.5)\n",
    "ax1.grid(color='gray',linestyle='--', linewidth=gridLineWidth)\n",
    "ax2.grid(color='gray',linestyle='--', linewidth=gridLineWidth)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"figures/Descriptors_and_weights_HQF.svg\", format=\"svg\", bbox_inches=\"tight\")\n",
    "show()\n",
    "print('Overall fitness (HQF) and its individual components (weights and descriptors):\\nD1, reward for high catalyst productivity; D2, resolution of low catalyst productivity;\\nD3, reward for high catalyst activity; w1, threshold against low catalyst activity;\\nw2, initiation-based catalyst elimination; w3, synthetic accessibility-based catalyst elimination;\\nw4, stereochemistry-based catalyst elimination.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we plot the HQF derived barriers against the AF derived barriers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 318x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comparison of barriers to metathesis and β-HE derived\n",
      "from HQF and AF modelling, using Ru-MCB as the reference point.\n",
      "Standard deviations on AF values are calculated using six different\n",
      "input structures\n"
     ]
    }
   ],
   "source": [
    "fig, ax = subplots(figsize=(3.18, 3))\n",
    "#fig = plt.figure(figsize=(5, 3))\n",
    "#ax = fig.add_subplot(axes_class=axisartist.Axes)\n",
    "\n",
    "# Define data\n",
    "HQmet = BarriersMetathesis_from_MCB\n",
    "HQBH = BarriersBHE_from_MCB\n",
    "AFmet = AF_BarriersMetathesis_from_MCB\n",
    "AFBH = AF_BarriersBHE_from_MCB\n",
    "\n",
    "#define data (Sorted from lowest to highest x-value)\n",
    "#DE Metathesis\n",
    "x1 = np.array([AFmet[0], AFmet[2], AFmet[1], AFmet[3], AFmet[4]])\n",
    "y1 = np.array([HQmet[0], HQmet[2], HQmet[1], HQmet[3], HQmet[4]])\n",
    "\n",
    "#DE B-HE Decomposition\n",
    "x2 = np.array([AFBH[0], AFBH[1], AFBH[2], AFBH[3], AFBH[4]])\n",
    "y2 = np.array([HQBH[0], HQBH[1], HQBH[2], HQBH[3], HQBH[4]])\n",
    "\n",
    "#calculate equation for trendline: Metathesis\n",
    "z1 = np.polyfit(x1, y1, 1)\n",
    "p1 = np.poly1d(z1)\n",
    "\n",
    "#add trendline to plot\n",
    "plt.plot(x1, p1(x1), color=\"black\", linewidth=seriesLineWidth, linestyle=\"dotted\")\n",
    "\n",
    "#calculate equation for trendline: B-HE\n",
    "z2 = np.polyfit(x2, y2, 1)\n",
    "p2 = np.poly1d(z2)\n",
    "\n",
    "#add trendline to plot\n",
    "plt.plot(x2, p2(x2), color=\"black\",linewidth=seriesLineWidth, linestyle=\"dotted\")\n",
    "\n",
    "AF_metathesis_barriers=[AF_H0_met_bar, AF_HI_met_bar, AF_HIIprime_met_bar, AF_HII_met_bar, AF_HC1Ph_met_bar]\n",
    "AF_decomp_barriers=[AF_H0_BH_bar, AF_HI_BH_bar, AF_HIIprime_BH_bar, AF_HII_BH_bar, AF_HC1Ph_BH_bar]\n",
    "x_err_metathesis=[];x_err_decomp=[]\n",
    "\n",
    "for barrier in AF_metathesis_barriers:\n",
    "    x_err_metathesis.append(statistics.stdev(barrier))\n",
    "for barrier in AF_decomp_barriers:\n",
    "    x_err_decomp.append(statistics.stdev(barrier))\n",
    "\n",
    "# Define candidate names\n",
    "candidate_names = [\"$\\mathbf{H0}$\", \"$\\mathbf{HI}$\", \"$\\mathbf{HII\\prime}$\", \"$\\mathbf{HII}$\", \"$\\mathbf{HC1^{Ph}}$\"]\n",
    "\n",
    "# Define variables for plot style\n",
    "EBfmt='.k';csize=cSize;cthick=seriesLineWidth; mwidth=seriesLineWidth;lwidth=seriesLineWidth;msize1=mSize*1.5; msize2=mSize*1.5;color1=\"#055AFA\";color2=\"#FAA505\"\n",
    "\n",
    "# Define markers/error bars for metathesis barriers and put in list\n",
    "m0='';m1='';m2='';m3='';m4='';\n",
    "me0='';me1='';me2='';me3='';me4='';\n",
    "metathesis_markers=[m0, m1, m2, m3, m4]\n",
    "metathesis_errors=[me0, me1, me2, me3, me4]\n",
    "\n",
    "# Draw the markers/error bars in the plot.\n",
    "i = 0\n",
    "for error in metathesis_errors:\n",
    "    error = plt.errorbar(AFmet[i], HQmet[i], xerr=x_err_metathesis[i], linestyle='none', fmt=EBfmt, markersize=msize1/2, capsize=csize, capthick=ebLineWidth, elinewidth=ebLineWidth, markeredgewidth=mwidth, zorder=2, label=\"Standard deviation\" if i == 0 else None)\n",
    "    metathesis_markers[i] = plt.plot(AFmet[i], HQmet[i], color=color1, linestyle='none', marker='^', markersize=msize1, zorder=1, label=\"Metathesis\" if i == 0 else None)\n",
    "    i = i + 1 \n",
    "\n",
    "# Define markers/error bars for B-H elim. barriers and put in list\n",
    "bh0='';bh1='';bh2='';bh3='';bh4='';\n",
    "bhe0='';bhe1='';bhe2='';bhe3='';bhe4='';\n",
    "decomp_markers=[bh0, bh1, bh2, bh3, bh4]\n",
    "decomp_errors=[bhe0, bhe1, bhe2, bhe3, bhe4]\n",
    "\n",
    "# Draw the markers/error bars in the plot.\n",
    "i = 0\n",
    "for error in decomp_errors:\n",
    "    error = plt.errorbar(AFBH[i], HQBH[i], xerr=x_err_decomp[i], linestyle='none', fmt=EBfmt, capsize=csize, capthick=ebLineWidth, elinewidth=ebLineWidth, markeredgewidth=mwidth, zorder=2)\n",
    "    decomp_markers[i] = plt.plot(AFBH[i], HQBH[i], color=color2, linestyle='none', marker='d', markersize=msize1, zorder=1, label=chr(946) + '-HE' if i == 0 else None)\n",
    "    i = i + 1 \n",
    " \n",
    "# Add labels next to B-HE markers\n",
    "for i, (xi, yi) in enumerate(zip(x2, y2)):\n",
    "    xoffset=-17\n",
    "    yoffset=5\n",
    "    if i==4:\n",
    "         yoffset=5\n",
    "         xoffset=-19\n",
    "    elif i==1:\n",
    "         xoffset=5\n",
    "    label = f'{candidate_names[i]}'  # You can customize the label as needed\n",
    "    plt.annotate(label, (xi, yi), textcoords=\"offset points\", xytext=(xoffset,yoffset), ha='left')\n",
    "\n",
    "# Add labels next to metathesis markers (offset to make clear distinctions)\n",
    "for i, (xi, yi) in enumerate(zip(x1, y1)):\n",
    "    if i==0:\n",
    "         yoffset=-2\n",
    "         xoffset=3\n",
    "    elif i==1:\n",
    "         yoffset=-15\n",
    "         xoffset=8\n",
    "    elif i==2:\n",
    "         yoffset=0\n",
    "         xoffset=-22\n",
    "    elif i==3:\n",
    "         yoffset=3\n",
    "         xoffset=3\n",
    "    elif i==4:\n",
    "         yoffset=0\n",
    "         xoffset=4\n",
    "    label = f'{candidate_names[i]}' \n",
    "    plt.annotate(label, (xi, yi), textcoords=\"offset points\", xytext=(xoffset,yoffset), ha='left')\n",
    "\n",
    "x_tick_values = [10, 12.5, 15, 17.5, 20, 22.5, 25, 27.5, 30, 32.5]\n",
    "y_tick_values = x_tick_values\n",
    "\n",
    "# Filter out the tick values that are not integers for both x and y axes\n",
    "integer_x_tick_values = [value for value in x_tick_values if value == int(value)]\n",
    "integer_y_tick_values = [value for value in y_tick_values if value == int(value)]\n",
    "\n",
    "# Set tick labels for integer tick values for both x and y axes\n",
    "plt.xticks(integer_x_tick_values)\n",
    "plt.yticks(integer_y_tick_values)\n",
    "\n",
    "# Set empty string labels for non-integer tick values for both x and y axes\n",
    "xlabels = [\"\" if value not in integer_x_tick_values else str(value) for value in x_tick_values]\n",
    "ylabels = [\"\" if value not in integer_y_tick_values else str(value) for value in y_tick_values]\n",
    "plt.xticks(x_tick_values, xlabels)\n",
    "plt.yticks(y_tick_values, ylabels)\n",
    "\n",
    "# Enable the grid for every tick\n",
    "plt.grid(True, linestyle='--')\n",
    "\n",
    "# Hide major ticks pointing towards empty labels for both x and y axes\n",
    "for tick, xlabel, ylabel in zip(plt.gca().xaxis.get_major_ticks(), xlabels, ylabels):\n",
    "    if xlabel == \"\":\n",
    "        tick.tick1line.set_visible(False)\n",
    "        tick.tick2line.set_visible(False)\n",
    "\n",
    "for tick, ylabel in zip(plt.gca().yaxis.get_major_ticks(), ylabels):\n",
    "    if ylabel == \"\":\n",
    "        tick.tick1line.set_visible(False)\n",
    "        tick.tick2line.set_visible(False)\n",
    "\n",
    "# Add labels and legend\n",
    "plt.xlabel('$\\mathsf{\\Delta E^{\\u2021}}$ ($\\mathit{AF}$) [kcal/mol]', fontsize=axisTitleFontSize)\n",
    "plt.ylabel('$\\mathsf{\\Delta G^{\\u2021}}$ ($\\mathit{HQF}$) [kcal/mol]', fontsize=axisTitleFontSize)\n",
    "plt.title('')\n",
    "\n",
    "# Add legend to the plot\n",
    "plt.legend()\n",
    "\n",
    "# Calculate R^2 value for metathesis\n",
    "y_pred = p1(x1)\n",
    "residuals = y1 - y_pred\n",
    "ss_residual = np.sum(residuals**2)\n",
    "ss_total = np.sum((y1 - np.mean(y1))**2)\n",
    "r_squared = 1 - (ss_residual / ss_total)\n",
    "\n",
    "# Display R^2 value on the plot\n",
    "plt.annotate(f'$\\mathsf{{R^{2}}}$ = {r_squared:.2f}', xy=(0.35, 0.1), xycoords='axes fraction', fontsize=fontSize)\n",
    "\n",
    "# Calculate  second R^2 value for B-HE\n",
    "y_pred = p2(x2)\n",
    "residuals = y2 - y_pred\n",
    "ss_residual = np.sum(residuals**2)\n",
    "ss_total = np.sum((y2 - np.mean(y2))**2)\n",
    "r_squared = 1 - (ss_residual / ss_total)\n",
    "\n",
    "# Display R^2 value on the plot\n",
    "plt.annotate(f'$\\mathsf{{R^{2}}}$ = {r_squared:.2f}', xy=(0.75, 0.6), xycoords='axes fraction', fontsize=fontSize)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"figures/Barriers_HQF_vs_AF.svg\", format=\"svg\", bbox_inches=\"tight\")\n",
    "show()\n",
    "print('Comparison of barriers to metathesis and β-HE derived\\nfrom HQF and AF modelling, using Ru-MCB as the reference point.\\nStandard deviations on AF values are calculated using six different\\ninput structures')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also compare the results of the expert driven and the automated procedure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 318x230 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comparison of fitness scores obtained with HQF and AF methods.\n",
      "Standard deviations on AF values are calculated over data from\n",
      "six different input structures. \n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "categories = ['$\\mathbf{H0}$', '$\\mathbf{HI}$', '$\\mathbf{HII\\prime}$', '$\\mathbf{HII}$', '$\\mathbf{HC1^{Ph}}$']\n",
    "\n",
    "fig = plt.figure(figsize=(3.18, 2.3))\n",
    "ax = fig.add_subplot(axes_class=axisartist.Axes)\n",
    "\n",
    "# Bar width\n",
    "bar_width = 0.35\n",
    "\n",
    "\n",
    "# Old colors\n",
    "#37C873 - red\n",
    "#C8378C - green\n",
    "\n",
    "# Plot the bars for both groups\n",
    "bar1 = ax.bar(np.arange(len(categories)), HQF_fitnesses, bar_width, edgecolor='#227c48', hatch=None, color='#37C873', label='$\\mathit{HQF}$')\n",
    "bar2 = ax.bar(np.arange(len(categories)) + bar_width, fitnesses, bar_width, edgecolor='royalblue', hatch='..', color='white', label='$\\mathit{AF}$')\n",
    "\n",
    "# Customize the error bars\n",
    "ax.errorbar(np.arange(len(categories)) + bar_width, fitnesses, yerr=fitnessStds, fmt='.k', ecolor='black', elinewidth=ebLineWidth, capsize=cSize, capthick=ebLineWidth, label='Standard deviation')\n",
    "\n",
    "ax.set_ylim(0, 30)\n",
    "ax.set_yticks([0,5,10,15,20,25,30])\n",
    "\n",
    "# Adjusting tick marks\n",
    "ax.axis[\"top\",\"right\"].toggle(all=False)\n",
    "ax.axis[:].major_ticks.set_tick_out(True)\n",
    "\n",
    "# Customize the plot\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('Fitness (F)', fontsize=axisTitleFontSize)\n",
    "ax.set_title('')\n",
    "ax.set_xticks(np.arange(len(categories)) + bar_width / 2)\n",
    "ax.set_xticklabels(categories)\n",
    "ax.legend()\n",
    "plt.grid(axis = \"y\", linestyle='--', color='gray', linewidth=gridLineWidth)\n",
    "\n",
    "# Show the plot\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"figures/Fitness_HQF_AF_barplot.svg\", format=\"svg\", bbox_inches=\"tight\")\n",
    "plt.show()\n",
    "print('Comparison of fitness scores obtained with HQF and AF methods.\\nStandard deviations on AF values are calculated over data from\\nsix different input structures. ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we look at the individual descriptors and weights of AF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 318x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overall fitness (AF) and the individual components: D1, reward for high catalyst productivity;\n",
      "D2,resolution of low catalyst productivity; D3, reward for high catalyst activity;\n",
      "w1, threshold against low catalyst activity; w2, initiation-based catalyst elimination;\n",
      "w3, synthetic accessibility-based catalyst elimination; w4, stereochemistry-based catalyst elimination.\n"
     ]
    }
   ],
   "source": [
    "# Create a figure with two subplots in a 2:1 ratio\n",
    "fig = plt.figure(figsize=(3.18, 3))\n",
    "gs = fig.add_gridspec(2, 1, height_ratios=[2, 1])\n",
    "\n",
    "# Specify axis type for the first subplot\n",
    "ax1 = host_subplot(gs[0], axes_class=axisartist.Axes)\n",
    "fig.add_axes(ax1)\n",
    "\n",
    "# Specify axis type for the second subplot\n",
    "ax2 = host_subplot(gs[1], axes_class=axisartist.Axes)\n",
    "fig.add_axes(ax2)\n",
    "\n",
    "# Plotting on the primary y-axis\n",
    "ax1.errorbar(catLabel, d1s, yerr=d1Stds, capsize=cSize, linestyle='dashed', linewidth=seriesLineWidth, marker='s', markersize=mSize, markerfacecolor='green', elinewidth=ebLineWidth, capthick=ebLineWidth,color='green', label=\"$\\mathit{D_{1}}$-AF\")\n",
    "ax1.errorbar(catLabel, d2s, yerr=d2Stds, capsize=cSize, linestyle='dashed', linewidth=seriesLineWidth, marker='d', markersize=mSize, markerfacecolor='blue', elinewidth=ebLineWidth, capthick=ebLineWidth,color='Blue', label=\"$\\mathit{D_{2}}$-AF\")\n",
    "ax1.errorbar(catLabel, d3s, yerr=d3Stds, capsize=cSize, linestyle='dashed', linewidth=seriesLineWidth, marker='^', markersize=mSize, markerfacecolor='orange', elinewidth=ebLineWidth, capthick=ebLineWidth,color='orange', label=\"$\\mathit{D_{3}}$-AF\")\n",
    "ax1.errorbar(catLabel, fitnesses, yerr=fitnessStds, capsize=cSize, linestyle='solid', linewidth=seriesLineWidth, marker='s', markersize=mSize, markerfacecolor='red', elinewidth=ebLineWidth, capthick=ebLineWidth,color='red', label=\"AF\")\n",
    "\n",
    "# Set labels\n",
    "ax1.set_xlabel('')\n",
    "ax1.set_ylabel(\"Descriptor Value\", fontsize=axisTitleFontSize)\n",
    "\n",
    "# Create a custom legend with the desired order\n",
    "handles = [\n",
    "    Line2D([0], [0], linestyle='dashed', marker='D', markerfacecolor='green', color='green'),\n",
    "    Line2D([0], [0], linestyle='dashed', marker='v', markerfacecolor='blue', color='Blue'),\n",
    "    Line2D([0], [0], linestyle='dashed', marker='o', markerfacecolor='orange', color='orange'),\n",
    "    Line2D([0], [0], linestyle='solid', marker='s', markerfacecolor='red', color='red')\n",
    "]\n",
    "\n",
    "labels = [\n",
    "    \"$\\mathit{D_{1}}$-AF\",\n",
    "    \"$\\mathit{D_{2}}$-AF\",\n",
    "    \"$\\mathit{D_{3}}$-AF\",\n",
    "    \"AF\"\n",
    "]\n",
    "\n",
    "# Set custom legend\n",
    "leg = ax1.legend(markerfirst=False, loc='best', ncol=1, frameon=True, framealpha=0.9)\n",
    "leg.get_frame().set_linewidth(0.5)\n",
    "plt.grid(color='gray',linestyle='--',linewidth=0.5)\n",
    "\n",
    "# Adjust grid and tick marks/labels\n",
    "ax1.grid(color='gray',linestyle='--',linewidth=0.5)\n",
    "ax2.grid(color='gray',linestyle='--',linewidth=0.5)\n",
    "\n",
    "# Hides x-axis tick marks and labels\n",
    "ax1.axis[\"top\",\"bottom\",\"right\"].toggle(all=False)\n",
    "ax2.axis[\"top\",\"right\"].toggle(all=False)\n",
    "ax1.axis[:].major_ticks.set_tick_out(True)\n",
    "ax2.axis[:].major_ticks.set_tick_out(True)\n",
    "\n",
    "\n",
    "# set -y-axis limits for the first axis\n",
    "ax1.set_ylim(-1, 28)\n",
    "\n",
    "color1 = 'cyan'; color2 = 'brown'; color3 = 'magenta'; color4 = 'black'\n",
    "\n",
    "# Plotting on the primary y-axis\n",
    "ax2.errorbar(catLabel, w1s, yerr=w1Stds, capsize=cSize, linestyle=':', linewidth=seriesLineWidth, marker='D', markerfacecolor=color1, markersize=mSize, elinewidth=ebLineWidth, capthick=ebLineWidth,color=color1, label=\"$\\mathit{w_{1}}$-AF\")\n",
    "ax2.errorbar(catLabel, w2s, yerr=w2Stds, capsize=cSize, linestyle=':', linewidth=seriesLineWidth, marker='v', markerfacecolor=color2, markersize=mSize*1.1, elinewidth=ebLineWidth, capthick=ebLineWidth,color=color2, label=\"$\\mathit{w_{2}}$-AF\")\n",
    "ax2.errorbar(catLabel, w3s, yerr=w3Stds, capsize=cSize, linestyle=':', linewidth=seriesLineWidth, marker='o', markerfacecolor=color3, markersize=mSize, elinewidth=ebLineWidth, capthick=ebLineWidth,color=color3, label=\"$\\mathit{w_{3}}$-AF\")\n",
    "ax2.errorbar(catLabel, w4s, yerr=w4Stds, capsize=cSize, linestyle=':', linewidth=seriesLineWidth, marker='x', markerfacecolor=color4, markersize=mSize, elinewidth=ebLineWidth, capthick=ebLineWidth,color=color4, label=\"$\\mathit{w_{4}}$-AF\")\n",
    "\n",
    "ax2.set_xlabel('')\n",
    "ax2.set_ylabel(\"Weight Value\", fontsize=axisTitleFontSize)\n",
    "\n",
    "# Adjust legend\n",
    "box = ax2.get_position()\n",
    "leg = ax2.legend(markerfirst=False, loc='best', ncol=2, frameon=True, framealpha=0.9)\n",
    "leg.get_frame().set_linewidth(0.5)\n",
    "ax1.grid(color='gray',linestyle='--',linewidth=0.5)\n",
    "ax2.grid(color='gray',linestyle='--',linewidth=0.5)\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"figures/Descriptors_and_weights_AF.svg\", format=\"svg\", bbox_inches=\"tight\")\n",
    "show()\n",
    "print('Overall fitness (AF) and the individual components: D1, reward for high catalyst productivity;\\nD2,resolution of low catalyst productivity; D3, reward for high catalyst activity;\\nw1, threshold against low catalyst activity; w2, initiation-based catalyst elimination;\\nw3, synthetic accessibility-based catalyst elimination; w4, stereochemistry-based catalyst elimination.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 318x230 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import mpl_toolkits.axisartist as axisartist\n",
    "\n",
    "# Data for the bar chart\n",
    "objects = ['$\\mathbf{H0}$', '$\\mathbf{HI}$', '$\\mathbf{HII\\prime}$', '$\\mathbf{HII}$', '$\\mathbf{HC1^{Ph}}$']\n",
    "categories = ['Yield, 1 h', 'Yield, 4 h']\n",
    "\n",
    "# Data from RCM experiment (See SI)\n",
    "data = np.array([\n",
    "    [1, 12],\n",
    "    [5, 21],\n",
    "    [24, 33],\n",
    "    [29, 40],\n",
    "    [80, 90]\n",
    "])\n",
    "errors = np.array([\n",
    "    [0, 1],\n",
    "    [1, 2],\n",
    "    [2, 3],\n",
    "    [2, 2],\n",
    "    [2, 1]\n",
    "])\n",
    "\n",
    "# Set up figure and axis\n",
    "fig = plt.figure(figsize=(3.18, 2.3))\n",
    "ax = fig.add_subplot(axes_class=axisartist.Axes)\n",
    "\n",
    "# Bar width\n",
    "bar_width = 0.35\n",
    "\n",
    "# X-axis positions for the groups\n",
    "x_positions = np.arange(len(objects))\n",
    "\n",
    "# Plot the bars for each category with error bars\n",
    "for i, category in enumerate(categories):\n",
    "    if category == 'Yield, 1 h':\n",
    "        bar_color = 'white'\n",
    "        bar_hatch = '...'\n",
    "    elif category == 'Yield, 4 h':\n",
    "        bar_color = '#1f77b4'\n",
    "        bar_hatch = None\n",
    "    ax.bar(x_positions + i * bar_width, data[:, i], bar_width, color=bar_color, hatch=bar_hatch, label=category, edgecolor='#1f77b4', yerr=errors[:, i], capsize=3)\n",
    "\n",
    "# Adjusting tick marks\n",
    "ax.axis[\"top\",\"right\"].toggle(all=False)\n",
    "ax.axis[:].major_ticks.set_tick_out(True)\n",
    "\n",
    "# Set labels and title\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('RCM Yield (%)')\n",
    "ax.set_title('')\n",
    "\n",
    "# Set object labels on the x-axis and make them bold\n",
    "ax.set_xticks(x_positions + bar_width / 2)\n",
    "ax.set_xticklabels(objects, fontweight='bold')\n",
    "\n",
    "# Add legend\n",
    "ax.legend()\n",
    "plt.yticks([0, 20, 40, 60, 80, 100])\n",
    "plt.yticks(fontname='Arial')\n",
    "\n",
    "# Save the plot\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"figures/yieldBarChart.svg\", format=\"svg\", bbox_inches=\"tight\")\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}