dp_ratio.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from bs4 import BeautifulSoup\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = \"/Users/smsharma/Desktop/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Get (heuristic) threshold for direct production graph for a heavy mediator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "masses = [100000]  # Pick large mediator mass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loop over graphs and grab cross sections\n",
    "# Pick \\lambda = 1, check also for \\lambda = 0.3\n",
    "\n",
    "cxns = []\n",
    "\n",
    "for mass in masses:\n",
    "    with open (data_dir + \"MG5_aMC_v2_5_6_patch_int_signal/bin/sig_tchannel_lambda1//Events/html_lambda1_\"+str(mass) + \"_0.html\", \"r\") as myfile:\n",
    "        data=myfile.read()\n",
    "        \n",
    "    soup = BeautifulSoup(data) # Parse the HTML as a string\n",
    "    \n",
    "    for table in soup.find_all('table')[1:]:\n",
    "        for row in table.find_all('tr'):\n",
    "            column_marker = 0\n",
    "            columns = row.find_all('td')\n",
    "\n",
    "            for icolumn, column in enumerate(columns):\n",
    "                graph_cxn = None\n",
    "                if icolumn == 0:\n",
    "                    graph_name = (column.get_text())\n",
    "                if icolumn == 1:\n",
    "                    graph_cxn = (column.get_text())\n",
    "                if graph_cxn is not None:\n",
    "                    cxns.append(float(graph_cxn))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, '$\\\\log_{10}(\\\\sigma [\\\\mathrm{arb.}])$')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 443.077x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(np.log10(cxns), np.linspace(-25, -10, 50));\n",
    "plt.xlabel(\"$\\log_{10}(\\sigma [\\mathrm{arb.}])$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigma_dp_thresh = 1e-17  # Eyeballing # Similar for \\lambda = 0.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Get xsec ratios "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1. $\\lambda = 0.3$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.1. Get DP graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "masses = [100000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dp_frac = []\n",
    "\n",
    "dp_graphs = []\n",
    "rest_graphs = []\n",
    "\n",
    "for mass in masses:\n",
    "    with open (data_dir + \"/MG5_aMC_v2_5_6_patch_int_signal/bin/sig_tchannel_lambda0p3//Events/html_lambda0p3_\"+str(mass) + \"_0.html\", \"r\") as myfile:\n",
    "        data=myfile.read()\n",
    "        \n",
    "    soup = BeautifulSoup(data) # Parse the HTML as a string\n",
    "    \n",
    "    for table in soup.find_all('table')[1:]:\n",
    "    \n",
    "        dp_sum = 0.\n",
    "        rest_sum = 0.\n",
    "\n",
    "        for row in table.find_all('tr'):\n",
    "            column_marker = 0\n",
    "            columns = row.find_all('td')\n",
    "\n",
    "            for icolumn, column in enumerate(columns):\n",
    "                graph_cxn = None\n",
    "                if icolumn == 0:\n",
    "                    graph_name = (column.get_text())\n",
    "                if icolumn == 1:\n",
    "                    graph_cxn = (column.get_text())\n",
    "                if graph_cxn is not None:\n",
    "                    if float(graph_cxn) > sigma_dp_thresh: \n",
    "                        \n",
    "                        dp_graphs.append(graph_name)\n",
    "                    else:\n",
    "                        rest_graphs.append(graph_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2. Get xsec ratio of DP/rest graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "masses = [100] + list(np.arange(300,2000, 100))+  list(np.arange(2000,7000, 500))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2af9d03c0734439583786dcb57455a0a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=28), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "dp_frac = []\n",
    "dp_sum_ary = []\n",
    "\n",
    "for mass in tqdm(masses):\n",
    "    with open (data_dir + \"MG5_aMC_v2_5_6_patch_int_signal/bin/sig_tchannel_lambda0p3//Events/html_lambda0p3_\"+str(mass) + \"_0.lhe\", \"r\") as myfile:\n",
    "        data=myfile.read()\n",
    "        \n",
    "    soup = BeautifulSoup(data) # Parse the HTML as a string\n",
    "    dp_sum = 0.\n",
    "    rest_sum = 0.\n",
    "    \n",
    "    for table in soup.find_all('table')[1:]:\n",
    "    \n",
    "\n",
    "\n",
    "        for row in table.find_all('tr'):\n",
    "            column_marker = 0\n",
    "            columns = row.find_all('td')\n",
    "\n",
    "            for icolumn, column in enumerate(columns):\n",
    "                graph_cxn = None\n",
    "                if icolumn == 0:\n",
    "                    graph_name = (column.get_text())\n",
    "                if icolumn == 1:\n",
    "                    graph_cxn = (column.get_text())\n",
    "                if graph_cxn is not None:\n",
    "                    if graph_name in dp_graphs:\n",
    "                        dp_sum += float(graph_cxn)\n",
    "                    else:\n",
    "                        rest_sum += float(graph_cxn)\n",
    "\n",
    "    dp_sum_ary.append(dp_sum)\n",
    "    dp_frac.append(dp_sum/(dp_sum+rest_sum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2. $\\lambda = 1$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1. Get DP graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "masses = [100000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dp_graphs = []\n",
    "rest_graphs = []\n",
    "\n",
    "for mass in masses:\n",
    "    with open (data_dir + \"MG5_aMC_v2_5_6_patch_int_signal/bin/sig_tchannel_lambda1//Events/html_lambda1_\"+str(mass) + \"_0.html\", \"r\") as myfile:\n",
    "        data=myfile.read()\n",
    "        \n",
    "    soup = BeautifulSoup(data) # Parse the HTML as a string\n",
    "    \n",
    "    for table in soup.find_all('table')[1:]:\n",
    "    \n",
    "        dp_sum = 0.\n",
    "        rest_sum = 0.\n",
    "\n",
    "        for row in table.find_all('tr'):\n",
    "            column_marker = 0\n",
    "            columns = row.find_all('td')\n",
    "\n",
    "            for icolumn, column in enumerate(columns):\n",
    "                graph_cxn = None\n",
    "                if icolumn == 0:\n",
    "                    graph_name = (column.get_text())\n",
    "                if icolumn == 1:\n",
    "                    graph_cxn = (column.get_text())\n",
    "                if graph_cxn is not None:\n",
    "                    if float(graph_cxn) > sigma_dp_thresh: \n",
    "                        dp_graphs.append(graph_name)\n",
    "                    else:\n",
    "                        rest_graphs.append(graph_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2. Get xsec ratio of DP/rest graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "masses = [100] + list(np.arange(300,2000, 100))+  list(np.arange(2000,7000, 500))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "832322fe984c4917a0cabcf99fa6edd6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=28), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "dp_frac_lambda1 = []\n",
    "dp_sum_ary_lambda1 = []\n",
    "\n",
    "for mass in tqdm(masses):\n",
    "    with open (data_dir + \"MG5_aMC_v2_5_6_patch_int_signal/bin/sig_tchannel_lambda1//Events/html_lambda1_\"+str(mass) + \"_0.html\", \"r\") as myfile:\n",
    "        data=myfile.read()\n",
    "        \n",
    "    soup = BeautifulSoup(data) # Parse the HTML as a string\n",
    "    dp_sum_lambda1 = 0.\n",
    "    rest_sum_lambda1 = 0.\n",
    "    \n",
    "    for table in soup.find_all('table')[1:]:\n",
    "    \n",
    "\n",
    "\n",
    "        for row in table.find_all('tr'):\n",
    "            column_marker = 0\n",
    "            columns = row.find_all('td')\n",
    "\n",
    "            for icolumn, column in enumerate(columns):\n",
    "                graph_cxn = None\n",
    "                if icolumn == 0:\n",
    "                    graph_name = (column.get_text())\n",
    "                if icolumn == 1:\n",
    "                    graph_cxn = (column.get_text())\n",
    "                if graph_cxn is not None:\n",
    "                    if graph_name in dp_graphs:\n",
    "                        dp_sum_lambda1 += float(graph_cxn)\n",
    "                    else:\n",
    "                        rest_sum_lambda1 += float(graph_cxn)\n",
    "\n",
    "    dp_sum_ary_lambda1.append(dp_sum_lambda1)\n",
    "    dp_frac_lambda1.append(dp_sum_lambda1/(dp_sum_lambda1+rest_sum_lambda1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x11c55cda0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x540 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig=plt.figure(figsize=(9,7.5))\n",
    "\n",
    "lw = 2.5\n",
    "\n",
    "plt.plot(masses, np.array(dp_frac)*1, color = 'k', label = \"$\\lambda = 0.3$\",lw=3, alpha=0.5, ls='--')\n",
    "plt.plot(masses, np.array(dp_frac_lambda1)*1, color = 'k', label = r\"$\\lambda = 1$\",lw=3, alpha=0.5)\n",
    "\n",
    "\n",
    "plt.xscale(\"log\")\n",
    "plt.xlabel(r\"$M_\\Phi$ [GeV]\")\n",
    "plt.ylabel(r\"$\\sigma_{pp\\rightarrow \\chi\\overline\\chi}/\\sigma_\\mathrm{tot}$\")\n",
    "plt.ylim(0.2,1.2)\n",
    "plt.xlim(min(masses), max(masses))\n",
    "\n",
    "leg = plt.legend(loc='lower right')\n",
    "\n",
    "plt.tick_params(axis='both', which='major')\n",
    "\n",
    "title = r\"$t$-channel\"\n",
    "plt.title(title)\n",
    "ax = plt.gca()\n",
    "ttl = ax.title\n",
    "ttl.set_position([.5, 1.02])\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.tick_params(axis='both', which='major')\n",
    "\n",
    "plt.axhline(1.,ls='--',lw=0.8, color='grey')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:root] *",
   "language": "python",
   "name": "conda-root-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}