Simulate Rings.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0452d3d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting package metadata (current_repodata.json): ...working... done\n",
      "Solving environment: ...working... failed with initial frozen solve. Retrying with flexible solve.\n",
      "Solving environment: ...working... failed with repodata from current_repodata.json, will retry with next repodata source.\n",
      "Collecting package metadata (repodata.json): ...working... done\n",
      "Solving environment: ...working... done\n",
      "\n",
      "## Package Plan ##\n",
      "\n",
      "  environment location: C:\\Users\\SHEN\\anaconda3\\envs\\syde\n",
      "\n",
      "  added / updated specs:\n",
      "    - openmm\n",
      "\n",
      "\n",
      "The following packages will be downloaded:\n",
      "\n",
      "    package                    |            build\n",
      "    ---------------------------|-----------------\n",
      "    fftw-3.3.10                |nompi_h52fa85e_103         1.0 MB  conda-forge\n",
      "    khronos-opencl-icd-loader-2022.05.18|       h8d14728_0          80 KB  conda-forge\n",
      "    openmm-7.6.0               |   py39h6dc0912_0        10.5 MB  conda-forge\n",
      "    openssl-1.1.1q             |       h8ffe710_0         5.8 MB  conda-forge\n",
      "    python_abi-3.9             |           2_cp39           4 KB  conda-forge\n",
      "    ------------------------------------------------------------\n",
      "                                           Total:        17.3 MB\n",
      "\n",
      "The following NEW packages will be INSTALLED:\n",
      "\n",
      "  fftw               conda-forge/win-64::fftw-3.3.10-nompi_h52fa85e_103 None\n",
      "  khronos-opencl-ic~ conda-forge/win-64::khronos-opencl-icd-loader-2022.05.18-h8d14728_0 None\n",
      "  openmm             conda-forge/win-64::openmm-7.6.0-py39h6dc0912_0 None\n",
      "  python_abi         conda-forge/win-64::python_abi-3.9-2_cp39 None\n",
      "\n",
      "The following packages will be UPDATED:\n",
      "\n",
      "  ca-certificates    pkgs/main::ca-certificates-2022.10.11~ --> conda-forge::ca-certificates-2022.12.7-h5b45459_0 None\n",
      "  certifi            pkgs/main/win-64::certifi-2022.9.24-p~ --> conda-forge/noarch::certifi-2022.12.7-pyhd8ed1ab_0 None\n",
      "\n",
      "The following packages will be SUPERSEDED by a higher-priority channel:\n",
      "\n",
      "  openssl              pkgs/main::openssl-1.1.1s-h2bbff1b_0 --> conda-forge::openssl-1.1.1q-h8ffe710_0 None\n",
      "\n",
      "\n",
      "\n",
      "Downloading and Extracting Packages\n",
      "\n",
      "openmm-7.6.0         | 10.5 MB   |            |   0% \n",
      "openmm-7.6.0         | 10.5 MB   |            |   0% \n",
      "openmm-7.6.0         | 10.5 MB   | 7          |   8% \n",
      "openmm-7.6.0         | 10.5 MB   | ##1        |  22% \n",
      "openmm-7.6.0         | 10.5 MB   | ###6       |  36% \n",
      "openmm-7.6.0         | 10.5 MB   | ####9      |  50% \n",
      "openmm-7.6.0         | 10.5 MB   | ######8    |  68% \n",
      "openmm-7.6.0         | 10.5 MB   | ########4  |  85% \n",
      "openmm-7.6.0         | 10.5 MB   | ########## | 100% \n",
      "openmm-7.6.0         | 10.5 MB   | ########## | 100% \n",
      "\n",
      "python_abi-3.9       | 4 KB      |            |   0% \n",
      "python_abi-3.9       | 4 KB      | ########## | 100% \n",
      "\n",
      "fftw-3.3.10          | 1.0 MB    |            |   0% \n",
      "fftw-3.3.10          | 1.0 MB    | 6          |   6% \n",
      "fftw-3.3.10          | 1.0 MB    | ########## | 100% \n",
      "fftw-3.3.10          | 1.0 MB    | ########## | 100% \n",
      "\n",
      "khronos-opencl-icd-l | 80 KB     |            |   0% \n",
      "khronos-opencl-icd-l | 80 KB     | ########## | 100% \n",
      "khronos-opencl-icd-l | 80 KB     | ########## | 100% \n",
      "\n",
      "openssl-1.1.1q       | 5.8 MB    |            |   0% \n",
      "openssl-1.1.1q       | 5.8 MB    | #2         |  13% \n",
      "openssl-1.1.1q       | 5.8 MB    | ####8      |  49% \n",
      "openssl-1.1.1q       | 5.8 MB    | #######5   |  75% \n",
      "openssl-1.1.1q       | 5.8 MB    | ########## | 100% \n",
      "Preparing transaction: ...working... done\n",
      "Verifying transaction: ...working... done\n",
      "Executing transaction: ...working... done\n",
      "Retrieving notices: ...working... done\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "==> WARNING: A newer version of conda exists. <==\n",
      "  current version: 22.9.0\n",
      "  latest version: 23.3.1\n",
      "\n",
      "Please update conda by running\n",
      "\n",
      "    $ conda update -n base -c defaults conda\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "!conda install --yes --prefix {sys.prefix} -c conda-forge openmm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0be6b591",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "from matplotlib import pyplot as plt\n",
    "from openmm import app\n",
    "import openmm as mm\n",
    "from openmm import unit\n",
    "import sys\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ba59625e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reload(T = 50, gamma = 1/50, length = 10, dt = 0.1, skipSteps = 1, \n",
    "           f_pdb = \"pdb\", f_ff = \"forcefield\", srSize = 10):\n",
    "    fname = \"{}fs_{}ps_{}K_{}ss.xyz\".format(dt, length, T, skipSteps)\n",
    "    totSteps = int(length*1000/(skipSteps * dt))\n",
    "    print(\"totSteps\", totSteps)\n",
    "\n",
    "    a = np.loadtxt(fname)\n",
    "    nParticles = a.shape[-1]//3\n",
    "    a = a.reshape(totSteps+1, 3, nParticles)\n",
    "    print(a.shape)\n",
    "\n",
    "    return a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "69dd49a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclidean_distance(r1,r2):\n",
    "    d = np.sqrt(\n",
    "        np.sum(\n",
    "            np.square(r1-r2)\n",
    "        )\n",
    "    )\n",
    "    return d\n",
    "\n",
    "def find_closest_monomer(p_small,p_large):\n",
    "    n_small = np.shape(p_small)[0]\n",
    "    n_large = np.shape(p_large)[0]\n",
    "\n",
    "    distance_matrix = np.zeros((n_small,n_large))\n",
    "\n",
    "    # Calculate the distance from each unit of the smaller ring to each unit on \n",
    "    # the longer ring\n",
    "    for i in range(n_small):\n",
    "        for j in range(n_large):\n",
    "            r1 = p_small[i,:]\n",
    "            r2 = p_large[j,:]\n",
    "            distance_matrix[i,j]= euclidean_distance(r1,r2)\n",
    "\n",
    "    #Return the distance \n",
    "    closest_monomer_to_each_bead = np.argmin(distance_matrix,axis=1)\n",
    "    return closest_monomer_to_each_bead\n",
    "\n",
    "def calculate_circle_center_of_mass(ring):\n",
    "    return np.mean(ring,axis=0)\n",
    "\n",
    "def calculate_vector_magnitude(v):\n",
    "    return np.sqrt(np.sum(np.square(v)))\n",
    "\n",
    "def calculate_angular_displacement(position_time_tensor):\n",
    "\n",
    "\n",
    "    small_ring_carbon_indices=(0,10)\n",
    "    large_ring_carbon_indices=(10,210)\n",
    "    \n",
    "    #Extract the small ring positions\n",
    "    p_small = position_time_tensor[:,:,\n",
    "                    small_ring_carbon_indices[0]:small_ring_carbon_indices[1]]\n",
    "        \n",
    "    #Extract the large ring positions\n",
    "    p_large = position_time_tensor[:,:,\n",
    "                    large_ring_carbon_indices[0]:large_ring_carbon_indices[1]]\n",
    "    \n",
    "    # Find the closest monomer to each bead for the initial position, \n",
    "    # transposing just to give the matrix the right shape \n",
    "    initial_closest_monomers_to_each_bead = find_closest_monomer(\n",
    "        p_small[0,:,:].T,\n",
    "        p_large[0,:,:].T\n",
    "    )\n",
    "    \n",
    "    initial_index = int(np.mean(initial_closest_monomers_to_each_bead))\n",
    "    \n",
    "    nt = np.shape(position_time_tensor)[0]\n",
    "    angular_displacement = np.zeros(nt)    \n",
    "\n",
    "    # find the initial radius of the beads\n",
    "    theta = 2*np.pi/p_large.shape[-1]\n",
    "    \n",
    "    for i in range(nt):\n",
    "        # find the angle within the plane of r_s_CoM and r_l_CoM for each node\n",
    "        small_center = calculate_circle_center_of_mass(p_small[i,:,:].T)\n",
    "        #print(small_center)\n",
    "        # find the current monomer index\n",
    "        sm_mono_index = find_closest_monomer(np.array([small_center]), \n",
    "                                             p_large[i, :, :].T)\n",
    "        \n",
    "        # difference in index between init and current \n",
    "        delta = sm_mono_index - initial_index\n",
    "\n",
    "        # angular distance according to the initial monomer geometry\n",
    "        ang_disp = delta * theta\n",
    "\n",
    "        angular_displacement[i] = ang_disp\n",
    "        \n",
    "    return angular_displacement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d32f3d16",
   "metadata": {},
   "outputs": [],
   "source": [
    "def runSim(T = 50, gamma = 1/50, length = 10, dt = 0.1, skipSteps = 1, f_pdb = \"pdb\", \n",
    "           f_ff = \"forcefield\", srSize = 10):\n",
    "    \"\"\"\n",
    "    Function to run the openMM simulation (NVT) with given params and \n",
    "    pdb+forcefields\n",
    "\n",
    "    Saves a xyz file of a compressed 3d array. See the function reload() to get \n",
    "    an idea of how to load and manipulate the output array (and format the file \n",
    "    name). The final array should have dims defined by \n",
    "    [n_timesteps, 3 (xyz), n_particles]\n",
    "\n",
    "    parameters:\n",
    "    T: int\n",
    "        Temperature\n",
    "    gamma: float\n",
    "        Friction parameters for Langevin\n",
    "    len: float\n",
    "        Total length of the simulation in ps\n",
    "    dt: float\n",
    "        Size of the timesteps in ps\n",
    "    f_pdb: str\n",
    "        Name of the pdb file (excluding the file extension, which should \n",
    "        simply be .pdb)\n",
    "    f_ff: str\n",
    "        Name of the forcefield file (excluding the file extension, which should \n",
    "        simply be .xml)\n",
    "    srSize: int\n",
    "        Number of monomer units in the small ring\n",
    "    \"\"\"\n",
    "    # set up strings\n",
    "    # THE FOLLOWING FILE NAMES ARE PLACEHOLDERS: CHANGE WHEN POSSIBLE\n",
    "    path = os.getcwd()\n",
    "    pdbPath = os.path.join(path, \"pdb_files/{}.pdb\".format(f_pdb))\n",
    "    forcefieldPath = os.path.join(path, \"pdb_files/{}.xml\".format(f_ff))\n",
    "    \n",
    "    # output a little description so i dont forget what i ran 5 min ago\n",
    "    reminder =\"Now Running: dt = {}fs; length = {}ps; T = {}K; {} steps skipped\"\n",
    "    print(reminder.format(dt, length, T, skipSteps))\n",
    "\n",
    "    # set up params\n",
    "    kB = 1.38e-23\n",
    "    beta = 1./(kB * T) # needs kb\n",
    "    steps = int(length*1000/dt)\n",
    "    indSteps = int(length*1000/(dt*skipSteps))\n",
    "\n",
    "    # load external files for topo and PES\n",
    "    pdb = app.PDBFile(pdbPath)\n",
    "    topo = pdb.topology\n",
    "\n",
    "    # identify atoms in topology\n",
    "    particles = []\n",
    "    # future update maybe: collect residues to identify number of atoms/chain\n",
    "    # residues = []\n",
    "    for atom in topo.atoms():\n",
    "        particles.append(atom)\n",
    "        # residues.append(atom.residue)\n",
    "\n",
    "    # add bonds between the individual rings\n",
    "    c1 = particles[0:srSize]\n",
    "    c2 = particles[srSize:]\n",
    "    numParticles = len(particles)\n",
    "    # hy1 = particles[20:40]\n",
    "    # hy2 = particles[40:60]\n",
    "\n",
    "    # create arrays to store xyz coords in\n",
    "    # format is timestep:xyz:particle#\n",
    "    traj = np.zeros((indSteps+1, 3, numParticles))\n",
    "\n",
    "    for i, C in enumerate(c1):\n",
    "        topo.addBond(C, c1[i-1])\n",
    "        # topo.addBond(C, hy1[i])\n",
    "        # topo.addBond(C, hy2[i])\n",
    "    \n",
    "    for i, C in enumerate(c2):\n",
    "        topo.addBond(C, c2[i-1])\n",
    "        # topo.addBond(C, hy1[i])\n",
    "        # topo.addBond(C, hy2[i])\n",
    "\n",
    "    forcefield = app.ForceField(forcefieldPath)\n",
    "    unmatched_residues = forcefield.getUnmatchedResidues(topo)\n",
    "    print(\"unmatched residues\\n\", unmatched_residues)\n",
    "    nonbonded = app.NoCutoff\n",
    "\n",
    "    cutoff = 2**(1/6)*unit.nanometer\n",
    "\n",
    "    system = forcefield.createSystem(topo, nonbondedCutoff = cutoff,\n",
    "                                    constraints = None)\n",
    "    system.setDefaultPeriodicBoxVectors((200, 0, 0), \n",
    "                                        (0, 200, 0),\n",
    "                                        (0, 0, 200))\n",
    "\n",
    "    integrator = mm.LangevinIntegrator(T*unit.kelvin, gamma, \n",
    "                                       dt*unit.femtoseconds)\n",
    "\n",
    "    platform = mm.Platform.getPlatformByName('CUDA')\n",
    "    simulation = app.Simulation(topo, system, integrator, platform)\n",
    "    simulation.context.setPositions(pdb.positions)\n",
    "    simulation.context.computeVirtualSites()\n",
    "    simulation.context.setVelocitiesToTemperature(T*unit.kelvin)\n",
    "\n",
    "    # equilibration step\n",
    "    # simulation.step(1000)\n",
    "\n",
    "    # save initial steps\n",
    "    current = simulation.context.getState(getPositions = True)\n",
    "    positions = np.array(current.getPositions()/unit.nanometer)\n",
    "    traj[0, :, :] = positions.transpose()\n",
    "\n",
    "    for step in range(indSteps):\n",
    "        simulation.step(skipSteps)\n",
    "        # extract positions\n",
    "        current = simulation.context.getState(getPositions = True)\n",
    "        positions = np.array(current.getPositions()/unit.nanometer)\n",
    "        traj[step+1, :, :] = positions.transpose()\n",
    "\n",
    "    # save the trajectory as an xyz file\n",
    "    traj_r = traj.reshape(traj.shape[0], -1)\n",
    "    np.savetxt(\"{}fs_{}ps_{}K_{}ss.xyz\".format(dt, length, T, skipSteps), traj_r)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2857678",
   "metadata": {},
   "source": [
    "## Suggestions \n",
    "\n",
    "1. Change temperature to inverse of KB\n",
    "2. Add units back\n",
    "3. Remove virtual sites? \n",
    "4. Does it work with just a small ring? \n",
    "5. Look at positions at step zeros\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "b3c27a61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now Running: dt = 0.1fs; length = 37ps; T = 1K; 3700 steps skipped\n",
      "unmatched residues\n",
      " []\n"
     ]
    }
   ],
   "source": [
    "runSim(T = 1, gamma = 1, length = 37, dt = 0.1, skipSteps = 3700, \n",
    "           f_pdb = \"scaled_rings\", f_ff = \"unitary_ff\", srSize = 10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "268ccd6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\SHEN\\anaconda3\\python.exe: Error while finding module specification for 'openmm.testInstallation' (ModuleNotFoundError: No module named 'openmm')\n"
     ]
    }
   ],
   "source": [
    "!python -m openmm.testInstallation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "dd98e73c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "totSteps 100\n",
      "(101, 3, 210)\n"
     ]
    }
   ],
   "source": [
    "a = reload(T = 1, gamma = 1, length = 37, dt = 0.1, skipSteps = 3700, \n",
    "           f_pdb = \"scaled_rings\", f_ff = \"unitary_ff\", srSize = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "85af6932",
   "metadata": {},
   "outputs": [],
   "source": [
    "dis = calculate_angular_displacement(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "98672686",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff5388d7df0>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.arange(10001),dis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "13973408",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_mean_square_displacement(initial_closest_monomers_to_each_bead,current_closest_monomers_to_each_bead,mean_square_distance_particles_large):\n",
    "    #Calculating the mean square displacement\n",
    "    average_square_change_of_index = np.mean(\n",
    "        np.square(\n",
    "            current_closest_monomers_to_each_bead - initial_closest_monomers_to_each_bead\n",
    "        )\n",
    "    )\n",
    "    MSD = mean_square_distance_particles_large*average_square_change_of_index\n",
    "    return MSD\n",
    "\n",
    "def calculate_MSD(position_time_tensor,small_ring_carbon_indices,large_ring_carbon_indices):\n",
    "    \n",
    "    #Extract the small ring positions\n",
    "    p_small = position_time_tensor[:,:,small_ring_carbon_indices[0]:small_ring_carbon_indices[1]]\n",
    "        \n",
    "    #Extract the large ring positions\n",
    "\n",
    "    p_large = position_time_tensor[:,:,large_ring_carbon_indices[0]:large_ring_carbon_indices[1]]\n",
    "    \n",
    "    #Find the closest monomer to each bead for the initial position, transposing just to give the matrix the right shape \n",
    "    initial_closest_monomers_to_each_bead = find_closest_monomer(\n",
    "        p_small[0,:,:].T,\n",
    "        p_large[0,:,:].T\n",
    "    )\n",
    "    \n",
    "    nt = np.shape(position_time_tensor)[0]\n",
    "    mean_square_displacements = np.zeros(nt)\n",
    "    \n",
    "    #Calculating the MSD at each position, starting at 1\n",
    "    for i in range(1,nt):\n",
    "        #Finding the array of closest monomers of each bead of the large ring to the small ring\n",
    "        #This returns an array of monomer indices that is shape n_small x 1 \n",
    "        current_closest_monomers_to_each_bead = find_closest_monomer(\n",
    "            p_small[i,:,:].T,\n",
    "            p_large[i,:,:].T\n",
    "        ) \n",
    "        \n",
    "        #Calculating the mean square particle distance for particles in the large ring\n",
    "        #Can be replaced by r0 once this is standardized to speed calculation\n",
    "        #mean_square_particle_distances_large_ring = calculate_mean_square_particle_distance(\n",
    "        #    p_large[i,:,:].T\n",
    "        #)\n",
    "        mean_square_particle_distances_large_ring = 1#since reduced units and sigma = 1\n",
    "        \n",
    "        #Given the initial position, current position and particle distance, find displacement\n",
    "        mean_square_displacement = calculate_mean_square_displacement(\n",
    "            initial_closest_monomers_to_each_bead,\n",
    "            current_closest_monomers_to_each_bead,\n",
    "            mean_square_particle_distances_large_ring\n",
    "        )\n",
    "        mean_square_displacements[i]=mean_square_displacement\n",
    "    return mean_square_displacements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8c42396a",
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_square_displacements = calculate_MSD(a,(0,10),(10,210))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b790b9ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def autocorrelation(obs,dt_0,n_supplied=False):\n",
    "    mean_obs = np.mean(obs)\n",
    "    std_obs = np.std(obs)\n",
    "    if not n_supplied:\n",
    "        n = len(obs)\n",
    "    else:\n",
    "        n = n_supplied\n",
    "    C_obs = np.zeros(n)\n",
    "    dts = np.zeros(n)    \n",
    "    for i in range(0,n):\n",
    "        dts[i] = dt_0*i\n",
    "        C_obs_i_j = 0\n",
    "        for j in range(0,n-i):\n",
    "            C_obs_i_j += (obs[j] - mean_obs) *(obs[j+i] - mean_obs)\n",
    "        C_obs[i] = (1/(std_obs**2))*(1/(n - i ))*C_obs_i_j\n",
    "    return C_obs,dts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "812d34ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "C_MSD,dts = autocorrelation(mean_square_displacements,1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "045c7272",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'MSD Autocorrelation')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "skip_step = 3700\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(dts,C_MSD)\n",
    "plt.axhline(0,color=\"k\",linestyle ='dotted')\n",
    "plt.axvline(skip_step,color=\"k\",linestyle ='dotted')\n",
    "plt.title(f\"Autocorrelation of MSD, optimal skip step: {skip_step}\")\n",
    "plt.xlabel(\"Time Step Size\")\n",
    "plt.ylabel(\"MSD Autocorrelation\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e6753ee5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'MSD')"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.loglog(np.arange(101),mean_square_displacements)\n",
    "plt.title(\"Mean Square Displacement of Small ring around Large Ring\")\n",
    "plt.xlabel(\"Independent time step\")\n",
    "plt.ylabel(\"MSD\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "syde",
   "language": "python",
   "name": "syde"
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}