convert_playground.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from pytrr import GroTrrReader\n",
    "import pandas as pd\n",
    "from sklearn import utils\n",
    "from tqdm import trange\n",
    "import matplotlib.pyplot as plt\n",
    "import statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "energy_path = 'energy.xvg'\n",
    "trr_path = 'traj.trr'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_energy_colvar(colvar, frames):\n",
    "    with open('../WTE_1/COLVAR', 'r') as c:\n",
    "        c = c.readlines()\n",
    "    c = [l.rstrip('\\n') for l in c]\n",
    "    energy = []\n",
    "    for e in c[1:frames+1]:\n",
    "    #     print(e.split())\n",
    "        energy.append(e.split()[1])\n",
    "    energy = [float(e)*0.239006 for e in energy] #kj/mol to kcal/mol\n",
    "    energy = np.array(energy)\n",
    "#     print(energy)\n",
    "    return energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_energy_xvg(xvg, frames):\n",
    "    with open(xvg,'r') as e:\n",
    "        e = e.readlines()\n",
    "    e = [l.rstrip('\\n') for l in e]\n",
    "    del e[:2000]\n",
    "#     del e[:23]\n",
    "\n",
    "#     idx = len(e) - 1     #make idx file\n",
    "#     idx = np.arange(idx)\n",
    "#     np.random.shuffle(idx)\n",
    "#     np.savetxt('idx.txt', idx)\n",
    "\n",
    "    idx = np.loadtxt('idx.txt') #load idx file\n",
    "    idx = idx.astype(int)\n",
    "    e = np.array(e)\n",
    "    e = e[idx]   #shuffle\n",
    "    energy = []\n",
    "    for c in e[1:frames+1]:\n",
    "        energy.append(c.split()[1])\n",
    "    energy = [float(e)*0.239006 for e in energy] #kj/mol to kcal/mol\n",
    "    energy = np.array(energy)\n",
    "    print(energy.shape)\n",
    "    return energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_distribution(energy, traj, n_samples, discard, nmols, npzfile):\n",
    "    \"\"\"\n",
    "    inputs: energy_file, trr_file, \n",
    "            n_samples: no. of frames for the output file, \n",
    "            discard: number of frames to discard from the input file\n",
    "            nmols: number of molecules in the system\n",
    "            npzfile: file output name\n",
    "    \"\"\"\n",
    "    ener_og = np.loadtxt(energy)\n",
    "    ener_og = ener_og[discard:]\n",
    "    print('ener_og shape', ener_og.shape)\n",
    "    \n",
    "    (n, bins, patches) = plt.hist(ener_og[:,1], bins=50) #default bins = 50\n",
    "#     m = statistics.mean(ener_og[:,1])\n",
    "#     plt.axvline(m, color='black')\n",
    "\n",
    "#     sd = statistics.stdev(ener_og[:,1])\n",
    "\n",
    "#     plt.axvline(m + sd, color='red')\n",
    "#     plt.axvline(m - sd, color='red')\n",
    "\n",
    "#     plt.axvline(m + 2*sd, color='red')\n",
    "#     plt.axvline(m - 2*sd, color='red')\n",
    "\n",
    "#     plt.show()\n",
    "    bin_id = []\n",
    "    for ener in range(len(ener_og[:,1])):\n",
    "        for b in range(len(bins)):\n",
    "\n",
    "            if ener_og[:,1][ener] <= bins[b]:\n",
    "                bin_id.append((ener_og[:,1][ener],b))\n",
    "                break\n",
    "    tmp = np.array(bin_id)\n",
    "    tmp_dict = {}\n",
    "    for i in range(len(tmp)):\n",
    "        if int(tmp[i][1]) in tmp_dict:\n",
    "            tmp_dict[int(tmp[i][1])].append(i)\n",
    "        else:\n",
    "            tmp_dict[int(tmp[i][1])] = [i]\n",
    "            \n",
    "    sampled_bins = np.random.choice(np.arange(len(bins)), size=n_samples+100, replace=True)\n",
    "    sampled_frames = []\n",
    "    counter = 0\n",
    "    while len(sampled_frames) < n_samples:\n",
    "        bin_idx = sampled_bins[counter]\n",
    "        try:\n",
    "            frame_idxs = tmp_dict[bin_idx]\n",
    "            sel_frame_idx = np.random.choice(frame_idxs, size=1, replace=False)[0]\n",
    "            sampled_frames.append(sel_frame_idx)\n",
    "        except:\n",
    "            pass\n",
    "        counter += 1\n",
    "    plt.hist(ener_og[sampled_frames,1])\n",
    "    plt.show()\n",
    "    \n",
    "    np.savetxt('sampled_frames.txt', sampled_frames)\n",
    "    \n",
    "    energy = ener_og[sampled_frames,1]\n",
    "    energy = np.multiply(energy,0.239006) #kj/mol to kcal/mol\n",
    "    print('energy_final shape', energy.shape)\n",
    "    \n",
    "    fxyz = []\n",
    "    xyz = []\n",
    "    with GroTrrReader(traj) as trrfile:\n",
    "        for frame in trrfile:\n",
    "            frame_data = trrfile.get_data()\n",
    "            fxyz.append(frame_data['f'])\n",
    "            xyz.append(frame_data['x'])\n",
    "            \n",
    "    fxyz = fxyz[discard:]\n",
    "    xyz = xyz[discard:]\n",
    "    \n",
    "    fxyz = np.array(fxyz)\n",
    "    xyz = np.array(xyz)\n",
    "    \n",
    "    fxyz = fxyz[sampled_frames]\n",
    "    xyz = xyz[sampled_frames]\n",
    "    \n",
    "    fxyz = np.multiply(fxyz, 0.0239006) #kj/mol/nm to kcal/mol/A\n",
    "    xyz = np.multiply(xyz,10) #nm to A\n",
    "    print('fxyz_shape', fxyz.shape)\n",
    "    print('xyz shape', xyz.shape)\n",
    "    w_name = np.array(b'water_trr_xyz')\n",
    "    w_theory = np.array(b'')\n",
    "    w_type = np.array(b'd')\n",
    "    w_z = np.array([8,1,1]*nmols, dtype='uint8')\n",
    "    np.savez(npzfile, E=energy, R=xyz, F=fxyz, theory=w_theory, type=w_type, z=w_z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ener_og shape (8000, 2)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy_final shape (200,)\n",
      "fxyz_shape (200, 750, 3)\n",
      "xyz shape (200, 750, 3)\n"
     ]
    }
   ],
   "source": [
    "get_distribution('energy.xvg', 'traj.trr', 200, 2001, 250, 'test.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = np.load('test.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['E', 'R', 'F', 'theory', 'type', 'z']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file.files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_npz(traj, xvg, frames, npzfile, nmols):\n",
    "    fxyz = []\n",
    "    xyz = []\n",
    "    with GroTrrReader(traj) as trrfile:\n",
    "        for frame in trrfile:\n",
    "            frame_data = trrfile.get_data()\n",
    "            fxyz.append(frame_data['f'])\n",
    "            xyz.append(frame_data['x'])\n",
    "#             if len(xyz) > frames-1:\n",
    "#                 break\n",
    "    #removing 1ns frames\n",
    "    del fxyz[:2000]\n",
    "    del xyz[:2000]\n",
    "    \n",
    "    fxyz = np.array(fxyz)\n",
    "    xyz = np.array(xyz)\n",
    "    \n",
    "    \n",
    "    #shuffling\n",
    "    idx = np.loadtxt('idx.txt')\n",
    "    idx = idx.astype(int)\n",
    "    fxyz = fxyz[idx]\n",
    "    xyz = xyz[idx]\n",
    "    \n",
    "    \n",
    "    fxyz = fxyz[:frames]\n",
    "    xyz = xyz[:frames]\n",
    "    \n",
    "    fxyz = np.multiply(fxyz,0.0239006) #kj/mol/nm to kcal/mol/A\n",
    "    xyz = np.multiply(xyz,10) #nm to A\n",
    "    \n",
    "    energy = get_energy_xvg(xvg, frames)\n",
    "    w_name = np.array(b'water_trr_xyz')\n",
    "    w_theory = np.array(b'')\n",
    "    w_type = np.array(b'd')\n",
    "    w_z = np.array([8,1,1]*nmols, dtype='uint8')\n",
    "    np.savez(npzfile, E=energy, R=xyz, F=fxyz, theory=w_theory, type=w_type, z=w_z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(200,)\n"
     ]
    }
   ],
   "source": [
    "make_npz(trr_path, energy_path, 200, 'water250_nvt_200.npz', 250)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = np.load('water250_nvt_200.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['E', 'R', 'F', 'theory', 'type', 'z']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file.files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200, 750, 3)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file['F'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200, 750, 3)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file['R'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200,)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file['E'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sampling code below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {},
   "outputs": [],
   "source": [
    "ener_og = np.loadtxt('energy.xvg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,8))\n",
    "(n, bins, patches) = plt.hist(ener_og[:,1], bins=50)\n",
    "\n",
    "m = statistics.mean(ener_og[:,1])\n",
    "plt.axvline(m, color='black')\n",
    "\n",
    "sd = statistics.stdev(ener_og[:,1])\n",
    "\n",
    "plt.axvline(m + sd, color='red')\n",
    "plt.axvline(m - sd, color='red')\n",
    "\n",
    "plt.axvline(m + 2*sd, color='red')\n",
    "plt.axvline(m - 2*sd, color='red')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "metadata": {},
   "outputs": [],
   "source": [
    "bin_id = []\n",
    "for ener in range(len(ener_og[:,1])):\n",
    "    for b in range(len(bins)):\n",
    "#         if b < 50:\n",
    "#             if (ener_og[:,1][ener] > bins[b]) and (ener_og[:,1][ener] < bins[b+1]):\n",
    "        if ener_og[:,1][ener] <= bins[b]:\n",
    "            bin_id.append((ener_og[:,1][ener],b))\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {},
   "outputs": [],
   "source": [
    "tmp = np.array(bin_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "metadata": {},
   "outputs": [],
   "source": [
    "tmp_dict = {}\n",
    "for i in range(len(tmp)):\n",
    "    if int(tmp[i][1]) in tmp_dict:\n",
    "        tmp_dict[int(tmp[i][1])].append(i)\n",
    "    else:\n",
    "        tmp_dict[int(tmp[i][1])] = [i]\n",
    "\n",
    "# tmp_dict = OrderedDict(sorted(tmp_dict.items()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ener_og shape (8000, 2)\n"
     ]
    },
    {
     "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": [
    "get_distribution('energy.xvg', 200, 2001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'bins' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-cf74185077ee>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mn_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m200\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0msampled_bins\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchoice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbins\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mn_samples\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreplace\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0msampled_frames\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mcounter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msampled_frames\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mn_samples\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'bins' is not defined"
     ]
    }
   ],
   "source": [
    "n_samples = 200\n",
    "sampled_bins = np.random.choice(np.arange(len(bins)), size=n_samples+100, replace=True)\n",
    "sampled_frames = []\n",
    "counter = 0\n",
    "while len(sampled_frames) < n_samples:\n",
    "    bin_idx = sampled_bins[counter]\n",
    "    try:\n",
    "        frame_idxs = tmp_dict[bin_idx]\n",
    "        sel_frame_idx = np.random.choice(frame_idxs, size=1, replace=False)[0]\n",
    "        sampled_frames.append(sel_frame_idx)\n",
    "    except:\n",
    "        pass\n",
    "    counter += 1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200,)"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ener_og[sampled_frames,1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "metadata": {},
   "outputs": [
    {
     "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.hist(ener_og[sampled_frames,1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 379,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sampled_frames)"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}