{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "from collections import defaultdict\n",
    "import copy\n",
    "from image_matrix_helper import compute_master_list, imshow_list, rgb_map\n",
    "import random\n",
    "import time\n",
    "\n",
    "nb_start = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hints at Non-Equilibrium Behavior\n",
    "\n",
    "In this notebook, we again simulate the systems presented in `search_and_combinatorics.ipynb`, but we do so in order to see how the number of correctly placed particles evolves towards its equilibrium value over the course of the simulation.\n",
    "\n",
    "We will use much of the code from that section so we copy it here without additional explanation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parameter function definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# helper function definitions\n",
    "gamma_func = lambda E0, Ev, T: 4*np.sqrt(2)*np.exp(E0/T)*(Ev/T)**(3/2)\n",
    "delta_func = lambda Del, T: np.exp(Del/T)\n",
    "phi_func = lambda x, z, gamma, delta: x*(1+ 1/(z*gamma))/(1-delta) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Microstate transitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## dissociation operator\n",
    "def trans_dissoc(free_objs, bound_objs):\n",
    "        \n",
    "        # indices of non-empty\n",
    "        indxs = [i for i, x in enumerate(bound_objs) if x != \"-\"]\n",
    "        \n",
    "        # random choice for bound object\n",
    "        random_indx = random.choice(indxs)\n",
    "\n",
    "        ## new state vector \n",
    "        free_objs_new = copy.deepcopy(free_objs)\n",
    "        bound_objs_new = copy.deepcopy(bound_objs)\n",
    "\n",
    "        # putting empty slot\n",
    "        bound_objs_new[random_indx] = '-'\n",
    "        # appending previously bound object to free objects\n",
    "        free_objs_new.append(bound_objs[random_indx])\n",
    "\n",
    "        return free_objs_new, bound_objs_new\n",
    "\n",
    "\n",
    "## association operator\n",
    "def trans_assoc(free_objs, bound_objs):\n",
    "    \n",
    "        # random element to associate\n",
    "        elem = random.choice(free_objs)\n",
    "\n",
    "        # indices of empty spaces\n",
    "        indxs = [i for i, x in enumerate(bound_objs) if x == \"-\"]  \n",
    "\n",
    "        # random choice for empty space\n",
    "        random_indx = random.choice(indxs)\n",
    "\n",
    "        ## new state vector \n",
    "        free_objs_new = copy.deepcopy(free_objs)\n",
    "        bound_objs_new = copy.deepcopy(bound_objs)    \n",
    "\n",
    "        ## state\n",
    "        free_objs_new.remove(elem)\n",
    "        bound_objs_new[random_indx] = elem      \n",
    "\n",
    "        return free_objs_new, bound_objs_new\n",
    "\n",
    "## permutation operator\n",
    "def trans_perm(free_objs, bound_objs):\n",
    "    \n",
    "    Ncomp = len(bound_objs)\n",
    "    i1 = int(random.choice(range(Ncomp)))\n",
    "    i2 = int(random.choice(range(Ncomp)))\n",
    "\n",
    "    ## new omega vector \n",
    "    bound_objs_new = copy.deepcopy(bound_objs)\n",
    "    bound_objs_new[i2] = bound_objs[i1]\n",
    "    bound_objs_new[i1] = bound_objs[i2]\n",
    "    \n",
    "    return free_objs, bound_objs_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logarithm of Botlzmann factor\n",
    "\n",
    "The logarithm of the Botlzmann factor for a microstate (i.e., the temperature normalized negative energy of the microstate) is defined as \n",
    "\n",
    "\\begin{equation}\n",
    "\\beta E(\\boldsymbol{k}, \\boldsymbol{m}) = \\sum_{i=1}^R(m_i \\ln \\delta_i + k_i \\ln \\gamma_i).\n",
    "\\label{eq:sim_en}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_boltz(free_objs, bound_objs, mstr_vec, deltas, gammas, name_key):\n",
    "    \n",
    "    elem_set = list(set(mstr_vec))\n",
    "    count_dict = dict()\n",
    "    for elem in elem_set:\n",
    "        count_dict[elem] = bound_objs.count(elem)\n",
    "\n",
    "    bind_log_factor = 0\n",
    "    for elem in elem_set:\n",
    "        key = name_key[elem]\n",
    "        bind_log_factor += count_dict[elem]*np.log(gammas[key])\n",
    "        \n",
    "        \n",
    "    corr_log_factor = 0\n",
    "    for j in range(len(bound_objs)):\n",
    "        if bound_objs[j] == mstr_vec[j]:\n",
    "            elem = bound_objs[j]\n",
    "            key = name_key[elem]\n",
    "            corr_log_factor+=np.log(deltas[key])        \n",
    "    \n",
    "    return bind_log_factor+corr_log_factor    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function to count the number of correctly bound particles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def m_calc(bound_objs, mstr_vec):\n",
    "    \n",
    "    num = 0\n",
    "    for k in range(len(mstr_vec)):\n",
    "        if mstr_vec[k] == bound_objs[k]:\n",
    "            num += 1\n",
    "    return num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Metropolis Hastings algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Metropolis Monte Carlo Algorithm \n",
    "\n",
    "## loads uniform random sampling \n",
    "runif = np.random.rand\n",
    "\n",
    "def met_assembly_grid(Niter, free_objs, bound_objs, mstr_vec, deltas, gammas, name_key, only_physical_trans = False):\n",
    "    '''\n",
    "    #################################################################\n",
    "    # function to sample using Metropolis \n",
    "    #  \n",
    "    # n_iter:  number of iterations\n",
    "    # initial_state: initial state for the start position for our chain\n",
    "    # gamma: energy cost for incorrect component\n",
    "    # temp: temperature \n",
    "    ##################################################################\n",
    "    '''\n",
    "    \n",
    "    # Initialize state values\n",
    "    free_objs_vals = [0]*(Niter+1)\n",
    "    bound_objs_vals = [0]*(Niter+1)\n",
    "    \n",
    "    # Set initial values\n",
    "    free_objs_vals[0] = free_objs[:]\n",
    "    bound_objs_vals[0] = bound_objs[:]\n",
    "        \n",
    "    # Initialize acceptance counts\n",
    "    # We can use this to tune our number of steps\n",
    "    accepted = 0\n",
    "    \n",
    "    # debugging code\n",
    "    debug_assoc, debug_dissoc, debug_perm = 0, 0, 0\n",
    "    \n",
    "    for i in range(Niter):\n",
    "    \n",
    "        # get current monomer and dimer states\n",
    "        current_free_objs = copy.deepcopy(free_objs_vals[i])\n",
    "        current_bound_objs = copy.deepcopy(bound_objs_vals[i])\n",
    "        \n",
    "        N_free = len(current_free_objs)\n",
    "        N_bound = len(current_bound_objs)-len(current_free_objs)\n",
    "        \n",
    "        u_trans = runif()\n",
    "        \n",
    "        # only allow for physical transitions\n",
    "        if only_physical_trans: \n",
    "            u1, u2 = 1/2, 1\n",
    "        # includes permutation transition\n",
    "        else:\n",
    "            u1, u2 = 1/3, 2/3\n",
    "        \n",
    "        if u_trans < u1: #first type of transition; monomer association \n",
    "            \n",
    "            if N_free < 1:\n",
    "                \n",
    "                log_alpha = np.log(1e-15) \n",
    "            \n",
    "            else:\n",
    "                # proposed new monomer and dimer states\n",
    "                new_free_objs, new_bound_objs = trans_assoc(current_free_objs, current_bound_objs)\n",
    "\n",
    "                # transition elements\n",
    "                log_init = log_boltz(current_free_objs, current_bound_objs, mstr_vec, deltas, gammas, name_key)\n",
    "                log_final = log_boltz(new_free_objs, new_bound_objs, mstr_vec, deltas, gammas, name_key)\n",
    "\n",
    "                # weight\n",
    "                num = N_free*N_free\n",
    "                den = N_bound+1\n",
    "\n",
    "                # Log-acceptance rate\n",
    "                log_alpha = log_final-log_init+np.log(num/den) \n",
    "            \n",
    "        elif u1 <= u_trans < u2: #second type of transition; bound monomer dissociation\n",
    "            \n",
    "            if N_bound <1:\n",
    "                \n",
    "                log_alpha = np.log(1e-15) \n",
    "                \n",
    "            else: \n",
    "                \n",
    "                # proposed new monomer and dimer states\n",
    "                new_free_objs, new_bound_objs = trans_dissoc(current_free_objs, current_bound_objs)\n",
    "\n",
    "                # transition elements\n",
    "                log_init = log_boltz(current_free_objs, current_bound_objs, mstr_vec, deltas, gammas, name_key)\n",
    "                log_final = log_boltz(new_free_objs, new_bound_objs, mstr_vec, deltas, gammas, name_key)\n",
    "\n",
    "                # weight\n",
    "                num = N_bound \n",
    "                den = (N_free+1)*(N_free+1)   \n",
    "\n",
    "                # Log-acceptance rate\n",
    "                log_alpha = log_final-log_init+np.log(num/den) \n",
    "            \n",
    "        elif u2 <= u_trans: #third type of transition; switching bounded elements\n",
    "            \n",
    "            if N_bound <2:\n",
    "                \n",
    "                log_alpha = np.log(1e-15) \n",
    "            \n",
    "            else:\n",
    "                \n",
    "                # proposed new monomer and dimer states\n",
    "                new_free_objs, new_bound_objs = trans_perm(current_free_objs, current_bound_objs)\n",
    "\n",
    "                # transition elements\n",
    "                log_init = log_boltz(current_free_objs, current_bound_objs, mstr_vec, deltas, gammas, name_key)\n",
    "                log_final = log_boltz(new_free_objs, new_bound_objs, mstr_vec, deltas, gammas, name_key)\n",
    "\n",
    "                # Log-acceptance rate\n",
    "                log_alpha = log_final-log_init\n",
    "            \n",
    "        # Sample a uniform random variate\n",
    "        u = runif()\n",
    "\n",
    "        # Test proposed value\n",
    "        if np.log(u) < log_alpha:\n",
    "            # Accept\n",
    "            free_objs_vals[i+1] = new_free_objs\n",
    "            bound_objs_vals[i+1] = new_bound_objs\n",
    "            \n",
    "            #log_current_prob = log_proposed_prob\n",
    "            accepted += 1\n",
    "        else:\n",
    "            # Stay put\n",
    "            free_objs_vals[i+1] = free_objs_vals[i]\n",
    "            bound_objs_vals[i+1] = bound_objs_vals[i]\n",
    "\n",
    "    # return our samples and the number of accepted steps\n",
    "    return free_objs_vals, bound_objs_vals, accepted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Image grid for completely correct configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# defining master_list\n",
    "master_list =compute_master_list()\n",
    "# testing plot\n",
    "imshow_list(master_list, title = 'Completely Correct Configuration');\n",
    "# defining Nelems\n",
    "Nelems = np.zeros(8)\n",
    "key_list = list(rgb_map.keys())[:-1]\n",
    "name_key_ = dict()\n",
    "for j in range(len(key_list)):\n",
    "    name_key_[key_list[j]] = j\n",
    "    Nelems[j] = master_list.count(key_list[j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9.,  9., 10.,  5.,  7.,  6.,  3., 51.])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# displaying copy-number counts of the various elements\n",
    "Nelems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simulating system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperature Run: 1 ; Current Time: 3.77 secs\n",
      "Temperature Run: 2 ; Current Time: 7.26 secs\n",
      "Temperature Run: 3 ; Current Time: 10.92 secs\n",
      "Temperature Run: 4 ; Current Time: 15.27 secs\n",
      "Temperature Run: 5 ; Current Time: 20.33 secs\n",
      "Temperature Run: 6 ; Current Time: 24.63 secs\n",
      "Temperature Run: 7 ; Current Time: 29.11 secs\n",
      "Temperature Run: 8 ; Current Time: 32.96 secs\n",
      "Temperature Run: 9 ; Current Time: 36.75 secs\n",
      "Temperature Run: 10 ; Current Time: 41.17 secs\n",
      "\n",
      "Total Simulation Run Time for Search Limited: 41.17 secs\n",
      "----------\n",
      "\n",
      "Temperature Run: 1 ; Current Time: 2.07 secs\n",
      "Temperature Run: 2 ; Current Time: 4.06 secs\n",
      "Temperature Run: 3 ; Current Time: 6.02 secs\n",
      "Temperature Run: 4 ; Current Time: 8.54 secs\n",
      "Temperature Run: 5 ; Current Time: 10.64 secs\n",
      "Temperature Run: 6 ; Current Time: 12.97 secs\n",
      "Temperature Run: 7 ; Current Time: 14.92 secs\n",
      "Temperature Run: 8 ; Current Time: 16.97 secs\n",
      "Temperature Run: 9 ; Current Time: 19.03 secs\n",
      "Temperature Run: 10 ; Current Time: 21.1 secs\n",
      "\n",
      "Total Simulation Run Time for Combinatorics Limited: 21.1 secs\n",
      "----------\n",
      "\n",
      "Temperature Run: 1 ; Current Time: 2.9 secs\n",
      "Temperature Run: 2 ; Current Time: 5.13 secs\n",
      "Temperature Run: 3 ; Current Time: 7.3 secs\n",
      "Temperature Run: 4 ; Current Time: 9.52 secs\n",
      "Temperature Run: 5 ; Current Time: 11.68 secs\n",
      "Temperature Run: 6 ; Current Time: 13.88 secs\n",
      "Temperature Run: 7 ; Current Time: 16.02 secs\n",
      "Temperature Run: 8 ; Current Time: 18.37 secs\n",
      "Temperature Run: 9 ; Current Time: 20.5 secs\n",
      "Temperature Run: 10 ; Current Time: 22.7 secs\n",
      "\n",
      "Total Simulation Run Time for Indeterminate: 22.7 secs\n",
      "----------\n",
      "\n",
      "------------------------------\n",
      "------------------------------\n",
      "Total Simulation Run Time for Only Physical Trans = True: 84.98 secs\n",
      "Temperature Run: 1 ; Current Time: 4.43 secs\n",
      "Temperature Run: 2 ; Current Time: 8.98 secs\n",
      "Temperature Run: 3 ; Current Time: 13.4 secs\n",
      "Temperature Run: 4 ; Current Time: 18.18 secs\n",
      "Temperature Run: 5 ; Current Time: 22.89 secs\n",
      "Temperature Run: 6 ; Current Time: 27.97 secs\n",
      "Temperature Run: 7 ; Current Time: 33.13 secs\n",
      "Temperature Run: 8 ; Current Time: 37.85 secs\n",
      "Temperature Run: 9 ; Current Time: 42.39 secs\n",
      "Temperature Run: 10 ; Current Time: 46.76 secs\n",
      "\n",
      "Total Simulation Run Time for Search Limited: 46.76 secs\n",
      "----------\n",
      "\n",
      "Temperature Run: 1 ; Current Time: 3.67 secs\n",
      "Temperature Run: 2 ; Current Time: 7.15 secs\n",
      "Temperature Run: 3 ; Current Time: 10.9 secs\n",
      "Temperature Run: 4 ; Current Time: 14.87 secs\n",
      "Temperature Run: 5 ; Current Time: 18.39 secs\n",
      "Temperature Run: 6 ; Current Time: 21.97 secs\n",
      "Temperature Run: 7 ; Current Time: 25.6 secs\n",
      "Temperature Run: 8 ; Current Time: 29.24 secs\n",
      "Temperature Run: 9 ; Current Time: 32.66 secs\n",
      "Temperature Run: 10 ; Current Time: 36.52 secs\n",
      "\n",
      "Total Simulation Run Time for Combinatorics Limited: 36.52 secs\n",
      "----------\n",
      "\n",
      "Temperature Run: 1 ; Current Time: 3.38 secs\n",
      "Temperature Run: 2 ; Current Time: 6.6 secs\n",
      "Temperature Run: 3 ; Current Time: 9.91 secs\n",
      "Temperature Run: 4 ; Current Time: 13.37 secs\n",
      "Temperature Run: 5 ; Current Time: 16.7 secs\n",
      "Temperature Run: 6 ; Current Time: 19.94 secs\n",
      "Temperature Run: 7 ; Current Time: 23.57 secs\n",
      "Temperature Run: 8 ; Current Time: 26.86 secs\n",
      "Temperature Run: 9 ; Current Time: 30.28 secs\n",
      "Temperature Run: 10 ; Current Time: 34.22 secs\n",
      "\n",
      "Total Simulation Run Time for Indeterminate: 34.22 secs\n",
      "----------\n",
      "\n",
      "------------------------------\n",
      "------------------------------\n",
      "Total Simulation Run Time for Only Physical Trans = False: 202.48 secs\n",
      "------------------------------\n",
      "------------------------------\n",
      "Total Simulation Run Time for all: 202.48 secs\n"
     ]
    }
   ],
   "source": [
    "# whether to only include physical transitions\n",
    "only_physical_trans = True\n",
    "\n",
    "# starting time\n",
    "t0_start = time.time()\n",
    "\n",
    "# setting parameter dictionary\n",
    "param_dict = {'Search Limited': {'Del_bar':7.7501 , \n",
    "                                 'sigma_D':2.0, \n",
    "                                 'E0_bar':3.0, \n",
    "                                 'sigma_E':1.0},\n",
    "              'Combinatorics Limited':{'Del_bar': 4.75, \n",
    "                                 'sigma_D': 2.0, \n",
    "                                 'E0_bar': 16.0, \n",
    "                                 'sigma_E':3.0}, \n",
    "              'Indeterminate': {'Del_bar': 6.75, \n",
    "                                 'sigma_D': 2.0, \n",
    "                                 'E0_bar': 10.75, \n",
    "                                 'sigma_E': 3.0}, }\n",
    "\n",
    "\n",
    "# dictionary that contains both physical and unphysical transitions\n",
    "m_full_data_dict = defaultdict(dict) \n",
    "\n",
    "num_trajs = 10 # number of trajectories to plot for each data set\n",
    "\n",
    "for bool_ in [True, False]:\n",
    "    \n",
    "    # defining whether to include only physical transitions\n",
    "    only_physical_trans = bool_    \n",
    "\n",
    "    # empty list of list of trajectories\n",
    "    bound_list_dict = {'Search Limited': [[]]*num_trajs,\n",
    "                  'Combinatorics Limited':[[]]*num_trajs, \n",
    "                  'Indeterminate':[[]]*num_trajs }\n",
    "\n",
    "    # number of steps for MC algortihm\n",
    "    Nmc = 10000\n",
    "\n",
    "    # initial monomer and dimer states; \n",
    "    # system in microstate of all correct dimers\n",
    "    random.seed(0)\n",
    "    free_objs_0 = random.sample(master_list, len(master_list))\n",
    "    bound_objs_0 = ['-']*len(master_list) \n",
    "    mstr_vec = copy.deepcopy(master_list)\n",
    "\n",
    "    # make copy of initial monomer and dimer states \n",
    "    free_objs_copy = copy.deepcopy(free_objs_0)\n",
    "    bound_objs_copy = copy.deepcopy(bound_objs_0)\n",
    "\n",
    "    # temperature set    \n",
    "    T0 = 0.5\n",
    "\n",
    "    for type_ in list(bound_list_dict.keys()):\n",
    "\n",
    "        # start time for particular type\n",
    "        t0 = time.time()      \n",
    "\n",
    "        # getting parameter values\n",
    "        dict_vals = param_dict[type_]\n",
    "\n",
    "        # drawing energy values\n",
    "        np.random.seed(24)\n",
    "        R=8\n",
    "        Del_bar, sigma_D = dict_vals['Del_bar'], dict_vals['sigma_D']\n",
    "        Dels = np.random.randn(R)*sigma_D+Del_bar\n",
    "        E0_bar, sigma_E = dict_vals['E0_bar'], dict_vals['sigma_E']\n",
    "        E0s = np.random.randn(R)*sigma_E+E0_bar \n",
    "        Evs = np.ones(R)*0.001\n",
    "\n",
    "        # defining helper functions\n",
    "        gammas_ = gamma_func(E0s, Evs, T0)\n",
    "        deltas_ = delta_func(Dels, T0)  \n",
    "\n",
    "\n",
    "        for k in range(num_trajs):\n",
    "            # metroplois generator\n",
    "            _, bound_list_dict[type_][k], _ = met_assembly_grid(Nmc, \n",
    "                                                                free_objs_copy,\n",
    "                                                                bound_objs_copy,\n",
    "                                                                mstr_vec,\n",
    "                                                                deltas_,\n",
    "                                                                gammas_,\n",
    "                                                                name_key_, \n",
    "                                                               only_physical_trans=only_physical_trans) \n",
    "\n",
    "            t_prelim = time.time()\n",
    "            print(\"Temperature Run:\",str(k+1),\"; Current Time:\", round(t_prelim-t0,2),\"secs\")\n",
    "\n",
    "\n",
    "        t1 = time.time()\n",
    "        print(f\"\\nTotal Simulation Run Time for {type_}: {round(t1-t0,2)} secs\")\n",
    "        print(\"----------\\n\") \n",
    "\n",
    "    # copying data    \n",
    "    m_full_data_dict[only_physical_trans] = bound_list_dict\n",
    "    t2 = time.time()    \n",
    "    print(\"------------------------------\\n------------------------------\")   \n",
    "    print(f\"Total Simulation Run Time for Only Physical Trans = {only_physical_trans}: {round(t2-t0_start,2)} secs\")      \n",
    "\n",
    "\n",
    "t3 = time.time()    \n",
    "print(\"------------------------------\\n------------------------------\")   \n",
    "print(f\"Total Simulation Run Time for all: {round(t2-t0_start,2)} secs\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting simulated values of $m/N$ for each system type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary that contains both physical and unphysical transitions\n",
    "m_t_full_data_dict = defaultdict(dict) \n",
    "\n",
    "# dictionary for final values of m/N\n",
    "m_t_dict = {'Search Limited': [[]]*num_trajs,\n",
    "              'Combinatorics Limited':[[]]*num_trajs, \n",
    "              'Indeterminate':[[]]*num_trajs }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "for bool_ in [True, False]:\n",
    "    \n",
    "    # defining whether to include only physical transitions\n",
    "    only_physical_trans = bool_    \n",
    "    \n",
    "    # getting list of bound states\n",
    "    bound_list_dict = m_full_data_dict[only_physical_trans]\n",
    "\n",
    "    # dictionary for final values of m/N\n",
    "    m_t_dict = {'Search Limited': [[]]*num_trajs,\n",
    "                  'Combinatorics Limited':[[]]*num_trajs, \n",
    "                  'Indeterminate':[[]]*num_trajs }\n",
    "\n",
    "    # filling in dictionary values for m/N\n",
    "    for type_ in list(m_t_dict.keys()):\n",
    "        m_t_dict[type_] = [[m_calc(elem, master_list)/(len(master_list)) for elem in bound_list_dict[type_][k]] for k in range(num_trajs)]\n",
    "\n",
    "    # dictionary for values of m/N \n",
    "    m_t_full_data_dict[bool_] = m_t_dict  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Only Physical Transitions: True\n",
      "System Type: Search Limited\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Only Physical Transitions: True\n",
      "System Type: Combinatorics Limited\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Only Physical Transitions: True\n",
      "System Type: Indeterminate\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Only Physical Transitions: False\n",
      "System Type: Search Limited\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Only Physical Transitions: False\n",
      "System Type: Combinatorics Limited\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Only Physical Transitions: False\n",
      "System Type: Indeterminate\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for bool_ in [True, False]:\n",
    "    \n",
    "    # getting dictionary value for particular transition type\n",
    "    m_t_dict = m_t_full_data_dict[bool_]\n",
    "    \n",
    "    for type_ in list(m_t_dict.keys()):\n",
    "\n",
    "        plt.figure(figsize = (7,5))\n",
    "        ax = plt.subplot(111)\n",
    "\n",
    "        for k in range(num_trajs):\n",
    "            plt.plot(m_t_dict[type_][k])\n",
    "\n",
    "            # plot formatting\n",
    "            ax.set_xlabel(r'simulation time', fontsize = 18,labelpad=10)\n",
    "            plt.xlim([0, 10000])\n",
    "            plt.ylim([0,1.1])\n",
    "            plt.ylabel(r'$m/N$', fontsize = 18)\n",
    "            # plt.yaxis.set_label_coords(-0.1,.5)\n",
    "\n",
    "            ax.axhline(y = 1.0, color = 'k', linestyle = 'dashed', linewidth = 2)\n",
    "\n",
    "\n",
    "            # Hide the right and top spines\n",
    "            ax.spines['right'].set_visible(False)\n",
    "            ax.spines['top'].set_visible(False)\n",
    "\n",
    "            # Only show ticks on the left and bottom spines\n",
    "            ax.yaxis.set_ticks_position('left')\n",
    "            ax.xaxis.set_ticks_position('bottom')\n",
    "\n",
    "            # increase label size\n",
    "            ax.tick_params(axis='both', which='major', labelsize=12)\n",
    "            ax.tick_params(axis='both', which='minor', labelsize=12)    \n",
    "            # plt.legend(loc = 'best', fontsize = 12)\n",
    "\n",
    "        plt.grid(alpha = 0.45)  \n",
    "        type_name = type_.replace(' ', '_').lower()\n",
    "        print('Only Physical Transitions:', bool_)\n",
    "        print('System Type:', type_)\n",
    "        print()\n",
    "\n",
    "    #     if only_physical_trans:\n",
    "    #         suffix = 'phys'\n",
    "    #     else:\n",
    "    #         suffix = 'nonphys'\n",
    "    #     plt.savefig(f'hints_neqbm_{suffix}_{type_name}.png', bbox_inches='tight', format = 'png')\n",
    "\n",
    "        plt.show()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Notebook Runtime: 3.502 mins\n"
     ]
    }
   ],
   "source": [
    "print('Total Notebook Runtime: %.3f mins' % ((time.time()-nb_start)/60))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}