alanine_dipeptide.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from simtk.openmm.app import *\n",
    "from simtk.openmm import *\n",
    "from simtk.unit import *\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tqdm\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.tsa.ar_model import AutoReg\n",
    "\n",
    "TEMPERATURE = 310*kelvin\n",
    "FRICTION = 1/picosecond\n",
    "TIMESTEP = 2*femtoseconds\n",
    "\n",
    "SIGMA0 = (MOLAR_GAS_CONSTANT_R * TEMPERATURE ).value_in_unit(kilojoule_per_mole) * 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GaMD in OpenMM\n",
    "The most convenient way to implement GaMD in OpenMM is using a custom integrator. In the custom integrator, the force has already been calculated by OpenMM. That means we can't edit the potential energy function and expect to re-calculate the force. Instead, we find out what the change in potential energy would have done to the force, and do the same thing within the integrator.  \n",
    "\n",
    "Normally, the force is the negative of the gradient of the potential $V(\\vec r)$:\n",
    "$$f = -1 \\left( \\frac{\\partial V(\\vec r)}{\\partial \\vec r}\\right)$$\n",
    "\n",
    "In GaMD, we use a modified potential:\n",
    "\n",
    "$$V'(\\vec r) = V(\\vec r) + dV(\\vec r)$$ \n",
    "\n",
    "where:\n",
    "\n",
    "$$dV(\\vec r) = \\frac{k}{2} (E - V(\\vec r))^2$$\n",
    "\n",
    "So the modified force is now:\n",
    "\n",
    "$$f' = -1 \\left( \\frac{\\partial V(\\vec r) + \\frac{k}{2} (E - V(\\vec r))^2}{\\partial \\vec r}\\right)$$\n",
    "\n",
    "Separate into two derivatives with the Sum rule:\n",
    "\n",
    "$$f' = - \\left( \\frac{\\partial V(\\vec r)}{\\partial \\vec r}\\right) -  \\left( \\frac{\\partial \\frac{k}{2} (E - V(\\vec r))^2 }{\\partial \\vec r}\\right)  $$\n",
    "\n",
    "\n",
    "Now to start simplifying. The left hand term is already $-f$ and we can move $\\frac{k}{2}$ outside (Constant rule):\n",
    "\n",
    "$$f' =  f -  \\frac{k}{2} \\left( \\frac{\\partial (E - V(\\vec r))^2 }{\\partial \\vec r}\\right)  $$\n",
    "\n",
    "Expanding the right hand side:\n",
    "\n",
    "$$f' =  f -  \\frac{k}{2} \\left( \\frac{\\partial (E^2 - 2EV(\\vec r) + V(\\vec r)^2) }{\\partial \\vec r}\\right)  $$\n",
    "\n",
    "$E^2$ is a constant and doesn't affect the derivative, so remove it:\n",
    "\n",
    "$$f' =  f -  \\frac{k}{2} \\left( \\frac{\\partial ( - 2EV(\\vec r) + V(\\vec r)^2) }{\\partial \\vec r}\\right)  $$\n",
    "\n",
    "Factor out one of the $V(\\vec r)$ terms so we can do a chain rule afterwards:\n",
    "\n",
    "$$f' =  f -  \\frac{k}{2} \\left( \\frac{\\partial ( V(\\vec r)(- 2E + V(\\vec r)) }{\\partial \\vec r}\\right)  $$\n",
    "\n",
    "Now use the chain rule:\n",
    "\n",
    "$$f' =  f -  \\frac{k}{2} \\left( \\frac{\\partial V(\\vec r) }{\\partial \\vec r}\\cdot(-2E + V(\\vec r)) + \\frac{\\partial (-2E + V(\\vec r)) }{\\partial \\vec r} \\cdot V(\\vec r) \\right)  $$\n",
    "\n",
    "\n",
    "This is where life gets easier. The left derivative is $-f$ again. The $-2E$ can be removed from the right derivative, since it's a constant, meaning the right derivative is just $-f$ as well!\n",
    "\n",
    "$$f' = f - \\frac{k}{2} \\left( -f\\cdot(-2E + V(\\vec r)) -fV(\\vec r) \\right) $$\n",
    "\n",
    "One step at a time...\n",
    "\n",
    "$$f' = f - \\frac{k}{2} \\left( 2fE - fV(\\vec r) -fV(\\vec r) \\right) $$\n",
    "\n",
    "then \n",
    "$$f' = f - \\frac{k}{2} \\left( 2fE - 2fV(\\vec r) \\right) $$\n",
    "\n",
    "then \n",
    "$$f' = f - \\frac{k}{2} \\left( 2f(E - V(\\vec r)) \\right) $$\n",
    "\n",
    "then \n",
    "$$f' = f - fk \\left( E - V(\\vec r) \\right) $$\n",
    "\n",
    "\n",
    "\n",
    "So finally, we have the modified force being the original force multiplied by a factor of $k$, $E$, and $V(\\vec r)$:\n",
    "\n",
    "$$f' = f \\cdot (1 - k(E - V(\\vec r) )$$ \n",
    "\n",
    "\n",
    "----------------------------\n",
    "\n",
    "The custom integrator below is a Langevin integrator with some extra parameters like $E$ and $k$ (one of each for the dihedrals force group, and one of each for everything else, which Miao et al. call 'total' potential), which are used to calculate the modified force. \n",
    "\n",
    "It also has methods to calculate the magnitude of the boost, which can be used later to re-weight the free energy estimates.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomGaMDLangevinIntegrator(CustomIntegrator):\n",
    "    def __init__(self, temperature, friction, dt, ktot, Etot, kgrp, Egrp, forceGroup):\n",
    "        self.ktot = ktot \n",
    "        self.Etot = Etot \n",
    "        self.kgrp = kgrp\n",
    "        self.Egrp = Egrp\n",
    "        self.forceGroup = str(forceGroup)\n",
    "        \n",
    "        CustomIntegrator.__init__(self, dt)\n",
    "            #lew added:\n",
    "        self.addGlobalVariable(\"ktot\", self.ktot)\n",
    "        self.addGlobalVariable(\"Etot\", self.Etot)\n",
    "        self.addGlobalVariable(\"kgrp\", self.ktot)\n",
    "        self.addGlobalVariable(\"Egrp\", self.Egrp)\n",
    "        self.addGlobalVariable(\"groupEnergy\", 0)\n",
    "        \n",
    "            #normal langevin:  \n",
    "        self.addGlobalVariable(\"temperature\", temperature);\n",
    "        self.addGlobalVariable(\"friction\", friction);\n",
    "        self.addGlobalVariable(\"vscale\", 0);\n",
    "        self.addGlobalVariable(\"fscale\", 0);\n",
    "        self.addGlobalVariable(\"noisescale\", 0);\n",
    "        self.addPerDofVariable(\"x0\", 0);\n",
    "        \n",
    "        self.addPerDofVariable(\"fgrp\", 0)\n",
    "        \n",
    "            #normal langevin:                                                                  \n",
    "        self.addUpdateContextState();\n",
    "        \n",
    "        self.addComputeGlobal(\"groupEnergy\", \"energy\"+self.forceGroup)\n",
    "        self.addComputePerDof(\"fgrp\", \"f\"+self.forceGroup)\n",
    "        \n",
    "        self.addComputeGlobal(\"vscale\", \"exp(-dt*friction)\");\n",
    "        self.addComputeGlobal(\"fscale\", \"(1-vscale)/friction\");\n",
    "        #original line:                \n",
    "        self.addComputeGlobal(\"noisescale\", \"sqrt(kT*(1-vscale*vscale)); kT=0.00831451*temperature\");\n",
    "        self.addComputePerDof(\"x0\", \"x\");\n",
    "            #original langevin line:                                                                                      \n",
    "        #self.addComputePerDof(\"v\", \"vscale*v + fscale*f/m + noisescale*gaussian/sqrt(m)\");  \n",
    "            #GaMD:\n",
    "        dof_string = \"vscale*v + fscale*fprime/m + noisescale*gaussian/sqrt(m);\"\n",
    "        dof_string+= \"fprime= fprime1 + fprime2;\"\n",
    "        #fprime2 is the dihedral force modified by the boost. Boot calculated using group only. \n",
    "        dof_string+= \"fprime2 = fgrp*((1-modifyGroup) + modifyGroup* (1 - kgrp*(Egrp - groupEnergy)) ) ;\"\n",
    "        #fprime1 is the other forces modified by the boost, but the boost is calculated using TOTAL energy. \n",
    "        dof_string+= \"fprime1 = ftot*((1-modifyTotal) + modifyTotal* (1 - ktot*(Etot - energy)) );\"\n",
    "        \n",
    "        dof_string+= \"ftot=f-fgrp;\"\n",
    "        dof_string+= \"modifyGroup=step(Egrp-groupEnergy);\"\n",
    "        dof_string+= \"modifyTotal=step(Etot-energy);\"\n",
    "        self.addComputePerDof(\"v\", dof_string); \n",
    "            #normal langevin                                            \n",
    "        self.addComputePerDof(\"x\", \"x+dt*v\");\n",
    "        self.addConstrainPositions();\n",
    "        self.addComputePerDof(\"v\", \"(x-x0)/dt\");\n",
    "        self.addComputePerDof(\"veloc\", \"v\")\n",
    "        \n",
    "    def setKtot(self, newK):\n",
    "        if not is_quantity(newK):\n",
    "            newK = newK/kilojoules_per_mole\n",
    "        self.setGlobalVariableByName('ktot', newK)\n",
    "        \n",
    "    def setEtot(self, newE):\n",
    "        if not is_quantity(newE):\n",
    "            newE = newE*kilojoules_per_mole\n",
    "        self.setGlobalVariableByName('Etot', newE)\n",
    "        \n",
    "    def setKgrp(self, newK):\n",
    "        if not is_quantity(newK):\n",
    "            newK = newK/kilojoules_per_mole\n",
    "        self.setGlobalVariableByName('kgrp', newK)\n",
    "        \n",
    "    def setEgrp(self, newE):\n",
    "        #if not is_quantity(newE):\n",
    "        #    newE = newE*kilojoules_per_mole\n",
    "        #    print(newE)\n",
    "        self.setGlobalVariableByName('Egrp', newE)\n",
    "          \n",
    "    def getGrpBoost(self, grpEnergy):\n",
    "        kgrp = self.getGlobalVariableByName('kgrp')/kilojoules_per_mole\n",
    "        Egrp = self.getGlobalVariableByName('Egrp')*kilojoules_per_mole\n",
    "        if not is_quantity(grpEnergy):\n",
    "            grpEnergy = grpEnergy*kilojoules_per_mole # Assume kJ/mole\n",
    "        if (grpEnergy > Egrp):\n",
    "            return 0*kilojoules_per_mole #no boosting\n",
    "        return ( 0.5 * kgrp * (Egrp-grpEnergy)**2 ) # 'k' parameter should instead be per kj/mol\n",
    "    \n",
    "    def getTotBoost(self, totEnergy):\n",
    "        ktot = self.getGlobalVariableByName('ktot')/kilojoules_per_mole\n",
    "        Etot = self.getGlobalVariableByName('Etot')*kilojoules_per_mole\n",
    "        if not is_quantity(totEnergy):\n",
    "            totEnergy = totEnergy*kilojoules_per_mole # Assume kJ/mole\n",
    "        if (totEnergy > Etot):\n",
    "            return 0*kilojoules_per_mole #no boosting\n",
    "        return ( 0.5 * ktot * (Etot-totEnergy)**2 ) # 'k' parameter should instead be per kj/mol\n",
    "        \n",
    "    def getEffectiveEnergy(self, totEnergy, grpEnergy):\n",
    "        if not is_quantity(totEnergy):\n",
    "            totEnergy = totEnergy*kilojoules_per_mole # Assume kJ/mole\n",
    "        if not is_quantity(grpEnergy):\n",
    "            grpEnergy = grpEnergy*kilojoules_per_mole # Assume kJ/mole\n",
    "        \n",
    "        group_boost = self.getGrpBoost(grpEnergy)\n",
    "        total_boost = self.getTotBoost(totEnergy)\n",
    "        \n",
    "        return totEnergy + group_boost + total_boost\n",
    "        \n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setup_system(filename):\n",
    "  \"\"\"Creates a 'system' object given a pdb filename\"\"\"\n",
    "  pdb = PDBFile(filename)\n",
    "  forcefield = app.ForceField('amber99sbildn.xml', 'tip3p.xml')\n",
    "  system = forcefield.createSystem(pdb.topology, nonbondedMethod=app.CutoffPeriodic, constraints=HBonds,)\n",
    "  system.addForce(MonteCarloBarostat(1*bar, 310*kelvin))\n",
    "  set_dihedral_force_group(system)\n",
    "  print('Created system')\n",
    "  return system, pdb\n",
    "\n",
    "\n",
    "def set_dihedral_force_group(system, g=2):\n",
    "  \"\"\"Sets the dihedral forcegroup to a number other than 0,\n",
    "  which will be used by serial tempering\"\"\"\n",
    "  print('Scanning forces:')\n",
    "  for f in system.getForces():\n",
    "    if isinstance(f, PeriodicTorsionForce):\n",
    "      print('Found the torsions - setting group to 2')\n",
    "      f.setForceGroup(2)\n",
    "    print(f.getForceGroup(), f.__class__)\n",
    "\n",
    "def setup_simulation(system, pdb, integrator):\n",
    "  \"\"\"Creates a simulation object\"\"\"\n",
    "  #platform = Platform.getPlatformByName('CPU')\n",
    "  platform = Platform.getPlatformByName('OpenCL')\n",
    "  prop = {'OpenCLPrecision':'single'}\n",
    "  simulation = Simulation(pdb.topology, system, integrator, platform, prop)\n",
    "  simulation.context.setPositions(pdb.positions)\n",
    "  simulation.minimizeEnergy()\n",
    "  simulation.context.setVelocitiesToTemperature(310*kelvin)\n",
    "  print('Created simulation')\n",
    "  return simulation\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename ='./alanine-dipeptide-explicit.pdb'\n",
    "output_directory = './'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scanning forces:\n",
      "0 <class 'simtk.openmm.openmm.HarmonicBondForce'>\n",
      "0 <class 'simtk.openmm.openmm.HarmonicAngleForce'>\n",
      "Found the torsions - setting group to 2\n",
      "2 <class 'simtk.openmm.openmm.PeriodicTorsionForce'>\n",
      "0 <class 'simtk.openmm.openmm.NonbondedForce'>\n",
      "0 <class 'simtk.openmm.openmm.CMMotionRemover'>\n",
      "0 <class 'simtk.openmm.openmm.MonteCarloBarostat'>\n",
      "Created system\n"
     ]
    }
   ],
   "source": [
    "system, pdb = setup_system(filename)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "integrator = CustomGaMDLangevinIntegrator(TEMPERATURE,\n",
    "                                         FRICTION,\n",
    "                                         TIMESTEP,\n",
    "                                         1/kilojoules_per_mole,\n",
    "                                         -1e6*kilojoules_per_mole, #set a ridiculous low threshold to start\n",
    "                                         1/kilojoules_per_mole,\n",
    "                                         -1e6*kilojoules_per_mole, #set a ridiculous low threshold to start\n",
    "                                         2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created simulation\n"
     ]
    }
   ],
   "source": [
    "sim =setup_simulation(system, pdb, integrator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#These functions help calculate the k and E parameters based on Miao's rules\n",
    "\n",
    "def get_statistics(pe_trace, boost_trace=0):\n",
    "    arr = np.array(pe_trace)\n",
    "    arr = arr + np.array(boost_trace)\n",
    "    Vmax = arr.max()\n",
    "    Vmin = arr.min()\n",
    "    Vavg = arr.mean()\n",
    "    Vstd = np.std(arr)\n",
    "    \n",
    "    return [Vmax, Vmin, Vavg, Vstd]\n",
    "\n",
    "def calc_parameters(Vmax, Vmin, Vavg, Vstd, mode='low', sigma_0=SIGMA0, verbose=False):\n",
    "    E = Vmax\n",
    "    k_0 = min(1, (sigma_0/Vstd) * ((Vmax-Vmin)/(Vmax-Vavg)))\n",
    "    k = k_0 * (1 / (Vmax - Vmin) )\n",
    "    \n",
    "    if verbose:\n",
    "        return E, k, k_0\n",
    "    else:\n",
    "        return E, k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collect some statistics from cMD:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e63bed583780447183b01b028ee76f12",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=2000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "grp_nrgs = list()\n",
    "tot_nrgs = list()\n",
    "\n",
    "\n",
    "for i in tqdm.tqdm_notebook(range(2000)):\n",
    "    sim.step(100)\n",
    "    \n",
    "    grp_nrg = sim.context.getState(getEnergy=True, groups={2}).getPotentialEnergy()/kilojoule_per_mole\n",
    "    tot_nrg = sim.context.getState(getEnergy=True).getPotentialEnergy()/kilojoule_per_mole\n",
    "    \n",
    "    grp_nrgs.append(grp_nrg)\n",
    "    tot_nrgs.append(tot_nrg)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7faedfaedcd0>]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(grp_nrgs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initial estimate of k and E from the cMD run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Egrp: 74.74067687988281\n"
     ]
    }
   ],
   "source": [
    "#if doing total boost as well:\n",
    "# Vmax, Vmin, Vavg, Vstd = get_statistics(tot_nrgs,0)\n",
    "# E,k = calc_parameters(Vmax, Vmin, Vavg, Vstd, sigma_0=SIGMA0*10)\n",
    "# sim.integrator.setEtot(E)\n",
    "# sim.integrator.setKtot(k)\n",
    "\n",
    "#for dihedral boost:\n",
    "Vmax, Vmin, Vavg, Vstd = get_statistics(grp_nrgs, 0)\n",
    "E,k = calc_parameters(Vmax, Vmin, Vavg, Vstd, sigma_0=SIGMA0*3)\n",
    "print('Egrp:',E)\n",
    "sim.integrator.setEgrp(E)\n",
    "sim.integrator.setKgrp(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run iterative estimation of k, E parameters:\n",
    "\n",
    "We have an estimate of the parameters from conventional MD above. Now we run short stints, continually updating those estimates based on the behaviour of the potential energy in response (for example, E is based on Vmax, thus will it gradually increase as the boost potential leads the system into higher energy regions of phase space). \n",
    "\n",
    "Eventually Vmax and Vstd, and thus k and E, should converge.\n",
    "\n",
    "The below uses about 5 nanoseconds of simulation (there's also small equilibrations at the start of each step)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b4d824f5868040b3a9f1d1fd3d1dc498",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72.06260091871177 0.06225944620826417 1\n",
      "82.09384155273438 0.038324366209415824 1\n",
      "85.8898696899414 0.03345702565529297 1\n",
      "88.64773559570312 0.030630728620655624 1\n",
      "92.1520767211914 0.027661525982163704 1\n",
      "92.1520767211914 0.027661525982163704 1\n",
      "92.1520767211914 0.027661525982163704 1\n",
      "92.1520767211914 0.027661525982163704 1\n",
      "92.1520767211914 0.027661525982163704 1\n",
      "92.73403930664062 0.027223286250288168 1\n",
      "92.73403930664062 0.027223286250288168 1\n",
      "93.76701354980469 0.026478680506730284 1\n",
      "93.76701354980469 0.026478680506730284 1\n",
      "94.07250213623047 0.026266214810875738 1\n",
      "94.07250213623047 0.026266214810875738 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "100.96233367919922 0.022241224894151437 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "101.30975341796875 0.02207068382542855 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.27568817138672 0.021609984022019663 1\n",
      "102.85260009765625 0.021343888536177778 1\n",
      "102.85260009765625 0.021343888536177778 1\n",
      "102.85260009765625 0.021343888536177778 1\n",
      "102.85260009765625 0.021343888536177778 1\n",
      "102.85260009765625 0.021343888536177778 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "grp_nrgs = list()\n",
    "tot_nrgs = list()\n",
    "\n",
    "grp_boosts = list()\n",
    "tot_boosts = list()\n",
    "\n",
    "ks = list()\n",
    "k_0s = list()\n",
    "vmaxs = list()\n",
    "\n",
    "gks = list()\n",
    "gk_0s = list()\n",
    "gvmaxs = list()\n",
    "\n",
    "for _ in tqdm.tqdm_notebook(range(50)):\n",
    "    #equil:\n",
    "    sim.step(1000)\n",
    "    \n",
    "    for i in range(200):\n",
    "        sim.step(250)\n",
    "        \n",
    "        grp_nrg = sim.context.getState(getEnergy=True, groups={2}).getPotentialEnergy()/kilojoules_per_mole\n",
    "        tot_nrg = sim.context.getState(getEnergy=True,).getPotentialEnergy()/kilojoules_per_mole\n",
    "        \n",
    "        grp_boost = sim.integrator.getGrpBoost(grp_nrg)/kilojoule_per_mole\n",
    "        tot_boost = sim.integrator.getTotBoost(tot_nrg)/kilojoule_per_mole\n",
    "        \n",
    "        grp_boosts.append(grp_boost)\n",
    "        tot_boosts.append(tot_boost)\n",
    "        \n",
    "        grp_nrgs.append(grp_nrg)\n",
    "        tot_nrgs.append(tot_nrg)\n",
    "              \n",
    "#In this example, I will only alter the dihedral boost\n",
    "        \n",
    "#     Vmax, Vmin, Vavg, Vstd = get_statistics(tot_nrgs, tot_boosts)\n",
    "#     E,k,k_0 = calc_parameters(Vmax, Vmin, Vavg, Vstd, sigma_0 = SIGMA0*10,verbose=True)\n",
    "#     sim.integrator.setEtot(E)\n",
    "#     sim.integrator.setKtot(k)\n",
    "    \n",
    "#     ks.append(k)\n",
    "#     k_0s.append(k_0)\n",
    "#     vmaxs.append(E)\n",
    "#     print(E, k, k_0)\n",
    "\n",
    "    #smaller SIGMA0 for dihedrals group, i.e. below calculates up to an StdDev of 6kT :\n",
    "    Vmax, Vmin, Vavg, Vstd = get_statistics(grp_nrgs, grp_boosts)\n",
    "    E,k,k_0 = calc_parameters(Vmax, Vmin, Vavg, Vstd, sigma_0 = SIGMA0*6, verbose=True)\n",
    "    sim.integrator.setEgrp(E)\n",
    "    sim.integrator.setKgrp(k)\n",
    "    \n",
    "    gks.append(k)\n",
    "    gk_0s.append(k_0)\n",
    "    gvmaxs.append(E)\n",
    "    print(E, k, k_0)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Boost magnitude histogram\\n(should be gaussian)')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2,2)\n",
    "fig.set_figwidth(15)\n",
    "fig.set_figheight(10)\n",
    "ax[0,0].plot(gvmaxs)\n",
    "ax[0,0].set_title('Vmax convergence:')\n",
    "\n",
    "ax[0,1].plot(gks)\n",
    "ax[0,1].set_title('kgrp convergence:')\n",
    "\n",
    "ax[1,0].plot(grp_boosts)\n",
    "ax[1,0].set_title('Boost magnitudes:')\n",
    "\n",
    "\n",
    "ax[1,1].hist(grp_boosts[-6000:],bins=55)\n",
    "ax[1,1].set_title('Boost magnitude histogram\\n(should be gaussian)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Add a trajectory reporter and do some production run:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "sim.reporters.append(DCDReporter('diala_gamd_traj.dcd', 150))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "production = dict()\n",
    "production['grp_nrgs'] = list()\n",
    "production['tot_nrgs'] = list()\n",
    "\n",
    "production['grp_boosts'] = list()\n",
    "production['tot_boosts'] = list()\n",
    "\n",
    "def report(sim, prod):\n",
    "    grp_nrg = sim.context.getState(getEnergy=True, groups={2}).getPotentialEnergy()/kilojoules_per_mole\n",
    "    tot_nrg = sim.context.getState(getEnergy=True,).getPotentialEnergy()/kilojoules_per_mole\n",
    "        \n",
    "    grp_boost = sim.integrator.getGrpBoost(grp_nrg)/kilojoule_per_mole\n",
    "    tot_boost = sim.integrator.getTotBoost(tot_nrg)/kilojoule_per_mole\n",
    "        \n",
    "    prod['grp_boosts'].append(grp_boost)\n",
    "    prod['tot_boosts'].append(tot_boost)\n",
    "        \n",
    "    prod['grp_nrgs'].append(grp_nrg)\n",
    "    prod['tot_nrgs'].append(tot_nrg)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "91655a8d05e74c0995e025cd0d8a2115",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=100000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for _ in tqdm.tqdm_notebook(range(int(30*500000/150))): #30 nanoseconds\n",
    "    report(sim, production)\n",
    "    \n",
    "    sim.step(150)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results.\n",
    "\n",
    "Below shows the dihedral angles of so-called alanine dipeptide. We would expect, from conventional MD, to see on the order of 4 or 5 transitions into the 'rare' state over 1000ns. So far, simulating 30 nanoseconds, we see 9 or maybe 10 transitions already. We would expect probably an order of magnitude increase in sampling, so the boost that was used here might be a little bit too aggressive. The downside of this is that the boost probably isn't gaussian shaped enough despite having low standard deviation. This can be fixed with more careful equilibration.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mdtraj as md\n",
    "##the dihedral idices:\n",
    "indices = np.array([[4, 6, 8, 14],[6, 8, 14, 16]])\n",
    "\n",
    "traj = md.load_dcd('./diala_gamd_traj.dcd', top='./alanine-dipeptide-explicit.pdb')\n",
    "\n",
    "dihedrals = md.compute_dihedrals(traj, indices, periodic=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7faeb3e3fd10>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#slow moving dihedral:\n",
    "plt.scatter(np.arange(len(dihedrals)), np.where(dihedrals[:,0]>2, dihedrals[:,0]-2*np.pi, dihedrals[:,0]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.08221536042910715"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#boosts histogram - actually not too bad!\n",
    "_=plt.hist(np.array(production['grp_boosts']), bins=55)\n",
    "\n",
    "\n",
    "#using Miao's anharmonicity calculator:\n",
    "def anharm(data):\n",
    "    var=np.var(data)\n",
    "    # hist, edges=np.histogram(data, 50, normed=True)\n",
    "    hist, edges=np.histogram(data, 50, density=True)\n",
    "    hist=np.add(hist,0.000000000000000001)  ###so that distrib\n",
    "    dx=edges[1]-edges[0]\n",
    "    S1=-1*np.trapz(np.multiply(hist, np.log(hist)),dx=dx)\n",
    "    S2=0.5*np.log(np.add(2.00*np.pi*np.exp(1)*var,0.000000000000000001))\n",
    "    alpha=S2-S1\n",
    "    if np.isinf(alpha):\n",
    "       alpha = 100\n",
    "    return alpha\n",
    "\n",
    "\n",
    "anharm(grp_boosts) #come to think of it, 0.08 might not be great.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/lewis/miniconda3/envs/lew_conda/lib/python3.7/site-packages/ipykernel_launcher.py:9: RuntimeWarning: divide by zero encountered in log\n",
      "  if __name__ == '__main__':\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQoAAAD8CAYAAACPd+p5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAsbklEQVR4nO2de5RddZXnv/u+q+6tqluVJ+QdSQhvhRigFUUUO4MzS0RdqGvE8dGMDkp3O9C6enCctnE1SqvdTGMj0qwB1xq0sYG2W0wbdBCkw6OQEMMrIQkhRZ71rrpV973nj3ur7tm7bt1f3XrdU2F/1srK/dX5nXN+95zKzu/3/e0HMTMMwzBqEWj0AAzD8D9mKAzDcGKGwjAMJ2YoDMNwYobCMAwnZigMw3BSt6EgohgRPU1EzxPRC0T0F1X6bCKiHUSUIaIbZmeohmE0itA0zskAuIyZh4koDOC3RPQLZn7S06cXwPUArpyFMRqG0WDqnlFwieFyM1z+w6rPcWZ+BkBu5kM0DKPRTGdGASIKAngWwGkAbmfmp6Z5nWsBXAsA8Xj8gk2bNk3nMoZhTIFnn322m5mXTOfcaRkKZi4AeCsRJQE8SERnM/PuaVznTgB3AsDmzZu5s7NzOsMxDGMKENHB6Z47LUMxBjP3E9GjALYCqNtQeNnz8hG87x03j7ePXBIXx1NrCqIdWTIi2msX94p2f7pJtGOh/PjnXFGuuEiNJRyU9xrOREU7Hsmqa8sV1pqEHEuQZDxNJJAX7WxRvobj6YRov9K9VI6np1m0O54Jj39uOyDHEv6lNL7bi/djIfHOq24d/5xaFhTHRpfKNxeVjx2BvHzui3bJ3xna8bxoL7RnU4utp39FtLe98q0ZXW86ux5LyjMJEFETgPcBeHlGozAMw9dMZ0ZxCoB7yjpFAMA/MvO/EtHnAYCZ7yCi5QA6AbQCKBLRnwA4k5kHZ2nchmHMI3UbCmbeBeBtVX5+h+fzUQArZzY0oCUaxn+98AysTCYmjJSCRdEOBWS72CqnpeRtuiLr1VqEWV9LXoDUBUMkxzJhbQNGH5/A48WHkaYRfdAwfMeMNIrZJN8cwInzK7pEuoPxp287A+euXYNwIg6Kqn+MylBElK5QC/0Pm9Q/5CLrtlyhaaMUotr3DirDEeQChvvbkOi5DC+Ff4iwOr+3Seozy2NDov3/iqeJdv+mymvMxSPy3KHzRPvywEdF22/rcj2+0Ps3j3+O9qv34LCx8WNSr8m3hEVbthY2WpOYbXztwr26JV4yEvpf8gKHiJBIRtHMpzR6KIYxJXxtKAKgk85IjEFEoIlrEsPwJb42FIZh+APfaBQcBHItlXa+rQAOMLi8dR4KFnHaORcjcqhr1u6ZW70CXS8+jojSCPLKfgYC8nhAaRxag4iQ9JPQmki0fDxKeVzS/Cp6itLnQ9MSSIt2cbWcify6sGH882hO+mAMr5bXfvIJqUn4XbOIHag4R6TbpT9JVgnWkUH5nPPNWtOQ78lv33UmFPbuF+2hqy+a1ev7xlBMhcihLrzYfwgAEFaCov7HGg5MLjDmy+LkusT6uu7PzGBmBAK1lwyFQgHBYLBmH8NYSCwoQ9EIDh3swqev+gwufteF+N1Tz+HMc8/EKy+8gnQ6jSuu3IobbvpjAMDbN12Gj19zFR791RO49vMfR3tHG275y9uRzWaxdt0q/N2dNyORaHbczTD8iRmKKbBvz3789R234Jt/8w309/ajo6MNhUIBV3/gGrz4+5dxzrkbAQDRWBQ/+9V9GOo5gU997I/xwMN3IR5vxm1/fRe+f9s9+LM//0KDv4lhTA/fGAoOAtm2yhqTmvMlR6VAde8ovbRw+TJ4FwtevwXtwwAAAY9DVYAYK1evwNsvPA9AET9/4Of4v3f/BPlCHseOnsD+V/bgvPNOA4Fx5Ue2IkBFPPfMTrzy8j584LL/DADIZnPYcuF5CJeXR+HyYIIAlgaLODU4ou4vlzZFPlLzu+1btHj8856BmDjWfZ58xZdulT7/Ll+C+dYwghsmXw4Or5CaQzilNQnZP35MOb4p9HfT+FnDcI09lKn93evFN4bCzzTHS4Lg668dwg/+9h+w7fH7kWxvw/XXfhXpdMbTr/Sbysx4z2UX4+4ffRvARPHTMBYatj1aB0ODw2iKN6G1rQUnjnXj1798vGq/t285F0/teA779r0OABgZGcXeva/N40gNY3ZZUDOK7KqVODO5ataul1+9oq7+Z517Bs4+70y8+4L/iNVrV2HLRedX7bd4SQe+/8Ob8dlr/gzZTCkk/Wv/64vYsGHtTIdsGA3BN4aCCkB4qLI2L4YYRBVtIUiMA7v/ffy41ihiwaln3fMGeREmxoh5lwpr1qzAI888PB7/8d0ffBtRlU8iTAXs2vPLcqsAAuPS92zBb564DwAQGd+6LZavX7o/ERCjIApqBM0k4zVWhWTQbZqlsnB627Hxz10dbeIY7ZNtF432q9D+AF4W7+4Q7aGV8jkUleASGpK/E6FuGTOj1ala+ojfcL2X8770vVm9ny09DMNw4psZhXESs3YtcHBqWdi21zr4bz+djdEIjqIZn6QrZv26Jxu+NhRFlDwhT8bAMGaGOzHGScLBgwBP7bvW2vbLeULOAffSQ6e+m7D02Lsf23n2jc/JiG8MRTEIZFsrv0yFVAgHU8NYNJhCKJFAIFI7h4RGx1ewx5NCJ57RiWkC+rgeq+pfhE5so49LmBk9fTlEgqX/ZdsCMh5jpChzci5W7uA9xWHRXh6paBhLW+Wx19aq3KNvyH9NSfgbr27Qv0yOvaVLahApdVzHuSSVodhevB8gGl/vu3wT5pKZakMT8nh85uIZj0lcb1avNsv87wO78SUAa5paEA2rwCz1j3mC45TDGIhjcBgKZSn08aAyBfp4CDouhREJHsSixN9OOibD8BO+NhQD+Rxu3vscAOCsjTJqdElM/s+5ofm4aIfVzkRGz0s9pNWxlqCM1syx/B+9LTgq2qeG++T5AXl8bbhf9reAMWOBYbsehmE48c2MgopAaLSyBMgX5XLg9f6kaAfadULbxaK9LCp9D7yzgryq69GkfDCOZKXvgV5aRANqbVyUfg865L2glj39RTnbSShzHSX5WjKqf2TCUqbSblI1RhCUz2lwvaqFceUW0f7tAzdiPqlnbe6t+1KNpKphwhfLfKHpddIPQ6PvPZ8+JTO9tvYB0XEwM8VmFIZhODFDYRiGE98sPYI5IHGoMl1KOxJUp3Jyut+nthj1FmY8VInyzCtxcjA/9XMBYKQgSwwOqXsvDcltuCHlch2HvF6G5XIhzXKpMcRyqdFflOnuAp6lRyIsr633dnXJEZ0eTqd91y7Vsz39rme6r0sAunjkiZtE27V0cY3tzYzNKAzDcGKGwjAMJ2YoDMNw4huNgkn66od7pY6QWySHmspKjaI9Kv36UwV5fChf0RW052SL0iD0dqnWNIaVRjGitkeTKrVdc0BeP1WU1+9ieTyqnEhTajs3xfJ+3Z46B8dHWsSxQJPUO3TyO+32HBqS59NeefZ8h6F776e3APOL5Vh1LIemXo1jIbHtFZnicII7+n0zu77NKAzDcGKGwjAMJ2YoDMNw4huNIpBjxI9VIkCHV0ldIN0v09C3xWXg1UC2ti+EV5eIBuW6vSctQ7G1G3REBZi1hOW6vi0sx3IsJ13AY6TcqtVTXxGUAW6HlQaig9J68tKPIlOc/DUW8/L/At01mJV6TXqZvHdMuUFr3wSX3wVQSkYztmau101aX7/WWPS1Gp3W72TCZhSGYTgxQ2EYhpO6DQUR3U1Ex4lo9yTH24noQSLaRURPE9HZMx+mYRiNZDoaxf8B8HcA7p3k+J8D2MnMHyKiTQBuB/Be10UDOUbsWMWfIJiJ1+gN9A7I48VWqUmEgzLjVa4w9WQxmZB8LM1hmZpuOCfX8cdI7ue3dUjN4kReHg+T1Dy0hvFaTobMjxTl/X6fWina+4cr/QfTsi9y8v+C+GGpSRQi8rnF+mTsR75F6jE6XuIRtX+v0TqB1hzq0Sz0vV2p6xZS+n2/U/eMgpkfA9Bbo8uZAH5V7vsygLVEtGx6wzMMww/MhUbxPICrAICItgBYA2BltY5EdC0RdRJRZy6XmoOhGIYxG8yFobgFQDsR7QTwJQDPAdB+xAAAZr6TmTcz8+ZwuPZSwzCMxjHrfhTMPAjg0wBApbz1B8p/akL5gvDVj/ZKwzF6ilxL5zNy6Ll8bQ0ik6v0DwV1MTmJTl33WrdMoba4Vc5+Tk0MiLZO1jtUlD4g/YVm0dYahD5+ILNEtI9lWkX7kCdN4MCAPBcqpWC0X2oUubjSKA7IVaUzhsBBcMN6YM/keoG+nk5f986rbq2MTZ2r63zkm1WKw4eermusJxOz7TMy6zMKIkoSjRfP/ByAx8rGwzCMBUrdMwoiug/ApQAWE1EXgK+jHJLIzHcAOAPAvURUAPAigM/O2mgNw2gIdRsKZv644/gOABumPSLDMHyHb2I9itGQSKeuwh0QyMpVEiekPjqakbqALhuYSlVWuK0tMl/ESFrmd9A+F4GAvJbOZ6HjSvYNSz+Ixe0yT0JXdpFot4XkeI5kk6L9xqhs7xuQ5/d3V2I/Qifkc4j2y7GFMnnVRk1m4vcAlDUO+vYErWMM7Ruhc0Z4I3j6PynL5EWHpNakNQmtYbyZmODvouJi6sVcuA3DcGKGwjAMJ2YoDMNwQqxLdTeIVurgC6kSEtKryrZnknKtPfwW5QsRl2vveJuMtxhJVUQPUjkpAwEZ31BUOSrDEXltnQsjHpGxICvi/aLdEdE5NGX/RFAKBbuGVoj23l6pefT1yXwUzS9W9Jdon3yfz/39l0Vbaw4676RGawbaz2FKa1+i8ZLwXr+Iaox2SH3IWxov1qf0lSFVD0Xn0jhWW4B55ImbxNhOdojoWWaelnBjMwrDMJyYoTAMw4kZCsMwnPjGj8JFtk39QEkUXFAaRp+MeQiEKycEQrVjPaD8JDKj0jehO6fiSpIy52VRxRxoPwtdF2T/iNQgdL6LgUEZ9xI4Lv0+vLg0icn8GaaKKyeE1jAA4BHPeQlVe6PnIpmBoKlXvpuBNZ4YnYx8rrEDqo6H0ih0Lo3wLzsnjM2YGjajMAzDiRkKwzCcmKEwDMOJbzQKikYQXFPJWdDSJffIh1fJdXl4UNq4bLPSHZSvRGtrxfdhcFDWACFtLpVGEY4qH40muT+v/Si0xtAaTsv+ym8iRNKP440BKcgUUvI1JY7LAbcclOeLc1WdjZnWutB+Fa46HNpPY/gsqceMLiHVlt/VW9a1+xx5LNMi9Q1do0T7UbyZ6nrMdk0Tm1EYhuHEDIVhGE7MUBiG4cQ3GoUmtUzugbMyabk2tS536AypkYpuEAzJc0nlm8gOST2kGJb9C1Gpn6Sysv/qRJ/sr/woerPSL6I3I30+8irWJPaGfBZak0i8XtFf6s0f4cK11r10q/TLyCsNYoyxOIxMi/RByalQEyXfIJeovJtCk3xP/aerfKC9Srv5idRT3kz4PmemYRgnH2YoDMNwYobCMAwnvtEoNpy9Ets6K+tdvfYthuU6vbdNrk8pLP0oihm1Fh726AhBudbVGgWUpsCqfueQ8sMItct796i6qdqPIhmW+Sz60vJ6w93y/BYV0qDx+jZsc6xN6127uvo/uk1qIlrTGMtzOaZN5FXZkbD6bqnVSj/yuLBonaqoQl7IEcIz274FbyZsRmEYhhMzFIZhODFDYRiGE99oFHt3dwkfAF1nsutS6dfPSlfgrKrFEVWaxXBF4wjEZOxGUeeXULktqEleqzkhN/uTTVKDiAWln0W2KK+/d1DWEh0ckd82OCj7F9TD8PpNAAtrrR0/Jp/l0S3yu5IqZ11Ien6g4nd4RJ47ulz+v6frnVaLe9mOinaxkJ6jC4v1MAxj3jFDYRiGEzMUhmE48Y1Gof0odG7G0KhcoOZlaQsEhlQeg6i0geSp+6FjPTQ8Kte+2o8ik5Y+HX0h6QcRD8v8FJrBrMxXkcvKsQey8rsmDk297kSjfQWq3u/e/45n7inl8rzgc98Vh3Rt1NTZKthjxPNstP9LUj7nYLd8DycukbrWs9XyhRKdVNrEXGEzCsMwnJihMAzDiRkKwzCc+Eaj2PPsfrG+Tl+5RRwPSNcEUFGubYNKwyi2TK5D5NLya5PSN0JLpF9EbkBqCkV172hYbv73jMqAhoLKL5HNSw0kn5H3V2ErSP5oh2jXWlP7bb2tfRXaVd2PY1tUzZITMoDDG99RjKp3Oizfi44bKUopqWoujpPVj8LyURiGMe/UbSiIaCsRvUJErxLRVyfpcykR7SSiF4joNzMfpmEYjaSupQcRBQHcDuByAF0AniGinzHzi54+SQDfB7CVmV8noqWzMVAdYhztkT8YXa+21VSYObzuvsolm+OyrZcaULuTXndwAOgOyHxui9vlHHggJbft8splXLsix06oFPZqGTbbZQIbSfyoXE5kk/K95uOVh19MyBdRVKUhCzF5brRf3kuXO9SlB4zJqXdGsQXAq8y8n5mzAH4M4IOqzycAPMDMrwMAMx+f+TANw2gk9RqKFQAOedpd5Z952QignYgeJaJnieiamQzQMIzGU++uB1X5mXYbDAG4AMB7ATQB2EFETzLzngkXI7oWwLUAEEOzPmwYhk+o11B0AVjlaa8EcLhKn25mTgFIEdFjAM4DMMFQMPOdAO4EgLbYcvaWFNTl4Bapc/vXq6ErTSKQlpOlYouKX/b2HZTXCi6XYdy5lNQkKCLX1Xq7NJWRW3wRtX2aHlQaiDK/obS0vYkXukV7IWkS24v3CzdpvUWZgNQNUsvldmne28ypB6XeQ3qJbIdSyo2/WjlEc+GeEvUuPZ4BsIGI1hFRBMDHAPxM9flnAJcQUYiImgFcCOClmQ/VMIxGUdeMgpnzRPRFAP8GIAjgbmZ+gYg+Xz5+BzO/RETbAOwCUARwFzPvnu2BG4Yxf9TtmcnMDwN4WP3sDtW+FcCtMxuaYRh+wTcu3BwKIr+4ZdLj+ahjlaS8eye4+3pS5wVUmHmxSV6bdWo8dWud3p9V6jydGm9gVKW6a5KaBfWo9P8j8n61nstCw6UH6PQCRy+uiBSjS1XaPJbtyIB8D1rr0f4oxtQxF27DMJyYoTAMw4kZCsMwnPhGo9i46RQ88sRN4229Vh1aI21aTm63I9yvSgiqMn/eUPJipHZqOa1hBFTcN6uSg8GI1BxSWel30RyVKdt0SUJuVaUFwkojeROhfR2iZ1w8/plDKh2ifIwT4oGyquxk/Fjtezc6jaCfsRmFYRhOzFAYhuHEDIVhGE58o1HoVHg6+izmWasCQPMReXxwvVq/qviLquFsZQJxmWcvQFLDKORV3IhKpdeyTMaGBJWfRVtU+lVkkvL8voKsPZBaIY+3v4kc4LUu4NWqBk6TgYPxY/K9DayT2pBOn6jjh1z3NirYjMIwDCdmKAzDcGKGwjAMJ77RKDZesB7bOytrxEu3ypwLTb3S16DnTDn0bFIHe6gbtHkWrCmVf0L5TeSGZT4Jisp7J5fKnJjar2Jxc0q0IwF5/tLEsGiPpOX9cnHZ1mtz7WPi9T852Qh1e561eg49Z8jnlOmQ5zapJIzDq5XjhTFlbEZhGIYTMxSGYTgxQ2EYhhPfaBSa0JDcBO/bIIM7IgOyf3qJbFNelRgc8XxV5VORG5X77+GEjM0I6Rp/imSz9KNojUi/iaLSMIpqAMmEPP/4crn2HlY5NothuVavVipvjIXuG+DNxREdku8hmJX/z8V6VQxOtnZMz9bTv4JtqNRJWUi5SOcbm1EYhuHEDIVhGE7MUBiG4cQ3GoWO9ci/f3PN/tk22Q6omg95leMBHl8JCsm1KwWlH4XOidkWlxpCoSjta5vSJNY094p2b1bqK+e2viHah5raRVtXxDyWT8r77ZOvzVtT82TzqfDmp4ip2qHaL8KlSWgKe/eLvy0fxeTYjMIwDCdmKAzDcGKGwjAMJ77RKCgagbf26GiztGGhUbn+HFon27rOZKFJahYUr2gWOrYjEpU5L8PB2jkym8PSx6M1IjUMzVkJqUkkg7JwRyIoNY58UebMzOZlu+ccGdSQi1f8Khb6OruWT4imEJHvJd0h220HVS7TZfI5PnkS1x6d7d8Dm1EYhuHEDIVhGE7MUBiG4cQ3GgVnsuP72QCAsxbX7K81icxSuR7V8RzhSEV3KKg1f6Egr5WIydyKTUqT0H4Ty6IyP8W66AnRXhKSxxcFZT6KdEjGmsRI3q8jIvNb/Ev6bNHOnqjEQwQ3rMdCRq+la2kW2m9i2dNS++k5V8bE6Jqulwc+iu2ee5yMWsVsYTMKwzCcmKEwDMOJGQrDMJz4RqMoJpsx+p4tkx7PJKXoUGhSfv1hFa+h2qFQoepnAIhFpCYQCshz42GZn6I9Khe7YSrUbCeDUmNYExoU7ZwSVDqUhqE5c/lR0X7unEq+inx8ec1zFxpezaWg6pLGWmQ8UN8ZUpPQdT3aXpXvbftJ7Ecx29/JZhSGYTipy1BQiduI6FUi2kVE59fo900i2kNELxHR9bMzXMMwGkG9S4//AGBD+c+FAP6+/LfmvwBYBWATMxeJaOlMBmkYRmOp11B8EMC9zMwAniSiJBGdwsyqEii+AOATzFwEAGY+ri+kCeRY1IbUtSwKMdm/eKr0ZSBVazSs4jfisYrOoGM3Qiq2Q2sSy2LSD0L7NTQHZf8gSY0jGVC1SZWPRwxSb0mG5PVysUOi/XrLItHuXlWpXXooK5OHXvC574r2s3d9WbT9FhtSy2+CVT4KjdaxijL1KJp6Ze5R86OYOvVqFCsAeH9ru8o/07wFwNVE1ElEvyCiDdMdoGEYjadeQ1GtJni1tEJRAGlm3gzghwDurnoxomvLxqQzl0tV62IYhg9wGgoiuo6IdhLRTgCHUdIexlhZ/pmmC8A/lT8/CODcatdm5juZeTMzbw6H49W6GIbhA5waBTPfDuB2ACCiDwD4IhH9GCURc6CKPgEADwG4DKWZxLsB7Kl3YLqGQ/dSlZ9C1drQ8RrRqNxED3p8I4IkJ0GtUal3dCg/iVRBLnZDeXnvgLpeQBU+HSpKgSUZkBpER1C+hoLWLAIy9uSsZpnf4khbJYHosUUt4li2JSHab/uC1CyWzXNsiNYgdGyKbnvremh07VHlvoK8KjU62iFjfHDlFuDBn2L0yi1Vx2aaRYV6lx4PA9gP4FWUlhT/bewAET1MRKeWm7cA+DAR/R7AXwH43CyM1TCMBlHXrkd5t+O6SY5d4fncD+ADMxqZYRi+wTwzDcNw4ptYD8oXEOqu+Cv0vEeKm0XlF5EdkHviTR3SVyGvck60tlTW+aN5mf+hd1T6bOjji2K1d2RGC+Gax1Ms19JplmMb4dq1TbU9jyvNoiNcGV8kIp/T4Omyve4hqZ+IHCCY+3V6vdfzjienar1kk7JvSKUubXtVaj2jS+Sm3ZLHuwEAiRdKf8PHuTzqfS9j9VTHmGldVZtRGIbhxAyFYRhOfLP04FBQbIW17ZNT5HyznK7nVsvpt0aHjvelK3tlEeWyTWp7M1eQ99Lp80+k5ZZjIizH0pWVLtaaAkv73F+UYeVxlQqvpyiXRkdzsp5if65yXH8XRORzPH6+XAYthZzOP7pNTlnnGz1l9m6XqqhxRPplu6C2QzXhlHw26XUdwJ7y32j8d6+Fa6kx10tGm1EYhuHEDIVhGE7MUBiG4YRKPlSNp5U6+EJ673j7ja/+Qc3+qY3SDTqakDpBSJUNLHrC0IsqJL1JuXvrdb4OS29rki7fKxP9oh0PybEkw3LfbllYpsLTJQU1maLcfu3OS43kye51459PpOS2ct8bUs/o2Cn1lvgxqdeMbxWWmem2GgCACJji75lea3tDy3X6/WybCitXiltkQLZb3pBbxb994Ma6xrbQIaJny4GadWMzCsMwnJihMAzDiRkKwzCc+MaPQrPiln8X7de/LjWLpgPSH2B0hbR5xaRc93vLCBZH5NfOBKQ7OIK116ypmOzfNyI38FtUScL1bXLdP5SXYefaBTyuUusdHm0V7axajL962JP+rluOLXFEPpeslCzQdkBqOVqTmOv9ee03odPdeVPwpxdJTUJrEGlVhVJ/19FRqc9YKrypYzMKwzCcmKEwDMOJGQrDMJz4RqPYeMF6bO+srBH12jVxSOoGqRVyvRocljYvF1a52gue/sqPIjAi165FFR+BJulrkM+p/jF5vZGs1Bxe6pFl/tI5+dhPbZV+FZmCPD6YlrpDf5/0lQgdrhwPD6lQ6p1S70gtk2OLHegVbVeqOo1Lw9A6gMZ1/abeyrNPL5bPRWsQKoQGyzrldw8NqfSIG9YDe9xjMGxGYRjGFDBDYRiGEzMUhmE48Y1GseflI3jfO24eb+uBedeqAJBt0T2kzeMhlX7ulIqff6RbagyFmNQ/gir1P2dkOzgqdYBUQq77OSY1jkCzjDEopuX99w5JvwpWfh5afwnlVKzK0Uq77aC8V/iXnaIdV+nkdCo8jfar0NpRvWg/iXSLfHbpdvndc/HKd4sMyPeUaa/tV6H1mGizeo4tYZGPwpgcm1EYhuHEDIVhGE7MUBiG4cQ3GgVSo6Adz1fajr3tyJCOx5Dr1ZwMj0DsSOWrtu5XuRM7VJyICv1oPiL7D6+S9+KQPJ+UphB/Q66VBzZJvSXyhtRTotK1ASq7P4IqXag3z0JoRPmAKLTfxLYqfg+1cGkarvNd4xlYt0y0vRqFznmpKjNOKCmo0nig6aGnq45B6zhjWInBCjajMAzDiRkKwzCcmKEwDMOJfzQKhV4LJ9TxmKcGCCDzFgDAopdUXY8NKvbDQ/yoXNcPrZH2U5eiC6kKg4WoPB4/rPf7Zf9gSl6/6bg83tQtxxPKyLZea3t9E7xlGQFM0HpcOTBd6/BqsRz1kFd+EyGZqgMBVbwj7wlroYJ8zlqT0Cx5/Jhoaz2mdBGa9Du/mTUJjc0oDMNwYobCMAwnZigMw3Dim7oemzdv5s7O6vvZgDvGoOciuf+udQXvejYgwyHQvlduyGs9Qx/X8QiaQkTVmwhP0nHs+i+NiLZex2tfA5cvg5f5XmdX0yy2809xOX2kav/RK7eIdu8m+WzJI88UdGpT5U+itaPIoPzdTv5ohxxX8X6r6zFFbEZhGIYTMxSGYTipy1AQ0SYi2kFEGSK6oUa/y4jod0S0m4juISLfbsMahuGm3n/AvQCuB3DlZB2IKADgHgDvZeY9RPQNAJ8C8A/THSTgrjexSPXXOQa86/y88sHQNHXLx6I1AmDya1e7t86LoHnkiZtE+51X3SrarpwQs1IfdJaoqol4fBUu+vh3xCHtI9Kq6oz0nFPRe6K9UvvRsR+a+DHplGF+EdOnrhkFMx9n5mcA5Gp0WwQgw8x7yu3tAD48zfEZhuED5kKj6AYQJqIxdfUjAFZV60hE1xJRJxF1njhxYg6GYhjGbDDrhoJL+60fA/A9InoawBCA/CR972Tmzcy8ecmSJdW6GIbhA5waBRFdB+CPys0rmPmw6xxm3gHgkvL57wewcSaDBGae52D4rEphytgxuQE/cJqME2l7Vfo1aB8NfVxrEhPqRyi/i1iftJtac9BxLBo/aRKunA3ve8fNeKT8NwAkVSyK970AEzWLaG/l2RVkalFE+2Vbaxb6d8CbkxUAaMfzNWuPWj6KCs4ZBTPfzsxvLf9xGgkAIKKl5b+jAL4C4I6ZDdMwjEZS7/bociLqAvBlADcRURcRtZaPPUxEp5a73khELwHYBeBfmPnXszpqwzDmlbq2R5n5KICVkxy7wvP5RgA3zmxohmH4hQXrCJVT9Smg8h7qGAKvLiFycwKILpN9tWah9+N1zoe+M6SG0dIlh6Y1Ca1huHxENH5aO7vuPfasxv7WcSpajzn8bllXNdpX0R0KqsZrtkW2802ynVRj0e99LNbD8lG4MRduwzCcmKEwDMOJGQrDMJwsWI1C75HnVU1LnVfSu97U++n5qKrroUIztKag19naVUwf7//kxaLdpq7nyrXhJ02iXra98i2Avj2p74f+bvHT5LPSeUW86HonTSr3qfZvebSKFlTLj8KoYDMKwzCcmKEwDMOJGQrDMJwsGI3C5YcfgqxfoTULb46H/OomeW5G1+uU9jO9TCZrDCkfDh1zH1K+AS4/DK1pnExr5a2nfwXb4NZhxshLFxYs3l3JV6pzmRbVb6/LX0Xj8qMwKtiMwjAMJ2YoDMNwYobCMAwnvtUo6s0/offpz/nT74n2sqcrRR903YyhlbLdcbes/zB09UWiPdohN/CbemURzIF1cqG9+Afyeroe6IS4FQcLya9iTH+ZrBZJUD2LaL/MKdF9dkWXyMswkAl1SnW9lYTSKBbSc/MbNqMwDMOJGQrDMJz4pqRgK3XwhfTe8bZrO9SFDjP3ol229faoXlroFGuji+X5S34na9nppY1GT5GTvzsu2q6SgQtuyuwp26fd5zV9Z8hlWyY5uQu3LinY1C3fo94ufXRblS1aKyk4JWxGYRiGEzMUhmE4MUNhGIYT32yPbrxgPbZ3Tn3tzcpF28XQispXbXlDrl1Ty6QmEZLZ+CdoCKPvXy7aJ86X+3ahUbnm1Sna9Fpap6xPyNv7Kj3/TNH6jdYNzr5Bbmtzrd9QpVEMr5D/7z15n7y2bY9OH5tRGIbhxAyFYRhOzFAYhuHEN34UbbHlfPGaT016XK/jta6gKYZItSufc62yb0i6QUzwm9Dk4vLautSdTtGm0fv/LQelZqE1Ec1C0iwuD3wU2/mnuJw+AqB+/5gjX/6D8c/pJfK9tLwm+2r378Tro6JdVR8xP4opYTMKwzCcmKEwDMOJGQrDMJz4RqPYvHkzd3ZWygJe9PHviOM6vmJ4lRx3aFTqBqxMYCFa6R+QbhQID6tSdW21n0kgq/q3yzDzUErePB9XMQgnpIiRTcrjS2WlAbT85Mma4/G9P4BHB6g3Zuf4dRWNQoeZZ9rle2rbK4/r8H9dwgFATf1kIVPNZ8Q0CsMw5hQzFIZhODFDYRiGE99oFDofhU6RduhDMr5i5FS5ri8mpPBAIfm9vF+ThmUAAeWl5kByaYtCQt6LckoPUfdGTtnfgBwLRVR5gKK8XqBb7ve3vyiPt78kg1G86f996WNRw1dBr6X1ez9xybLxzwOnqcuqxxgakc9pzf1Haw6rVO5w6mPzs4YxlbGaRmEYxpxihsIwDCd1GQoi+iAR7SKinUTUSUTvnKTfF4noVSJiIlpcrY9hGAuHevNR/ArAz5iZiehcAP8IYFOVfk8A+FcAj071wsX2OIb+sJIWX/vpjy5VmkRMtqOtMoAin5NfLRyp6AiFmNQUIlGVn6JflhwMhKVokWhJy7GwyjcRkWniYyF5/VxR2ufmsOx/MLxItHsiqpReWOaVbDtQO0enn9FraV160Jszs+mYPLcgX9MEzSKvSjvOdGx+Ro9V5yZ95ImbZnT9ugwFMw97mnEAVVUgZn4OAIgmT4xqGMbCoe4MV0T0IQB/BWApgA/M5OZEdC2AawEg0tw+k0sZfmbNmtLuwhTYpn/wnWq9Zgn6WmlshpO6DQUzPwjgQSJ6F4C/BPC+6d6cme8EcCcAJDpW+WOf1ph9Xnttyl310qPrP1W2xSdsWzuWHqc8rvIHKGY6HX8z4fSjIKLrAPxRuXkFMx/2HDsA4O3M3D3Jua8B2DzZcdX3BICDABYDcPb3CTbWucHGOjeczszTEm6cMwpmvh3A7QBARKcREZXFzPMBRAD0TOfGVe6zpHyPzuk6hcw3Nta5wcY6NxBRp7tXder1o/gwgN1EtBMl43E1l6ckRPQwEZ1a/nw9EXUBWAlgFxHdNd0BGobReOrd9fgWgKo+wsx8hefzbQBum9nQDMPwC370zLyz0QOoAxvr3GBjnRumPVbfBIUZhuFf/DijMAzDZ5ihMAzDSUMMxUILLiOiTUS0g4gyRHRDjX6XEdHviGg3Ed1DRPNe25VK3FZ+brvK29iT9fsmEe0hopeI6PoGjHUrEb1SHutXJ+lzafn35AUi+s18j7E8hruJ6DgR7Z7keDsRPVh+3k8T0dnzPUbPWGLlMTxffmZ/UaXPlH6fBcw8739QqsM7po+cC+DlSfq9DcBaAK8BWNyIsZbHsRTA2wF8E8ANk/QJADgEYGO5/Q0An23AWK8A8AsABOAiAE9N0u/TAO4FEBj7jvM8ziCAfQDWo+SP8zyAM1WfJIAXAaxuxBg943gXgPMB7J7k+K0Avl7+vAnArxoxzvL9CUCi/DkM4CkAF6k+zt9n/achMwpmHubyiOEILmPm1+ZtYJPAzMeZ+RkAuRrdFgHIMPOecns7Sn4n880HAdzLJZ4EkCSiU6r0+wKAbzBzESh9x/kcJIAtAF5l5v3MnAXwY5TG7uUTAB5g5tcbNEaU7/sYgN4aXc5EKbIazPwygLVEtKxG/zmj/N7HgjfD5T+s+kzl91nQMI2CiD5ERC8D+DmAzzRqHLNIN4AwEY156X0EwKoGjGMFSjObMbrKP9O8BcDV5aXfL4how7yMrsJUxrkRQDsRPUpEzxLRNfM2uvp4HsBVAEBEWwCsQcnZsCEQUbDsFHkcwHZmfmqm12yYoWDmB5l5E4ArUQouW9CUZ0gfA/A9InoawBCAfO2z5oRqYZrVZmxRAGkuuR//EMDdczqqiUxlnCEAF6AUpfyHAL5GRBvnemDT4BaUDNpOAF8C8Bwa8+4BAMxcYOa3omSstsyGZjJvhoKIriuLUjvHXL2B8WndW/yWCWuy8daCmXcw8yXMvAXAYwD2us6ZDbxjBXAYciazsvwzTReAfyp/fhAlrWg+6YJ7nF0AtjFzikuBhY8BOG+exjdlmHmQmT9d/sd5DYAlAA40dlQAM/ejlDxq60yvNW+GgplvZ+a3lh9mM5Wz2sx2cNls4R0veyJma0FES8t/RwF8BcAdcznGMdSzfQjANeVdjYsADDDzkSqnPQTgsvLndwPYU6XPXPIMgA1EtI6IIijNxn6m+vwzgEuIKEREzQAuBPDSPI/TCREly98BAD4H4DFmHmzQWJYQUbL8uQmlNBAvz/jCDVJmvwLgBQA7AewA8E7PsYcBnFr+fD1K/6vkUfrf5q4GjXd5eRyDAPrLn1urjPdWlH6RXwHwJw0aK6EUsLcPwO9RCvOv9myTKOlDvy+/g/MaMNYrUDJQ+wD8j/LPPg/g854+N6K087G7gc/0PgBHUBL/ugB81jtOABejNHt8GcADANobMc7yWM5Faemzq/zM/qd+rrV+nyf7Yy7chmE4Mc9MwzCcmKEwDMOJGQrDMJyYoTAMw4kZCsMwnJihMAzDiRkKwzCc/H/E4sxamMBXygAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Probability density of the boosted trajectory:\n",
    "\n",
    "a,b,c = np.histogram2d(dihedrals[:,0], dihedrals[:,1], bins=55)\n",
    "\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1)\n",
    "ax.imshow(np.log(a).T, origin='lower')\n",
    "\n",
    "\n",
    "# Create a Rectangle patch\n",
    "rect = patches.Rectangle((30,0),10,50,linewidth=1,edgecolor='r',facecolor='none', label='rare')\n",
    "\n",
    "# Add the patch to the Axes\n",
    "ax.add_patch(rect)\n",
    "ax.legend()\n",
    "\n",
    "num_ticks = 6\n",
    "_ =ax.set_xticks(np.linspace(0,55, num_ticks))\n",
    "_ = ax.set_xticklabels([str(i) for i in np.around(np.linspace(-np.pi, np.pi, num_ticks),1)])\n",
    "_ =ax.set_yticks(np.linspace(0,55, num_ticks))\n",
    "_ = ax.set_yticklabels([str(i) for i in np.around(np.linspace(-np.pi, np.pi, num_ticks),1)])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}