From 25ec2e7169122e7859b5faafb8d58f36ce24644a Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 20 Jan 2021 11:57:06 -0700 Subject: [PATCH 01/35] Initial structure. --- Notebooks/HTF_CG_Demo.ipynb | 512 ++++++++++++++++++++++++++++++++++++ 1 file changed, 512 insertions(+) create mode 100644 Notebooks/HTF_CG_Demo.ipynb diff --git a/Notebooks/HTF_CG_Demo.ipynb b/Notebooks/HTF_CG_Demo.ipynb new file mode 100644 index 0000000..4997ffb --- /dev/null +++ b/Notebooks/HTF_CG_Demo.ipynb @@ -0,0 +1,512 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n", + "import networkx as nx\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "import hoomd\n", + "import hoomd.md\n", + "import hoomd.htf as htf\n", + "import numpy as np\n", + "import gsd\n", + "import gsd.hoomd\n", + "import pickle\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HOOMD-blue 2.9.3 DOUBLE HPMC_MIXED TBB SSE SSE2 SSE3 \n", + "Compiled: 01/11/2021\n", + "Copyright (c) 2009-2019 The Regents of the University of Michigan.\n", + "-----\n", + "You are using HOOMD-blue. Please cite the following:\n", + "* J A Anderson, J Glaser, and S C Glotzer. \"HOOMD-blue: A Python package for\n", + " high-performance molecular dynamics and hard particle Monte Carlo\n", + " simulations\", Computational Materials Science 173 (2020) 109363\n", + "-----\n", + "HOOMD-blue is running on the CPU\n", + "notice(2): Group \"all\" created containing 88 particles\n" + ] + } + ], + "source": [ + "# building a HTF model for coarse graining\n", + "fname = '100-length-4-peek-para-only.gsd'\n", + "gsdfile = gsd.hoomd.open(fname)\n", + "context = hoomd.context.initialize('--mode=cpu')\n", + "system = hoomd.init.read_gsd(filename=fname)\n", + "context.sorter.disable()\n", + "set_rcut = 10." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finding molecules...\r", + "Finding molecules...0.00%\n" + ] + } + ], + "source": [ + "molecule_mapping_index = htf.find_molecules(system)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "typeid : 2\n", + "a : 1\n", + "b : 87\n", + "type : ca-ca\n", + "\n", + "[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87]]\n", + "oh 0\n", + "ca 1\n", + "ca 2\n", + "ca 3\n", + "ca 4\n", + "os 5\n", + "ca 6\n", + "ca 7\n", + "ca 8\n", + "ca 9\n", + "c 10\n", + "o 11\n", + "ca 12\n", + "ca 13\n", + "ca 14\n", + "os 15\n", + "ca 16\n", + "ca 17\n", + "ca 18\n", + "ca 19\n", + "os 20\n", + "ca 21\n", + "ca 22\n", + "ca 23\n", + "ca 24\n", + "c 25\n", + "o 26\n", + "ca 27\n", + "ca 28\n", + "ca 29\n", + "os 30\n", + "ca 31\n", + "ca 32\n", + "ca 33\n", + "ca 34\n", + "os 35\n", + "ca 36\n", + "ca 37\n", + "ca 38\n", + "ca 39\n", + "c 40\n", + "o 41\n", + "ca 42\n", + "ca 43\n", + "ca 44\n", + "os 45\n", + "ca 46\n", + "ca 47\n", + "ca 48\n", + "ca 49\n", + "os 50\n", + "ca 51\n", + "ca 52\n", + "ca 53\n", + "ca 54\n", + "c 55\n", + "o 56\n", + "ca 57\n", + "ca 58\n", + "ca 59\n", + "ca 60\n", + "ca 61\n", + "ca 62\n", + "ca 63\n", + "ca 64\n", + "ca 65\n", + "ca 66\n", + "ca 67\n", + "ca 68\n", + "ca 69\n", + "ca 70\n", + "ca 71\n", + "ca 72\n", + "ca 73\n", + "ca 74\n", + "ca 75\n", + "ca 76\n", + "ca 77\n", + "ca 78\n", + "ca 79\n", + "ca 80\n", + "ca 81\n", + "ca 82\n", + "ca 83\n", + "ca 84\n", + "ca 85\n", + "ca 86\n", + "ca 87\n", + "{'ca': 72, 'oh': 1, 'c': 4, 'o': 4, 'os': 7}\n", + "1 0\n", + "1 87\n", + "2 1\n", + "3 2\n", + "4 86\n", + "4 3\n", + "4 5\n", + "5 6\n", + "6 7\n", + "6 85\n", + "7 8\n", + "8 9\n", + "9 10\n", + "9 84\n", + "10 12\n", + "10 11\n", + "12 83\n", + "12 13\n", + "13 14\n", + "14 81\n", + "14 15\n", + "15 16\n", + "16 17\n", + "16 80\n", + "17 18\n", + "18 19\n", + "19 79\n", + "19 20\n", + "20 21\n", + "21 78\n", + "21 22\n", + "22 23\n", + "23 24\n", + "24 77\n", + "24 25\n", + "25 26\n", + "25 27\n", + "27 28\n", + "27 76\n", + "28 29\n", + "29 30\n", + "29 74\n", + "30 31\n", + "31 32\n", + "31 73\n", + "32 33\n", + "33 34\n", + "34 72\n", + "34 35\n", + "35 36\n", + "36 71\n", + "36 37\n", + "37 38\n", + "38 39\n", + "39 40\n", + "39 70\n", + "40 41\n", + "40 42\n", + "42 69\n", + "42 43\n", + "43 44\n", + "44 67\n", + "44 45\n", + "45 46\n", + "46 47\n", + "46 66\n", + "47 48\n", + "48 49\n", + "49 50\n", + "49 65\n", + "50 51\n", + "51 52\n", + "51 64\n", + "52 53\n", + "53 54\n", + "54 63\n", + "54 55\n", + "55 57\n", + "55 56\n", + "57 62\n", + "57 58\n", + "58 59\n", + "59 60\n", + "60 61\n", + "61 62\n", + "63 64\n", + "65 66\n", + "67 68\n", + "68 69\n", + "70 71\n", + "72 73\n", + "74 75\n", + "75 76\n", + "77 78\n", + "79 80\n", + "81 82\n", + "82 83\n", + "84 85\n", + "86 87\n", + "unsorted particles: [0, 5, 10, 11, 15, 20, 25, 26, 30, 35, 40, 41, 45, 50, 55, 56]\n", + "unsorted bonds: [(1, 0), (4, 5), (5, 6), (10, 11), (14, 15), (15, 16), (19, 20), (20, 21), (25, 26), (29, 30), (30, 31), (34, 35), (35, 36), (40, 41), (44, 45), (45, 46), (49, 50), (50, 51), (55, 56)]\n", + "graph edges: [(1, 87), (1, 2), (2, 3), (3, 4), (4, 86), (6, 7), (6, 85), (7, 8), (8, 9), (9, 10), (9, 84), (12, 10), (12, 83), (12, 13), (13, 14), (14, 81), (16, 17), (16, 80), (17, 18), (18, 19), (19, 79), (21, 78), (21, 22), (22, 23), (23, 24), (24, 77), (24, 25), (27, 25), (27, 28), (27, 76), (28, 29), (29, 74), (31, 32), (31, 73), (32, 33), (33, 34), (34, 72), (36, 71), (36, 37), (37, 38), (38, 39), (39, 40), (39, 70), (42, 40), (42, 69), (42, 43), (43, 44), (44, 67), (46, 47), (46, 66), (47, 48), (48, 49), (49, 65), (51, 52), (51, 64), (52, 53), (53, 54), (54, 63), (54, 55), (57, 55), (57, 62), (57, 58), (58, 59), (59, 60), (60, 61), (61, 62), (63, 64), (65, 66), (67, 68), (68, 69), (70, 71), (72, 73), (74, 75), (75, 76), (77, 78), (79, 80), (81, 82), (82, 83), (84, 85), (86, 87)]\n", + "[{1, 2, 3, 4, 86, 87}, {6, 7, 8, 9, 10, 12, 13, 14, 81, 82, 83, 84, 85}, {79, 16, 17, 18, 80, 19}, {74, 75, 76, 77, 78, 21, 22, 23, 24, 25, 27, 28, 29}, {32, 33, 34, 72, 73, 31}, {67, 36, 37, 38, 70, 71, 39, 40, 42, 43, 69, 44, 68}, {65, 66, 46, 47, 48, 49}, {64, 51, 52, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63}]\n", + "19\n", + "1\n", + "4\n", + "6\n", + "10\n", + "14\n", + "16\n", + "19\n", + "21\n", + "25\n", + "29\n", + "31\n", + "34\n", + "36\n", + "40\n", + "44\n", + "46\n", + "49\n", + "51\n", + "55\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAD3CAYAAAC+eIeLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABeJ0lEQVR4nO29d3gc9bX//5rt2l2tJKvLTe4F2+AWTDcGTDAYSGJacG4cSMgvwM0lhNybb0hIgwRucnEahJKEGnoI1YALyAZsg23cLVlusiVZXbtabd+dnd8fox1ppdWqWJJVPq/n4cGamf3MjLR79sw573OOpCiKgkAgEAgGBN3pvgCBQCAYSQijKxAIBAOIMLoCgUAwgAijKxAIBAOIMLoCgUAwgAijKxAIBAOIMLoCgUAwgAijKzhtLF68mIyMDILBoLZt1apVmEwm7Ha79t8vf/lL7d82mw1JkuL2nzhxgsWLF2OxWOK2L1++HICioiJ0Oh12u53U1FSmTZvGU089dbpuWzDCEUZXcFooKyvj448/RpIk3nrrrbh9//3f/43H49H++/nPf679e//+/QC4XC5t27hx4wD4y1/+Eve6t99+W1uzoKAAj8eD2+1m9erVfOc73+HgwYMDd8MCQQvC6ApOC88++yyLFi1i1apVPPPMMwN2XkmSWLZsGaNGjWLPnj0Ddl6BIIbhdF+AYGTy7LPPcvfdd3P22WezaNEiampqyM3N7ffzRqNR3nnnHerr65k8eXK/n08gaI/wdAUDzieffMLx48e5/vrrmT9/PpMmTeKFF17Q9v/+978nPT2d9PR0srKyur3u97//fe116enp/OxnP9P2nTx5kvT0dFJSUvjKV77Cww8/zNy5c/v0vgSC7iCMrmDAeeaZZ1i6dKlmUL/+9a/HhRjuueceXC4XLpeL+vr6bq/7pz/9SXudy+Xi17/+tbavoKAAl8uF2+3m+9//Ph9++GHf3ZBA0ANEeEEwoPj9fl555RVkWSYvLw+AYDCIy+Vi9+7d/X5+s9nMQw89xLRp03jjjTe49tpr+/2cAkFbhNEVDChvvPEGer2evXv3YjKZtO3XX389zz777IBcg8lk4oc//CG/+tWvhNEVDDgivCAYUJ555hm+9a1vMW7cOPLy8rT/7rzzTv75z38SiUR6vfadd94Zp9OdP39+p8fecsstnDhxIk5WJhAMBJJoYi4QCAQDh/B0BQKBYAARRlcgEAgGEGF0BQKBYAARRlcgEAgGEGF0BQKBYAAROl3BiKHeE+S1HRWUVLtxByI4LAam5zm4bv4YMu3m0315ghGCkIwJhhWJDGtaipHjjT62HGkAIBiJasdbDDoUYPG0bG6/aDJnjk0/PRcuGDEIoysYFuwud/FI0WE2ltYB8Ya1O0gSWAx67l02nZWLCvvhCgUCFRFeEAx5nt9axgNrSghEZHrrQigK+MMyD6wpBhCGV9BviESaYEijGtxi/OHeG9y2+MNRHlhTwp4K16kvJhAkQIQXBEOW3eUubnxyK/6wjPfARurf+h0AqQuuZtSlt+Et/pimT14g7KoGOQyAedxs8r7+WwC8JZ+o+50n0dtGkTpvGWmLViBJcPnMXB5bueC03Ztg+CLCC4IhyyNFhwlEZCLueho/eBR0eojK2v6IuxadLR1cVYAEKARP7CVwfA+SwUj9Gw8hmSzYZlxI4PhuXEVPozPbSJ17BR8drKPBE+y1qkEoJQSdIYyuYEhS7wmysbSOaFSh4d2H0admYskej6/4Y+0Yx5e+SuDoDowZBRjb7Iu4qvEd/hxQSD/vJhxnfxV/2S5qX/opTVteJXXuFUjAa19U8N0LJ/XoupIl9CyGalavLxVKiRGOiOkKhiSv7agAoHnbmwQqDpC1/B4kvSnumOZtbxIo348xu5BgxQEAdBY7KVMXEao5AoApfwoA5jz1/7K7lmjAQyASpaSquUfX9PzWMm58civrimsIRqIdFBSBlm1rD9Rw45NbeX5rWY/vWzD0EZ6uYEhSUu2mueoozo3PkH7BSky5E+P2h+rKcG58BuuURfiKN2nb9Wk56EwpyF4XAJIppeX/Fu0Y2etEZ7HjDoS7vI5YGOG9fVXsrWwi2o0MiVBKjGyE0RUMSdyBCL6Dm0GOEDixl2D5fkK1xwDwH/qMUPVhkCNEwwEskxYQqj5C1OskXHOUmpd+it6WjuyuQwn5AbT/A+htGQA4LMZOz982jKAoCiFZtbaJEnoxZL+bqr/fiexpRDLbGPeDl3lgTQlzxqQzZ0x6n/5+BIMXYXQFQxKHxaC6jCgEju6I2xdpqkFRogn3AYQbKjEXTMPvriNYVYpl3GyCVYcA0Duy0VnsWAw6puenJjx3Z7rgzhJ6MRrffwTZ1xS3LRCRebTosFBKjCCE0RUMSabnOci9+BukX3Cztq3+ndV4923QPMzKx29DMpgI15XFvdY6/TyC5fsBcH30FE2bX9H2pS26DgAFWDFvTIfztuqC4+O1itJ5Qg/As3cDvtItpJ17A02fvtjmdZyyUkIwtBBGVzAkWTF/DKvXlyY9xlwwHe/+j+K2WQrnooQCRP1uzGNmEqo5ihL0AmCbtQT73CsAuHhaNpl2c5z0q8LpZ+cJJ80lm2na8irh+uOgN2DKLsQyYT6B43sACNefAKB5+1s0b38LU8E0wg3lOL50LZZxs+OMLtBrpYRgaCKMrmBIkmU3c9HUbNYV12iP+FlX/YCsq34AqJ6n7KnHmDVWk4vFPOBg1SEyr7gTSa/GbKv/+WOC5fvQmW1IkgTAoomZ3Pbc9g7SLy1mqzdinboInTGFQMV+mj59EUvhWRizxuE/tpNIQzmSKQUl5CfSVIshLZf0C79BsKK4w730RikhGLoIyZhgyHLH4slYDPqE+5JJycz5UzSDC0BUnUCsT80EVM/z/neLO0i/FEXBWfQ0ALnX/5Lsa/6HzGXfxzbzIjWGq9MTcVZ1SM5FvU5QFOpe/w3Ojc+o+8IBal/9paai6I5SQjA8EJ6uYMhy5th07l02vUOMNSYXSyQla4/7838TrCzBkJFP6txlgBrPjSTQfkWcJ5HddUgGM02f/Yva136F3paBYVQBnSXt0BtBDhOuK4uPLUdl/Ee2oYSDQHKlhGB4IYyuYEgT07i2VRMkk5I5DSYyFq8CwPXJCzR98gKG9Dxyb3wAndkKqK9vH7PNXnEfkeZGAJRIkMDRHUgGE5GmGiKuKrK/ei/WqecAUPf2/+FriSVnX/tjrFPO1q43cHwPNS/+RJOMAUmVEoLhhzC6giHPykWFzBmTzqNFh1l7oCaplCxYWYKiRGlc+xienWsw5U4i57pfoLer2txEMdtgVSlKOIDv4KfaWpYJ8wjXHkP2OgHwHfpMM7oRVw0AktlGyuSFXV5/Z0oJwfBEGF3BsGDOmHQeW7mAh9cd5BFuTiolc258Fs/ONSDpMOZOpGnrqwDo0/No/vzfgBqztYyfE3eOaKA12ZV+4UqCJw/iXPc4ALqWyjYA5JB2jCTFp00s4+cw/sfvaD9LUqtSQjAyEEZXMKz4j3MKeXzTUeQkkyPkZnVsD0oU75512nZj3pSEMVvHwmtInX8VqfOuVL1dOULNiz/VEnAgYTtjMQCB8n2Eqg8jmW3YZ1/a5fVaDHpuXzy5t7crGIKIfrqCYcdtz22Pk5J1l0BFMTXP/wgAw6gxmEdPx1e8CSUSIvur92IeN5uGNX/EX7pFe41kSmHUpbdhn3MZAHX//g2+g5txfOkrZCy5Nen5Uow67l02Q/ReGGEIT1cw7Lhj8WQ+PlSPP9yxFDcZeqtD+3fW8rsx50+lwWjG88W7+A59hvfAJvylW7DPu5KMi2+hecfbuIqepnnnGs3oZn/lJ12eR8xjG9kIoysYdnQmJYvRmTpBb0sHvQHkCNXP/TfGUQWadldnSiFQpVbAmfMmozOaMedPBSDcUNGt6zLpJSRJ4uJp2dy+eLJocjNCEUZXMCxpKyVr6/EmUye4Nr8CshqnlYxmws6qlpJeNWaryGHC9SdwFj1D8ORBAmW7ADCPmZn0WnQSzB6dxrLZ+ayYJyZHjHSE0RUMW2JSsnte3U1pradDRVl7dYKv5BMArDMvInh8D3I4AKiNzs0F0zBmjkXS6fEd/hzP3vXoUxzYZi0h4+JvJTy/CCMIEiGMrmBYM2dMOjMLHJTWejqtKIupEySDWi5szptC5hXfp3HtX/HuXa9pcXVmK6OWfo9RS7+X9JwWgw4FRBhBkBBhdAXDHndADRnIPjegVpRFXDVYp5+Pr3gTjeseQ5+aSdo519O49lGcH/4N54d/014ve5xdnkMvScwbl86YDCvT81NFGEHQKcLoCoY9Dov6Nu9KnZB15V2Y8ibhP7YTUNDbM2l8709xr0uEkH4JeoIwuoJhz/Q8B2ZDNUpaDpLZihL0te5sEfPqTCkochhzwTTMBdMAtZINwFJ4VsJ1RcxW0BtEcYRgSNK2ubg7EMFhMTA9z8F18zs+1td7gpz30IcEI1FcH/+Tpk9fxJA5BnNBS/GDHCHvG78jVHUI74EijNmFhOuOE6wsRjLbyF+1GmNGgbaeiNkKTgVhdAVDirYDIYG4MecxY7h4Wja3XzSZM8ema/tiVWpRWca16Tm8ezcQDfkwZo4j/YKvkzJpIf6jO2hc/ySRphokvQHL2FmkL16FKXs8BWkWZuQ7cFiMfR6z7ckXiGDoI4yuYMjQ2UDI9iR67N9d7uLGJ7f2uEoNIMWo5+XbFvW5R9vbLxDB0EYYXcGQoLOBkMlon+DqizX6ilP5AhEMbYTRFQx62nupsUbgichcdhf2Oa3dvfQSzBuXweiMFKbnOQCFP244fFqN3WAy/oKBR6gXBIOeR4pUIxlD78gidcHV2s9KKIBnz1oADBn5ca+VFdh23Mm2404shmoUYO64dAB2nnAhoQ6GjNHXSbL28Vo5qvDp4fqE44CS4Q9HeWBNCXPGpIvE3RBHGF3BoKbeE2RjaV2cV2rMKGDUpbdpP7u3vw2AKXcSlrFndLpWzLh+dqwRi0HP3ZdOwRuS2VBSS70niIREps3IJTNy+eY5haeUxEoWr01Ep014LPY21y/zaNFhHlu5oNfXJTj9CKMrGNS8tiN5By9FUWjeoRrd1IXXdGtNRQF/WOahDw6ikyT0OkkzitXuAEfqvDy+6WinSayu1AbdjdfGSNaEhzZGV1Hgo4N1NHiCQtUwhBFGVzCoKal2J/US/Yc/J+I8id6WgW3GBdr2UM1RnEVPEao6jBIJYUjL0aY/xIgqEFWUDo/6MY947YEaNpXWa3Hd5GqDalavL2Vito2jdd4uPdsYXTXhaY8EvPZFBd+9cFK31hcMPoTRPQ0IXWb3ifVN6Izm7W8CYJ+3DEnfOsa89l/3I7trMWYXYhxVgO/gFhrX/hVj5tguDVuMmEf8wJpiPjvWyPri2k6915ih3r1rd6fG3rNnPQ1r/pDwXJ014Ul0npKq5gQrCIYKwugOIN3xlIQuM55Y34REhGrLCBzfg2QwkTp3mbZdkSPIzfUAZF19D6bsQqqevotQ9WEiTTU9vgZ/OMrbe6q6dWwyYx/DUjgXY5b6s+xpxFfySadNeGIThtviDoR7fA+CwYMwugNEV3G+zh5pRzqxvgmJHtfdLV6ubeZi9NY0bbukN5C6YDnN296k/q3fYxxVQKj6CMacCQmNWKj+BK6PniJ48iCKHMYy/kxGXXobhrQcdX83QhWy383Jv91BtKUNZGJjL7Vc70WarC3cWKn18U3UhCfR9Tosxg7bBEMHYXQHgJ7oMts+0gIj3vCumD+G1etLO2yXfU34DmwEIHXh1R32W6ecg690K+G6MsJ1ZaAzYJ2yCKntqHQgGvBQ+9JPkT2NpExaiKQ34ivdTK3zJPm3/gVJ0nUrVNH4/iNE/W5t3UTG3le6VT12wxM0rn0UvSMH+1lLkzbhaY/FoGN6fmrPfomCQYXudF/AcGd3uatlZEz3hfDQqsvcU+HqnwsbImTZzVw0NRtJit+ut6Yx7p7XGf/jdzBlF8btk/1ual/9OXJTDbk3P8SYu17ClDuBpk9fxLPr/bhjAxXFyJ5G9Gm55Fz3c7K/+hOMORMI15/Ad3BLh1BF9ld+gilPTWLFQhWevRvwlW4h7ZzrW1aVCNeV4Tu4GXT6VmMvSZjyp2Cbfj6WifOJOE/i+vAfWMaoMrf6dx6m/t0/4N27HiSdNta9LQqwYt6YU/qdCk4vwtPtZ2LC/up//phg+b64fcascRR8+1G8BzbS/MW7hBsqUMJBDOm5OBZei3TWUqHLpOfTfSOuGpRwEHQGzPlTkQxGjJljCVUdIlxfHnesZFAf1aN+N2FXNZLOgOxpBCBcewxp+nlJQxWRploa1z+O40vXYsqNKQoUcm9+CGP2eGpf/hlNn76I3paOfe4y7LMv0c7tLHoa99bXUOQwjkUr8O7dgK/kY4xZ40m/4Otai0ntWiW1aEMkW4c2wuj2I4mE/W0rqfT2UQD4j35BxFVNysR5yN4mAmU7aXjvT+isaXykP2fE6zK7mu7bHmPmWHSWVKKBZmpeuhdDeh7eA5sAMI+NHyJpGTcb85iZBCsOcPKxb8fti43pSRaqqP/X/RjSckm/8Bt4dq/TXpvI2EdcVXEtIjV0ejIWryJj8aqk92Ux6Ll98eQu718wuBFGtx9JJOxvW0kVI3X+VWRecacmeYp5xYGyXUgzzhG6TOKn+3ZVdKAzWci5/he4Nj1HqPqI6plm5GM/68vYZlwYd6yk05N702/wlnxMuL4cgyObQPk+fAc2orOmaaEKJRzs4L0iSQTL92HMLqTu9d8Q8bq0dSv+8g0shWdpcVzz2Jk0rPkT0YAHU/4UogEP/kOfAWpirSvU3gvTRQnwMEAY3X4kkbC/fPUNAJjyJpG+eBXm/KmY86fEvzCqalP1qZlCl9mG2HTfR4sO89HBug59E9piLphG7o33d3NlBfsZFwNqgs616TkAUgrPShqqCFUdAmj1gNsQDXjwH/48zthHQ348u95XY71KFFPOBFIXXI191pJOr0x0GRt+CKPbjxyoas1m60wppExaiD41k2BlCYHje6h9+T4Kvv1X9PYM7Tj35/8mWFmCISNf054KXWYrc8ak89jKBTR4grz2RQUlVc1UOH18ccKF3MuGeTUv/Qy91YFkthE4uoOo303KpIVYxs8hGgp0GqqwzbqYnOt+rq0T634mmW2M+8HLHc6TeublpJ55ebeuSUynGL4Io9tP7C53caTW00kCbSx6Rw6yu5aqp+8iGvQCCpLRQtTXhCE9j9wbH0BntgJCl5mITLs5LuTSm3aJMUw5E/AWf0w00IzePgrHohWkn/91oGehilPBoJM4f3IWep3UL9MpBIMH0U+3n7jtue2sPVCjGV3bnKXoTBZAlTs17/pA1X7mTMBcMA3/0R3IbrVSLeva/4dt+nmA6vH84LKpIz6m2x162mhmsCB65Y4sBrWnO1R7FMRUC23x7v8Qy/gzMTiy8RZ/jOyuRWdLJ/fG+3Fve1MzuACeXe8RrNiPISMf89nXCF1mN+kq5msx6AjLURTUZjenGxGvHZkMSqM71HsUdNaOMHDsCwAks42UKYtIv/AbRFzV+Eo3xx9XtotA2S7MY2dx8X98e1B/wQw2EsV83YFw3CP7e/uqejQq59IZOawvrulR6MKsl5iUY+dInbffG6ULhhaDzugOhx4FbVUL7RNo4boyJCDz8jvQ2zPw7FlPpKHFSEs6UhcsJ2PxKiS9Eb2E0GX2kvYx37Z0xyNubxR7O9MsmfEfSV+mQ/WptT8YVDHd3iRDLEYdF07JxmrSD5o/5i3PbOPDklpA7ZcqtdSwKnKYyse/i+yuJevqH2n6TEWJEnFVU//GQ4RqjpB+4TdIO/cGpuXa+eCurjWcgt7TE6O4p8LVI0MtEBOPEzFoPN22PQq0TvqoFVyjLr0NJRLG+dE/8B3aiux1ok9xYCmcS8Yl32btgXgjfbpDEHJUvZ5oOEA04MWQmtnxIElHNOhDZ7YiSTqMGQWY8qcQqjlCuLESgJn5aR1fJ+hTknnE7elO6GKkeW0xEnmyvlCETaX1BOXokH1q7Q8GjdGN9SiIuOtp/OBR0Okh2lpr37TlFZp3vI1ktmGddh7B43vw7tsAKGRddXfcWqf7j3nSFQCg5oV7CVUd7LBfZ0vHMn4OVU/fhT41k9DJUpRIUNufMmGe6CY1iOmJoR7u9HQWXCJGWme9QWF0Y9n+aFSh4d2H0admYskej6/4Y+2YiKsagNQzl5Kx5FbcO97Gue5xIk21na57Ov6Y9Z4gxxvUNn2SXq/+32RV513pDRjScsm+9sforWlYCs/Cs3cDxAyupCNz2X9hO2MxUUURqgXBoKa7ce5ET64AkaZanEVPETi2i2g4gMGRxf8U38Kc1fcM6/DMoDC6sWx/87Y3CVQcIP8/Hsa97c24Y+xzr8B3aCvNu9cie50EynYjGc04zv5ql+sP5Pjq13ZUtLYhlNTOmePufiXhseaCaXh2vU/aeTfR9OmLSKYUrQvVhCzbiH1UFQw+2ocP6j1BDpx0dzlKvrMnV9nXRPXzP0JubsA8ejrG7EIi7jr8jVXDvrPeoDC6JdVumquO4tz4DOkXrMSUO7HDMcascaRMmIvv4Ga8+4u07XWv/Ur79qx49BZkd0fP1zx2FvkrHxyQP2Z3+y20bQloGTdbbaDShvy0jg2sBYKBpqvwQbLR8WFXDdXP3k005EftBAxh50kAmre/hdzcgG3WJWRd9YO4NYf7xONBYXTdgYjaBESOEDixl2D5fkK1xwDwH/oMp8FExFWD7+Bm7POuxLHgGqr+fgeKHN+TwD7nMqKB1uYwvtItyO46jBkFAza+uu0gxc76LeTf+gj17zystQQMVhR3WEevkzpsEwgGkq7CB8lGx8tRmaqn/hMl6MOYXYgSCRNxVmoTMgLHdwPqjLjyP68EWSZl0nwyLvkOkiNjWHfWGxRG12ExtIwoUQgc3RG3L9JUQ7CyRBuFYsqdTOMHf0Fny+jg1aaff5P2b9nXpE0JSF2wHBiY8dX1ntaEWPaK+xLKxQJlu+JaAsot96aEA9S++ksyl/0XDsvofrtGgaAtiZUHMptK6zrt4tbV6PiG9/+iGtzcSRR864/Uv7OaiLMSU56qO5d96ns+WLEf64wLCVaW4N1fRDQUQP+1nw7rznqDwuhOz3OQe/E3SL/gZm1b/Tur8e7boIUOGt7/C+H6EzjXP44SCWoNwDujeecalEgIy/g5mHImAP0/vnp3uYsDJ9U3UzK5WKw5doeWgFEZ/5FtmJSwUC4I+p3ehg78pVvjRsnXvPgTAPSpWaQtWkHq/KvwH9kOgOyu5fjvrgVZbllzC5LBhN6aRsR5Etucy8hc+j2CVaVUP3M3/qPbUaLysO6sNyiMbmfDB9uScfEtRIM+fMWb1ASVomBIz9NUDW1R5Aiene8BkLrgmrh9/fnHfKToMHJLYsG77yMaP3hELVGS9Eg6PUokiGS24tm9FsloARQMablYCs+ieftbWktAg0EnlAuCfuVUQgft0Vns6GwZRFzV2uh4Jaw+8UX98U6O3FxHsLIEY04hwco2YbWWi5AMJpB0w7qz3qAwurHhg+uKa7Q3QNZVP4gLsOvMVoyZYwAJy4S5SJKuQ9w3Nu7EW7wJ2dOIISOflMkL487VX39MbTQP6htWNbg6JIMJJRJCiUaxTJiHMWsc4YZyLIVnIrvr8R/ZRrj+RNxaYg6WoD/pqvKzq9BBe3Ju+JU6On7tX7XR8cbMMQQri7HPu5LMpd+j5pVfEji6DSQduTc9QMRVjWf3Wrx71qGEgwRPlgBgP2MJKUb9sH7SGxRGF7o5fLCLuG+M5u1vAaomUJJaBx73Z8FBTPYW94a98f4u37An/34n4boyMq/4PvYzl2LQSaLfgqDf6LryM0TD+ie1rne1r/0KJSpjSM3CsfAaUudf1WHNun8/iGPhNXGj4zt4si3qBXQ6kHQYR40mZ8V9uDY+i/fARvS2DBznXEf6eTcN+4nHg8bodmf4YPoFNyeN+wIEyvcRqj6MZLZhn31p3Ov7848Zk4pFnCeR3XVIBjNNn/2L2td+pb6h2rxhgycP4t1fRMRVTbiuDGPmWFKmLgJgVoFjWAvDBaeXrio/Gzf8De+u97SflUgIlCiR5jotdBAbJa9EZcI1R5HdtTg3PKmu1TI6Xmexx3mykaZYcdOXteRyysT5pEycH3d9I2Hisa7rQwaOlYsKuXfZDFKM+tYCgx6ieblnLkVnatW69vcfMyYVi2VllUiQiKsG6/TzkT0NNK57DF/pFgDC9eU073gb/xH1ccsycZ52rcP5zSY4vSSq/LROOzfuGF/JJ3E/x6ZX621q4tp36DNss5aQ/83V5H9zNY5FK1ryEyAZzOSs+BnmgmmaJ2vMHIv3wEaUcAjHOdeRseSWpNc4EiYeDxpPN0ZPhg+2j/sCZH/lJwmP7e8/psOi/ir1Vkfr9S2/W411Gc1arMs69Rzscy7FNnuJ1lmsedub6FMcpJ17w7BOIAhOL92p/JQMJvUfeiPIYa35UkyyqTOlaKPkpZbR8QDura9hHjODlEmtOZREnmwyRsrE40FndCF5NydfKMLG0loCke53pByIP+b0PAdGfRVKWg4YTBAJUf38fyMZTEgG1XvVmVKIBn0o0QhVf78T2dMIOvVPEG6sxKSXhnUCQXB66U7lZ9o519O49lFoKTwKHNkGqBryWOjgVEbJJ2KkTdAYlEY3RmfdnHrbULo/WTF/DP/7QYlaWRcJqefXG9Fb04k4qwAJ2xmLWwZR+oj6mtQXtoxbT5kwj0hUNLkR9B/dqfzMWLwKU94kfEd3ECzbRaiuTK0i0+nJ+dpPMRdMwzbr4h6Pkk/ESO1BPKiNbmf0pvP/QNBWuWCdcSHBE3uRPQ2Y8iaTfsHXMRdMQ5+aRcS5R/1GUIjrLCYQ9CfdqfxU5DDmgmmYC6bB+V/XktW2mRdpoYOejJIH9a1u1uu4aGo2VpNhxPcgHpJGFwZfQ+nXdlSguKo05UI06CUa8qO3jcI++xJSJi0k0lRLqOYwjrO/SsrEBdS8+JO4zmIGnTSsa84Fp5fuVH4273gH74EijNmFhOuOE6wsRjLbSDvvxh6fb6R6sl0xZI1ujMHSULqk2k3Ao4YM2ioXfMWbVKmNfRTu7W8lbXITkpVhXXMuOL10p/LTkJGP7PcQ3LsBSW8gZdJC0hevwphR0OX6Bh3MKkgj024e0Z5sVwx5oztYcAciyZULhz/vssmN3pY+rGvOBaeX7lR+pkycz+jbuq84gJGXCDtVhNHtIxwWA4a0HCSzFSXoo+G9vxCuPart9+5dD3Te5CZWqy530RRaIDgVulX52U1E+KB3CKPbR0zPc2Axm3EsuIamT18k0qJvjDXnsU4/H1PeJNIWrcB36DMa1z2utabUO3IwpOcCUNXkP123IBgBdKfyMxEWg8RFU3NEIqwPEEa3j1gxfwwPrysl7bwbUeQw7s/fAMCUO4n0C74eJxq3TjkbnSlFa4nXlmP13mHdNV9w+omFAAab7HKkMKjKgIcyWXYz4zOtWpWOefR0ACLOk9S/9XtqXvwJwarWJIZl/Byyv3pvh3V0kqpgEAj6k5WLCnn5tkVcPjMXs0GHxRBvCiwGHWaDjstn5vLybYuEwe1DhKfbhxSkWzhU6wE6H9VT8O2/ordndLpGfzdaFwhiDDbZ5UhBGN0+RK9r9RY6HdVzYk+X5ZJCwSAYSAaL7HKkIMILfUis6U00HFD7KiRC6vpXLpreCATDF+Hp9iHT8xyYDdV4XU1UPvldLOPPxODIJlhZguyuRWdLxzJ+DuGGcpq2vEakpVF01O+m/p3V6K0O8pd+Z9g3vUk0CHF6noPr5ovHWcHwR1KUZLlLQU+o9wQ576EP8Xs9OD/8G4Hje5A9jUhmK+aC6aRf+A1M2eMJHN+TULmgd+Qw6ftPs/l/lgxL45NsEGJM87l4Wja3XzSZM8emn56LFAj6GWF0+5jbntseV/HTEyQJLp+Zy2MrF/T9hZ1mBmNnOIHgdCBiun3MHYsnYzHoe/Xa4do1v3UQYnKDC2oTLH9Y5oE1xTy/tWxArk8gGEiE0e1jYhU/Kcae/WqHa9f8toMQe4I/HOWBNSXsqXD1z4UJBKcJkUjrB0TFTyuPFB3GeWQnNS8kHqOUuewubDMvwvnRP/Ad2orsdaJPcWApnMuoS7/No0WHh2W4RTByEUa3nxisjdYHktggRH1qljbgEEAJBfDsWQuorQSbtrxC8463kcw2rNPOI3h8D959GwCFj+z3iLJowbBCGN1+ZKRX/MQGIRozChh16W3advf2twG1L4Vl7Bl4dr0PqBOcM5bcinvH2zjXPU6kqRYJRGN3wYAxEHJGYXQHgJFa8VNS7Y6ThYE60qh5h2p0UxdeA4B97hX4Dm2lefdaZK+TQNluJKMZx9lfFWXRggEhuZyxmtXrS/tMzigSaYJ+wx2IdNjmP/w5EedJ9LYMbDMuAMCYNY6UCXNRgl68+4uQvU5M+dMwZY1vWUeURQv6j+e3lnHjk1tZV1xDMBLt4CgEWratPVDDjU9uPWVVjfB0Bf1GrCy6Lc3b3wTAPm8Zkl4td258/xF8Bzdjn3clGRffQvOOt3EVPU3dmw+S/83VorG7oE9pG0IornJzuNaD3I23WFs5I9DrxLcwuoJ+I1YW3XRkV4cKvKaP/0nTx/8kc9ld+Eo3A+D54l08X7yrHROqPgKIxu6CviFRCMG97U08e9YRrj8BSpS0826KG9wZaarFWfQUgWO7iIYDGBxZpF+0igeQmDMmvVcJcGF0Bf1GrLG73qGqFwJluwjXn8CQMZqIU52sYcjIx5QzgVD1YSSDCUN6PuGGclCiWgtM0dhd0BVdJcA6q4gMVR9GZ7GjT83SJrnEkH1NVD//I+TmBsyjp2PMLiTiriPSVEMgIvdaziiMrqDfiDV2PyQXkHbuDZpKwTrtXNxbX9XUC7k3/QbXxmfwHf6ccGMlKGpMLfOqu4HWxu59nYwUjXeGPt1JgE3MtnG0ztshVguQtfyHANT+63787Yxu8/a3kJsbsM26JG54J6ihho8O1vXKGRBGV9CvxBq7661pjLvndRRF4eQT3wVa1Qs6s5VRS7/HqKXfw/XpizR9/E8s4+eQMv5MoO8buw9kplrQM3ryRdhVP4+YLr64qplQzVGcRU8RqjqMEglhSMshdf5VpM67EgC5uQGAps0v49m7gdR5ywgc363u8zRS/ueVIMukTJpPxiXfQW9N67WcURhdQb/StrE7JFYvxFDkCJ6d7wGQuuCauH19pWDo7gd17YEaNpXWD9tKwcFGT78IW/t5dK+8vPZf9yO7azFmF2IcVYDv4BYa1/4VY+ZYJIORUPUhQFXSRAPNuIqeRmdNU6+lYj/WGRcSrCzBu7+IaChAztd+2mtnoN+NrniEG9m0VzAkUi/E8BZvQvY0YsjIJ2Xywrh9PWns3tl7TkLhDxsOdeuD2leZakHX9PSL8AJbDU/+eFXCtdSy8gtxffoS3gMb1fdTeh5yS+/qrKvvwZRdSNXTdxGqPkykqQbfoc+011unnoN57BnUvvRTokEfALY5l5G59HsEq0qpfuZu/Ee3o0RlJJ2+V85Avxld8QgngFYFQzASJVRbRuD4HiSDidS5yzoc27z9LQBSF1yN1G7Chi/UUfPbnmTvOZO+ilB3dEHtiDXe6W2mWpCcnnissS/C946FkpaVN274G56dazBkFGCftQTfwc2A+revf+v3GEcVEKo+gjFnAtap5+D65IW485jzpqj/kNsZ1JZvBMlg0ibA9GbKS78Y3VN5hBOe8fBixfwxrF6vTkF2t3i5tpmL0bc8usUIlO9TFQxmG/bZl3ZYZ92BGq57bDOjM1ISvh+6es+FZIX6dx4mULYL2e9GZ7JiyptMxkXfxJSnxuQ6kwdJM84TjXf6gd3lLn7489/i3Lk2oWRLiYTiPFZjRj5p59+Mbfp5ScvK615/AIDMK/4Ty7jZGLPG4dzwJJLBRLiujHBdGegMWKcswlPysRbPBfAd2krYVd16kZIO7551KOEgwZMlANjPWIIkSVgMul5Neelzo9ubb64H1hRT4fRztN4rPONhRpbdzEVTs3l/Rym+AxsBCBzfzYn/W4GkN2IqmKoWRMS83DOXojOlIPvdVP39zpbJGzbG/eBlth13su24s8P7YW+lq1vvuUhTLeZxs9GZrQSO7yFw7AtqG8oZc/tTSeVBp5KpFnTOI0WH8VYe6lSylchjrX/jQQzf+F/Mo2cAicvKJYMJUHXepvypBE8eVI+NhMi9+SGM2eOpfflnNH36Iqb8aZpaBiBce4xw7THt56xr/hv3llfxHtiI3paB45zrSD/vJnU9YMW8MT2+7z41uhsP1vKLtw8Q6WEFkT8c5bFNRzvdL5IbQ5s7Fk9mY2kd4+55neMPXqXOiis8E3/ZbgJHd1BbV8bo7z6J9BWT9prG9x9B9jUlXK/t+6HoYB0n3/w//Md2JvRgKx69pcOHGcCYq3q3cnMDihxJKg8CROOdPibWgS6ZZMtX8gnQ0WNt2vwKOdf9HEicmE0753oa1z6K88O/4fzwb3FrmvOnIhmMGDPHEqo6hDl/CnpbOv7Dn5F+8bdIO/tr+I/tpPbln6F3ZGObfj626ed3uH5JUjsE9uZLuE+MbiyWtr64hpi99R3cTNOWVwnXHwe9AVN2Idkr7kNvseMt+YSmT14g7DyJ3jaK1HnLSFu0osvziOTG0CP23gi1GMrclb/DMkb1UiKuGiofuxW5uYFQ/QnMeerUDM/eDfhKt5B27g00ffpip2srivpEFHbVdOrB2udcRjTQmmH27PsQJeAh4qoCwPGla5H0hi7lQaLxTt8S60CXjPYea6jFAw3VlWnHJErMps5bhilvEv5jOwEFncWBc91fAah56V4M6Xl4D2wCwDx2JtbULPyHP6fpkxcJ1x0nULYLgLRF13V6bacy5eWUja4WSwvLxPxb74GN1L/1O9AbsU5dhM6YQrCqFCUcINhQTv0bDyGZLNhmXIi3eBOuoqdxFT2trWnMGkfBtx/tNKbD9PN4YE0J40bZOFDlFvHfQUpcnLVlW8zgAijRluSYpENvHwWoIYCG9/6EZDDRtOUV9bhQQP3g5U1CiYQTNjzPuOTb6FNSCVYfpvrpuzQPNv38m7Tzyb4m7VFUCfrQp2ZhHj2zZZ8b6FweBKLxTl+SqANdezrzWGWPE6DTxKwihzEXTMNcMA2A+ndWA6CzZRCuL1eTaBn52M/6MrYZFwKQdc2PaPrkRbwHNqG3Z5B+0Texz70i4XWd6pSXUzK6ieK3iqLgbDGgudf/Esv4OXGvaVz7GKCQft5NOM7+KqGao4TrypBMKdjnXAagfQCTxXQYPYNVT3+OUa8T8d8BpjvJzq5i+9GQn4Z31Q+D40vXYrCPQlGi1L/zMJLeSMrkhSjhIP7Dn4MiU/v6/Yy5/alOG56HG8ox5U3WPNaYB9uW5p1rQFEwj5uNY8E11P37N9S98VtG3/YEemsaEefJpPKg3mSqBYlJ1IGuPe09Vr09k8b3/oTe6lDX6CQx69n1Ad4DRRizCwnXHSdYWYxktpG38iGMGQUJz2WbcaFmgDujr6a89Nrodjb7KuI8ieyuQzKYafrsX9S+9is1AL3wGlLnX0WoRm1iYspXZRmSKQUAJeQn/fyvo7PYtbW6iulEFRK2YQMR/+0PuisDvGx6btK5aLKvidpXf0Go6hD2My8nffG31O3ueoLl+zBmF6KEAsh+d+tr3HVE3PVEWjLL7RuehxsrCFWpKom2Hqz2+oAXzxdrAHAsvJaUCfOQTBaUoI9IUw3GnEKClcWtL2gnD+ptplqQmEQd6NrTmcdqKTwL2dekJWZTF14d9zpDRj6y30Nw7wYkvYGUSQtJX7yqU4PbFX095aXXRveRosMEIjLQLn7bol9TIkHC9eVIphQirioa1z2G69MXNcFxzNjSRo9Z8ci3MBdMIX3xqpaAd9cxnc4Q8d+ek8yDfW9fVbdlgOsO1FD7dmJ5li4lleqXforsPIlktuLZ9yHBymLSzr9Zi+lqsp72ROVOG55nLb+HlMKz8B/9Is6DNaTnAuDe+hqy14lktOA7sg3XxmdQgj501jRMuZPQp2bi2b22U3lQbzPVgsTE9Nv1O94jWH5Ac8Z8h7YSaarFOnURcnNDQo817bwbtbLyRKRMnM/o2+af0vXpJYnJOTZm5qf1+ZSXXhndWOZRUTrGb4lG8R38FIDUBcvx7lkHkkTU04gSDqK3pSO761BCars+naE1Y613ZBE4vofal++j4Nt/7TKm0x2EuL1ruvJgf7/2IFFFoTuiFEVRpTSdybOIysiexpajJYwZBYSdJ6l/40HyvvG/jP/xOwBU//PHBMv3acdlf/VeDOm5SBYbKRPm4ju4Ge/+IgDM42ZjyhqPZDCRMnF+nAcbM7r+w59pF+jdsx691YF1+vmknXcjOosNncVGzor7cG18toM86FQy1YLExPTbwfIDLfPwVGKSLUNaDubR0/vUY+0OAzEoVlKUZLNqE/PYxiOsXl9KICxT+ddbkN115N70Gyzj56DIYcr/dDNK0EfeNx/GnD+VmpfvI3DsCyRTCpZxc+LkGb6jX1D3yn3oHdmM/u4TVD7+XWR3LVlX/wjbzIsInjyoxXS8+z4i4jwZdy2tSbfOEywGayqXz8wV4vYEdFnIcnxPh164MTKX3YV9zqVdqlFiyS0kXZwmsj0pkxZqUiAA/9Ed1L7S8rNOz+jbnsBZ9DS+ko+1hufO9U/g2f0BOosd64wLCJbvJ1x/Ap01jdG3PYHOYiNQvo+af/4YyWxjzB1Po4s9ZXWTFKOel29bJL60+5jbntvOuuKapNOyk6GT6JYjEMOsl5iUY+dInfe0Dortlacbyzx2Fr81j55B4OgO6t95GHPBdALH9wAgGS04Fn1Nk2eEao5qiY8O8gxJ1yGm07xDbXBtyBxDyoR5QGvSLdlE2ayr7hbi9gR0p5Al1gs3RvuSy2BlcZwaJXB8t9osxGxDiUYI15fHJbcyLr6FikdWITfXYyqYRjTgIeKsBkXGX7aLYNUhTLkTkXR6okEfhlFjiDRWQFSm+oX/p5VmmvMmozOaMY89A8/uD4gGPHh2r+vgwQIdCi96wqlmqgWdc8fiyXx8qB5/WO7xa1OMeladO56nNx/v1GGI0d57Pd2DYntldGOZx5jMRokEibhqsE4/H1/xJiKuKlKmntNq+Fp+I9GAB2PWOFLnX4ln91otEI7egOfARpp3rkF216ri+fFzOmQhoz4XADkr7uvwiNFZgiXSpAquhbg9nt3lLn7y6CuUP/c/CfdnLrsLU+5EnB/+jWDVIZSQH70jB8eXvgK0llzW/ut+2qpR/GW7qH3ppzRteRVDWo4WImib3IqFjUItlUIacpjaV36OpNNjHjeLSFMtcnO9uk9niCtycBY9Q/DkQU1TaZk4n9zrf5nwXrK/kthTT8ZAPGaOdM4cm869y6b3qFsYtH4RrlxUyBWz8nm06DAfHazrtvd6ugfF9sroxjKPMekGQNbyuzHnT6XBaMbzxbtE/c1Eg17QGzHnTyFYcQAUBSUcIBr0o7PYMY+ZSbCiGNnTQKhiP5LZRsqURaRf+A301rQOWUidJZVooJnqp9WKIVPeJC3plmyiLPR9T9ahziNFh4laM5J6sRF3HbLXhSlnIsGK/QAdSi7bq1FizUJkdy0Ft6h62/bJrZgUqHn3WgyOLE0KBBD1uzHmTlL7H4T86K0OzJMWkHbejdS/9XvCdWWYx80h4qrCs3c9+hQHtllLyLj4W736PZj0UlwjnIF8zBS0JriThbhiJPoinDMmncdWLjjt3mtP6JXRjWUelbQcJLMVpUWRAGhebaj6MKBqdaNBL3UVB9DbR2FIzSJ1/lVkXnEnNS/9DNnT2mxCCXqJOE9iyh7foXxTkcMogM6SinX6eQQrS+KSbrGJsvEJljnaRFkQ4vYYsUSoIaMgaeMQAOuUs/GVbqGuYj9KJIjsro0ruZS9LqBVjSKZLNp6steJMXNsh+SWPnVUQimQuoCOnOt+jqElbBQ8eRDv/iJcRc8QrivDmDmW7K/8GH1K6xd+b0gx6vivS6YgSdKQ+KAOZ1YuKmTOmPQee6xtOd3ea0/oldGNZR4lvRHHgmto+vRFLX7rK94ESCjhAJLeSP3b/4fsVdUGsqeR+ndWq95Li2cEaqVI1OvENHoG1ilnA3Qo3/SVbkF212Gdeg6ZX74TRQ5rSbfAiT34SrcmnSgLvWvDNhxJVIKZqHFIe2Jyv7Yll+3VKLH/Azg3Povelk6wfH+cPCuReD2WZIsVSsQI15dr14WkwzJxXsK4rFEvoUMiFI322FsSnH6GosfaW3pldGOdo9YV15B23o0ochjv3g34Sj7GmDUe24wLcH70DxQ5HOfJEo3g3bcBvSOHjCW3tm72OjFk5JN7/S/Rma0AHcs3tYkCyztekKRTNcK0SbDkTwUg3KAaGCFubyVRCWayiQ4acrhDyaUpZyJ+dx3BqlIs42YTrFI78KM3EjyxTwsRtE1uxYWNdHoksw0l6I0rlIhhn3MpttlLiLiqqX/jIZq3vYk+xUHauTdox6gxvhmn7C0JTj9DyWPtLb0ujtAyjwpkLF5FxuJV2r5wYyXOj/4BoMnGGtb+Fc8X72KbfSlZV94FoCW5QEL2uqh7/X4tRtuW5p1rWrLWEs6ipzE4sglWlsQl3QLHdxOuP9EhwWIeoyZvhLi9lUQlmMkmOrSlfcllWzVK22Yhoy75DqnzOjYqh1bxeqSplpqXf0aksRLHohVx7yFQPWud2Yok6TBmFGDKn0Ko5og6vDK2ljHeax0p3pJg6NJro5ss82hIEuvVmVJQlCiNax9DdtcimaykTDmbcO2xuBhtbPx227lZlsKziDRWEjyxF8lsjUu6ZVx8C5JOj+/w5x0SLELcHk/7EsyuJjpE2/wd25dcWsbM7FGzkLZUP3cPsqcRvSMbJRKicf0TANhmXoS5YBpVT9+FIT1XHbfS3ID/yHYATS64YHwG9101s4PXOhK8JcHQ5ZQa3nSWeWwb661+5u641/iPbEMypeDZqdbBKyEfvv0fafujAQ+BE3uwzbwIiJ+blXPDLzuMcYnRdqJse06lDdtwpO0IHei8cUi4oZymLa8RaZkvJRktuD/7N3qrIy481FmzEAk1hqpAwjhrrDJNdtdpWloAXYoDc8E0LIVn4Sv5hMCxXairSOjto1AiIQCy7CYRJhAMORJbsB6wclEhL9+2iMtn5mI26DDrJQC1Pjo1q+UsenTWdFKmnI39rC/HjceII2ZQ2xjWZHOzuoMQt3dkxfzWMEuyxiGyx4l33waCJ9TiFiUcwLtvA96ST7t1HotRz+9WzNHeGxZD/N8vVvJrKpiG/cyl6NPUkl3PrvdQIiEyL7+dlEkL0dszsJ2xWG104mmk4b0/4Tv0mVbwIhAMJXpVBtwZDZ4gz2wp408fqnKxWP187MPVlqat/8JV9BSG7PFYRs8gWFlCuK4MnS2dglsfURtHn0L5pshSJ+dUSzC7Ipbciv3u28dZq90BDpx0468o7tDUHCBv1R8w501WK9RyCrU4c+w9lTp/OQVXfI8fXDZVhBIEQ4o+HdeTaTdjNRk6CM7LV6uZ5rbFDDEDGqk7gadO7U5mzBpP1jX/rT3iJivf1Elg0OnQSSJL3RtOpQQzGZ192bWPs9718k72n3R32dS8rbQQgJZj9KmZouBFMCTp88GUJdVuzeDqTCnq42FqZodiBsloxpQ/BVPOBGR/M/5DnxGuVzWbpmy1oKGz8k1JgqUzc3ng2tkiS91LeluCqZPUWK1RrzulL7v2CopETc07vObzfxOsLMGQka8l/ETBi2Co0edGt+2HKXvFfUiSGuNtX8xgm7UE++xLtGOdRU/j3voavoOfknrWl5OeI5YYE1nqU6O3JZhXzMo/5S+7tgqKzpqat8X1yQs0ffIChvQ8cm98QNNzi4KXgac7k0MGG8muWYEBvZ8+N7qxD1M0HCAa8GJIzex4kKQj4qpK3Bezi2SZSIz1Lb0twTzVL7vpeQ4a3vsxgeN7W5oVKejT81oSpuoXdajmKI0bnlT7dkRl0BnIW/k7TU6okxAFLwNIdyeHDKYxWcmu2aSv4n8/UJvV63US4bgeHP13P32aSIPWXrve+ioqn/wulvFnasUMbRNldf/+LdGAB1P+FKIBD/5Dn4ESJfOqu7HPWtLxQkVirN8ZyKKC0ppmpuU5QGdQ47QtZcCS0YJ99iXYZi1B9rpoWPNHoi1jeySjBfuZSwG1IY9j/nLW33Uhk3OF4e1vuuq7HGMwfU67e83J6I/76XNPN9aXQZeSin3WEgLH9yQsZrDNuhjPrvfxHdwMShRTzgRSF1zdweCKxNjAMZDhmg9Lasn/xu+oeu5H6oaW5uZKOEDzF+9iypuCfc6l+CYt1CYLKOGAllw1j51F+oLlbDhYK4xuP9OdvssxBsuYrJ5cczL643763NOFU5cjFaRZmJHvEImxYcxdL+/kjV2tU0DCjZWcfOK7IOkYfcfTcYk0X+kW6l5/AL0jhzG3/yNuna+cNZrVN5w1UJc94thd7uLGJ7f2utH46Zi40dU117+TeH6fKW8S3gMbaf7iXcINFSjhIIb0XBwLr8V+5tI+u58+93Th1DvCP7ZyvvBohzltE67dUS50vo5QL/QnD68vpeKt1QQriom465D0RkwFU8m4+BZNZaREQrg+fQnvgY3InkaMGfmknX8z0ozzeLTo8ICPyXqk6DDl//5dp4Y1WHWIaCgAikLU30zg2BdUV5Uy7q6X8B/9goirmpSJ85C9TQTKdtLw3p/QWdOQpp7dJ/dzyhVpiYjJkVKMPVteJMlGDrGEq+xroubFnxCsLOlUuZB8HaFe6A92l7tY9fTnbCytw7N7LZLZim3mhUhmK4GjO6h95T6tHLtxw99wb3kFSafHPmsJssdJ/RsPEqgoHvCqwViv6NhgVPucy9ClpKqDUV+/H1A715nHzMB+5lLMLTpxJeDBf2wnqfOvYvT3/k7W8nvIvfHXmMfOAiBQtgtFoU/up188XTj1jvCC4c30PAc6z24qX/hpp13GukK06+wfYgmo2JNq7srfdagalJsbCNWfwJw3GV/JJwBkXvGfWMbNxpg1DueGJ2na/App4385oGOyYr2i825+UNsWG4wqNzegyBHSzv4aksFEuL4c2dekHSe760iZMDd+wTbFONA3Y7/6zehC33SEFwxPVswfw53L70Fubui0y1j7hjtRv1trgp+x5FbRrrMfSJSA6qpqUDKYAAhVH8GUP5VQ7TH157qyAa8abNsr2r3j7Q6DUSW9avI8u9cRrj2qvU6fmkXK1EVxayUqxumL++lXowsjqyO8oPtk2c1a46P2XcZMORMxF0zTGu7EiDXc0TtyGHXJraJdZx/T1bDSUZffjnffhwDY516heo+eRs3oOj/8G84P/6YdL3vUiTEDGXdvmyvwlXyacDAqgGPB1TSs+YP2s9zcQNTXrI2B6qwYRz3Hqd1PvxvdGKJ6TNCeXSecSbPMlvFzEjZLAtGusz/oalipe/tbRBoqsJ95ObLX1fporjeS9/Xf4j+2E1C0QaOxwbUDGXdvW+mYd/ODKJFQ3GDU/Fv+gnFUgTaRJFxfQdU/7gBFoemz18i84j9pXPsYnp1rMOVOIue6X2jFOK3nOLX7GTCjKxC051RHcItwVN/R1bBS9EYiDRU4Fq3AmDmWhjV/JO3cG2j69EVASTho1FJ41oDH3afnOTAqxwkpOnUUlMEUNxg1cHQ7NS++jmXcLHQWO8Hy/VqzZyUcxLXpebXXt6TDmDuRpq2vAq3FOH1xP8LoCk4rIuE6OOhqWClyGL0jG9nrwr3tDYw5E9DZ0lv2Rah+7p64QaOS2abOT2Rg4+4r5o/hgb+9RtUb/4t57BmaYY0NRjWPm42y6Tm1KCsaBX2rCbRO/lKLtw4oUbx71mn7zGNn4Zi/vE/uRxhdwWlHJFxPP8mGlcaQ3XV4964HIFxzBDk241DStQ4a1RtImbSQ9MWrMI0qGPC4e5bdzDmzJ/PWpgICx3Z1GIxqyi7ENvtS/Ee2I3sb0RnNGHImkDrvSmxnLMZ2xmKyrvpBwrX7auyXMLqCQYFIuJ5ekg0rTbvgZtLPu4lIUy2Vf70FY3YhBkc2gZYklSKHMWbkk3fzg+hj3i+nL+5+702XsNdj6zRXkHn57b1at6/uRxhdwaBCJFxPD90aVtoS+wnXlRGuK2s9OCrjP7INJdxaNHA64+69zRUkoy/vp196LwgEgqHFYxuP8L8flOAr20PNi4mHB2QuuwsgTmoVI++bq7UpHynGwRF3H6xdxvqlDFggEAwtlkzPIaqA3pGF/awva32tU6aeox1jyMjX/m0pnIt16rnqD3qDFlY4f1ImL9+26LQbXOg4NLf9YFSTXkInqX2ZTS0DdWNYDDrMBh2Xz8zt8/sR4QWBQMCHJbXoJDBmFJD55TvJ/PKdgCoZ85duwZQ7CcvYM/A4qwC1atA+59IO68wfnzGoEp3dyRUAA5pHEEZXIBBQUu0m2u4RvK1kLHXhNXH7Gjc8QePaR9E7ckidewWOlv1//ugwJTXNg2p6BHSdKxjIPIIILwgEgoTqhZhkTG/LwDbjAnWjJGHKn4Jt+vlYJs4n4jyJc8OTNO96H4CoAmsP1HDjk1t5fmvZAN7B0EF4ugKBoIN6AVolY/Z5y5D0aulrdwbKDpbpEYMV4ekKBAKm5zkwt0k0JZSMARFXVeIFEgyU9YejPLCmhD0Vrr6+3CGN8HQFAoE22zCGu8XLtc1cjN6aRuB451Iy9biLiDTV4ix6Sq0ECwcwOLLIWLyKR4uyBnx6xGBGeLoCgYAsu5mLpmYjSeo0D9+BjQCkLlQ7jukdWaQuuBrz+DPRWdPVKc4tOM65npSJ86l+/kf4ij/GmDka++xLMGQUEHbVDPj0iMGOKI4QCARAz4ZQure/jXP945hyJ5H/rT/i2vQcTZtfxjbrkg69CywGHbddOBGryUBJtRt3IILDYmB6noPr5o+88m5hdAUCgUZ3RpcrisLJJ75LxHmSzKvuxj5rCdXP3UOwsgRL4VxCdcdAlkmZNJ+MS76D3pqmaoD1urimOrFGRounZQ86iVl/IsILAoFAY+WiQu5dNoMUox5JSnxMIimZ7HMDEKzYT8rEBeisaXj3F9Hw3p8BVUrWvotZIBIlGImOOImZSKQJBII42rbaXHugpkPRRCIpmd6aRsR5Etucy8hc+j2CVaVUP3M3/qPbUaIykk7f6fnaS8y+PCuf13ZUDNtQhDC6AoGgA7Hy2YfXHeTRoiNEWixvZ1IyY04hwcri1gVaopaSwZRQTpYIfzjKfW/t55fvHEAnSe1CEdWsXl86LEIRIqYrEAg6pd4T5LyHPtQMYP2aP+Ldsw77nKVkLvu+dly4sZKTf7sdSadHn5pFxF0LcgT0Rizj55Bx8S2YsscDUPHoLcju2g7nMo+dFTc6PRHDYXqIiOkKBIJO6UpKFsM4ajQ5K+7DmDlWmzahjvTJIHB0B7Wv3IcSCQFgn3MZqQuu1v7TO7LV4zMKuryetqGIoRoDFp6uQCBISk+kZACBimIsY2YAEHHVUPnYrQDkrfoD5rz4yQuyr4mKP38DlCiSwYRkMGMqmBrnGXv2rE/Yw3f8rX/krV/8x6DqatYdhKcrEAiSEpvEkGLsnrmIGVwAJdrSSEfSobeP6nBs8841qsE1WbGdsRjJbO3gGWvrFs6N85Bli4NHiw73/sZOEyKRJhAIuqQnU5tjREN+Gt5Vx7E7vnQthnZGV5EjeHa+B0DW8h9inXK25hnLzQ2E6k/EecaJevjGqt2GkqpBeLoCgaBbdDWJwWLQoWvR9sq+Jmpe/AnByhLsZ15O+uJvdVjPW7wJ2dOIISOflMkLgeSeceOGJzjx+69S+cT/h3ubKluTUBuQDyWEpysQDBD1nmC39ac9OXYg6WoSgzcY4S9vbaHyhZ8SaazEsWgFGYtXAdDw3p8IVhQTcdch6Y0oUTVGnLrgaiRJh+xzU/3PH7ecSaH66buwFM7FVDAVU/4UTDkTkP3N+A99hnPDk0hGM5z1ZUqqmk/PL6OXiESaQHAKdMc47i538UjRYTaW1gEkLYUFun3sYNSq1nuC5BWMRm5uQO/Ixtpmxlrz9rcwFUzDlD0e3+FtRL1OQGLM958HoOof/4nsaQSdgZRp5xI6sRfZ68R6xsVkL/+htk6sh69lwlxyb/g1l0zP4e/fXDjQt9prhKcrEPSC5Ia0Vcg/IdPGM1uOdxoHDbS8bu2BGj4sqUVRQFaULo/dVFo/KLWqWXYzcnMDALK7jubtb2n7HOdcT8ZF/wFA5JX7CBx1AgrBkwdxfvh31eACjgXLyVhyK+4db+Nc9ziRhk7CBy1FFw6Lsf9uqB8Qnq5A0EO6O9pbAvrzw2XQScwscJBlNw+a8AN0T2IWbqzk5BPfBUmHzppG1OtEZ0sn6m8GScKQlkvU50aRQxjS8rQxQdGAB/+hz0CJknnV3WSddSk/uGzqgM44O1WE0RUIekB3unDFCNUcxVn0FKGqwyiREIa0HFLnX0XqvCvxHthI8xfvEm6oQAkHMaTn4lh4LfYzl/b62gZT+CHZ7yka8lP78s8IVpbgOPuruD97vdN1zOPmkDJhLr7SzYQbT4ISxZhRQOqCq7HPvgSzQcfm/1ly2r9oeoIwugJBAhLFatNSjLy8rVx7zO+KWLmrMbsQ46gCfAe3AAq5N/0Gz94NBMp2Yhk/B9nbRKBsJwCSMQWUaJyBDtUcxfnh3whWHUIJ+dE7chhz+z86Pe9gKZWNPRG09XhlXxO1r/6CUNUh7Gdezqgv34nU0s6s7o2H8JV8jH3elWRcfAvNO97GVfQ0pvwp5H9zdYf1JQkun5k75KZSiJiuQNCGZLFanQSB6iTea/HHNH3yAhF3HaCghNVpCVlX34Mpu5Cqp+8iVH2YSFMNqfOvIvOKO7UuXcd/9xWQw0gGA5Zxs/Ed3ELj2r9izBxLNORH9row5UwkWLG/y3sYLIMhY93K7nl1N6W1HiJNtdS8/LMOqoYY4frjAJjzJqMzmjHnT1W3dxLTtRj03L54csJ9gxlhdAUjjs4UBxIKf9hwuNNYbVSB2n/d38F7jRnHiLsWfVoO5nGzkN31+I9sA6D2tV9jzptEqPoIxpwJWKeeg85i19ZV5AjIYUCdtjvqku/EGWj7nMuIuKpxb3sDANldi+vjf5J+wc1x1yf73VT9/U5kTyOS2ca4H7zMA2tKmDMm/bSVys4Zk84L31nEuQ9+SMVz9yB7GtE7slEiIRrXPwGoRQ/mgmmYx8wkXH8CZ9EzBE8eJFC2CwDzmJkd1k0x6rh32fQhVwIMwugKRhDJvFiDrkprX9gZihxBbq4HEnuvaWd/jbSzv6YdX/nYt4m4qpGbavA11YDOgHXKIiRTSty6zTve1v7tP7qTOvdv4gw0QKj6sBp6SELj+48g+5ritgUiMo8WHT6tj+BZdjOLp2VzqEWd0F7VYMqZiLlgGhkX34Kk0+M7/DmevevRpziwzVpCxsWthRWDJXRyKgijKxgRdKU46MrgAkh6A6kLltO87U3q3/o9xlEFHYxj8ORBvPuLCDdUEHFVA5C94j7MY2ZS+/LPaPr0RfS2dFLnXQmA65MXaPrkBfT2USiSjkjDCSINJzoY6KzlP8RXuoW61x9IeG2evRvwlW4h7dwbaPr0RW27ogyOUtk7Fk/m45+9l1TRoDNbGbX0e4xa+r0O+0x6CUmSuHhaNrcvnjwkPdwYwuj2ksFaMSToSHcUB+5tb+LZs45w/QlQoqSdd5P2+N5WaRAN+UGnJ1xXRriurINxDNeXx3muIGEZOwud2YoxcyyhqkOE68tRlCiNax/Ds3MNxuxCws6TEAmRe/NDGLPHJzTQnRFpqqVx/eM4vnQtlnGz44yuegVqqezplFXFmuZ0V/kRQyfBnNFpXDE7nxXzhsdnSxjdHtJdUfzpluwIVHaXu1oy6Mk/6KHqw+gsdvSpWR0abPuPfkHEVa0muEq3gKKulbn8Hpq3vxlnHO1zLsU2ewmh2uNUP/1foEQ5+fc7sIybjffAJgDMY2fi2vQ8np1rQNJhSMtVDTgSoarDWMaeEWegk6EoUerfeRhDWi7pF36DYEVxh2MCkeigKJXtSdOc4RBG6IxhZ3T70wPt6hF1KFQMjTQeKTpMzebXO/di2ykOEo2WiSkNQrVl+A5+SqzsIXTyYJxxjAZ96MxWJEmHOXcCKZO/hP/QVmSPE1/Jpxgz8rGf9WVsMy7Ef2SHurgSxX/4s5YzKbg++Seh2iNxBjrcUE7TltdarlHFd2grSjhA6vzlBMv3YcwupO713yD71QGRSjhA7au/JHPZf6G3peMOhPvpN9wz2s5f++hgHRLESfBiWuPhEEbojGFjdPvSA01kuH2hCJtK6whEuo79DRbJzkin3hNkY2ldUi+2M8VBxFWjHWPOnwKAMXMsOksq0YDqNQYqDhCua5E5jZ1J1dN3YUjPxZCeh9zcgP/IdgCyrrwL2xmL486bddUPyLrqB9rPwZMHcW16jlD1kQ4GOnB8D959G+JeH649RjTgJXXeVerPsXBHjKiM/8g2TbY2mEplu2qaM1zCCJ0xLIxuTzzQjQfruHBqFlaToYMnXOH0d2q4AerfeZhA2S5kvxudyYopbzIZF30TU15rrKy9bOcBXjutkp2RzGs7VH1nVkuzlNp/3Y+/ndFtrzg48fD1KCEf0aCnw3o6kwXbGYvVmK0kEWkojzeOJ/bhP7KdwIm96IwWTHmTSZ13ZQeDmwhzwTRyb7w/4T7L+DmMuuI/CZYfIHBiD7K7DmPOBEw5EwnVHmX8j9/Rjg0c30PNiz/RJGOgeo/T81O7vIaBJtNuHlLlu33FkDe6PSnLVBTVAK89EP/Bsxiq+f3ag0QVpcO46bZEmmoxj5uNzmwlcHwPgWNfUNtQzpjbn9KOaS/bGQySnZFKSbW7wxdnImKKg4irGiXkA8AwakyH41yfvEDzjrcxpOeRe9NvMKTlxO3PvPz2vrnwRNdYfiDO2w3XHiNcewxDWk5cJ69EKMCKeR3vR3B6GNJGN5YkKf/37zv1QLtTQtndss62k0qD1Yepfvou5OYGFDmCpDcklO0MFsnOSMQdiHTvuG1v4iveFLdN0rd+NLzFm2j84FGiAQ/oDNhmXtTB4J4qkqQ2sOmsy1j7cERnWMbPifN8JUmNj4r33uBhSBvdR4rU6qFkHmjEXZe0hDL2OJaIzGV3IRmMcY1JJLMVY+aY1jZ0X7oWSW9IKtsZDJKdkYjD0r23t6TTY8goUL9AI2oM1LNnHXJzA8bMMbg2PtN6rF5P0+aXCVQWY516Do75yztftyUDv+rc8Ryr93YrcQR0mmTqDUO1VHY4M2SNbixJoiide6D+Yzup+9ev414nu2s5/uBVqkE1mnFtfBZ0egB0JivGUaMJniwBwJCRj2f3WiKualImztMakwS9TgD0qVmYR8/sUrYzWCQ7I43peQ7MhuqkIYZo0EfW8h9S/87quMf3qNeJd98GDKNGxx0fS0wFj++BaBTH/OUdWjh2loHvbuIoUZKpwRNk38kmemKDh3Kp7HBmyBrdWJIkhnvH24Trywkc3w20DMJLzyV1wdUARJxVWmYaVIMaPFmCYVQBlglnaZnrmME15U7CMvYMJIMprjFJ9T9/TLB8HymTFuI/uoO6N35L7o33dynbcQf69nFU0DUr5o9h9fpSmnd/QLD8AKGaI4Aqt4o01WKdugjnR09pigOdLZ2o1wVA1vJ7sJ2xmIpH1RLU3K//Fsu42UQDXsr/cAMAOV/7KQDzxqUzbpStywx8TxJHiY7tdh/fYaxxHQ4MWaPbPkniK/mUYPk+oNUDNWYUMOrS29T9pVs0oxszqJaxZ8Rlrk/+/U5NdpO68BqgVS4UDQfVOF/L4Dzz6BkEKvajBH1auWcy2c5gkuyMFLLsZi6ams0Lb3aehLIUnqUpDmKWLGXKIk1xILcY4VjFmWSyaOvIXic6i51xo2ysvuGsfr8foXEdHgxZo9s+SZJ384MokRD+o19Q9+/fUPfGbxl92xMY0nMBaNs2OGZQIT5zHTOYOmsathkXxK0fOnmQ2n/9GiXkRzJb8ez7ECXoQ2dNwzr1XOxzLtOObS/bGaySnZHAHYsn8/Ghe/Bf2XUSqvZf9+M/tBVTzgRtm96WjuyuQwn5AbT/q/syAAa08GCka1yHA0PW6MaSJDEPVNLpkQwmUibORzJZVA+0qUYzuqHqQ+oLJV2cQe1YKw/2uVdo4YQYvtLN6gdOklBCQRSjD+v080k770Z0FlvSaxWSndNHb2v+Y5hyJuJ31xGsKsUybjbBKvV9pHdka+0Z2z/FDERfjpGqcR0ODFmjG0uSNB0/SP3bv8c89gx0FjvB8v2aB2rKnaSVUPoOtZRaSjoa3vsLequDjCW3arXy/iM7qHvtl+ox0dZOSG0bk5hyJ5Fz3S/Q2zOSXltb2U57yY5olDPwdFXznyzm61j0NfyHP6fpkxcJ1x3XerymLboOiC88EH05BN1hyI7rqfcEOe+hD/HUltPw3p8J1x0nGvKjtzowj5lJ2nk3Ysou7FQSpnfkUHDrX9CZrep6a/6Id886QG0knXXV3QA4Nz6Le8srqoc8+xJ0LbE9Q0Z+UrlQjBSjnpdvW4SiDO3R2sOBPRWuhPHQ9sqFGLEeDd7iTarRdVaht2eQOncZjkUrkCRJm9H13r4qkeQSdIsha3QBbntuO+uKa5K+yaHVoNrnLCVz2fe17ZWP34YhPRe9fRTefR9qiZRY5ho6/0Cax86Kk6olQpXszABEZ6XBRNt46CeH66jzhHq1TmxG1/mTs3ocvoi9N8TfeeQxpI1ud0Y9y74mKh/9FkokRP6tf8GUXajta/jgUfxHtiN7G9EZLRgyCtT2fLMvOaXrams8AfGBHMR05z3UGSlGPb++5gx+9ub+Xr/+5dsWCZXBCGNIG13oWe+F/qa9ZEdRYOm3/wfnzrUJ2woqkTDOj/6B79BWZK8TfYoDS+FcMi75NnZHuvhADhC9eQ/Fvhg3HarnnaItOD9KPKwyNhG4Peaxs8hf+eCQnGYrODWGbCItRk8aI/clFqOOi6Zkt3QrSyzZue257XgrD3XaVrBpyys073gbyWzDOu08gloLPwXD8rtFo5wBorfNtb88K59fv1tM7WudD6u0z7lMawUJql5cdtdhzCgQfTlGKEPe6ELXovG+pLtx140Ha1lfXJO0rWCsqCL1zKVkLLkV9463ca57nEhT7ZD+QA5FhUZvCg8e23iky2GV6effpK0h+5rw7HofgNQFahJW9OUYeQwLowvJReO+UISNpXUE5WhyLwbVqEqAUa/rdbXP81vL+MXbB5K2iQRVD+w7tJXm3WuRvU4CZbuRjGYcZ39Vu57B+oFMZFgdFiMnGn1sOdoADD3JVE8LD0qq3YQUXZfDKmM071yDEglhGT9HK8AQfTlGHsPG6MboTDTemVwIOhrU0ekpva72icUHuzNd1pg1jpQJc/Ed3Ix3fxEA5nFzMGWNBwbnBzKZFjUZQ2mUUXcLD2JVkdYp5+Ar3drpsEpQx7d7dr4HQOqCa9qtMzhG6QgGhmFndDujp15Mb7zL7g5BjNH4/iP4Dm7GPu9KMi6+heYdb+Mqepq6Nx8k/5urgcH1gexuw5VkxEYZ3ffWfl7ZUcGyWfmDOuyQDIfFgOx3U/vqz1HCwaSTfL3Fm5A9jRgy8kmZvLDdOqIvx0hixBjdGP1ZPtnVEESApk9f7DAiO3BsF7qlZsz5UwEIN7R2UBssH8ieZPgb3vsTwYpiIu46JL0RU8FUMi6+BVP2eO2YqAJ7KpooqXIP+rBDZ0zPc6BrrlXbPeoMmPOnIhmMCSf5Nm9/C4DUBVcjtRl+qZPAkTLiPoYjmo6jTwW9ItEQRIBQ9RHq31mtlZjqUhwYMsdimbQQyah2rJKb62h4/y80vPcnAMxjZgKDZ7ZVTz14z+61SGYrtpkXIpmtBI7uoPaV+1AiHYsQQrJCMBJl7YEabnxyK89vLevjq+8/VswfgylrHDpLKkQj1Lx0L/XvPBw3yRcgUL6PUPVhJLMN++xL49aIKvDytvIhdd+CU0N8xfYRnQ1BjDTXET7yuXZc1O8m6neTMmmhVsevM9vw7F2PPsWBbdYSMi5We7gOlkY5sQkdbUk2pDN35e+wjFEr8SKuGiofuxW5uYFQ/QnMeYmnGAzFCcpZdjMXzxqL9/pf4GyZ5BuqPhI3rBLaeLlnLtXKyNsSiESH1H0LTg1hdPuIzoYgWqcsIv2WP3fY7vr0RZDDWMbPIfem33TYP1hmW7Wd0NGWZCOSYgYXQGnpP4ykQ28fhXvbm0nDL/5wlAfWlAyZCcpq68h6TO0m+YZqjlLz8s+0gglj5lgM6Xna/khTLc6ipwgc20U0HMDgyOJ/im9hzup7hsR9C3qPCC/0Ed0dggjJM9kxBstsq/YTOmLk3fwg2Vf/iMzL7yDr6h8BaEM6Y0RDfhreVROCji9di8E+qkP4JRGxCcpDgVjryBRj/Eep9l/3Ezi2E31qJimT5hNuqKBx7V8JHN+D7Gui+vkf4Sv+GGPmaOyzL8GQUYC/sWrI3Leg9whPt4/o7hBESJ7JhsE12yrZGPNEI5JiU3RlXxO1r/6CUNUh7GdeTvpiNWSSrFgkxlArDImFBO5/t5hAJNplwUTg+G7k5gZssy7pMOF3KN23oHcIT7ePUPv7du/X2VkmG9Qx3IOp2U0yD95X8imenWuINFZqI5JAfXSufv6/CVUdwrFoBZlX/CeSJPXovLHCkKHCykWF3LBwLDpJHd8eqzirf+v31P37N3EFE7EvKdnTSPmfV1L+h5uof/v3yL6mIXffgp4jjG4fsWK+mvBq3v1BnFrBd2gr9e+sxle6BUieydZJ8NQ3Fw4agwvJPfi8mx9k3D2vk/3VnyJ7Gql747dEXDVUP3ePaogd2SiREI3rn6Bx/RMETx7s9nkHY2FIVzT5w1oVonXKOejTcgnXleE7uBl0eq1gQvapg0uDFftJmbgAnTUN7/4iGt77M4FIlC1HGk7jXQj6G2F0+4jYEMRghToEUXarFVvh2mN4920gVHMUSJ7JXjozlwumZg/shXdBIg8+Gg6itEzXaDsiiahMpKkG2dMIgOyuo3n7W9p/bXWr3WEwFYZ0h9hTQaxgQm6qIffmhxhz10uYcifQ9OmLeHa9j96aBoBtzmVkXXkXWcvVhvn+o9tRojKbDtUJCdkwRsR0+5DuDEHM/krHKRag9lYdDImz9sTGmLcldDL5iKTYqKJTZbAUhnSX2FNBxFWTtGDCmFNIsLK49YUt0hDJYAJJR1RBSMiGMcLo9iG9HYI4mBJn7Yl58G0ndOhTMzFkFKhyp5YRSd0d0plsHlnbBjGDpTCkJ8Tm9kUzx6KzpBINNFPz0r0Y0vPiCiZMuZPw7F6LZ9cHeL54V3u9/YwlWux7qEnnBN1nyDcxH4x0t0fBUBnPcyrTFdrT1TyyGLHZY0Mpix+b2xeMRAmePIirpWAi1tjcftaXcSxUJYKefR+pcjpF/XI25U0hb+VDqrfbQmwckOipPLwQRref6ElXs6HgyQzkhI6hbGy6M7dPURRqX7oX2evCmD0eX/HHpC64mlGX3tbh2KH45SNIjggv9BM97Wo22BnICR2DpTCkN8Qq1JI9FTRve5NAxQHy/+Nh3NveTLreYO6pLOgdwuj2M/3Z1Wyg6e50hXMnZTI+08quEy72VDZ12cy9LYM5vt0duorrh+rKcG58hvQLVmLKndjlekNROidIjjC6gh7RUw9+uMW3u0Ps+u97a3+HLxzfwc0gRwic2EuwfD+h2mMA+A99htNgImPxqg7rDTXpnCA5wugKekV3PfjezB4bDqxcVMi64ho2ltbH71AUQCFwdEfc5khTDcHKkoRrDTXpnCA5IpEmGDCGS3y7uzy28Qir15cmHWkUU3N0lkizGHT84LKpwyZEJRCermAAGU7x7e6QqLCkpwyWnsqCvkN4ugJBP9IdCVlnDGXpnKBzRO8FgaAfuWPxZCwGfa9eO5Slc4LOEUZXIOhHOmty3hVDXTon6BwR0xUI+pmeFJYMJ+mcIDEipisQDBDDrTRc0DuE0RUIBpiRJp0TxCOMrkAgEAwgIpEmEAgEA4gwugKBQDCACKMrEAgEA4gwugKBQDCACKMrEAgEA4gwugKBQDCA/P9i7cob++LFNAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# the OH hydrogen at the beginning(?)\n", + "print(system.bonds[1])\n", + "print(molecule_mapping_index)\n", + "graph = nx.Graph()\n", + "\n", + "unsorted_particles = []\n", + "unsorted_bonds = []\n", + "type_counts = {'ca': 0, 'oh': 0, 'c': 0, 'o': 0, 'os': 0}\n", + "# make a networkx graph with disconnected subgraphs of just ca-type carbons\n", + "for i, particle in enumerate(system.particles):\n", + " if particle.type == 'ca':\n", + " graph.add_node(i)\n", + " else:\n", + " unsorted_particles.append(i)\n", + " type_counts[particle.type] += 1\n", + " print(particle.type, i)\n", + " \n", + "print(type_counts)\n", + " \n", + "for bond in system.bonds:\n", + " if 'o' not in bond.type:\n", + " graph.add_edge(bond.a, bond.b)\n", + " else:\n", + " unsorted_bonds.append((bond.a, bond.b))\n", + " print(bond.a, bond.b)\n", + " \n", + " \n", + "print('unsorted particles:', unsorted_particles)\n", + "print('unsorted bonds:', unsorted_bonds)\n", + " \n", + "print('graph edges:', graph.edges)\n", + "print(list(nx.connected_components(graph)))\n", + "plt.figure()\n", + "plt.title('BEFORE')\n", + "nx.draw(graph, with_labels=True, font_weight='bold')\n", + "\n", + "# almost there. need to put the bridging ketone carbons into one bead\n", + "# and split those big groups into two\n", + "print(len(unsorted_bonds))\n", + "for i, bond in enumerate(unsorted_bonds):\n", + " if 'o' in list(system.particles)[bond[0]].type:\n", + " c_idx = bond[1]\n", + " elif 'o' in list(system.particles)[bond[1]].type:\n", + " c_idx = bond[0]\n", + " print(c_idx)\n", + " for graph_bond in graph.edges:\n", + " if c_idx in graph_bond:\n", + " graph.remove_edge(graph_bond[0], graph_bond[1])\n", + " break\n", + "\n", + "\n", + "plt.figure()\n", + "plt.title('AFTER')\n", + "nx.draw(graph, with_labels=True, font_weight='bold')\n", + "# then for each ignored O, just put it in the first atom it's bonded to\n", + "# and don't forget the ignored C's" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['oh',\n", + " 'os',\n", + " 'c',\n", + " 'o',\n", + " 'os',\n", + " 'os',\n", + " 'c',\n", + " 'o',\n", + " 'os',\n", + " 'os',\n", + " 'c',\n", + " 'o',\n", + " 'os',\n", + " 'os',\n", + " 'c',\n", + " 'o']" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[system.particles[i].type for i in unsorted_particles]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N_atoms: 13800 \n", + "N_molecules: 100 \n", + "N_atoms_per_molecule: 138\n" + ] + } + ], + "source": [ + "# get total N atoms\n", + "N = sum([len(m) for m in molecule_mapping_index])\n", + "# get molecule count\n", + "M = len(molecule_mapping_index)\n", + "# atoms per molecule\n", + "MN = len(molecule_mapping_index[0])\n", + "print('N_atoms:', N,'\\nN_molecules:', M,'\\nN_atoms_per_molecule:', MN)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# create a mapping for our molecules\n", + "# these are 100 4-monomer polymers, so let's try a 4-bead mapping\n", + "# therefore, we need a 4 x 138 matrix\n", + "# rough estimate for 4-bead mapping TODO: check this\n", + "mapping_arr = np.zeros((4,138))\n", + "\n", + "mapping_arr[0][:35]+=1\n", + "mapping_arr[1][36:71]+=1\n", + "mapping_arr[2][71:105]+=1\n", + "mapping_arr[3][105:]+=1\n", + "\n", + "bead_number = mapping_arr.shape[0]\n", + "\n", + "cg_mapping = htf.sparse_mapping([mapping_arr for _ in molecule_mapping_index],\n", + " molecule_mapping_index, system=system)\n", + "assert cg_mapping.shape == (M * bead_number, N)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "class MappingModel(htf.SimModel):\n", + " def setup(self, CG_NN, cg_mpaping, rcut):\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "uli-htf", + "language": "python", + "name": "uli-htf" + }, + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From b5c76325fb46e8042ebe8b407fbccb33a1a2c253 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 20 Jan 2021 13:20:36 -0700 Subject: [PATCH 02/35] Initial bead count correct --- Notebooks/HTF_CG_Demo.ipynb | 260 ++++-------------------------------- 1 file changed, 29 insertions(+), 231 deletions(-) diff --git a/Notebooks/HTF_CG_Demo.ipynb b/Notebooks/HTF_CG_Demo.ipynb index 4997ffb..f6a7c57 100644 --- a/Notebooks/HTF_CG_Demo.ipynb +++ b/Notebooks/HTF_CG_Demo.ipynb @@ -74,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 28, "metadata": { "scrolled": true }, @@ -89,223 +89,18 @@ "type : ca-ca\n", "\n", "[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87]]\n", - "oh 0\n", - "ca 1\n", - "ca 2\n", - "ca 3\n", - "ca 4\n", - "os 5\n", - "ca 6\n", - "ca 7\n", - "ca 8\n", - "ca 9\n", - "c 10\n", - "o 11\n", - "ca 12\n", - "ca 13\n", - "ca 14\n", - "os 15\n", - "ca 16\n", - "ca 17\n", - "ca 18\n", - "ca 19\n", - "os 20\n", - "ca 21\n", - "ca 22\n", - "ca 23\n", - "ca 24\n", - "c 25\n", - "o 26\n", - "ca 27\n", - "ca 28\n", - "ca 29\n", - "os 30\n", - "ca 31\n", - "ca 32\n", - "ca 33\n", - "ca 34\n", - "os 35\n", - "ca 36\n", - "ca 37\n", - "ca 38\n", - "ca 39\n", - "c 40\n", - "o 41\n", - "ca 42\n", - "ca 43\n", - "ca 44\n", - "os 45\n", - "ca 46\n", - "ca 47\n", - "ca 48\n", - "ca 49\n", - "os 50\n", - "ca 51\n", - "ca 52\n", - "ca 53\n", - "ca 54\n", - "c 55\n", - "o 56\n", - "ca 57\n", - "ca 58\n", - "ca 59\n", - "ca 60\n", - "ca 61\n", - "ca 62\n", - "ca 63\n", - "ca 64\n", - "ca 65\n", - "ca 66\n", - "ca 67\n", - "ca 68\n", - "ca 69\n", - "ca 70\n", - "ca 71\n", - "ca 72\n", - "ca 73\n", - "ca 74\n", - "ca 75\n", - "ca 76\n", - "ca 77\n", - "ca 78\n", - "ca 79\n", - "ca 80\n", - "ca 81\n", - "ca 82\n", - "ca 83\n", - "ca 84\n", - "ca 85\n", - "ca 86\n", - "ca 87\n", "{'ca': 72, 'oh': 1, 'c': 4, 'o': 4, 'os': 7}\n", - "1 0\n", - "1 87\n", - "2 1\n", - "3 2\n", - "4 86\n", - "4 3\n", - "4 5\n", - "5 6\n", - "6 7\n", - "6 85\n", - "7 8\n", - "8 9\n", - "9 10\n", - "9 84\n", - "10 12\n", - "10 11\n", - "12 83\n", - "12 13\n", - "13 14\n", - "14 81\n", - "14 15\n", - "15 16\n", - "16 17\n", - "16 80\n", - "17 18\n", - "18 19\n", - "19 79\n", - "19 20\n", - "20 21\n", - "21 78\n", - "21 22\n", - "22 23\n", - "23 24\n", - "24 77\n", - "24 25\n", - "25 26\n", - "25 27\n", - "27 28\n", - "27 76\n", - "28 29\n", - "29 30\n", - "29 74\n", - "30 31\n", - "31 32\n", - "31 73\n", - "32 33\n", - "33 34\n", - "34 72\n", - "34 35\n", - "35 36\n", - "36 71\n", - "36 37\n", - "37 38\n", - "38 39\n", - "39 40\n", - "39 70\n", - "40 41\n", - "40 42\n", - "42 69\n", - "42 43\n", - "43 44\n", - "44 67\n", - "44 45\n", - "45 46\n", - "46 47\n", - "46 66\n", - "47 48\n", - "48 49\n", - "49 50\n", - "49 65\n", - "50 51\n", - "51 52\n", - "51 64\n", - "52 53\n", - "53 54\n", - "54 63\n", - "54 55\n", - "55 57\n", - "55 56\n", - "57 62\n", - "57 58\n", - "58 59\n", - "59 60\n", - "60 61\n", - "61 62\n", - "63 64\n", - "65 66\n", - "67 68\n", - "68 69\n", - "70 71\n", - "72 73\n", - "74 75\n", - "75 76\n", - "77 78\n", - "79 80\n", - "81 82\n", - "82 83\n", - "84 85\n", - "86 87\n", "unsorted particles: [0, 5, 10, 11, 15, 20, 25, 26, 30, 35, 40, 41, 45, 50, 55, 56]\n", - "unsorted bonds: [(1, 0), (4, 5), (5, 6), (10, 11), (14, 15), (15, 16), (19, 20), (20, 21), (25, 26), (29, 30), (30, 31), (34, 35), (35, 36), (40, 41), (44, 45), (45, 46), (49, 50), (50, 51), (55, 56)]\n", - "graph edges: [(1, 87), (1, 2), (2, 3), (3, 4), (4, 86), (6, 7), (6, 85), (7, 8), (8, 9), (9, 10), (9, 84), (12, 10), (12, 83), (12, 13), (13, 14), (14, 81), (16, 17), (16, 80), (17, 18), (18, 19), (19, 79), (21, 78), (21, 22), (22, 23), (23, 24), (24, 77), (24, 25), (27, 25), (27, 28), (27, 76), (28, 29), (29, 74), (31, 32), (31, 73), (32, 33), (33, 34), (34, 72), (36, 71), (36, 37), (37, 38), (38, 39), (39, 40), (39, 70), (42, 40), (42, 69), (42, 43), (43, 44), (44, 67), (46, 47), (46, 66), (47, 48), (48, 49), (49, 65), (51, 52), (51, 64), (52, 53), (53, 54), (54, 63), (54, 55), (57, 55), (57, 62), (57, 58), (58, 59), (59, 60), (60, 61), (61, 62), (63, 64), (65, 66), (67, 68), (68, 69), (70, 71), (72, 73), (74, 75), (75, 76), (77, 78), (79, 80), (81, 82), (82, 83), (84, 85), (86, 87)]\n", - "[{1, 2, 3, 4, 86, 87}, {6, 7, 8, 9, 10, 12, 13, 14, 81, 82, 83, 84, 85}, {79, 16, 17, 18, 80, 19}, {74, 75, 76, 77, 78, 21, 22, 23, 24, 25, 27, 28, 29}, {32, 33, 34, 72, 73, 31}, {67, 36, 37, 38, 70, 71, 39, 40, 42, 43, 69, 44, 68}, {65, 66, 46, 47, 48, 49}, {64, 51, 52, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63}]\n", - "19\n", - "1\n", - "4\n", - "6\n", - "10\n", - "14\n", - "16\n", - "19\n", - "21\n", - "25\n", - "29\n", - "31\n", - "34\n", - "36\n", - "40\n", - "44\n", - "46\n", - "49\n", - "51\n", - "55\n" + "unsorted bonds: [(1, 0), (4, 5), (5, 6), (9, 10), (10, 12), (10, 11), (14, 15), (15, 16), (19, 20), (20, 21), (24, 25), (25, 26), (25, 27), (29, 30), (30, 31), (34, 35), (35, 36), (39, 40), (40, 41), (40, 42), (44, 45), (45, 46), (49, 50), (50, 51), (54, 55), (55, 57), (55, 56)]\n", + "os\n", + "27\n", + "targeting: [55, 4, 6, 6, 6, 10, 14, 16, 19, 21, 21, 25, 25, 29, 31, 34, 36, 36, 40, 40, 44, 46, 49, 51, 51, 51, 55]\n", + "['ca-oh', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'ca-ca', 'c-ca', 'c-o', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'c-o', 'c-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-ca', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'ca-ca', 'c-o', 'c-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-ca', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'c-ca', 'c-o', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca']\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAD3CAYAAAC+eIeLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABVeElEQVR4nO2deXxU5b3/32fO7JmZJGQPW9gXWWRRQVQWlyqIei1arPZqtdVba3u1tb3+6u1ye0trq1dubbVWq9WrrbVSK6KoIBhwAUWWIEsIAQJJyDbZJrPPnDm/P07mJEMmC1vI8rxfL15kznnOc+YkZz7znO8qqaqqIhAIBIJewXCu34BAIBAMJoToCgQCQS8iRFcgEAh6ESG6AoFA0IsI0RUIBIJeRIiuQCAQ9CJCdAUCgaAXEaIrOKsUFBRgs9lwOBykp6ezZMkSysvLAbjjjjswm804HA793/Tp0wEoKytDkqSk+wAqKiq49dZbycjIICUlhQsvvJC33nor4dySJJGSkoLD4WDo0KF873vfQ1EUff+CBQuwWq0J51i6dGkv/FYEgxkhuoKzzpo1a/B6vVRVVZGTk8N3vvMdfd8Pf/hDvF6v/q+oqCjh2Kampg77GhoauOSSSzCbzezduxe3280DDzzAV7/6VVatWpVwfFFREV6vl02bNvHqq6/y/PPPJ+z//e9/n3D+NWvWnKXfgkCgIURX0GtYrVaWLVvGvn37TmuelStX4nA4eO6558jNzcVms3HLLbfw8MMP8/3vf59kSZZjx45l3rx57Nq167TOLRCcLkJ0Bb2G3+/n1VdfZc6cOac1z/r16/nyl7+MwZB4+958880cO3aMkpKSDscUFxfz4YcfMnbs2NM6t0BwugjRFZx1brjhBtLS0nC5XKxfv54f/OAH+r7HHnuMtLQ0/d/tt9+ecGxmZqa+77HHHgPA7XaTl5fX4TzxbW63W982c+ZMUlJSmDRpEgsWLODee+9NOOa73/1uwvl//OMfn7HrFgiSYTzXb0Aw8HnjjTe44oorUBSF1atXM3/+fN3E8OCDD/KLX/yi02PdbjdGY+JtmpmZSVVVVYex8W2ZmZn6th07djBmzBhee+01HnroIXw+HxaLRd//xBNP8I1vfOO0rk8gOBnESlfQa8iyzI033ogsy3z00UenPM8VV1zBP/7xD2KxWML2v//97wwfPpzx48cnbJckiZtvvpm5c+fy85///JTPKxCcCYToCnoNVVVZvXo1jY2NTJo06ZTneeCBB/B4PNx1111UV1cTDAZ55ZVXWLFiBY8++iiSJCU97qGHHuKZZ56hurr6lM8tEJwuQnQFZ52lS5ficDhwuVw8/PDDvPjii5x33nkA/OY3v0mIk21vGuiMjIwMPvroI4LBIJMnTyYjI4PHH3+cl156ia985SudHjd16lTmz5/Po48+qm+77777Es4/a9as079ggaALJFHEXCAQCHoPsdIVCASCXkSIrkAgEPQiQnQFAoGgFxGiKxAIBL2IEF2BQCDoRURGmuCkcHtDrNpeQXG1B08wistqZGKui5tmDSPDYel+AoFgkCNCxgQ9oqi8iScLS9lUUgdAKNqWDWY1GlCBBROyuHf+WKYPTzs3b1Ig6AcI0RV0y8tby1ixtphgVKGru0WSwGqUeXjxRG6bU9Br708g6E8I84KgSzTB3U8gEut2rKpCIKKwYu1+ACG8AkEShCNN0ClF5U2sWFvcI8FtTyASY8XaYnZXNJ2dNyYQ9GOEeUHQKXe/9Dnr99dQ9fJDhMr3JOwzZY4g/xtP6a+VgIeq5+5D8TYgWVIY8cCr5KVauH3uKOFkEwjaIcwLgqS4vSE2ldQl2HCds6/Tf5YdQxLGN7z7JIq/OWFbVXOIle+XsPL9EuFkEwhaEaIrSMoTGw4SURLNCkOuuDvpWO8XG/CXbCH14q/Q/PErCfviUQ7r9tWwucQtnGyCQY8QXUEHXt5axl8+PUrsBMNT+UqtbKI5dwxpC+7AkjeeaHMtDe//EdeFN2AdMbWD6MYRTjaBQEOIriCBeLSC0k5wDWYbtjEXIDszCFUWEzy6m9pXf0LeXU/ifutxDFYHwaO78Xz+JgBqOIAS9BI8spPmj/5K1FMHqBhTc3DOXMIKJKYNS2PasLRzco0CwblEONIEOkXlTSx/diuBiJKwXVVVvRuDqkSo/OM9KJ5aMpY8QP3bK7VBkoTB4iAWbAHAOnI6lmGTCFUdxJiajeJxEzi0DYCcr/6SG665kqdvm917FycQ9BHESleg82RhKcGoQvVfOo9W8BV/jOKtB6B+7W/bBqiqLrgAwaNFZFzzXdIuvU3fdvy5+4jUlRFtrOaDA3XUe0MiqkEw6BCiKwA6j1aIhfz49mxEjSnUv/t7/Ac/hZiCZDRjyhlNuLIYAHPeeCJ1ZajRMBjNjHzwdQBCxw/g21tItKmaSF0Zpozh2MbPQQJW7ajgnsvGnIOrFQjOHUJ0BQCs2l7RYduQK+4mFvIjGQwEj+7Gt2cjksWObdwc0i77GrGQn5qXfwBA1FOHZfhUgke2QzSMv2QL9vFzibjLadm+RptQMmAdPROD2UYwGqO4qqXDOQWCgY4QXQEAxdWehCI2kBitkHn9D7Hkaa3NQ8cP4N31LuHaMn1s5rXfwzZqBvXr/oB3x9v4D36KffxcHNOuIGXqIqJN1bjf+DUt21Yj21ykXvwVPMFIr12fQNBXEGnAAgA8waj+czxawT7pUmRXlh6toHgbAfTVa6j8C/0YydRqm221TxjMNmIhv7ZPMmBKz8ecN047vqESAJfVdNavSyDoa4iVrgAAl7XtVsha9pOk0QrBY7tJmTw/YfVa/fJ/EPM1UvePX2AbeyH+/ZtBMpBy3gKqXrgfY1oOxrRclJZ6Aoc+B8A2aiZGCSbmOc/JtQoE5xKx0hUAMDHXhcVoIBYJongbkg+SDB1Wr7axFwCgRoL4iz/ElDmS7GU/xpI/AWvB+UTqK/HuXk+oYh/m3LFkLHmAlPMWEFW1UDSBYLAh4nQFgBa9MO/XG/G5q6h89h6sI6djdGURqiwmUleGISWN/LuepPqlH3RcvaoxnLOvJ1Sxj4j7KMhGzFkFZC37CbLVASQviGMzybx69xyRJCEYVIiVrgCATIeF+eOzkO1OHFMWEW2oxLdnI5F6Laoh5mui4olbiTYeJ3h0N97d6wke3Y1kNINsouXz1YSrD2LKGknKhEuIhfyokaA+f7KCOMGowlOFpb16nQLBuUbYdAU6314wlg8PupGu+a6+LZ4ocWKFsdQ5y3C/tZLAkR0Q9qO2JrGFqw6SevFyMha3zdFZQRxVRSRJCAYdYqUr0Jk+PI2HF0/EZup4Wwy54m79X+qcZQA4Z11LzvL/Ro2EkIwWDK2mBPdb/0PL9rcAOhTEOZF4koRAMFgQK11BAvHqXz9bs49ouzJjySqMWfLGEazQqoap0RCgjVcjIRrWP43sGILn8zcxpuaQdtnXCLWObY9IkhAMNoToCjpw25wC1u+vYVOJu9MKY/nf+AOyIx3Z7tKPU6NhjOl5WEdMxVu0Dn/pZ4TK92DKKqDu9V+iBDzauEiQ2tf+i4zF/46ckjZgkiREe3pBTxCiK0iKbNBMDN3F7BpTs0E2gRJBdmSQs3wFzVtXARBrFdlIXRmRurK2yWMKgUPbUCMhoP8nSXTdnr5adM4QJCBEV5AUl9VILBIkFvRhdGZ0HCAZUNUYDe8/C4q2UpVMFpo++queIJF68VfIXvYT/ZDg0d3UvPIjPWQMwGo09Oskie7a0wdF5wzBCQjRFSRlYq4LY6iFI09/MyFmV/HUYkhJwzpyGk2bX8a7cy0gYcoaSbSpCt/eD5AdQ8j40r1Y8id0ex4VWDZz2Fm/njNFexPC/ioPpbXehILvnSE6ZwjiCNEVJGXZrGH8z9tazG7w6G5Cx75IqDAm21NRWupbR6sJ5oOY34NtzAWEaw7TuPFPhKoOooYDyK5sRj70lj5OkmDhhKx+Ye9MZkLwbFuNd/d6Iu5joMZInXcLaZfeqh8Tba6lsfDPBI/sIhYJYnRlkjb/DtE5Y5AjRFeQlEyHhYVTR7Le+N2kj80Amdc+QLS5JmkcL2jlHhVfE+bs0YQq9nY43mqUuXfB2LPy/s8knZkQwtWlGKwOZGcmiqc24RjF30z1yz9AaanHMnQipqwCop46os01BCIKD75WxCvfnNMvvnAEZxYhuoJOiSdLnNi+JxnJOgXbx12EfdxF+Eu2UJdEdP/98rF9frUX7xkXiMQ67Mtc+n0Aav/xCwIniG7L52+itNSTMuVyMq99oMOxJbVe5j6ykYUThYNtsCFEV9Ap8WSJzkSnPcnieLvCKKFHRfRVisqbWLG2uNtrT0bwaBEAireB8t/dBoqCbcws0i//JrI9FYCwEhMOtkHIgBXdnsZMitjKrokLQWce+u7ieDsjqtLnkyKeLCylufIgjR/8mXBVqRaHnJqNc9a1OGcuAcBX/JEusJ7P30QyWUidswzFr4XLhSr2Yp90GaHKYnx7C4mFg2R/+T/1cwgH2+BjwFUZ6zpm0oAKLJiQxZUTc1i3v6bbceLRT2N3RRNPFZbywYE6IkqMeLJaZ52CM6/7ASmT5wNo5oXXVyC7shl27/P6nJdPzOa52y/o9WvpCfGqa4eeuAPFU4spqwDTkHz8B7YAKjm3/BLJaKL6pR9qHkE1hmS2oYYDGBwZxFqbd5pyx5F/x0pCVSVUv/i9pOeyDJ9C7q2P9Kuqa2KxcuoMqJVuj2Mm99bw3t6aTucRsZUdmTYsjadvm029N8S/Pv8pe6tauo3j7Y6+nBSxansFqhJFaXEDkHndg5izCqh64X7C1aVEm2u0Jp2oGDOGE3Ufwz5uDr69HxALeHQB1onfkLIR5/mLQdK+jBRPHab0fKCt6lpfbk1/MokgQ9NtQpiTMGBEtyuHx4n0dGl/4qPf1VPyBv1NlOGwsHT6UErrSvA1NXeovds+jjdSX07zllVEPdoHNBbw4H5rJbLdRd5V3+zTSRHF1R7CqgHn7KW0bFuN+83HMA3JJ1x9CFP2KOzj59K4UVu1x1pLVoZqDmsHKxHM+RMIle8hUnMI99v/S+i41jXZOf1qhlx5N4q/Ge+ud7Vts5cCfb/qWk8XNe/trWH9vhoMkoRskESG3gkMCNHtzOERrjlMY2Hn9rh4hlQyMhbfj2PaFQAEIjF+8uZe/uutfRgkcRMtmzWMle+XYLB1HccbqTuKb88G/Tg1EsS3ZwOyKxv1qm/26aSIeM84+7i5+Eu2tqUyG4zYx81BMtuIhXxAm+hG3UfbJjDI2n/2VHz7NiGnpOOaexNp824BoGXnWtRoGOvIaZizR+mH9dXW9CezqAGIqRBT1YSiSSCeImGAiO6ThaUEox3Dmmr/8YsO9riGdX/AlDEc68hpyK7MhPhSNRzEu3sdAMb0vIS5YirEFJUT18mD8SaKFzxfvz9GRrvauydiHTktIRkiTn9Iiqj3hlACHmpf+ylqJETOrb/GlDWS2ld/TPPHryCnpCE7M1A8deR89VdYR0wlFvRS/r/LAZBkzXTiPP/qhIQJAFWJ4t35jrZ/9vUJ+/pK1bX2NtuKxgA7jzWiqOA/8AnNW17r0CFEaa7tkAjT3n5/IoPZgdjvRdftDbGppK7D40539jgAU3p+Qnyp5/M1AJhzxmAdft5JvY/BdhOdTAzvifT1pIii8ib2HvcQbarRivIYjFjyxiMZTZgyhhOuOkjEXY45ezQBTx2hqhKsI6YSqjoIgOzKQpI7/2j59m9G8TZgTM/Te8y151xWXevKZuvbtwn3m4+CbMI+fg4Gk41QVQlqJKgnwsjOTKL15SieWo6tvFkX5eDh7bTseJtIfQVqJIQxLQfXBTfA9KtYsbZ4UGXo9XvRXbU9eQFsSTZ2aY87EVVVadmuia7zAm310ZV5wrv7ferX/m+HeXJvX8mKtQM/zfNkYnjbYzMZeHjxxD79u3n4D69y6Ff/1rYhFuXYY/+i/dzqIIy2uAlVlQDQ9MELBEq3EW08DkDqnJu0jhqd0PL5mwA4Z1+HlMTheK4cjF3ZbFVVpbHwBQBybv4vrCOnJew3OjNRI0FNlAHJaCFlwiW6KAcO7yDaVI1t9EwUXzPBsp3Uv/MEBnsq0viL+rwD8UzS70W3uNqT8G3cnq7scScSKP2MaONx5JR0UiZdCnRtnohjLZiBKbPttZyS1i+80GeC7mJ42yNJ2gq3r5tf3N4Qe5uNutlJ8TYSqtird0iWnZnIzgwCB7diTM/HlDGcUPkeQuV7dEFuWPcUktkOgP/gViKN1aghL+G6Mm2emAIGI7axF3U4/7mqutadzTbaeBzFU4dktND86T+oXfVzzU59wfU4Z12bIMqg2bLbt2xyzrqWjGvu080u8TZQwbJd2Mdd1KcdiGeafi+6cYfHiXRnj4s70+K0fL4aAMfMxUiyqQfmCS02NWXyfN3hFqeve6HPJLfNKWDasDQ9hleizc4NbTHPCydkce+Cvp/2u2p7BeYhHc1Oje//EXPOGPK+/lvKf/tVADKu+Q7WEVPxbFtN44ZnMVhSUJUIaiSIGtZa1UdqjxCpPQKAZElBTknX7qtYlOYPXybz2sTY3XNRda0nmXfxZA81GiLaVIN94iX492/WOoQ4MzBljkDx1IFsBCWK4qmj8ulv6qJsyRuXOGFM+9zKreGGfdWBeDbo96Lrsia/hBPtcZGmKn210vD+M/iKPwI1RqTuGLFIUKsJa5BxzlgMaOYJx/lfwrvzHaqeu0/zRsdiunnCX7JVm2vDMzSsewrZlY1zxjW4Wk0Tg+kmah/Du2pHBcVVLXiCEVxWExPznCyb2X9C6k58ckpmdpKMZgDC1Ycw540nHBdVsxVLznkEDm5NqDjmXvM/+PZ+gHP6VaQvugvP9jU0rv8j0ebEeg3nysEYd0R35iSTrQ7C1Qf18bGQD1PGMFKmXYl3x9v4D36Kw56m7VQ0MZVMFhRvvS7K7U16ns/+SaiyGGN6nv556ysOxN6g34vuxFwXFmN1BxODKWM4BquTWLCF6r8+RKT2CGo0DGiOstCxL7RxWSORwgGU5lqIKUTqjiK32qsi7vK2CVsfCU1DhlL9yn8SqTsCkgHJaMY87DyCh7fTuOFZJJMF5/lXD6qbKE6Gw9Lvv2ROfHJKZnZKnXszDeueonHjn2jc+Cd9rOJthJyOczpmXIP/4FZaitah+BoJlhUhmSy4LroxYdy5cDDGHdHevZ07yUL15TS+/0zbQWqMpsIXsAyfAmip4O3bNgEYbC5sYy/QRTkuuk0f/ZXmj/6KMS2XnOUrMFjs+jEDpW1Td/R70Y3HjJ6IwWwl++af0bT5JUKVBzTBNcikL7wT58wlHHv0BgBsEy+hZctr+nHxyAbP9rc0O10csx2j3YW/+COQDNgmXIxsthOqKiHj6m/Tsv0tPFtX4T/wMc7zr9bmGCQ30UDixCenE81OAM6ZizHnjiFwZCegIjsyaHjniQ7CE8eUOQLbqBn4D3yCb28hAJYR0zBnjtTHyBLnxMG4antFt06yhnVPA2AtOJ9g2S59pR+3Y6ect0D/fBHTolliAQ/Bsl2AJsqqGqNh3dN4d67FnDOG7Jt+1qE2R1/OUDyT9HvRbYsZrengyLHkTyBn+S8IlO2i9m//iWQ0Yxt3EYqvCYxmiIbxbn8b25jZ+A9swZRdgH38XL34NKDfSJIkofgaAbCNvZD0+f+qp28m0M4bPVhuooFE+yencG0ZwaO7kYxmnDMWtxUtrzsKqLoJwf3WSgAMNifBIzsBLfnBlFVAysR5NLz7JP4Dn+CYuYT0hXfSsn0NTYUvULf6EfJu144dm+04Jw7GLYfr8dVVdOkkC9ccAsA1Zxnm3LF4d7+vH28cMpTq//t+h3nVSJBoQyUALdvX6CYagKi3nuat2kLHmJ6Ha9bSft+26WTo96IL3ceMWkdMxTJsMqGKfRx/+hsJ+2L+JvwHPkmIbHD/4xcY03KJtdQTC3oB7SaKf4tHm2s4/sw9IMmYc8ciO9IJHPwUQC/yYpAYNDfRQKL9k5OndZWbMnkBsj1VL1ouWVNQg14CpZ8RLNtFqHI/yEYidUeRTFYA1HAA9xuPYPzabzQbKWDJHYvBZNHLXkbq28IdJ+el9uZlAlrEwocH67p1kim+JgAMVgfpC+4g7bKvcew3rfbt1ut1zr4OVY0Rriwm0lAJagyDJQVz7jiMaTkEjuwkWq+Z62K+Jj1szjJ8Cq5ZS/td26bTYUCIbjxm9Cdv7iWWJGxJMsjk3PJLfMUfEnGXY7A6aSr8M6gx7OctZMiV9+iRDUiS3jbclDGccN1RzRMdaxN0NRrBnD+RcGUx4ePFml03exTO2dfhmLJIHzdYbqKBRPzJ6d3tJfj3bQLAeYEWPhYvWl71fw8SPl5MuPYIksmCbcwFBFrLO0omC2okiGR1oHobaFj/RyzDJhNxH6Ox8EVCxw/oj92WYZOBcxMmFg8Ri6kkmEUyl34PS9546k0W3R4rp6SheOr0Aj7tC/nEk0CSFbFvj+JvpvKpr6NGw+Td+bvE1Od+kKF4JhkQogta6NJr2ysoqmjuZISK47yFAJotTtUcb47zFiJbHXqmUbg1qyihZfgJ6Dfmuj/g3fE29kmXkbnk/oQxuS7roLmJBhrxJ6cRD76edL+ckgZA6sVf0SMUjj32ZVTa6jDEWiNlIg3HtTKQBhl/6Wd4v3gf2eYiZcoi0hd+Hej9MLETQ8SMqdlIFjtqyN82qNVWZzDbus68a60x0V0R+85qTUDfz1A80wwY0QW4Zkoe+6s8hJO0Z63524+R7S4kSwqBQ5/r25s/+Ru+fYX49m0GIGXKQrJv+qm+v61tuOZl7ezGPJGrzkvixhb0C04l2y590V00rHuqw3Y1GsZgsTPkqm8x5Kpvddh/LlZ5TxaWcuTFHxA6tqfDPvdbj2PJG49vr7bKb9m5FtmZCUDzR68QqTuqr9RT59xE4NC2bovYd1VrQpakPp+heKYZUKLbZo/rKLrm7FH49n9ILNiC7BiC/byFxLz1hGuOaOnB6Xk4zr+alEmXdTK7hGv2dTR//Ip2Y+ZPxL9/s+69bY8swXcWjks+jaBf0D7brif1JU42oiFOb6/y4iFi8Y9IPPNOVWNE6o4Sra/At28TqAoGxxDsYy7QfB6Awe7Ct28zsiOdtPm345hxDY4Z1yQtYh88tlv3b3RVa2JsdkqfzlA8Gwwo0e0qkmHIlfcw5Mp7TnrO9pWy1JiCqkTwfbEBf/GHmDJHknbpV7HkT0g45srJOcK0MACIZ9vd8/J2qpqDXY5VlQiW/An6vRCPaLAWnN/pMeeiDsWJtUqS2WLLf/tVYgEPMW8D3qL39O0xv4eRP3wDNRqh8YPnqXzq61qRG7sLa8EM0hbc3jZJuyiermpNnAsH4rlmQIkunF71q+6QDDLpC+4gfcEdnY6xmQaXfWqgM21YGrfPLeDx9Qeo3/EuofJ9egiV/+BWos212MfPQWmpx7evEFNWAZG6o4Qq9yNZUkidt7zDnOeyDsWJGXfJbLHxOFwAx8wlBI/u1iIPWu23zVv+Tsv2NVoNE1VBCXjw7dmA/+BW1JBPL2IPECzfQ7i6FMmSgmNqYrr8YAoTa0/3PVX6GXF7nM3U+5fWHypoCU6eZbOGIUkSofJ9+PZs0GoMoNVV8O3ZQLjmMMb0PJSAF+8XGwjXlWEbcwG5t/0mIZbbIktYjAa+NDmHV++ec04eq+MZd/GGovZJlyK7snRbrOJtJHXuzfp474639VAvNRICINpUDYBj6uU4pl2p+zTUSBDbuDnkLF+hdzzWV7nTr+rg+xhMYWLtGXArXTi56ldngv5SQUtwauhmq6UPkHntA52OG3r3rE735adauf3ignNehyKecZe17Ced2mKdMxfTsutdIrWHtSw8SdIdgtCW1uzd8wH2sRcgGYxIJguZ1/8H9rEXJpwv61+Sd2YZbGFi7RmQogs9q36lqCpD7GYa/GFkSUpaHWvmiDQAdhxr6vcVtASnzumYrWwmmadvm9Un7o+JuS5MahkBb0unDUVVJYLRmYHRmYHszMC3/0OIhomF/Cjexh6lNXfHYAsTa8+Aa8GejO6qX/WkOtZAqKAlOD1Otk8YxE1Ok/rME5DbG+LC//cKR/7wzYSGopG6MgwpaeTf9ST+/R/i3VuIObvNPq3VzVPJvO4H+Eu24i/+sENaszlvnJ7W3BV97XfS2wzYlW57uqt+1ZPqWAOhgpbg9BgIRdszHRYumzqKui4aihpcmcT8zXi/2IAkG7GOmU24+jAxXwNIhh6lNSejr/5OeptBIboCwZliIBRtf+Ca6Xxa8UCnphJL1iiiLXUJK+GYr0GPSggeLeoyrVmWoH1+Un/4nfQmg8K8IBCcDfqzyakrU0ks5Kdx458IHt2N4m1Astix5E8k7bKvYc4aSSzkp2nTi/hLP0PxNSLbXFgLzid94dexuTL41vzRHGsI9LvfSW8hRFcgGKR01YjyVJAk+NLknAHfG/B0EaIrEAxidlc0dWoqOVlsJplX754z6M0H3SFEVyAQJJhK9lU1U1rrJUndqE4Z7BEJJ4MQXYFA0IGemh5ERMLJI0RXIBAkpSvTg4hIOHWE6AoEgi7pz1EafREhugKBQNCLDLgqYwKBQNCXEaIrEAgEvYgQXYFAIOhFhOgKBAJBLyJEVyAQCHoRIboCgUDQiwjRFQgEgl5EiK5AIBD0IkJ0BQKBoBcRoisQCAS9iBBdgUAg6EWE6AoEAkEvIkRXIBAIehEhugKBQNCLiBbsAoFgUOH2hli1vYLiag+eYBSX1cjEXBc3zeqd+sCinq5AIBgUFJU38WRhKZtK6gAIJemEsWBCFvfOH8v04Wln7X0I0RUIBAOevtTzTZgXBALBgKAzswGo/HbDQQKR7tvLqyoEIgor1u4HOCvCK1a6AoGgX9OV2cAsS4RPppd8OwwSXDoui7mjM86ovVeIrkAg6Lf0xGxQ/84ThCr2E/XUIckmzPnjSV94J+askQD49m2iZcfbROorUCMhjGk5uC64Acf0q4Azb+8VIWMCgaBfognufgKRru203qJ1SBY7KZMvQ7LYCR7eTu3ff4IaDQMQOLyDaFM1ttEzsQybTMR9jPp3nsB/8FNAaz0fisZYt6+G5c9u5eWtZaf1vsVKVyAQ9DuKypuYf/0t+I/t7XQFG645TOPGPxGsLIZoGNmVTe5Xf0Xl03cBkHvH/2LJHUuo6iDm7AIk2QRA9V8eIlS+B+espQy58p4O57aZDDy8eNIp23uFI00gEPQ7niwspXnnu5jzJ5Ay+TICZUXaCraujKH3PItkNBP11KH4mrDkjiNUsRcANRbVJpAMeD77J5Gawx1Em9YxSsDD8We/RdRTB6gYU3NwzlwCM5ewYm0x04alMW1Y2km/d7HSFQgE/Qq3N8TFj2zAc3Qf1mGTAIg21XRYwcbxl2yh7vUVGJyZmFyZhCqLcV10I55PX8ecPwFz1kgCZUUozTVIFjtqyI8xPY+UKZcTqtyPMTUbxeMmcGgbADm3/BJbwTS+NDmHp2+bfdLvX6x0BQJBv6GovIkHVxURVlRdcCFxBSs7hiQ9NuZrItTixjH9S6Qt+Dq2cXM7iLYa8iM7MshZvgJjanbC8cefu49IXRnRpmpUdRofHKij3hs66agGIboCgaBfEI9UCESUhO2xcID6t1cC4LrwBowniK7ib24dGMU1ZxnpC+4A0AVXVWM0bnpRH5990890wQ0dP4BvbyHRpmoidWWYMoZjGz8HAAlYtaOCey4bc1LXIURXcNY517nugv5PW6RCYoKD4m+m9rWfEa46qK9gT6Sp8AXtB8mAGg3T8P4zAKRMno8lfwKNH/wZ//7NAJiyRuL9Yj18Acb0PAwmGy3b1+jHW0fPxGC2AVpUQ3FVy0lfixBdwWnRlaBWNAa6yHWvZuX7Jb2S6y7o3xSVN/Gjp/5O+Uv/0ekY54X/AkqUyj/cieJrRLa5sBbMIP3ybxALerVBaoyWz9/UjzFnj8aYlovviw36tkjdUSJ1RwGwDJ9C7q2PkDJ1EdGmatxv/JqWbauRbS5SL/4KAJ5g5KSvR4iu4JTounhINY++V4yKllaZzFMbbB2/bl8Nm0vcZzXXXdC/ebKwlJg9Hefs6/RtajiId/c6AAz2NELlewlXlYBsxDpiKpHaMnx7NhCq2ItlxDRCx3YjmazYJ8xDtrtIX3QXdat/Q/27v4dYFMloxjJiakLIWSzk1/4Peqn5y0Mo3gYAIg2V+vtwWU0nfT1CdAUnTXdZQMFo9znucXoj113Qf3F7Q2wqqcOYns+QK+7Wt3s+X6P/HPM3EfY3aS+UKCmT5hMbeyGN6/9ItKmaaFM1AGokiG/PBmRXNumL7tJNCpLJCpKB4OHtVJfvJfvmn2EdPoWqF+7HmJZDpLEKxduon882aiagpQlPzHOe9DUJ0RWcFJ3Z1uIEj+6m5pUfJd2Xsfh+HNOuINpcS2Phnwke2UUsEsToyiRt/h2sQDrl2EfBwGTV9ooO21RV1e2sGdd+D8eURQQr9lH795+CqlK/9n+TzpWx+H6aPvoriqeWo49c2zZfJJjwc7BsN9bhU7AWnI9v/4eowRaQTaBEkIwWUs5bAEBMhcsnZJ94mm4RoivoMTfecjtvv/8BkebkGUAVT92J4qnt9Hhjeh6Kv5nql3+A0lKPZehETFkFRD11RJtrCEQUHlxVxCvfmCMcbAIAiqs9CaYrgEDpZ0QbjyOnpJMy6VIATJkjsI2agf/AJ/o42ZmJZegk/MUfAtr955h2JbFgm/PLX7IFxVOHfcI8/Ac+BsmAY8bVAKTOWYZvXyGui27ENnq2tpiQ2yTTIMGGA7WMzTm51a4QXUGP+eff/q/LDKDObmgAc84YrMPPo2nzSygt9aRMuZzMax/ocI6SGi9zH9nAwonZwsEmwBOMdtjW8vlqABwzF+upuw3vPon/wCc4Zi4hfeGdtGxfQ1PhC4SOFwNt9591+Hn6PIq/Ge+udwGINGp22njImarGcL/1OMbUHNIu+xqhiv0d3kdMRUQvCM4ebm+I4bc/hiFvItAWTK601BN2H8OSO5a0S27Rxyv+Zlp2vqO/dl5wPQDBo0Xafm8D5b+7DRQF25hZpF/+TWR7KgBhRRUONgEALmuiRIVrywge3Y1kNOOcsVjfHnG3RhzkjsVgsmDJGw+A4nEDbfdfe1p2rkWNhpHMNiK1ZQkhZ4rHTah8D6asAupe/yVKwANo5ofa1/6LjMX/jpySJqIXBGeP3208iDF/IrFWx1l3GUAtO9eCot2Q7R8DFb9284Yq9mKfdBmhymJ8ewuJhYNkf/k/9eOFg00AMDHXhcVYrZsYPK2r3JTJC/QvaUCvDtZY+CKh4wcIlu1q3aMm3H9xVCVKy/a3tJ/DgYSkCW2jdqNH6sqI1JW1bY8pBA5tQ42EABG9IDhLvLy1jJe3HtUFt7sMIFWJ4m23ynXMXEyoYn+Cg02NhvF98b7+OnBoW4JzI07u7StZsVY42AYry2YNY+X7JYD29OTftwkA5wXXJYxLX3gnkkHGX/oZ3i/eR7a5MKSkE/M1Jpgh4vj2bybWmqlmcGYmTZoY+dBb+vi4g1iypDDigVcBrc5uv4peEFlK/YN4tEK8+H5PMoB8+zfrMY3xx8BYyIdz9nUEjxYRqTuKKWM4kfpy/RjJIKPGFKwFMzBlDte3yylpBKMKTxWWnlJxEUH/JtNhYf74LNbvr0G2pzLiwdeTjjNY7Ay56lsMuepbgGaGqHr+vg5miDjtkyRiLe4OSROW/AndvjcVWDZz2Ele0TkQ3e6C6kWWUt+hqLyJ++79ll6zFIMMsShqJKQ/jqnRCA0fPI//4FY9E0iNttm54o+Bsj2VIVfcTaShkuN/updI43FtQGsojmXoJIJHi0iZPB/HtCsS3oeqcsrFRQT9n28vGMuHB90dai50RWdmCIBg+R7C1aVIlhSGffsFPa23K6wjpyWsfCUJFk7IOqX7sVc7R7y8tYzlz25l/f4aQq3V2Ntzpiu0C06PeM3SeNV9NRzQbFmSgVg4QMP7z1D9l/+gZfsaYiE/9gnzUKORhAiGEx8DTUOGkvXln4Ck3XoGsw3X3JuwT9Rsbg0bnuHYYzdS+cy/4dm2Wj8uXlxEMPiYPjyNhxdPxGbqmVx1ZYaAtlWuc/pVPRLcZFiNMvcuGNv9wCT02kq3u6D69ggnyrknngmUc9ujejUmb5GWdokaw7vj7YTxzulXkb7oLo4//x1iwRZkZwbDvv3iidNqxKKgRJBT0hl67/NIsgnvFxsw543DnD0KJdBC4OCnNG54FslkwXn+1adcXEQwMIhrQE/aqHdlhgDI+pfkyTs9RescMfGUfQy9IrpF5U18+55v4Du8EyXgwWC2Y84dS/r82zHnjkGNhmn6+G/49m1C8TZgSs8j9ZJbYeK806rQLjh14plA7WuW5t/9R44/cw9IBoZ++wWMjiF6JlBL0ToUXyMxXxOSycKQL32707mTxVmmTFmEY+rl+pjGwhfwbF2F/8DHOM/XgtVPJTxHMHC4bU4B04al8VRhKR8cqEMiMeU83kByTFYKh2q9hE6xC3BnSJK2wj3dMMZeEd0nC0sJNdZgGTEVg8VO8Ohugkd2UFtfzrB7/0zDhj/h3bkWY3o+jimL8B/4BPcbj2D82m+Qhk0STpRzwImZQJ1FLLTPBPLtLQTAMmIa5syRXaYEY5B1B0e8LUrM35zgHQZ0MwScWniOYGAxbVgaT982m3pviFU7KiiuasETjOCympiY52TZTM0R35MuwdAmpHdcPJIjbl+XYr5wQhb3Lhh72gvAsy66bm+IjcW15N76iL4tVF1K9Qv3o7TUoypR/MUfAZBxzXewjpiKKXMEjRuepfmTv2O56afCiXIOaJ8JlCxiId7WOtJQCWoM2ZVF1r/8iODRIpoKX6D2jV9iyR2PZLajRoIYLCmYckYTak2OsI6aqTs4Gt59Ug/fUSMhal9fQaC1E2vK5Pna+FMMzxEMTDIcli6Lh/d0VXyikHYn5meCsy66P/rnbqKtAZ6e7WuIuMv1rCTXhTcgyUYkoxmAcPUhzHnjCdce0V63BiWfaoV2wakTzwSKNtdS8+qPiTZUJgSQe4vWYc6fgGS2oYZ8KJ466l7/BRnXfBeASG0ZkepDGNPzsY6Yiv/AJ7rgAqQvuF2b54sN+Eu2YBtzIYFDn0EsSrBsF+bsUThnX4djyiLg1MNzBIOXnq6K29OdmJ8JzqroFpU38cpvHiJQtktLo1NViGlhH7IzE3PeeBrW/5FYa5Wfxo1/onHjn/Tj4+XUhBOl94lnAlW89CCKtwHZlZUQQD7k6vtwnn819e/+Xs9fV1rqqV/7ROsMEtD29GLMGE5T698249rvYc4qINpcS8P7f8R14Q3YRs8mcOizjuYFTi88RyDoDSE9Gc6o6J6Y8LC/qplIc22CLTfaUInB5kLxNuBe/WtQVSRLCpZRMwhX7EeNBDHnTyR8vBjZ7tLnFk6U3iWeCRRPclA8dQkB5BmL7we0TCA1HMDXGqKjxhRSpiwiWLYLxdugP73EO6kiGUiZdGmPCorEOZ3wHIGgr3FGRLerhIfcWx8hFgkRqtyvp4bGWotHxLHkjSfnK/+Ne+3/4tv9PuHWykCGlHR9jHCi9C7xTKDw/3urS0cEkkS0uQYA10U3kr7wTgBadqylYd1THZ5eACTZRLS5tkcFRU43PEcg6Guctuj2xEvYWPgC3l3vtWY0KSCbQQnr+4PlX3Ds8ZtRw/52R0lEag7RsvMdUmdeI5wo54DuMoG6Sgl2zlyMOXcMgSM7UXwNeHesBcAQf3rpQUERWZJ4ePEkEactGFCcVkZaW8JD12EZocpiTWRb7bkGkwVT9mgAJEsKKNF2githHTmdIdfcB0DzlteIqTA07dQyRwSnTleZQNHmWqpf/iHhqoO45iwj45rvIEmSvl9VIljyJ5A2b3lCWnC81YkxLYeRD72l/8u55ZeAdj+MfOgtzOk5fG3uCCG4ggHHKa90u+vQmbH4fsw5o2nc+CeiDVqgvcGeSizQQizkQwrZAVBDPhwzlxA4+ClKixtQiYX9pEy4hIZ3fofiqSUW9HL/q7to8ofFh7CX6SwTqLoTB1u8QpN313v49hViTM/Ht+cD7SCTjdR5y3t0XpNs4DsLx53pyxEIzjmnLLrddeg0pucRaTyO4m3EnD2aUMVeJKMZyWxFDflRmmu0wHc1hiV3bFuKKRCpr0AyW/XXiq+RqNUh0oLPEe1jHjcW1xJW1E4dbPEKTcb0PJSAl1D1h0hmK9bhU0hbcAem9Pyk52hfUEREKwgGMpKqdukmSYrbG2Lerzd2KFjj+XwNje//EXPOGPK+/luCR3fjXvMYcloO4Yr9bTbd1v8NVmdCcZQ41tGzCNcdJdbi7rDPNnIqWz/aLBwr54h6b4hbnt1KSa33rJ3DZpJ59e454m8sGJCckk23uw6d8dYYsjMDY3o+kZoj8UFYC2ZATEEympHTcjGm52stkPV3JJO55H6sI6YBIJltOGdfh+zK0uZMy+OpwtJTeduCM0CGw8Kjy6ZjM8lnZX4RrSAY6JyS6Pa4Q+eQoeTe+giZS78PaAkRsisT0Opc5t+xkqH3PMOI769iSGsmEzGFxo3PEzq6C4D0BV8n9eKv6GmizllL9bRgwbnhZEvt9QRJ0la4IlpBMNA5JZtuVx06DSlpVP7hroRqYraCGdogNaYXRfEVf4R37wcYzDbMuWOINmutuw1WJ779HyI70kmbfzuOGdfQ/MnfUKNhrCOnYc4eJdKC+wAnU2oPtHbVBknCaJDOajERgaCvc0qi21WHTslo6VBNLFzdZg6Q7S6UlnrMWSMwZRXgK/6I4JGd2j5nJkOu/Dfs4+fo49v323LObu0oK9KC+wQnW1RkaJrtrBcTEQj6Oqckul116MxY/F19nK/4Y9xv/ErPQFN8TRCLYswYQe7XHgMg4+r7UKNhAod3UPfPX1L3xq8YevczGNNytDla+20Z0/Owjb1An1ukBfcNTraoiHg6EQx2Tkl0u+vQGa8m5i/9LPHA1rbd0aZqjj1xKygK9rGzSb/8m9hGz9LDyaLNNbro6q01Zl+HJGqr9ln6WlERgaCvckqi212HTn/xx4TK9wCJJoPKP95NtPE4kgSWnDEEy3bh21tIsGIfBpMmuAZ7KuYc7cPbvoGcY2pbs0JRW1UgEPRXTtn9/O0FY7Eak4cN5d76CCMefJ2sG/8TxdtA3Ru/ItpUoxetTpl2JUOuvAdT9igAlGYt68w+8RJyblmBwZoCdN5ATtRWFQgE/ZVTzkiLhw21bzYZi4S0ouQGGclo7mAyMGUXEKrUsspMQ4aS8aV7qf6/7yNZ7Az99osJufuQvIGcyFYSCAT9mdOqMhYPG/rZmn1EYyrh4wdwr3kMy/DzMFgdhMr3JpgMZGcG3qJ1+HavR42ECLWWcHSct6iD4HaGqK0qEAj6M6eUBnwim0vquOOFzwjVV1L/zu+I1B0lFg4g211Yhk0mdd5yzFkFAAQOb6dp0/8Rdh/TEinOm0/avFv0lj1doWUrieB5gUDQfzkjogtw90ufs25fzZmYqgNnqvWxQCAQnGvOWLue7gped4VBAtkgIUsiW0kgEAxszthKF9oXNY91P7iVuMngmil5IltJIBAMeM6o6ELP2veAMBkIBILOObHJrctqZGKui5tm9f9F2BkXXYDdFU09zscXJgOBYHDQEyHtqsltXDsWTMji3vljmT487RxcxelzVkQ3Tk/z8QUCwcClp0I6KiOFF7ccHfBPyWdVdPsLA/lRRiA4l/TY3IiWaXoy9NcQ0kEtuifzKDM03SaEWSA4CU7FsX6ytG/t1F8WT4NWdHv6DQxtBbhlgzQgbUwCwZmmqLyJG/77L1S//xzhqlLUaBhjajbOWdfinLmEiqfuRPHUdjjOMnwKubc+AoBn22q8u9cTcR8DNUbqvFtIu/TWhPGSBHNGDcFpNfUbO/AZi9PtT5zsN3BMhZiqEo0lqnPcQbhuXw2bS9z91sYkEJxpniwspfzvP0dprsWUVYBpSD7+A1toWPcHTBnDcUy7MqEprb9kC4qnLqFbdLi6FIPVgezMTCrQAKoKWw43dGqe6Iuf0UElum5viN9tPMjLW4+iqODbtwn3m48CWr3eIVfcrY9VAh6qnrsPxduAZElhxAOvdjqvqkIgoogW8QIB2uescH8Vikfr5p153YOYswqoeuF+wtWlRJtrSLvkFn284m/Gu+tdAJyzl+rb470Va//xCwKdiG6c7h7X+9JndFCIbnvbbUSJEVMh6nHT8N5TbW3hT6Dh3Se1TheAGvJxbOXNmLMKyFr2E6qe/26nj0YreJRpw9JEKJxg0LJqewWSbMQ5eykt21bjfvMxTEPyCVcfwpQ9Cvv4uQnjW3auTeiBeCrUv/MEoYr9RD11SLIJc/540hfeiTlrZMK4QCTGirXF5/QzeubaufZRXt5axvJnt7J+fw2hqCa4qqpS//bjyM4M7BMu7nCM94sN+A98Amqr+cEgkzLhEmIhP2okiGPalThnX6f/i7eHN6XnE4wqokW8YFAT7xZuHzcXOTWHSF2Z9nkyyNjHzUFqXxs7SQ/EU8FbtA7JYidl8mVIFjvBw9up/ftPUKPhDmMDEYUHXys6Zx3FB/RKtzPbbcu21QQr9pH3r4/j2bY6YV+0uZb69U9rdYDDAQAkkzWh91tXj0aqit4ivi95TAWC3sITjKIEPNS+9lPUSIicW3+NKWskta/+mOaPX0FOScM5cwnQeQ/EkyXntkexDpsEQLSphsqn70JpqSfsPoYlt2Mp2JJaL3Mf2cjCib3vYBuwoltU3sSKtcUEIrEE2639vAX4iz/GPmEe7jcfJdJQCYBvzwcY0/PxF3+E0ZFBtKECZBMoEdSQj8qnv4nrgutxzro24TzJHo1Ei3jBYMZlNRJtqkGNhMBgxJI3HslowpQxnHDVQSLucn1svDsMBpmK397aIcoBtOYIAJ5P/0Hz1lUYXZmkzb+DlInz9HniggugtvZiRDIgO4Z0+j7DSuycONgGrOg+WVhKMKp0sN1GG6tAiRKuLiUW9CIZzaiRILFgC43rnwZATsvVJlHiHYclos3VNKx/WjNJtNqkOns0Ei3iBYOZibkuHDkjMVidxIIt1PztYYxpufj2bQbAMnwy0NYDESSi9RUdohwiTdUoHjeho0WtM0sYXVlIZgvR5uRlZGPhAPVvrwTAdeENGLsQXTg3DrYBadN1e0NsKqkjFktiu1VVQCXaUEnM34waCXY4XmmqPmGLSjyY13/wU31rV49GokW8YLCybNYwDGYr2Tf/DGvB+Vpn8OKPMaXnkX75N0mZdBnQbpXbGnuQed2DZP3LjzDnak+Iocpi/MUf6r4VNRoi2liJfexFpF50Y4fzKv5mal75EaHKYhzTv0Tagq/3+D3HHWy7K5pO/cJ7yIBc6a7aXgEkt91ahk4k7/bHAQgdP4D77ZVE67Xxpozh5Nz2awxmG+VP3Ioa8gMgWVJImTwf7861CQ0yO2sPD6DEBmXOiUDQ1i1ciZGz/Bedjov3QGzY8GzSKIecm35K7Ws/I1RZjLVgBuG6I6AoRJuqUPzNeqNb0HwxNa/+mGhDJa45y0hfcIe+z/3W4wTLdqEEPBjMdsy5Y0mff7su7nHiTvCnb5t9Zn8hJzAgRbe42kNL1WEaN71I2qW3Yc4ZnXRcxF2uCy6AdfRMDGYbkmzCNft6mj9+BQA1HNDNCN7d6wnXHMI1Z5n2aCQb8WxdRePG55BtLqwFM0i//Bscb3ac/QsVCPooJ9PUwD5uLv6SrUTqyojUlYHBqEc5KH4PAKGKvdgnXUaoshjf3kJi4SDZX/5PfY7jz38HNeQDIHB4hx61kDJ5PtHmWiwjpmKw2Ake3U3wyA5q68sZdu+fE95HbznBB6ToeoJRLURFiRI89gWh8r2Ea48AEDj4KY1GM+kL7sAx7QpSpi4i2lSN+41f07JtNbLNRerFXyF13nJUJULLznda/5gSluHnYUofSqiqhJYdb2snU6LEwkHsE+YROrob354NgErZ9Q+KCAbBoCVZt/BkdBflINtTiTYeJ2XalWRc9S1CVSVUv/g9Aoc/R40pSAaZqMetCy5ApPYwkdrDAJizR+tpxQCh6lKqX7gfpaUeVYkiyYkS2BtO8AEpui6rUbfdBg9vT9gXba4hVFlMLOTHYLEjSQZM6fmY88YRrjmkRzNIBpm0+bfj27cJJeQj55YVWEdOS5jLveZ/8O39AOf0q0hfdBee7WtoXP9Hos21GCQRwSAY3MSdUl3VOOkuysGUXUCocn/bAa2TSEYzSAY95t6UOQJT1kj8+z/skF0K4Nm+hoi7nGCrU8514Q0dBBd6xwk+IEV3Yq6LnIVfSyiO4X5rZesqFELle6h46utY8sdDLEa45hCxoBeAYFkR3qJ1OKZfRbTxOIqnDsloofnTf1C76ufIKel66JhjxjX4D26lpWgdiq+RYFkRksmC66IbRQSDQIAmvNOGpXXa1MCUMbzLKAdzzhi8Revw7V6PGgkROl4MgOO8RUiShOezNzqNuW+Pv/hjQuV7AJCdmViGTu507Nl2gg9I0V02axgr3y9J2NYWpaCVxjC6sojUV6K01IEKBpsTOSWdiPsY9e88gcGeisHm0o6Nhog21WCfeAn+/Zv10DHLiKnYRs3Af+ATfHsLAbCMmIY5U0s9FBEMAgFMG5bG07fN7tDUwGI08N7earJv/hlNm18iXH1Ic6Kl5+E4/2o9yiF72U9o2vR/+PZt0hY9c28ibd4thOvKuvXbxMm99RHUaJjA4R3U/fOX1L3xK4be/QzGtJwOY11W01n5PcQZkKIb957GW8Krqkos2JLwCGIdOY0hV9xNqOog5uwCAqXbaN7ymlYrTlVpePf3ZC37sT6nGvbj27cJg8mCGg3jP/gpvn2b8R/4BMfMJaQvvJOW7WtoKnyButWPkHf7yrP+xxMMbvpL/dg4GQ5LB3Pb3S99znroMsrBNnoWttGzOmzvid8mFgkhyUYkg4xkNGMbPUvLNg35iTbXdBBdq9HAxDzn6V9sFwxI0QXNe7phfw2K2nXaryVvXFvGmmzCYHUQC7SggrbSNRghFgWDjGPKIrx7NgJaREOkXsusseSOxWCyYMkbD0CkvqJX/niCwUnXxferWfl+SZ+qH9sVJxPl0IFu/DYA4eMHcK95DMvw8zBYHYTK96KG/BjsqZhzOvpbVGDZzGGncCU9Z8CK7vThaYzJdrBnz54uH0FUVaWx8AUAHNOuxLtzLcb0PPLu+K3maDPIelqhGlP0QG3F14hl2GQi7mM0Fr5I6PgBgmW7ALAMm9wrfzzB4KO74vsn1o/998vHAlKfXQ33NMohGWmX3prUb9PekSY7MzCm5xM8sotYOIBsd2GfeAmp85ZjsKYkzCdJWsPcs/17GbCiCzA5z8Vn/+j6EcQx7UoUTx0YZLw71wISqqLg27MR56xrMdgcKC0hYkEvvv2bMVjsxAItRD11ZN/0MySDjL/0M7xfvI9sc5EyZRFDFn29V/54gsHFyRTfj6e3PvLuAWQJlHYC3ddWwz2JcjhVTEOGJoSMdYXVKHPvgo7Fcc40A7pdz9ObDvHwj39Cw4d/TbrfMnwKaZd9jZq//Ie2QTZhHz+XwMGtqNEwWTc+jOJtpGHdUx0PNhgZ+cM3ks7bvm+TQHAmKCpvYvmzWyn/56OdZlf59m2iZcfbROorUCMhjGk5uC64Acf0q5LO2de66u6uaOo0ysFqNBBurYV9NujNJpcDeqW7bNYwVs6/Dee8r+rbTnwEcb/7pL7POmoGckoaxvR8rQbowU/JXHI/5twxBI7sBFRkRwYN7zyBbHclPaf2x5soBFdwRtELOHWRXRU4vINoUzW20TNRfM0Ey3bqkTj2cRd1mLMvdVOAzqMcXFYTE/OcTMp1cc/L20/N/tsJ5+KLZ0CLrp4Dvr+m00cWNdxW8CZY+hnty98YzDZUJYIlfwKW/AmAJtoA1oLzE+bpa6sGwcAhXsBJVekyu8o561oyrrmP+nd+R8R9VB/XsP5pjM5MzLljCNccpnHjnwhVHUQNB5Bd2Qy79/lz3k2hPcmiHOKcqv3XKEE0wcSiNaxcOCGLexeM7dXrHtCiCx29o5nXPkDmtQ/o+7Ou+z5N6bk0f/wKxoxhWPIn4t+/GVWJknLeAry73sO3rxBTVgGRuqOEKvcjWVJInbdcn8MsSyyamN3rfzzB4GDV9gpi7VYNnWVXWfLGAeir4eDRImK+JhRPHbWv/4Jh9/6ZqKcOxdeEOXs0oYq9+pyBSO8UezldTsb+G18I/fvlY5EkqcPKednMc+NMHPCi2xPvaLzOgu+LDfiLP8SUOZK0S7+KJX8CsaAXJeAl9MUGJNmIbcwFpC24Q+9aOj7HwSvfmCOcZoKzxto9VUTaecK6y67KvfURPJ/9E/++TVon3Ra3vhq2j7sI+7iL8Jdsoa6d6EI84qGWy8Znn/2LOg26y3I7l6vYnjCgHWnt6S7U5lQQDjPB2eblrWX85M29HRxI7bOrkKSE7Kqmj/5K80d/RTLbMdicKM01uC66kfSFd+rH+0u2UPf6Ct28EMdokPjZ0sn9xkTWmf33XK1ie8KAX+nG6e7b8WQRDjPB2aaovIlv3/MNfId3atEKJhvmvLGkz78Dc+4YYuEgoEIsRuWz/4YpLReDzUWoYi+SyYoa9qOE/d3WGmhPNKb2GcdaT+jK/ttXGTSiC117R/3hKJtK6ggpsR7ZiYTDTHC2ebKwlFBTjR6tECjdRvDITqrL95EydRH+A1u0EASjGevwKQSP7Gg9UsI+6VIMRjPR5joCh7Z1WWvgRPpCm/KBzKAxL/SE7uIE+7KdSDCwcHtDzPv1xoQUX1/JFtyvr9BeSDJySiqWYZNJnbccc1YBx1YuRw15T+o8ks2F0Z5K1FMHqBhTc3DOXIJr1hK+NDmnzzvW+iODaqXbHd3FCfZlO5FgYBFvOQVJohXa2WdDxw/g3fUe0aZq1JAX2ZWFqkSwjpiKweogWLZLa8ZqNOOYcjmxQLNWKKYVNeQnJpswpudhdGYSOLSNhnV/wJQxnA/k80Uh/rOAEN0k9Ec7kWBgUVzt0Ve5XUUrRNzltGxfo72QDFhHTiPSWJW01oA5q4CG1o7XOrEoirceDDLZd/6O48/dR6SujGhTda90URiMCNEVCPognmBU/7mrWrAntpzyfbGBtMu+Ruptv+kwp6qqBA5rdt+Ma7+HY8oiQFst+/YWUvvafxGpK8OUMRzb+DmiEP9ZQoiuQNAHcVmNXdaCrXrxAWJhf2L9hXYtp5SAh6rn7kPxNiBZUhjxwKsESj8j2ngcOSWdlEmX6ufqsFpubdAKohD/2UCIrkDQB5mY60KtOcjxN37ToRYsBhnriKkEjuxEjYYIHtlBdfkeVEVbHdtGzaTh3SdR/M0Jc7Z8rtWSdsxcjCS3FdjvqkGrKMR/5hGiKxD0QZbNGsavXx3SaS1Yc1YB9e89hb9kC2okhBoNY8odh2vWtYTryvAf+FifSw35OPrItdoLg4xsT6P65R8Sqa8gFg5iSs/Vq5G1Xy2LQvxnByG6AkEfJNNh4cq5M1if9kjSuHFPqznAYLET8zXqEQ3R5lrq1/8Bc+4YjK4c/CWftHU/AayjZhKqLNarkfkPbNH7Arbseodw9SFAWy2LQvxnByG6AkEfpatWNskiGlQ1hvutxzGl5ZH7tccIVezXRFeS9OPSF9yOGo2Qcc19SLKJevNTeHevByVCuLYMc+5YnDOX4DhvgSjEf5YQyRECQR+mq24RJ9ZfyFn+C2r++v8wZRVgdGWhBDyEjx/Qx6df+W+4Zl3bYZ7qlx4kVFlM2oI7SJ2zDNBqMLz+rYtFEtBZQKx0BYI+TPtShoGI0nV326ZqACJ1ZUTqyjrMZSuY0WGb57N/Eqosxpieh3PGYn37efkuIbhnCSG6AkEfJ16s6cHXiti9bXen3W3t4y/GMe1K/bjg0d3UvPIjAFIvvRVTxtCEeePVyIxpueQsX4HBYtf3ZQqzwllDiO4gw+0NsWp7RZ/tDitIzrRhafz1m3OYXVLS4+62kdaVL5CwilXVGA3rnsa7cy3mnDFk3/QzZEd6wrEiVOzsIUR3ANGVoFY0BniysJRNJXUACYVU+lp3WEFyMh0Wrrp4BuvTk0c0nEioUivR6Jh2FbI9Vd/etPllrfO1ZMCUM5rmra8BYEzPwzVrqQgVO8sI0R0AFJU3dSmoj75XjIpWBTDZZzVeTU3rHOAWZSv7MF1FNLRH8Tfj37cJAOcF1yXua6nXflBj+Hav17dbhk/BNWupCBU7y4johX7O2emI0XvtqAUnT1cRDaeLJCFKOp5lxEq3H3MyHz7fvk2433wUQG8/r0YjNH7wPP6DW1F8jcg2F9aCGaRf/g1RxLoPczLNGU8Wq1Hm3gVjz9yEgg4I0e2nFJU3tYYRxZIKasVTd6J4aruco3nL32nZvgbJkoJ9wjxCR3fj27MBUDEu/V6/6A7bG/RF52N37adObDneE0QLqt5BiG4/5cnCUoJRhajHTcN7T4FBhlibnc8x7UpiwRatnF/JFhRfY8J+QI/rdE6/ivRFd+HZvobG9X8k2lyLqsIHB+oGdRHr7mzl59r52F3RfVVV+e2G0h63Khe2/N5BiG4/w+0N8eInZby/v4ZYTKX+7ceRnRlYs0bi3/+hPi7tklsA8Hz2Bl5fU0IqaBzHjGvwH9xKS9E6FF8jwbIiJJMF10U3AgzqItbd2cr7kvOxq6L7F4/JFC2o+hhCdPsJ7VddUSVGTIWWbasJVuwj718fx7NtdYdjwnVlNG56EeuIKQTLdmFISSfma9T3mzJHYBs1A/+BT/DtLQTAMmIa5syRAIO2iPXJ2MpVFQIRpc920BUtqPoeQnT7AclWXXFBTbv0Nsw5o5Me5z/wCShRguV7tQ2t5oXAwU9pNJqJNtXgP/AJjplLSF94Jy3b19BU+AJ1qx8h7/aVwOArYt3eVn4y9PUOuqIFVd9BiG4fp7NVly6ox74gVL6XcO0RoE1Q0xfcoS3DUEHRhDMW8AAQba4hVFmsv7bkjsVgsmDJGw9ApL6tKeJgykxye0M8uKqImk9ex7t7PRH3MVBjpM67hbRLbwW0KJCWHW8Tqa9AjYQwpuXotWiDUUU4HwXdIkS3D9NVhILBkgKoBA9vTzgm2lyD/+BnpC+4g7RLbyVwaBvh6lLSr7yHcFUpvj0b9AiH+nd/T8R9jMbCFwkdP0CwbBcAlmFa48PBkpkUN90UHqgjrMQIV5disDqQnZkdIkACh3fotWgVXzPBsp3Uv/OEVvtg3EWD3vko6B7DuX4Dgs5JGqHQStqltzLsu39BdmYAYLC7AJBd2TimXQFAsHwP4epSJEsKjqlXdJg/feGdOGcuQTKa8H7xPmo0TMqURWQuuR9gUGQmvby1jOXPbmX9/hrCivY0kbn0++Te+khSs41z1rUM/dZzZC59kJzl/41l+BQA/Qsr7nwUCDpDrHT7KG5viE0ldV1GKLR8/iZKSz0pUy4HwLdnA/bxc0htjT5o3PgcoLVradr8EpnXPkDG1d+m6eO/UfGHu1C8DZjS80hf9A1SJs5LOL8kMeCLWJ9KZpclb1zihtaODPEvv8HqfBT0HLHS7aOs2q6tluIRCplLH0SSzQljgkeLAFC8DQSObMdgdRILeFD8zUQ9bqINxxNWxwANG/6EZ8vfkQwyjimLULyNuN94RC+OEmegZyadqsOsPZ3Voh1szkfBySFWun2U4moPLVWHu4xQUPyaIyxUsRf7pMsIVRbj21uIEgpAJJB0dewv/giAjGu+g3XEVEyZI2jc8CzNn/yd7Jt+CoDVKA34zKTH3y/p2mG2/0P9S615y9/xH/gY58wlOGcuAbquRavERDkTQecI0e2jeILRbiMUZHsq0cbjpEy7koyrvkWoqoTqF79H8NA2MBiSxu9KRm21HK4+hDlvvD5nuF2ngfnjs/tcvOmZoqi8iZUbSthUUtelwyzqqUUymlHDAYypOUTcx2hY9weMQ4biP/BJl7VoPyp18/LWsgH7OxScHkJ0+yguq1EP+UoWoRCqLMaUXZBoFogH8aox0i75WtLVcercm2lY9xSNG/9E48Y/6dsVb1vShN08MG+LeLxzvCxi5tLvA1D7j18QaCe6LUXvEak7pn9BSSYLksWBGvLi2fYGwUOfd1qLFiAaU/tssoTg3DMwP10DgFSbibRLb8WcPYrmLa8RcR9FjSkQU3CcfzUZV99H4OhuvDvfxbvjbbw73wGpzUQfLN9DqGJf0vhdc+4YAkd2AiqyI4OGd55Abo1+gIFpkzwZp1mofF9r4R+NSOvv0GBzYTC1mhE6qUUbp68nSwjOHUJ0+yhHG/xtsbmyCfv4OYSrDxFtPI4aU1D8zdS/9T+AimSyoEYjIBmQU7NRmms7XR2rSgRL/gQs+RMAcL+lZZ5ZC87Xxw60hIii8ia+/9Nf0bhzXVL7bZxYJETF7/8VxduAZElhyOXfpH7t/7btDwcIlG7FlDEc56xrcc5cgm//hzR/9FfC1aUc+58vY0zN0W2/IllCkAwhun0QtzfEJ6VuGgtfACDn5v/COnJawpimzS+htNRjGTEVNRwk4j4KshGjM5O8rz9BoGRrgmAAhMr30LTpJUKV+zBlFRCpO0qocj+SJYXUecuBgZkQ8WRhKb7Kg53ab+MEDm1D8Tfrrx3TriBl6iIqn/w6ircelAjGzBFE3OU0rPsDpozhRD21yKnZWEZMQfG4CRzapu+zjpwmkiUEHRCi2wdZtb2CSEMliqcOyWih+dN/ULvq58gp6bguuB7nrGt1z3ro2BfaQbIRoy0VJdCCGgnqcxlShhDzNWDKHo11xBRM2QX4Sz8j9MUGJNmIbcwFpC24A1N6PjDwEiLi8c6d2W/bE62vIHXecpo/fgW9sVEsppXFbMWcOxbJaCZcXUq0uYbUi75M6kVf1vcff+4+InVlWtnMkdMGdaU2QXKE6PZBiqs9BFq0FZcaDRFtqsE+8RL8+zfTsP5pZGeGHi4GYB01i2hzDdGGCmzj5mB0Zur70uf/q56hFscxZVHS8w7EhIh4vHMyWoreI1S+j1BVCaBl9YUqDwCghgPUvPpjjGm5yK4slOYaACL15YSrD2HKHoV9/FwAQscP4NtbSLSpmkhdGaaM4djGzwFEsoSgI0J0+yCeYDTBsZW59HtY8sZTb7Lg3fE2/oOfIplt2k7JABJEm7XVW6D0M83h1krDhmdoWPcUsisb54xrcF1wfafnHYgJEcXVnoTi4+050WEW8zcTLNuhvTDIROorCR77Akk2gWwEJUq46iAYjNjHzdH/BhF3OS3b12jHSQaso2diiP99GJiOScGpIzLS+iAuqxFjajZSu4B7QA8JM5htGF1ZrdtiRJtqsBZM11/7D34KkoQ5bxwpEy/BOnoW0cbjNG54lpZd7yY950Bt1eIJRjvdl3ntAwz91vMAmLIKsI25AHOrgxFVxZw1kryv/w7UGChRcm79NcPu/xvmnFE0f/wK3tbfpWPaFYz4jzfJv+cZzNmjaNm2Gs+nr+vnGWiOScHpIVa6fZCJuS6sFguu2dfT/PEruN96HEv+RPz7N4NkIOW8BcSCPgIHtwJgGpJPpPG4fnyg9DMyFv87jqmX69saC1/As3WVlll1/tX69oHeqsVl7eYWb/0ii9SVEWmXIEJMIXBoG47pV6NGQmAwYskbj2Q0YcoYTrjqIBF3ObGQH4PFjiQZMKXnY84bR7jmEJGGSmBgOiYFp4cQ3T7IslnDWPl+CanzlqMqEXxfbMBf/CGmzJGkXfpVLPkTUJUImCwQCRE4vAPZMQRTzhgiNYcwmG1Em6p051gC7WJ5ZQmunJwzoFu1TMx1YTFW497+DqHyfYRrDgHgP7iVUPUhlBY3BqsTNRrGmJqNddQMWj5/E0xWrPnjqVv9a22iWJRjj92IZLGhhlsdlZJExe9u08w5amvoXus+26iZwMBzTApOHyG6fZBMh4X547NYv7+G9AV3aAXJT0CSTaReeCPNH7+CMT23w0q4fu0TxIJezHnjiAW9BA5+CkDK5PkAyAaJ9757KWNzBvYqLP4FlizhIZ70YMoqwDQkH/+BLUTqy7UBqoria0KPYgAwyKghPwDOmUuIhfyAhCQbUSNh1HBA2zf7OlLOWzAgHZOC00eIbh/l2wvG8uFBt56ymoyuVsIpUxbi3fWuVr9BjWHOHoVz9nU4pixCkuDKSdkDXnCh3RfY0gfIvPYBfbuqaCtX1BiZ1z2IOauAqhfuJ1xdqplmpl2pjXn0XwAt9G74d/5PH2POHYspq4CMa+7THG1A9V8eIlS+RzdZWGTDgHNMCk4fIbp9lOnD03h48cQuU1clg9zpStg5/Us4p38p6XEDMUqhK5J9gUmyEefspbRsW437zccwDcnvEAomyUZsYy8gUPoZsYCHun/+MmGMwepIPNEJtXXnj88asGYbwakjohf6MLfNKeDhxZOwmeRkHdRPiYEapdAV8S8wmynxdrePm4ucmkOkrkx7IjDICaFgQFs0Qyza6RhIXlt3oBYOEpweQnT7OLfNKeDVu+fwpck5WIwGrMbEP5nR0DM1liSwmWQeXjxpQEYpdEf8Cyz+61ICHmpf+ylKc02noWBKwEPzx38DwGBPSzoGtNq6jRuf61BbV8TnCpIhvor7AdOGpfH0bbOp94ZYtaOC4qoWPMEILquJiXlOJue5+MunR/ngQB0SWhZUHKvRgIrm0BnIUQo94bY5BazfX8umkjqiTTVdhoIBRJtq9E7KyCZkqyNhjKrGaFj3dKe1dUV8riAZQnT7ERkOS6c5/JeOy+pUlJfNHCY86K3MHZ3B1sP1xDKGa+2Ngi3U/O1hjGm5+PZtBsAyfDKR+nKtALxBhphCzOum8ulvEG1NB7YMn0zT5pfx7lybtLZu9kXXi/hcQVIkVVVFbxHBoMHtDTHv1xsJRWOEjh+gafNLhKsP6XG6jvOvxnXB9QSP7qbmlR91nMAgk77wTlwXXI/7rZUJYWhxLMOnMPL23/DJfywSX3aCDgjRFQw67n7pc9bvr+Fs3fmSBF+anCPq6AqSIhxpgkHHtxeMxWqUux94igy2kDzBySFEVzDo6CyE7EwwGEPyBCeHcKQJBiXxsLkVa4sJRpXTNjUM9MJBgjOHsOkKBjW7K5p4qrC0y3C7mSPSANhxrEmE5AlOGyG6AgH0KNxOhOQJzgRCdAUCgaAXEY40gUAg6EWE6AoEAkEvIkRXIBAIehEhugKBQNCLCNEVCASCXkSIrkAgEPQi/x8W7N4Qsyhb/QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -315,7 +110,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -340,47 +135,52 @@ " else:\n", " unsorted_particles.append(i)\n", " type_counts[particle.type] += 1\n", - " print(particle.type, i)\n", " \n", "print(type_counts)\n", " \n", "for bond in system.bonds:\n", - " if 'o' not in bond.type:\n", + " if bond.type == 'ca-ca':\n", " graph.add_edge(bond.a, bond.b)\n", " else:\n", " unsorted_bonds.append((bond.a, bond.b))\n", - " print(bond.a, bond.b)\n", " \n", " \n", "print('unsorted particles:', unsorted_particles)\n", "print('unsorted bonds:', unsorted_bonds)\n", - " \n", - "print('graph edges:', graph.edges)\n", - "print(list(nx.connected_components(graph)))\n", + "\n", + "#print(list(nx.connected_components(graph)))\n", "plt.figure()\n", "plt.title('BEFORE')\n", "nx.draw(graph, with_labels=True, font_weight='bold')\n", "\n", "# almost there. need to put the bridging ketone carbons into one bead\n", "# and split those big groups into two\n", + "print(system.particles[5].type)\n", "print(len(unsorted_bonds))\n", + "\n", + "# need to remove ONE bond from each ketone C to break bridges\n", + "target_c_indices = []\n", "for i, bond in enumerate(unsorted_bonds):\n", - " if 'o' in list(system.particles)[bond[0]].type:\n", + " if 'o' in list(system.particles)[bond[0]].type and 'oh' not in list(system.particles)[bond[0]].type:\n", " c_idx = bond[1]\n", - " elif 'o' in list(system.particles)[bond[1]].type:\n", + " elif 'o' in list(system.particles)[bond[1]].type and 'oh' not in list(system.particles)[bond[1]].type:\n", " c_idx = bond[0]\n", - " print(c_idx)\n", - " for graph_bond in graph.edges:\n", - " if c_idx in graph_bond:\n", - " graph.remove_edge(graph_bond[0], graph_bond[1])\n", - " break\n", + " target_c_indices.append(c_idx)\n", + "print('targeting:', target_c_indices)\n", + "#for c_idx in target_c_indices:\n", + "# for graph_bond in graph.edges:\n", + "# if c_idx in graph_bond:\n", + "# graph.remove_edge(*graph_bond)\n", + "# break\n", "\n", + "# now put back the oxygens and their bonds to ONE bead each\n", "\n", "plt.figure()\n", "plt.title('AFTER')\n", - "nx.draw(graph, with_labels=True, font_weight='bold')\n", + "nx.draw(graph, with_labels=True)#, font_weight='bold')\n", "# then for each ignored O, just put it in the first atom it's bonded to\n", - "# and don't forget the ignored C's" + "# and don't forget the ignored C's\n", + "print([bond.type for bond in system.bonds])" ] }, { @@ -470,9 +270,7 @@ { "cell_type": "code", "execution_count": 17, - "metadata": { - "scrolled": true - }, + "metadata": {}, "outputs": [], "source": [ "class MappingModel(htf.SimModel):\n", From c1f040ea374fc96a7dd10b60be51a2ec8d931408 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Tue, 26 Jan 2021 16:42:11 -0700 Subject: [PATCH 03/35] Kernel dying when trying to find CG RDFs --- Notebooks/HTF_CG_Demo.ipynb | 373 ++++++++++++++++++++++++------------ 1 file changed, 249 insertions(+), 124 deletions(-) diff --git a/Notebooks/HTF_CG_Demo.ipynb b/Notebooks/HTF_CG_Demo.ipynb index f6a7c57..36ac926 100644 --- a/Notebooks/HTF_CG_Demo.ipynb +++ b/Notebooks/HTF_CG_Demo.ipynb @@ -7,7 +7,7 @@ "outputs": [], "source": [ "import os\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n", + "#os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n", "import networkx as nx\n", "import tensorflow as tf\n", "from tensorflow.keras import layers\n", @@ -46,12 +46,14 @@ ], "source": [ "# building a HTF model for coarse graining\n", - "fname = '100-length-4-peek-para-only.gsd'\n", + "# here use the single-molecule file for simplicity\n", + "# TODO: update to get one molecule from a .gsd with multiple\n", + "# e.g. grab first entry in htf.find_molecules(system) -> do the rest\n", + "fname = '1-length-4-peek-para-only.gsd'\n", "gsdfile = gsd.hoomd.open(fname)\n", "context = hoomd.context.initialize('--mode=cpu')\n", "system = hoomd.init.read_gsd(filename=fname)\n", - "context.sorter.disable()\n", - "set_rcut = 10." + "context.sorter.disable()" ] }, { @@ -74,33 +76,21 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "scrolled": true - }, + "execution_count": 4, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "typeid : 2\n", - "a : 1\n", - "b : 87\n", - "type : ca-ca\n", - "\n", - "[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87]]\n", - "{'ca': 72, 'oh': 1, 'c': 4, 'o': 4, 'os': 7}\n", - "unsorted particles: [0, 5, 10, 11, 15, 20, 25, 26, 30, 35, 40, 41, 45, 50, 55, 56]\n", - "unsorted bonds: [(1, 0), (4, 5), (5, 6), (9, 10), (10, 12), (10, 11), (14, 15), (15, 16), (19, 20), (20, 21), (24, 25), (25, 26), (25, 27), (29, 30), (30, 31), (34, 35), (35, 36), (39, 40), (40, 41), (40, 42), (44, 45), (45, 46), (49, 50), (50, 51), (54, 55), (55, 57), (55, 56)]\n", - "os\n", - "27\n", - "targeting: [55, 4, 6, 6, 6, 10, 14, 16, 19, 21, 21, 25, 25, 29, 31, 34, 36, 36, 40, 40, 44, 46, 49, 51, 51, 51, 55]\n", - "['ca-oh', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'ca-ca', 'c-ca', 'c-o', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'c-o', 'c-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-ca', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'ca-ca', 'c-o', 'c-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-ca', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'c-ca', 'c-o', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca']\n" + "['ca-oh', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'ca-ca', 'c-ca', 'c-o', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'c-o', 'c-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-ca', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'ca-ca', 'c-o', 'c-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-ca', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'c-ca', 'c-o', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca']\n", + "[{0, 1, 2, 3, 4, 86, 87}, {5, 6, 7, 8, 9, 84, 85}, {10, 11, 12, 13, 14, 81, 82, 83}, {15, 16, 17, 18, 80, 79, 19}, {77, 78, 20, 21, 22, 23, 24}, {74, 75, 76, 25, 26, 27, 28, 29}, {32, 33, 34, 72, 73, 30, 31}, {35, 36, 37, 70, 71, 38, 39}, {67, 68, 69, 40, 41, 42, 43, 44}, {65, 66, 45, 46, 47, 48, 49}, {64, 50, 51, 52, 53, 54, 63}, {55, 56, 57, 58, 59, 60, 61, 62}] 12\n", + "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -110,7 +100,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -120,162 +110,297 @@ } ], "source": [ - "# the OH hydrogen at the beginning(?)\n", - "print(system.bonds[1])\n", - "print(molecule_mapping_index)\n", "graph = nx.Graph()\n", - "\n", - "unsorted_particles = []\n", - "unsorted_bonds = []\n", - "type_counts = {'ca': 0, 'oh': 0, 'c': 0, 'o': 0, 'os': 0}\n", - "# make a networkx graph with disconnected subgraphs of just ca-type carbons\n", - "for i, particle in enumerate(system.particles):\n", - " if particle.type == 'ca':\n", - " graph.add_node(i)\n", - " else:\n", - " unsorted_particles.append(i)\n", - " type_counts[particle.type] += 1\n", - " \n", - "print(type_counts)\n", - " \n", + "# add all our particles and bonds\n", + "for particle in system.particles:\n", + " graph.add_node(particle.tag, name=particle.type)\n", "for bond in system.bonds:\n", - " if bond.type == 'ca-ca':\n", - " graph.add_edge(bond.a, bond.b)\n", - " else:\n", - " unsorted_bonds.append((bond.a, bond.b))\n", - " \n", - " \n", - "print('unsorted particles:', unsorted_particles)\n", - "print('unsorted bonds:', unsorted_bonds)\n", - "\n", - "#print(list(nx.connected_components(graph)))\n", + " graph.add_edge(bond.a, bond.b)\n", "plt.figure()\n", "plt.title('BEFORE')\n", - "nx.draw(graph, with_labels=True, font_weight='bold')\n", + "nx.draw(graph, with_labels=True)\n", + "# judiciously snip bonds\n", + "degrees_dict = dict(graph.degree())\n", "\n", - "# almost there. need to put the bridging ketone carbons into one bead\n", - "# and split those big groups into two\n", - "print(system.particles[5].type)\n", - "print(len(unsorted_bonds))\n", + "print([item.type for item in list(system.bonds)])\n", "\n", - "# need to remove ONE bond from each ketone C to break bridges\n", - "target_c_indices = []\n", - "for i, bond in enumerate(unsorted_bonds):\n", - " if 'o' in list(system.particles)[bond[0]].type and 'oh' not in list(system.particles)[bond[0]].type:\n", - " c_idx = bond[1]\n", - " elif 'o' in list(system.particles)[bond[1]].type and 'oh' not in list(system.particles)[bond[1]].type:\n", - " c_idx = bond[0]\n", - " target_c_indices.append(c_idx)\n", - "print('targeting:', target_c_indices)\n", - "#for c_idx in target_c_indices:\n", - "# for graph_bond in graph.edges:\n", - "# if c_idx in graph_bond:\n", - "# graph.remove_edge(*graph_bond)\n", - "# break\n", - "\n", - "# now put back the oxygens and their bonds to ONE bead each\n", + "for i, bond in enumerate(system.bonds):\n", + " if bond.type == 'c-ca' or bond.type == 'ca-c':\n", + " if degrees_dict[bond.a] == 3 and degrees_dict[bond.b] == 3:\n", + " graph.remove_edge(bond.a, bond.b)\n", + " elif bond.type == 'ca-os' or bond.type == 'os-ca':\n", + " if degrees_dict[bond.a] == 2 and degrees_dict[bond.b] == 3 or\\\n", + " degrees_dict[bond.a] == 3 and degrees_dict[bond.b] == 2:\n", + " graph.remove_edge(bond.a, bond.b)\n", + " degrees_dict = dict(graph.degree())\n", "\n", + "subgraph_list = list(nx.connected_components(graph))\n", + "print(subgraph_list, len(subgraph_list))\n", + "print(type(subgraph_list[0]))\n", "plt.figure()\n", "plt.title('AFTER')\n", - "nx.draw(graph, with_labels=True)#, font_weight='bold')\n", - "# then for each ignored O, just put it in the first atom it's bonded to\n", - "# and don't forget the ignored C's\n", - "print([bond.type for bond in system.bonds])" + "nx.draw(graph, with_labels=True)" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 5, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "['oh',\n", - " 'os',\n", - " 'c',\n", - " 'o',\n", - " 'os',\n", - " 'os',\n", - " 'c',\n", - " 'o',\n", - " 'os',\n", - " 'os',\n", - " 'c',\n", - " 'o',\n", - " 'os',\n", - " 'os',\n", - " 'c',\n", - " 'o']" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "N_atoms: 88 \n", + "N_molecules: 1 \n", + "N_atoms_per_molecule: 88\n", + "12\n" + ] } ], "source": [ - "[system.particles[i].type for i in unsorted_particles]" + "# now we have our beads grouped up, we need to get their mapping\n", + "# get total N atoms\n", + "N = sum([len(m) for m in molecule_mapping_index])\n", + "# get molecule count\n", + "M = len(molecule_mapping_index)\n", + "# atoms per molecule\n", + "MN = len(molecule_mapping_index[0])\n", + "print('N_atoms:', N,'\\nN_molecules:', M,'\\nN_atoms_per_molecule:', MN)\n", + "# make sure we didn't miss any particles\n", + "assert(sum([len(item) for item in subgraph_list]) == MN)\n", + "print(len(subgraph_list))" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "N_atoms: 13800 \n", - "N_molecules: 100 \n", - "N_atoms_per_molecule: 138\n" + "N_atoms: 88 \n", + "N_molecules: 1 \n", + "N_atoms_per_molecule: 88\n" ] } ], "source": [ - "# get total N atoms\n", + "# create a mapping for our molecules\n", + "# these are 4-monomer polymers, and we're doing 3 beads per monomer\n", + "# therefore, we need a 12 x 88 matrix\n", + "\n", + "\n", + "mapping_arr = np.zeros((12,MN))\n", + "\n", + "for i, subgraph in enumerate(subgraph_list):\n", + " for atom_idx in subgraph:\n", + " mapping_arr[i][atom_idx] = 1\n", + " \n", "N = sum([len(m) for m in molecule_mapping_index])\n", "# get molecule count\n", "M = len(molecule_mapping_index)\n", "# atoms per molecule\n", "MN = len(molecule_mapping_index[0])\n", - "print('N_atoms:', N,'\\nN_molecules:', M,'\\nN_atoms_per_molecule:', MN)" + "print('N_atoms:', N,'\\nN_molecules:', M,'\\nN_atoms_per_molecule:', MN)\n", + "# again make sure we didn't miss any atoms\n", + "assert(np.sum(mapping_arr) == MN)\n", + "\n", + "bead_number = mapping_arr.shape[0]\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "notice(2): Group \"all\" created containing 8800 particles\n", + "Finding molecules...99.00%\n", + "N_atoms: 8800 \n", + "N_molecules: 100 \n", + "N_atoms_per_molecule: 88\n" + ] + } + ], "source": [ - "# create a mapping for our molecules\n", - "# these are 100 4-monomer polymers, so let's try a 4-bead mapping\n", - "# therefore, we need a 4 x 138 matrix\n", - "# rough estimate for 4-bead mapping TODO: check this\n", - "mapping_arr = np.zeros((4,138))\n", - "\n", - "mapping_arr[0][:35]+=1\n", - "mapping_arr[1][36:71]+=1\n", - "mapping_arr[2][71:105]+=1\n", - "mapping_arr[3][105:]+=1\n", - "\n", - "bead_number = mapping_arr.shape[0]\n", + "fname = '100-length-4-peek-para-only-production.gsd'\n", + "gsdfile = gsd.hoomd.open(fname)\n", + "context = hoomd.context.initialize('--mode=cpu')\n", + "system = hoomd.init.read_gsd(filename=fname)\n", + "context.sorter.disable()\n", + "set_rcut = 11.0\n", + "molecule_mapping_index = htf.find_molecules(system)\n", "\n", "cg_mapping = htf.sparse_mapping([mapping_arr for _ in molecule_mapping_index],\n", " molecule_mapping_index, system=system)\n", + "N = sum([len(m) for m in molecule_mapping_index])\n", + "# get molecule count\n", + "M = len(molecule_mapping_index)\n", + "# atoms per molecule\n", + "MN = len(molecule_mapping_index[0])\n", + "print('N_atoms:', N,'\\nN_molecules:', M,'\\nN_atoms_per_molecule:', MN)\n", "assert cg_mapping.shape == (M * bead_number, N)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import MDAnalysis as mda\n", + "univ = mda.Universe(fname)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'c', 'ca', 'o', 'oh', 'os'}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "set(univ.atoms.types)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "class MappingModel(htf.SimModel):\n", - " def setup(self, CG_NN, cg_mpaping, rcut):\n", - " pass" + "class TrajModel(htf.SimModel):\n", + " def setup(self, CG_NN, cg_mapping, rcut):\n", + " self.CG_NN = CG_NN\n", + " self.cg_mapping = cg_mapping\n", + " self.rcut = rcut\n", + " #self.avg_aa_rdf = tf.keras.metrics.MeanTensor() # all atoms\n", + " self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # CG beads\n", + " #self.avg_cc_rdf = tf.keras.metrics.MeanTensor() # just C-C\n", + " #self.avg_co_rdf = tf.keras.metrics.MeanTensor() # just C-O\n", + " #self.avg_oo_rdf = tf.keras.metrics.MeanTensor() # just O-O\n", + " def compute(self, nlist, positions, box): \n", + " # get RDF\n", + " # calculate the center of mass of a CG bead\n", + " box_size = htf.box_size(box)\n", + " mapped_pos = htf.center_of_mass(positions[:,:3], self.cg_mapping, box_size)\n", + " print('made it past to mapped_pos')\n", + " # create the mapped neighbot list\n", + " mapped_nlist = htf.compute_nlist(mapped_pos, self.rcut, self.CG_NN, box_size, True)\n", + " print('made it past mapped_nlist')\n", + " # compute RDF for mapped and C-C in all-atom\n", + " cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut])\n", + " print('made it past cg_rdf')\n", + " #aa_rdf = htf.compute_rdf(nlist, [0.1, self.rcut], positions[:,3], type_i=1, type_j=1)\n", + " #print('made it past aa_rdf')\n", + " # compute ca-o (?) RDF\n", + " #cordf = htf.compute_rdf(\n", + " # nlist, [0.1,self.rcut], positions[:, 3], \n", + " # nbins=50, type_i=1, type_j=2)\n", + " # compute ca-ca(?) RDF\n", + " #ccrdf = htf.compute_rdf(\n", + " # nlist,[0.1,self.rcut], positions[:, 3], \n", + " # nbins=50, type_i=0, type_j=0)\n", + " #oordf = htf.compute_rdf(\n", + " # nlist,[0.1,self.rcut], positions[:, 3], \n", + " # nbins=50, type_i=2, type_j=4)\n", + " # average the RDFs\n", + " self.avg_cg_rdf.update_state(cg_rdf)\n", + " print('made it past avg_cg_rdf')\n", + " #self.avg_aa_rdf.update_state(aa_rdf)\n", + " #print('made it past avg_aa_rdf')\n", + " #self.avg_cc_rdf.update_state(ccrdf)\n", + " #self.avg_co_rdf.update_state(cordf)\n", + " #self.avg_oo_rdf.update_state(oordf)\n", + " return \n", + "nneighbor_cutoff = 32\n", + "model = TrajModel(nneighbor_cutoff,\n", + " CG_NN = nneighbor_cutoff,\n", + " cg_mapping=cg_mapping,\n", + " output_forces=False,\n", + " rcut=set_rcut,\n", + " check_nlist=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "made it past to mapped_pos\n", + "made it past mapped_nlist\n", + "made it past cg_rdf\n", + "made it past avg_cg_rdf\n", + "made it past to mapped_pos\n", + "made it past mapped_nlist\n" + ] + } + ], + "source": [ + "i = 0\n", + "for inputs, ts in htf.iter_from_trajectory(nneighbor_cutoff, univ, r_cut=set_rcut):\n", + " print(i)\n", + " i+=1\n", + " result = model(inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "start_idx = 0\n", + "\n", + "ccrdf = model.avg_ccrdf.result().numpy()\n", + "plt.figure()\n", + "plt.plot(ccrdf[1, start_idx:], ccrdf[0, start_idx:], label='C-C', color='C1')\n", + "plt.title(r'C-C RDF')\n", + "plt.xlabel(r'r')\n", + "plt.ylabel(r'g(r)')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "cordf = model.avg_cordf.result().numpy()\n", + "plt.figure()\n", + "plt.plot(ccrdf[1, start_idx:], cordf[0, start_idx:], label='C-O', color='C1')\n", + "plt.title(r'C-O RDF')\n", + "plt.xlabel(r'r')\n", + "plt.ylabel(r'g(r)')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "cordf = model.avg_oordf.result().numpy()\n", + "plt.figure()\n", + "plt.plot(ccrdf[1, start_idx:], cordf[0, start_idx:], label='C-O', color='C1')\n", + "plt.title(r'C-O RDF')\n", + "plt.xlabel(r'r')\n", + "plt.ylabel(r'g(r)')\n", + "plt.legend()\n", + "plt.show()" ] }, { From 30f47d145f5547097bb60cfbf25f542e1aeefead Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 27 Jan 2021 20:40:33 -0700 Subject: [PATCH 04/35] Position tracking of CG beads working --- Notebooks/HTF_CG_Demo.ipynb | 10541 +++++++++++++++++++++++++++++++++- 1 file changed, 10465 insertions(+), 76 deletions(-) diff --git a/Notebooks/HTF_CG_Demo.ipynb b/Notebooks/HTF_CG_Demo.ipynb index 36ac926..a4f9378 100644 --- a/Notebooks/HTF_CG_Demo.ipynb +++ b/Notebooks/HTF_CG_Demo.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -23,23 +23,13 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "HOOMD-blue 2.9.3 DOUBLE HPMC_MIXED TBB SSE SSE2 SSE3 \n", - "Compiled: 01/11/2021\n", - "Copyright (c) 2009-2019 The Regents of the University of Michigan.\n", - "-----\n", - "You are using HOOMD-blue. Please cite the following:\n", - "* J A Anderson, J Glaser, and S C Glotzer. \"HOOMD-blue: A Python package for\n", - " high-performance molecular dynamics and hard particle Monte Carlo\n", - " simulations\", Computational Materials Science 173 (2020) 109363\n", - "-----\n", - "HOOMD-blue is running on the CPU\n", "notice(2): Group \"all\" created containing 88 particles\n" ] } @@ -58,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -76,21 +66,21 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "['ca-oh', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'ca-ca', 'c-ca', 'c-o', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'c-o', 'c-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-ca', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'ca-ca', 'c-o', 'c-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-os', 'ca-ca', 'ca-os', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'c-ca', 'c-ca', 'c-o', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca', 'ca-ca']\n", + "[(1, 0), (1, 87), (2, 1), (3, 2), (4, 86), (4, 3), (4, 5), (5, 6), (6, 7), (6, 85), (7, 8), (8, 9), (9, 10), (9, 84), (10, 12), (10, 11), (12, 83), (12, 13), (13, 14), (14, 81), (14, 15), (15, 16), (16, 17), (16, 80), (17, 18), (18, 19), (19, 79), (19, 20), (20, 21), (21, 78), (21, 22), (22, 23), (23, 24), (24, 77), (24, 25), (25, 26), (25, 27), (27, 28), (27, 76), (28, 29), (29, 30), (29, 74), (30, 31), (31, 32), (31, 73), (32, 33), (33, 34), (34, 72), (34, 35), (35, 36), (36, 71), (36, 37), (37, 38), (38, 39), (39, 40), (39, 70), (40, 41), (40, 42), (42, 69), (42, 43), (43, 44), (44, 67), (44, 45), (45, 46), (46, 47), (46, 66), (47, 48), (48, 49), (49, 50), (49, 65), (50, 51), (51, 52), (51, 64), (52, 53), (53, 54), (54, 63), (54, 55), (55, 57), (55, 56), (57, 62), (57, 58), (58, 59), (59, 60), (60, 61), (61, 62), (63, 64), (65, 66), (67, 68), (68, 69), (70, 71), (72, 73), (74, 75), (75, 76), (77, 78), (79, 80), (81, 82), (82, 83), (84, 85), (86, 87)]\n", "[{0, 1, 2, 3, 4, 86, 87}, {5, 6, 7, 8, 9, 84, 85}, {10, 11, 12, 13, 14, 81, 82, 83}, {15, 16, 17, 18, 80, 79, 19}, {77, 78, 20, 21, 22, 23, 24}, {74, 75, 76, 25, 26, 27, 28, 29}, {32, 33, 34, 72, 73, 30, 31}, {35, 36, 37, 70, 71, 38, 39}, {67, 68, 69, 40, 41, 42, 43, 44}, {65, 66, 45, 46, 47, 48, 49}, {64, 50, 51, 52, 53, 54, 63}, {55, 56, 57, 58, 59, 60, 61, 62}] 12\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -100,7 +90,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -122,7 +112,7 @@ "# judiciously snip bonds\n", "degrees_dict = dict(graph.degree())\n", "\n", - "print([item.type for item in list(system.bonds)])\n", + "print([(item.a, item.b) for item in list(system.bonds)])\n", "\n", "for i, bond in enumerate(system.bonds):\n", " if bond.type == 'c-ca' or bond.type == 'ca-c':\n", @@ -144,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -174,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -214,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -251,17 +241,26 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 42, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[15.995788 15.995788 15.995788 90. 90. 90. ] 100-length-4-peek-para-only-production.gsd\n" + ] + } + ], "source": [ "import MDAnalysis as mda\n", - "univ = mda.Universe(fname)" + "univ = mda.Universe(fname)\n", + "print(univ.dimensions, fname)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 43, "metadata": { "scrolled": false }, @@ -272,7 +271,7 @@ "{'c', 'ca', 'o', 'oh', 'os'}" ] }, - "execution_count": 9, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -283,88 +282,10478 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 55, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0. 0. 0. ... 0. 0. 0.]\n", + " [0. 1. 0. ... 0. 0. 0.]\n", + " [0. 0. 1. ... 0. 0. 0.]\n", + " ...\n", + " [0. 0. 0. ... 1. 0. 0.]\n", + " [0. 0. 0. ... 0. 1. 0.]\n", + " [0. 0. 0. ... 0. 0. 1.]]\n" + ] + } + ], "source": [ + "adjacency_matrix = np.eye(M*12)\n", + "for i in range(M*12):\n", + " if i % 12 == 0:\n", + " adjacency_matrix[i][i] = 0\n", "class TrajModel(htf.SimModel):\n", " def setup(self, CG_NN, cg_mapping, rcut):\n", " self.CG_NN = CG_NN\n", " self.cg_mapping = cg_mapping\n", " self.rcut = rcut\n", - " #self.avg_aa_rdf = tf.keras.metrics.MeanTensor() # all atoms\n", - " self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # CG beads\n", - " #self.avg_cc_rdf = tf.keras.metrics.MeanTensor() # just C-C\n", - " #self.avg_co_rdf = tf.keras.metrics.MeanTensor() # just C-O\n", - " #self.avg_oo_rdf = tf.keras.metrics.MeanTensor() # just O-O\n", - " def compute(self, nlist, positions, box): \n", - " # get RDF\n", + " def compute(self, nlist, positions, box):\n", " # calculate the center of mass of a CG bead\n", " box_size = htf.box_size(box)\n", - " mapped_pos = htf.center_of_mass(positions[:,:3], self.cg_mapping, box_size)\n", + " mapped_pos = htf.center_of_mass(positions=positions[:,:3],\n", + " mapping=self.cg_mapping, \n", + " box_size=[16.,16.,16.])\n", " print('made it past to mapped_pos')\n", - " # create the mapped neighbot list\n", - " mapped_nlist = htf.compute_nlist(mapped_pos, self.rcut, self.CG_NN, box_size, True)\n", - " print('made it past mapped_nlist')\n", - " # compute RDF for mapped and C-C in all-atom\n", - " cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut])\n", - " print('made it past cg_rdf')\n", - " #aa_rdf = htf.compute_rdf(nlist, [0.1, self.rcut], positions[:,3], type_i=1, type_j=1)\n", - " #print('made it past aa_rdf')\n", - " # compute ca-o (?) RDF\n", - " #cordf = htf.compute_rdf(\n", - " # nlist, [0.1,self.rcut], positions[:, 3], \n", - " # nbins=50, type_i=1, type_j=2)\n", - " # compute ca-ca(?) RDF\n", - " #ccrdf = htf.compute_rdf(\n", - " # nlist,[0.1,self.rcut], positions[:, 3], \n", - " # nbins=50, type_i=0, type_j=0)\n", - " #oordf = htf.compute_rdf(\n", - " # nlist,[0.1,self.rcut], positions[:, 3], \n", - " # nbins=50, type_i=2, type_j=4)\n", - " # average the RDFs\n", - " self.avg_cg_rdf.update_state(cg_rdf)\n", - " print('made it past avg_cg_rdf')\n", - " #self.avg_aa_rdf.update_state(aa_rdf)\n", - " #print('made it past avg_aa_rdf')\n", - " #self.avg_cc_rdf.update_state(ccrdf)\n", - " #self.avg_co_rdf.update_state(cordf)\n", - " #self.avg_oo_rdf.update_state(oordf)\n", - " return \n", + " #cg_graph = htf.compute_cg_graph(DSGPM=False,\n", + " # infile=None,\n", + " # adj_mat=adjacency_matrix,\n", + " # cg_beads=M*12)\n", + " return mapped_pos, box, box_size\n", "nneighbor_cutoff = 32\n", "model = TrajModel(nneighbor_cutoff,\n", " CG_NN = nneighbor_cutoff,\n", " cg_mapping=cg_mapping,\n", " output_forces=False,\n", " rcut=set_rcut,\n", - " check_nlist=False)" + " check_nlist=False)\n", + "print(adjacency_matrix)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 92, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0\n", - "made it past to mapped_pos\n", - "made it past mapped_nlist\n", - "made it past cg_rdf\n", - "made it past avg_cg_rdf\n", - "made it past to mapped_pos\n", - "made it past mapped_nlist\n" + "100\n", + "[[ 0. 1.]\n", + " [ 1. 2.]\n", + " [ 2. 3.]\n", + " [ 3. 4.]\n", + " [ 4. 5.]\n", + " [ 5. 6.]\n", + " [ 6. 7.]\n", + " [ 7. 8.]\n", + " [ 8. 9.]\n", + " [ 9. 10.]\n", + " [10. 11.]\n", + " [12. 13.]\n", + " [13. 14.]\n", + " [14. 15.]\n", + " [15. 16.]\n", + " [16. 17.]\n", + " [17. 18.]\n", + " [18. 19.]\n", + " [19. 20.]\n", + " [20. 21.]\n", + " [21. 22.]\n", + " [22. 23.]\n", + " [24. 25.]\n", + " [25. 26.]]\n", + "[[1086. 1087.]\n", + " [1087. 1088.]\n", + " [1088. 1089.]\n", + " [1089. 1090.]\n", + " [1090. 1091.]\n", + " [1092. 1093.]\n", + " [1093. 1094.]\n", + " [1094. 1095.]\n", + " [1095. 1096.]\n", + " [1096. 1097.]\n", + " [1097. 1098.]\n", + " [1098. 1099.]\n", + " [1099. 1100.]\n", + " [1100. 1101.]\n", + " [1101. 1102.]\n", + " [1102. 1103.]\n", + " [1104. 1105.]\n", + " [1105. 1106.]\n", + " [1106. 1107.]\n", + " [1107. 1108.]\n", + " [1108. 1109.]\n", + " [1109. 1110.]\n", + " [1110. 1111.]\n", + " [1111. 1112.]\n", + " [1112. 1113.]\n", + " [1113. 1114.]\n", + " [1114. 1115.]\n", + " [1116. 1117.]\n", + " [1117. 1118.]\n", + " [1118. 1119.]\n", + " [1119. 1120.]\n", + " [1120. 1121.]\n", + " [1121. 1122.]\n", + " [1122. 1123.]\n", + " [1123. 1124.]\n", + " [1124. 1125.]\n", + " [1125. 1126.]\n", + " [1126. 1127.]\n", + " [1128. 1129.]\n", + " [1129. 1130.]\n", + " [1130. 1131.]\n", + " [1131. 1132.]\n", + " [1132. 1133.]\n", + " [1133. 1134.]\n", + " [1134. 1135.]\n", + " [1135. 1136.]\n", + " [1136. 1137.]\n", + " [1137. 1138.]\n", + " [1138. 1139.]\n", + " [1140. 1141.]\n", + " [1141. 1142.]\n", + " [1142. 1143.]\n", + " [1143. 1144.]\n", + " [1144. 1145.]\n", + " [1145. 1146.]\n", + " [1146. 1147.]\n", + " [1147. 1148.]\n", + " [1148. 1149.]\n", + " [1149. 1150.]\n", + " [1150. 1151.]\n", + " [1152. 1153.]\n", + " [1153. 1154.]\n", + " [1154. 1155.]\n", + " [1155. 1156.]\n", + " [1156. 1157.]\n", + " [1157. 1158.]\n", + " [1158. 1159.]\n", + " [1159. 1160.]\n", + " [1160. 1161.]\n", + " [1161. 1162.]\n", + " [1162. 1163.]\n", + " [1164. 1165.]\n", + " [1165. 1166.]\n", + " [1166. 1167.]\n", + " [1167. 1168.]\n", + " [1168. 1169.]\n", + " [1169. 1170.]\n", + " [1170. 1171.]\n", + " [1171. 1172.]\n", + " [1172. 1173.]\n", + " [1173. 1174.]\n", + " [1174. 1175.]\n", + " [1176. 1177.]\n", + " [1177. 1178.]\n", + " [1178. 1179.]\n", + " [1179. 1180.]\n", + " [1180. 1181.]\n", + " [1181. 1182.]\n", + " [1182. 1183.]\n", + " [1183. 1184.]\n", + " [1184. 1185.]\n", + " [1185. 1186.]\n", + " [1186. 1187.]\n", + " [1188. 1189.]\n", + " [1189. 1190.]\n", + " [1190. 1191.]\n", + " [1191. 1192.]\n", + " [1192. 1193.]\n", + " [1193. 1194.]\n", + " [1194. 1195.]\n", + " [1195. 1196.]\n", + " [1196. 1197.]\n", + " [1197. 1198.]\n", + " [1198. 1199.]]\n", + "Applying CG mapping to 100-length-4-peek-para-only-production.gsd\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] } ], "source": [ + "beads_per_molecule = 12\n", + "bonds_per_molecule = beads_per_molecule - 1 # linear polymer\n", + "bonds_matrix = np.zeros([bonds_per_molecule * M, 2])\n", + "#print(M)\n", + "bonds_matrix[0][1] = 1\n", + "offset = 0\n", + "\n", + "for i in range(1, bonds_matrix.shape[0]):\n", + " bonds_matrix[i][0] = i + i//11\n", + " bonds_matrix[i][1] = i+1 + i//11\n", + " \n", + "def make_frame(i, positions):\n", + " s = gsd.hoomd.Snapshot()\n", + " s.configuration.box = [16.,16.,16., 0., 0., 0.]\n", + " s.configuration.step = i\n", + " s.particles.N = beads_per_molecule * M\n", + " s.particles.position = positions\n", + " s.bonds.N = bonds_per_molecule * M\n", + " s.bonds.group = bonds_matrix\n", + " #print(s)\n", + " return s\n", + "\n", + "print(f'Applying CG mapping to {fname}')\n", + "f = gsd.hoomd.open(name=f'CG_traj-{fname}', mode='wb+')\n", "i = 0\n", "for inputs, ts in htf.iter_from_trajectory(nneighbor_cutoff, univ, r_cut=set_rcut):\n", - " print(i)\n", + " #print(i)\n", " i+=1\n", - " result = model(inputs)" + " result = model(inputs)\n", + " #print(result[0], np.array(result[0].shape))\n", + " particle_positions = np.array(result[0])\n", + " f.append(make_frame(i, particle_positions))" ] }, { From c1ef1fa36d995e3dee0527be732c412bca0899af Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Mon, 8 Feb 2021 09:28:47 -0700 Subject: [PATCH 05/35] First copy of CG demo .py file. Failing --- Notebooks/HTF_CG_Demo.py | 217 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 217 insertions(+) create mode 100644 Notebooks/HTF_CG_Demo.py diff --git a/Notebooks/HTF_CG_Demo.py b/Notebooks/HTF_CG_Demo.py new file mode 100644 index 0000000..25966e0 --- /dev/null +++ b/Notebooks/HTF_CG_Demo.py @@ -0,0 +1,217 @@ +import os +#os.environ['CUDA_VISIBLE_DEVICES'] = '-1' +import networkx as nx +import tensorflow as tf +from tensorflow.keras import layers +import hoomd +import hoomd.md +import hoomd.htf as htf +import numpy as np +import gsd +import gsd.hoomd +import pickle +import matplotlib.pyplot as plt + +# building a HTF model for coarse graining +# here use the single-molecule file for simplicity +# TODO: update to get one molecule from a .gsd with multiple +# e.g. grab first entry in htf.find_molecules(system) -> do the rest +fname = '1-length-4-peek-para-only.gsd' +gsdfile = gsd.hoomd.open(fname) +context = hoomd.context.initialize('--mode=cpu') +system = hoomd.init.read_gsd(filename=fname) +context.sorter.disable() + +molecule_mapping_index = htf.find_molecules(system) + +graph = nx.Graph() +# add all our particles and bonds +for particle in system.particles: + graph.add_node(particle.tag, name=particle.type) +for bond in system.bonds: + graph.add_edge(bond.a, bond.b) +plt.figure() +plt.title('BEFORE') +nx.draw(graph, with_labels=True) +plt.savefig('before.png') +# judiciously snip bonds +degrees_dict = dict(graph.degree()) + +for i, bond in enumerate(system.bonds): + if bond.type == 'c-ca' or bond.type == 'ca-c': + if degrees_dict[bond.a] == 3 and degrees_dict[bond.b] == 3: + graph.remove_edge(bond.a, bond.b) + elif bond.type == 'ca-os' or bond.type == 'os-ca': + if degrees_dict[bond.a] == 2 and degrees_dict[bond.b] == 3 or\ + degrees_dict[bond.a] == 3 and degrees_dict[bond.b] == 2: + graph.remove_edge(bond.a, bond.b) + degrees_dict = dict(graph.degree()) + +subgraph_list = list(nx.connected_components(graph)) +plt.figure() +plt.title('AFTER') +nx.draw(graph, with_labels=True) +plt.savefig('after.png') + +# now we have our beads grouped up, we need to get their mapping +# get total N atoms +N = sum([len(m) for m in molecule_mapping_index]) +# get molecule count +M = len(molecule_mapping_index) +# atoms per molecule +MN = len(molecule_mapping_index[0]) +print('N_atoms:', N,'\nN_molecules:', M,'\nN_atoms_per_molecule:', MN) +# make sure we didn't miss any particles +assert(sum([len(item) for item in subgraph_list]) == MN) + +# create a mapping for our molecules +# these are 4-monomer polymers, and we're doing 3 beads per monomer +# therefore, we need a 12 x 88 matrix + + +mapping_arr = np.zeros((12,MN)) + +for i, subgraph in enumerate(subgraph_list): + for atom_idx in subgraph: + mapping_arr[i][atom_idx] = 1 + +N = sum([len(m) for m in molecule_mapping_index]) +# get molecule count +M = len(molecule_mapping_index) +# atoms per molecule +MN = len(molecule_mapping_index[0]) +# again make sure we didn't miss any atoms +assert(np.sum(mapping_arr) == MN) + +bead_number = mapping_arr.shape[0] + +fname = '100-length-4-peek-para-only-production.gsd' +gsdfile = gsd.hoomd.open(fname) +context = hoomd.context.initialize('--mode=cpu') +system = hoomd.init.read_gsd(filename=fname) +context.sorter.disable() +set_rcut = 11.0 +molecule_mapping_index = htf.find_molecules(system) + +cg_mapping = htf.sparse_mapping([mapping_arr for _ in molecule_mapping_index], + molecule_mapping_index, system=system) +N = sum([len(m) for m in molecule_mapping_index]) +# get molecule count +M = len(molecule_mapping_index) +# atoms per molecule +MN = len(molecule_mapping_index[0]) +print('N_atoms:', N,'\nN_molecules:', M,'\nN_atoms_per_molecule:', MN) +assert cg_mapping.shape == (M * bead_number, N) + +import MDAnalysis as mda +univ = mda.Universe(fname) + +# create an edge list +beads_per_molecule = 12 +bonds_per_molecule = beads_per_molecule - 1 # linear polymer +bonds_matrix = np.zeros([bonds_per_molecule * M, 2]) +#print(M) +bonds_matrix[0][1] = 1 +offset = 0 + +# this puts the indices of bonded beads as pairs +# i.e. the edge list of a graph +for i in range(1, bonds_matrix.shape[0]): + bonds_matrix[i][0] = i + i//11 + bonds_matrix[i][1] = i+1 + i//11 + +# make adjacency matrix (N_beads x N_beads) +# adj_mat[i][j] = 0 if beads (i, j) not bonded, 1 if they are +adjacency_matrix = np.zeros([M * 12, M * 12]) +for pair in bonds_matrix: + i, j = int(pair[0]), int(pair[1]) + adjacency_matrix[i][j] = adjacency_matrix[j][i] = 1 + +a = nx.Graph(adjacency_matrix) +#print('cg_mapping IS THIS --> ', cg_mapping) +#print('adjmat IS THIS --> ', adjacency_matrix) +b = dict(nx.all_pairs_shortest_path_length(a)) +# print(b[12]) # this DOES have the key 12 +class TrajModel(htf.SimModel): + def setup(self, cg_num, adjacency_matrix, CG_NN, cg_mapping, rcut): + self.cg_num = cg_num + self.adjacency_matrix = adjacency_matrix + self.CG_NN = CG_NN + self.cg_mapping = cg_mapping + self.rcut = rcut + self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # set up CG RDF tracking + def compute(self, nlist, positions, box): + # calculate the center of mass of a CG bead + box_size = htf.box_size(box) # [16., 16., 16.] + mapped_pos = htf.center_of_mass(positions=positions[:,:3], + mapping=self.cg_mapping, + box_size= box_size) + print('made it past to mapped_pos') + #print(self.adjacency_matrix) + # print( + # dict( + # nx.all_pairs_shortest_path_length( + # nx.Graph( + # self.adjacency_matrix + # ) + # ) + # ).keys() + # ) + cg_graph = htf.compute_cg_graph(DSGPM=False, + infile=None, + adj_mat=self.adjacency_matrix, + cg_beads=self.cg_num) + # create mapped neighbor list + mapped_nlist = htf.compute_nlist(mapped_pos, self.rcut, self.CG_NN, box_size, True) + # compute RDF for mapped particles + cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut]) + self.avg_cg_rdf.update_state(cg_rdf) + return mapped_pos, cg_graph, box, box_size +nneighbor_cutoff = 32 +model = TrajModel(nneighbor_cutoff, + cg_num=M * 12, + adjacency_matrix=adjacency_matrix, + CG_NN=nneighbor_cutoff, + cg_mapping=cg_mapping, + output_forces=False, + rcut=set_rcut, + check_nlist=False) +#print(adjacency_matrix) + + + +def make_frame(i, positions): + s = gsd.hoomd.Snapshot() + s.configuration.box = [16., 16., 16., 0., 0., 0.] + s.configuration.step = i + s.particles.N = beads_per_molecule * M + s.particles.position = positions + s.bonds.N = bonds_per_molecule * M + s.bonds.group = bonds_matrix + #print(s) + return s + +write_CG_traj = False + +if write_CG_traj: + print(f'Applying CG mapping to {fname}') + f = gsd.hoomd.open(name=f'CG_traj-{fname}', mode='wb+') + i = 0 +for inputs, ts in htf.iter_from_trajectory(nneighbor_cutoff, univ, r_cut=set_rcut): + if i % 100 == 0: + print(f'made it to step {i:04d}', end='\r') + result = model(inputs) + #print(' cg_model is: ', result[1], end='\r') + particle_positions = np.array(result[0]) + if write_CG_traj: + f.append(make_frame(i, particle_positions)) + i+=1 + +cg_rdf = model.avg_cg_rdf.result().numpy() + +plt.figure() +plt.plot(cg_rdf[1,:], cg_rdf[0,:], label='Mapped (CG)') +plt.xlabel('r [$\AA$]') +plt.ylabel('$g(r)$') +plt.legend() +plt.savefig('CG_RDF.svg') \ No newline at end of file From 515ebf1c9d2844b1032b67873df91867a74f7620 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Mon, 8 Feb 2021 09:47:41 -0700 Subject: [PATCH 06/35] Fix cg_num arg --- Notebooks/HTF_CG_Demo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Notebooks/HTF_CG_Demo.py b/Notebooks/HTF_CG_Demo.py index 25966e0..bbd3fd3 100644 --- a/Notebooks/HTF_CG_Demo.py +++ b/Notebooks/HTF_CG_Demo.py @@ -169,7 +169,7 @@ def compute(self, nlist, positions, box): return mapped_pos, cg_graph, box, box_size nneighbor_cutoff = 32 model = TrajModel(nneighbor_cutoff, - cg_num=M * 12, + cg_num=12, adjacency_matrix=adjacency_matrix, CG_NN=nneighbor_cutoff, cg_mapping=cg_mapping, From 9b85ec1b183dacac56bf2dbee679f48e1c101498 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 17 Feb 2021 13:40:14 -0700 Subject: [PATCH 07/35] Able to calculate CG bonds/angles/dihedrals --- Notebooks/HTF_CG_Demo.py | 123 ++++++++++++++++++++++++++++++--------- 1 file changed, 96 insertions(+), 27 deletions(-) diff --git a/Notebooks/HTF_CG_Demo.py b/Notebooks/HTF_CG_Demo.py index bbd3fd3..9d5ca60 100644 --- a/Notebooks/HTF_CG_Demo.py +++ b/Notebooks/HTF_CG_Demo.py @@ -14,8 +14,11 @@ # building a HTF model for coarse graining # here use the single-molecule file for simplicity -# TODO: update to get one molecule from a .gsd with multiple -# e.g. grab first entry in htf.find_molecules(system) -> do the rest +# TODO: save out the CG Mapping to file, load it in +# TODO: break this file up into a few scripts +# e.g. one for making mapping, one for running from traj... +# TODO: once saving is set, get pipeline for starting a sim fresh with uli-init +# TODO: set up CG FF NN with all the molecule bond/angle/dihedral/LJ parameters fname = '1-length-4-peek-para-only.gsd' gsdfile = gsd.hoomd.open(fname) context = hoomd.context.initialize('--mode=cpu') @@ -110,7 +113,6 @@ beads_per_molecule = 12 bonds_per_molecule = beads_per_molecule - 1 # linear polymer bonds_matrix = np.zeros([bonds_per_molecule * M, 2]) -#print(M) bonds_matrix[0][1] = 1 offset = 0 @@ -127,11 +129,6 @@ i, j = int(pair[0]), int(pair[1]) adjacency_matrix[i][j] = adjacency_matrix[j][i] = 1 -a = nx.Graph(adjacency_matrix) -#print('cg_mapping IS THIS --> ', cg_mapping) -#print('adjmat IS THIS --> ', adjacency_matrix) -b = dict(nx.all_pairs_shortest_path_length(a)) -# print(b[12]) # this DOES have the key 12 class TrajModel(htf.SimModel): def setup(self, cg_num, adjacency_matrix, CG_NN, cg_mapping, rcut): self.cg_num = cg_num @@ -140,33 +137,65 @@ def setup(self, cg_num, adjacency_matrix, CG_NN, cg_mapping, rcut): self.cg_mapping = cg_mapping self.rcut = rcut self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # set up CG RDF tracking + + self.avg_cg_radii = tf.keras.metrics.MeanTensor() + self.avg_cg_angles = tf.keras.metrics.MeanTensor() + self.avg_cg_dihedrals = tf.keras.metrics.MeanTensor() + def compute(self, nlist, positions, box): # calculate the center of mass of a CG bead box_size = htf.box_size(box) # [16., 16., 16.] mapped_pos = htf.center_of_mass(positions=positions[:,:3], mapping=self.cg_mapping, box_size= box_size) - print('made it past to mapped_pos') - #print(self.adjacency_matrix) - # print( - # dict( - # nx.all_pairs_shortest_path_length( - # nx.Graph( - # self.adjacency_matrix - # ) - # ) - # ).keys() - # ) - cg_graph = htf.compute_cg_graph(DSGPM=False, + cg_features = htf.compute_cg_graph(DSGPM=False, infile=None, adj_mat=self.adjacency_matrix, cg_beads=self.cg_num) + + radii_tensor = [] + angles_tensor = [] + dihedrals_tensor = [] + + # because these are tensors, can't use list comprehension + for i in range(len(cg_features[0])): + cg_radius = htf.mol_bond_distance(CG=True, + cg_positions=mapped_pos, + b1=cg_features[0][i][0], + b2=cg_features[0][i][1] + ) + radii_tensor.append(cg_radius) + + for j in range(len(cg_features[1])): + cg_angle = htf.mol_angle(CG=True, + cg_positions=mapped_pos, + b1=cg_features[1][j][0], + b2=cg_features[1][j][1], + b3=cg_features[1][j][2] + ) + angles_tensor.append(cg_angle) + + for k in range(len(cg_features[2])): + cg_dihedral = htf.mol_dihedral(CG=True, + cg_positions=mapped_pos, + b1=cg_features[2][k][0], + b2=cg_features[2][k][1], + b3=cg_features[2][k][2], + b4=cg_features[2][k][3], + ) + dihedrals_tensor.append(cg_dihedral) + + self.avg_cg_radii.update_state(radii_tensor) + self.avg_cg_angles.update_state(angles_tensor) + self.avg_cg_dihedrals.update_state(dihedrals_tensor) + # create mapped neighbor list mapped_nlist = htf.compute_nlist(mapped_pos, self.rcut, self.CG_NN, box_size, True) # compute RDF for mapped particles cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut]) self.avg_cg_rdf.update_state(cg_rdf) - return mapped_pos, cg_graph, box, box_size + return mapped_pos, cg_features, box, box_size + nneighbor_cutoff = 32 model = TrajModel(nneighbor_cutoff, cg_num=12, @@ -176,10 +205,8 @@ def compute(self, nlist, positions, box): output_forces=False, rcut=set_rcut, check_nlist=False) -#print(adjacency_matrix) - - +# for writing out the CG trajectory def make_frame(i, positions): s = gsd.hoomd.Snapshot() s.configuration.box = [16., 16., 16., 0., 0., 0.] @@ -188,11 +215,14 @@ def make_frame(i, positions): s.particles.position = positions s.bonds.N = bonds_per_molecule * M s.bonds.group = bonds_matrix - #print(s) return s write_CG_traj = False +avg_bond_lengths = [] +avg_bond_angles = [] +avg_dihedral_angles = [] + if write_CG_traj: print(f'Applying CG mapping to {fname}') f = gsd.hoomd.open(name=f'CG_traj-{fname}', mode='wb+') @@ -201,8 +231,10 @@ def make_frame(i, positions): if i % 100 == 0: print(f'made it to step {i:04d}', end='\r') result = model(inputs) - #print(' cg_model is: ', result[1], end='\r') particle_positions = np.array(result[0]) + avg_bond_lengths.append(result[1][0]) + avg_bond_angles.append(result[1][1]) + avg_dihedral_angles.append(result[1][2]) if write_CG_traj: f.append(make_frame(i, particle_positions)) i+=1 @@ -214,4 +246,41 @@ def make_frame(i, positions): plt.xlabel('r [$\AA$]') plt.ylabel('$g(r)$') plt.legend() -plt.savefig('CG_RDF.svg') \ No newline at end of file +plt.savefig('CG_RDF.svg') + +# plot average CG bond radii +# cg_radii = model.avg_cg_radii.result().numpy() + +np.save('cg_radii.npy', np.array(avg_bond_lengths)) + +# plt.figure() +# plt.hist(np.array(avg_bond_lengths)) +# plt.xlabel('r [$\AA$]') +# plt.ylabel('Count') +# plt.title('CG Bond Length Histogram') +# plt.legend() +# plt.savefig('CG_Radii.svg') + +# plot average CG bond angles +# cg_radii = model.avg_cg_angles.result().numpy() + +np.save('cg_angles.npy', np.array(avg_bond_angles)) + +# plt.figure() +# plt.plot(cg_radii[1,:], cg_radii[0,:], label='Mapped (CG)') +# plt.xlabel('$\theta$ [Degrees(?)]') +# plt.ylabel('$g(r)$?') +# plt.legend() +# plt.savefig('CG_Angles.svg') + +# plot average CG dihedral angles +# cg_radii = model.avg_cg_dihedrals.result().numpy() + +np.save('cg_dihedrals.npy', np.array(avg_dihedral_angles)) + +# plt.figure() +# plt.plot(cg_radii[1,:], cg_radii[0,:], label='Mapped (CG)') +# plt.xlabel('$\phi$ [Degrees?]') +# plt.ylabel('$g(r)$?') +# plt.legend() +# plt.savefig('CG_Radii.svg') \ No newline at end of file From 2cd1818cfaf07872af3519709d22b183a7448b2b Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Thu, 18 Feb 2021 16:01:54 -0700 Subject: [PATCH 08/35] Can save out and load mapping indices from .npy files --- Notebooks/HTF_CG_Demo.py | 57 ++++++++++++++++++++++------------------ 1 file changed, 32 insertions(+), 25 deletions(-) diff --git a/Notebooks/HTF_CG_Demo.py b/Notebooks/HTF_CG_Demo.py index 9d5ca60..d87dd1b 100644 --- a/Notebooks/HTF_CG_Demo.py +++ b/Notebooks/HTF_CG_Demo.py @@ -11,6 +11,7 @@ import gsd.hoomd import pickle import matplotlib.pyplot as plt +import os # building a HTF model for coarse graining # here use the single-molecule file for simplicity @@ -19,13 +20,24 @@ # e.g. one for making mapping, one for running from traj... # TODO: once saving is set, get pipeline for starting a sim fresh with uli-init # TODO: set up CG FF NN with all the molecule bond/angle/dihedral/LJ parameters -fname = '1-length-4-peek-para-only.gsd' -gsdfile = gsd.hoomd.open(fname) -context = hoomd.context.initialize('--mode=cpu') -system = hoomd.init.read_gsd(filename=fname) -context.sorter.disable() -molecule_mapping_index = htf.find_molecules(system) +def get_mol_mapping_idx(filename): + '''Takes a filename of a .gsd file WITHOUT the '.gsd', loads that gsd, + then loads or creates a molecule mapping index from it.''' + # if the mapping doesn't exist, make it + gsdfile = gsd.hoomd.open(f'{filename}.gsd') + context = hoomd.context.initialize('--mode=cpu') + system = hoomd.init.read_gsd(filename=f'{filename}.gsd') + context.sorter.disable() + if not os.path.exists(f'{filename}-mapping.npy'): + molecule_mapping_index = htf.find_molecules(system) + np.save(f'{filename}-mapping.npy', np.array(molecule_mapping_index)) + # if it does, load from it instead + else: + molecule_mapping_index = np.load(f'{filename}-mapping.npy') + return system, molecule_mapping_index + +system, molecule_mapping_index = get_mol_mapping_idx('1-length-4-peek-para-only') graph = nx.Graph() # add all our particles and bonds @@ -88,13 +100,8 @@ bead_number = mapping_arr.shape[0] -fname = '100-length-4-peek-para-only-production.gsd' -gsdfile = gsd.hoomd.open(fname) -context = hoomd.context.initialize('--mode=cpu') -system = hoomd.init.read_gsd(filename=fname) -context.sorter.disable() set_rcut = 11.0 -molecule_mapping_index = htf.find_molecules(system) +system, molecule_mapping_index = get_mol_mapping_idx('100-length-4-peek-para-only-production') cg_mapping = htf.sparse_mapping([mapping_arr for _ in molecule_mapping_index], molecule_mapping_index, system=system) @@ -107,7 +114,7 @@ assert cg_mapping.shape == (M * bead_number, N) import MDAnalysis as mda -univ = mda.Universe(fname) +univ = mda.Universe('100-length-4-peek-para-only-production.gsd') # create an edge list beads_per_molecule = 12 @@ -165,6 +172,7 @@ def compute(self, nlist, positions, box): b2=cg_features[0][i][1] ) radii_tensor.append(cg_radius) + self.avg_cg_radii.update_state(radii_tensor) for j in range(len(cg_features[1])): cg_angle = htf.mol_angle(CG=True, @@ -174,6 +182,7 @@ def compute(self, nlist, positions, box): b3=cg_features[1][j][2] ) angles_tensor.append(cg_angle) + self.avg_cg_angles.update_state(angles_tensor) for k in range(len(cg_features[2])): cg_dihedral = htf.mol_dihedral(CG=True, @@ -184,9 +193,6 @@ def compute(self, nlist, positions, box): b4=cg_features[2][k][3], ) dihedrals_tensor.append(cg_dihedral) - - self.avg_cg_radii.update_state(radii_tensor) - self.avg_cg_angles.update_state(angles_tensor) self.avg_cg_dihedrals.update_state(dihedrals_tensor) # create mapped neighbor list @@ -194,11 +200,11 @@ def compute(self, nlist, positions, box): # compute RDF for mapped particles cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut]) self.avg_cg_rdf.update_state(cg_rdf) - return mapped_pos, cg_features, box, box_size + return mapped_pos, cg_features, radii_tensor, angles_tensor, dihedrals_tensor, box, box_size nneighbor_cutoff = 32 model = TrajModel(nneighbor_cutoff, - cg_num=12, + cg_num=12, # beads per molecule, not total adjacency_matrix=adjacency_matrix, CG_NN=nneighbor_cutoff, cg_mapping=cg_mapping, @@ -226,15 +232,15 @@ def make_frame(i, positions): if write_CG_traj: print(f'Applying CG mapping to {fname}') f = gsd.hoomd.open(name=f'CG_traj-{fname}', mode='wb+') - i = 0 +i = 0 for inputs, ts in htf.iter_from_trajectory(nneighbor_cutoff, univ, r_cut=set_rcut): - if i % 100 == 0: - print(f'made it to step {i:04d}', end='\r') + if i == 100: + break result = model(inputs) particle_positions = np.array(result[0]) - avg_bond_lengths.append(result[1][0]) - avg_bond_angles.append(result[1][1]) - avg_dihedral_angles.append(result[1][2]) + avg_bond_lengths.append(result[2]) + avg_bond_angles.append(result[3]) + avg_dihedral_angles.append(result[4]) if write_CG_traj: f.append(make_frame(i, particle_positions)) i+=1 @@ -249,7 +255,8 @@ def make_frame(i, positions): plt.savefig('CG_RDF.svg') # plot average CG bond radii -# cg_radii = model.avg_cg_radii.result().numpy() +cg_radii = model.avg_cg_radii.result().numpy() +print(cg_radii.shape) np.save('cg_radii.npy', np.array(avg_bond_lengths)) From 55985eb3888b2ddc153f4636190a5efa3fda65d2 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 24 Feb 2021 13:03:05 -0700 Subject: [PATCH 09/35] Model compiles but doesn't train (dict key error) --- Notebooks/HTF_CG_Demo.py | 150 ++++++++++++++++++++++++++++++++++----- 1 file changed, 133 insertions(+), 17 deletions(-) diff --git a/Notebooks/HTF_CG_Demo.py b/Notebooks/HTF_CG_Demo.py index d87dd1b..246cdf2 100644 --- a/Notebooks/HTF_CG_Demo.py +++ b/Notebooks/HTF_CG_Demo.py @@ -15,11 +15,10 @@ # building a HTF model for coarse graining # here use the single-molecule file for simplicity -# TODO: save out the CG Mapping to file, load it in # TODO: break this file up into a few scripts # e.g. one for making mapping, one for running from traj... # TODO: once saving is set, get pipeline for starting a sim fresh with uli-init -# TODO: set up CG FF NN with all the molecule bond/angle/dihedral/LJ parameters +# TODO: either calculate per-bead forces, or try just matching energies def get_mol_mapping_idx(filename): '''Takes a filename of a .gsd file WITHOUT the '.gsd', loads that gsd, @@ -37,7 +36,8 @@ def get_mol_mapping_idx(filename): molecule_mapping_index = np.load(f'{filename}-mapping.npy') return system, molecule_mapping_index -system, molecule_mapping_index = get_mol_mapping_idx('1-length-4-peek-para-only') +one_molecule_fname = '1-length-4-peek-para-only' +system, molecule_mapping_index = get_mol_mapping_idx(one_molecule_fname) graph = nx.Graph() # add all our particles and bonds @@ -101,7 +101,8 @@ def get_mol_mapping_idx(filename): bead_number = mapping_arr.shape[0] set_rcut = 11.0 -system, molecule_mapping_index = get_mol_mapping_idx('100-length-4-peek-para-only-production') +fname = '100-length-4-peek-para-only-production' +system, molecule_mapping_index = get_mol_mapping_idx(fname) cg_mapping = htf.sparse_mapping([mapping_arr for _ in molecule_mapping_index], molecule_mapping_index, system=system) @@ -136,6 +137,74 @@ def get_mol_mapping_idx(filename): i, j = int(pair[0]), int(pair[1]) adjacency_matrix[i][j] = adjacency_matrix[j][i] = 1 +# create Lennard-Jones energy-calculating layer +class LJLayer(tf.keras.layers.Layer): + def __init__(self, sigma, epsilon): + super().__init__(self, name='lj') + self.start_vals = [sigma, epsilon] + self.w = self.add_weight( + shape=[2], + initializer=tf.constant_initializer([sigma, epsilon]), + constraint=tf.keras.constraints.NonNeg() + ) + # call takes only particle radii (pass in from neighbor list) + # returns energy contribution from LJ interactions + def call(self, r): + r6 = tf.math.divide_no_nan(self.w[0]**6, r**6) + energy = self.w[1] * 4.0 * (r6**2 - r6) + # divide by 2 to avoid double-counting + return energy / 2. + +class BondLayer(tf.keras.layers.Layer): + # harmonic bond potential + def __init__(self, k_b, r0): + # we only have one bond type, so we only need one k & r0 + super().__init__(self, name='bonds') + # set initial values for bond spring constant (k_b) and equilibrium length (r0) + self.start = [k_b, r0] + self.w = self.add_weight( + shape=[2], + initializer=tf.constant_initializer([k_b, r0]), + constraint=tf.keras.constraints.NonNeg() + ) + + def call(self, r): + energy = self.w[0] * (r - self.w[1])**2 + # don't divide by 2 here because we are doing per-bond (not neighbor-list-based) + return energy + +class AngleLayer(tf.keras.layers.Layer): + # harmonic angle potential + def __init__(self, k_a, theta0): + # only one angle type, so we only need one k & theta0 + super().__init__(self, name='angles') + # set initial values for angle spring constant (k) and equilibrium theta + self.start = [k_a, theta0] + self.w = self.add_weight( + shape=[2], + initializer=tf.constant_initializer([k_a, theta0]), + constraint=tf.keras.constraints.NonNeg() + ) + def call(self, theta): + energy = self.w[0] * (theta - self.w[1])**2 + return energy + +class DihedralLayer(tf.keras.layers.Layer): + # harmonic cosine potential + def __init__(self, k_d, phi0): + # only one type of dihedral, so we only need one k & phi0 + super().__init__(self, name='dihedrals') + # set initial values for dihedral spring constant (k) and equilibrium phi + self.start = [k_d, phi0] + self.w = self.add_weight( + shape=[2], + initializer=tf.constant_initializer([k_d, phi0]), + constraint=tf.keras.constraints.NonNeg() + ) + def call(self, phi): + energy = self.w[0] * (tf.math.cos(phi) - tf.math.cos(self.w[1]))**2 + return energy + class TrajModel(htf.SimModel): def setup(self, cg_num, adjacency_matrix, CG_NN, cg_mapping, rcut): self.cg_num = cg_num @@ -149,6 +218,13 @@ def setup(self, cg_num, adjacency_matrix, CG_NN, cg_mapping, rcut): self.avg_cg_angles = tf.keras.metrics.MeanTensor() self.avg_cg_dihedrals = tf.keras.metrics.MeanTensor() + # energy layers + self.lj_energy = LJLayer(1., 1.) + # just a guess at bond length + self.bond_energy = BondLayer(1., 2.) + self.angle_energy = AngleLayer(1., 3.14/2.) + self.dihedral_energy = DihedralLayer(1., 3.14/2.) + def compute(self, nlist, positions, box): # calculate the center of mass of a CG bead box_size = htf.box_size(box) # [16., 16., 16.] @@ -200,7 +276,19 @@ def compute(self, nlist, positions, box): # compute RDF for mapped particles cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut]) self.avg_cg_rdf.update_state(cg_rdf) - return mapped_pos, cg_features, radii_tensor, angles_tensor, dihedrals_tensor, box, box_size + + # now calculate our total energy and train + nlist_r = htf.safe_norm(tensor=nlist[:, :, :3], axis=2) + lj_energy = self.lj_energy(nlist_r) + lj_energy_total = tf.reduce_sum(input_tensor=lj_energy, axis=1) + bonds_energy = self.bond_energy(radii_tensor) + angles_energy = self.angle_energy(angles_tensor) + dihedrals_energy = self.dihedral_energy(dihedrals_tensor) + subtotal_energy = tf.reduce_sum(bonds_energy) + tf.reduce_sum(angles_energy) + tf.reduce_sum(dihedrals_energy) + lj_forces = htf.compute_nlist_forces(nlist, lj_energy_total) + other_forces = htf.compute_positions_forces(positions=mapped_pos, energy=subtotal_energy) + total_energy = lj_energy + subtotal_energy + return mapped_pos, total_energy, radii_tensor, angles_tensor, dihedrals_tensor, lj_forces, other_forces, box, box_size # cg_features nneighbor_cutoff = 32 model = TrajModel(nneighbor_cutoff, @@ -231,20 +319,49 @@ def make_frame(i, positions): if write_CG_traj: print(f'Applying CG mapping to {fname}') - f = gsd.hoomd.open(name=f'CG_traj-{fname}', mode='wb+') -i = 0 + f = gsd.hoomd.open(name=f'CG-traj-{fname}.gsd', mode='wb+') + +# get our potential energies from the log file +logfile = f'{fname}.log' +print(f'Reading energies from {logfile}') +with open(logfile, 'r') as f: + header = f.readline() +potential_energy_idx = header.split('\t').index('potential_energy') +log_data = np.genfromtxt(logfile, skip_header=1) +potential_energies = log_data[:, potential_energy_idx] +energy_stride = 10 #int(log_data[:,0][1] - log_data[:,0][0]) + +i = 0 # index over gsd timesteps +j = 0 # index over energy steps (since we didn't write energy every frame) + +# all the 'None' here is so we only train on the energy +model.compile('Adam', [None, 'MeanSquaredError', None, None, None, None, None, None, None]) +losses = [] + +# set up training data and get the raw mapped statistics +inputs_list = [] for inputs, ts in htf.iter_from_trajectory(nneighbor_cutoff, univ, r_cut=set_rcut): - if i == 100: - break - result = model(inputs) - particle_positions = np.array(result[0]) - avg_bond_lengths.append(result[2]) - avg_bond_angles.append(result[3]) - avg_dihedral_angles.append(result[4]) - if write_CG_traj: - f.append(make_frame(i, particle_positions)) + if i % energy_stride == 0: + #labels = ts # TODO: iterate through the corresponding log file for our energies + # only grab neighbor list, positions, and box + inputs_list.append([np.array(item) for item in inputs]) + result = model(inputs) + particle_positions = np.array(result[0]) + avg_bond_lengths.append(result[2]) + avg_bond_angles.append(result[3]) + avg_dihedral_angles.append(result[4]) + if write_CG_traj: + f.append(make_frame(i, particle_positions)) + j += 1 i+=1 +try: + np.save('inputs.npy', np.array(inputs_list)) +except: + print('failed to save inputs') + +history = model.train_on_batch(x=inputs_list, y=potential_energies)#model.fit(x=inputs_list, y=potential_energies) + cg_rdf = model.avg_cg_rdf.result().numpy() plt.figure() @@ -256,7 +373,6 @@ def make_frame(i, positions): # plot average CG bond radii cg_radii = model.avg_cg_radii.result().numpy() -print(cg_radii.shape) np.save('cg_radii.npy', np.array(avg_bond_lengths)) From 442f089b407c72fe6da3a5f50c6c8b0f8273873c Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Thu, 4 Mar 2021 16:45:55 -0700 Subject: [PATCH 10/35] Update uli-init to use hoomd-tf --- uli_init/simulate.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/uli_init/simulate.py b/uli_init/simulate.py index cfcc6ad..e3e47b5 100644 --- a/uli_init/simulate.py +++ b/uli_init/simulate.py @@ -32,7 +32,8 @@ def __init__(self, mode = "gpu", gsd_write = 1e4, log_write = 1e3, - seed = 42 + seed = 42, + tf_model = None ): self.system = system @@ -47,6 +48,13 @@ def __init__(self, self.gsd_write = gsd_write self.log_write = log_write self.seed = seed + self.tf_model = tf_model # pass in a TF model here + + if tf_model is not None: + # only import this if we're using TF + import hoomd.htf as htf + # TODO: check if model is compiled already, error out if not + self.tfcompute = htf.tfcompute(tf_model) if ref_units and not auto_scale: self.ref_energy = ref_units['energy'] @@ -92,6 +100,8 @@ def quench(self, kT, n_steps, shrink_kT=10, shrink_steps=1e6): create_hoomd_simulation(self.system_pmd, self.ref_distance, self.ref_mass, self.ref_energy, self.r_cut, self.auto_scale) + if self.tf_model is not None: + sim.sorter.disable() _all = hoomd.group.all() hoomd.md.integrate.mode_standard(dt=self.dt) integrator = hoomd.md.integrate.nvt(group=_all, kT=shrink_kT, tau=self.tau) # shrink temp @@ -127,6 +137,9 @@ def quench(self, kT, n_steps, shrink_kT=10, shrink_steps=1e6): # Run the primary simulation integrator.set_params(kT=kT) integrator.randomize_velocities(seed=self.seed) + if self.tf_model is not None: + self.nlist = hoomd.md.nlist.cell(check_period=5) + self.tfcompute.attach(self.nlist, train=True, r_cut=self.r_cut, save_output_period=5) hoomd.run(n_steps) From f25f9af513a809f6d0bec57a5d7a9246cabd2eb6 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Mon, 8 Mar 2021 15:37:23 -0700 Subject: [PATCH 11/35] Add online demo file. Offline demo broken --- Notebooks/HTF_CG_Demo.py | 6 +- Notebooks/HTF_Online_CG_Demo.py | 304 ++++++++++++++++++++++++++++++++ 2 files changed, 307 insertions(+), 3 deletions(-) create mode 100644 Notebooks/HTF_Online_CG_Demo.py diff --git a/Notebooks/HTF_CG_Demo.py b/Notebooks/HTF_CG_Demo.py index 246cdf2..92e6701 100644 --- a/Notebooks/HTF_CG_Demo.py +++ b/Notebooks/HTF_CG_Demo.py @@ -288,7 +288,7 @@ def compute(self, nlist, positions, box): lj_forces = htf.compute_nlist_forces(nlist, lj_energy_total) other_forces = htf.compute_positions_forces(positions=mapped_pos, energy=subtotal_energy) total_energy = lj_energy + subtotal_energy - return mapped_pos, total_energy, radii_tensor, angles_tensor, dihedrals_tensor, lj_forces, other_forces, box, box_size # cg_features + return lj_forces + other_forces, mapped_pos, total_energy, radii_tensor, angles_tensor, dihedrals_tensor nneighbor_cutoff = 32 model = TrajModel(nneighbor_cutoff, @@ -335,7 +335,7 @@ def make_frame(i, positions): j = 0 # index over energy steps (since we didn't write energy every frame) # all the 'None' here is so we only train on the energy -model.compile('Adam', [None, 'MeanSquaredError', None, None, None, None, None, None, None]) +model.compile('Adam', ['MeanSquaredError', None, None, None, None, None]) losses = [] # set up training data and get the raw mapped statistics @@ -360,7 +360,7 @@ def make_frame(i, positions): except: print('failed to save inputs') -history = model.train_on_batch(x=inputs_list, y=potential_energies)#model.fit(x=inputs_list, y=potential_energies) +history = model.fit(x=inputs_list, y=potential_energies)# model.train_on_batch(x=inputs_list, y=potential_energies) cg_rdf = model.avg_cg_rdf.result().numpy() diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py new file mode 100644 index 0000000..240e514 --- /dev/null +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -0,0 +1,304 @@ +import os +os.environ['CUDA_VISIBLE_DEVICES'] = '-1' +import networkx as nx +import tensorflow as tf +from tensorflow.keras import layers +import hoomd +import hoomd.md +import hoomd.htf as htf +import numpy as np +import gsd +import matplotlib.pyplot as plt +import os +from uli_init.utils.smiles_utils import viz +import uli_init.simulate as simulate + +# building an HTF model for coarse graining + +def get_mol_mapping_idx(filename): + '''Takes a filename of a .gsd file WITHOUT the '.gsd', loads that gsd, + then loads or creates a molecule mapping index from it.''' + # if the mapping doesn't exist, make it + context = hoomd.context.initialize('--mode=cpu') + system = hoomd.init.read_gsd(filename=f'{filename}.gsd') + context.sorter.disable() + if not os.path.exists(f'{filename}-mapping.npy'): + molecule_mapping_index = htf.find_molecules(system) + np.save(f'{filename}-mapping.npy', np.array(molecule_mapping_index)) + # if it does, load from it instead + else: + molecule_mapping_index = np.load(f'{filename}-mapping.npy') + return system, molecule_mapping_index + +# Steps to do HOOMD-TF: +# 1) build HOOMD-TF keras model +# 2) compile keras model +# 3) create tfcompute object from model +# 4) set up HOOMD simulation (uli-init code) +# 5) pass in model to uli-init Simulation object +# 7) run the hoomd simulation (call the quench method) + +one_molecule_fname = '1-length-4-peek-para-only' +system, molecule_mapping_index = get_mol_mapping_idx(one_molecule_fname) + +graph = nx.Graph() +# add all our particles and bonds +for particle in system.particles: + graph.add_node(particle.tag, name=particle.type) +for bond in system.bonds: + graph.add_edge(bond.a, bond.b) +# judiciously snip bonds +degrees_dict = dict(graph.degree()) + +for i, bond in enumerate(system.bonds): + if bond.type == 'c-ca' or bond.type == 'ca-c': + if degrees_dict[bond.a] == 3 and degrees_dict[bond.b] == 3: + graph.remove_edge(bond.a, bond.b) + elif bond.type == 'ca-os' or bond.type == 'os-ca': + if degrees_dict[bond.a] == 2 and degrees_dict[bond.b] == 3 or\ + degrees_dict[bond.a] == 3 and degrees_dict[bond.b] == 2: + graph.remove_edge(bond.a, bond.b) + degrees_dict = dict(graph.degree()) + +subgraph_list = list(nx.connected_components(graph)) + +# now we have our beads grouped up, we need to get their mapping +# get total N atoms +N = sum([len(m) for m in molecule_mapping_index]) +# get molecule count +M = len(molecule_mapping_index) +# atoms per molecule +MN = len(molecule_mapping_index[0]) +print('N_atoms:', N,'\nN_molecules:', M,'\nN_atoms_per_molecule:', MN) +# make sure we didn't miss any particles +assert(sum([len(item) for item in subgraph_list]) == MN) + +# create a mapping for our molecules +# these are 4-monomer polymers, and we're doing 3 beads per monomer +# therefore, we need a 12 x 88 matrix + + +mapping_arr = np.zeros((12,MN)) + +for i, subgraph in enumerate(subgraph_list): + for atom_idx in subgraph: + mapping_arr[i][atom_idx] = 1 + +N = sum([len(m) for m in molecule_mapping_index]) +# get molecule count +M = len(molecule_mapping_index) +# atoms per molecule +MN = len(molecule_mapping_index[0]) +# again make sure we didn't miss any atoms +assert(np.sum(mapping_arr) == MN) + +bead_number = mapping_arr.shape[0] + +set_rcut = 7.0 +fname = '100-length-4-peek-para-only-production' +system, molecule_mapping_index = get_mol_mapping_idx(fname) + +cg_mapping = htf.sparse_mapping([mapping_arr for _ in molecule_mapping_index], + molecule_mapping_index, system=system) +N = sum([len(m) for m in molecule_mapping_index]) +# get molecule count +M = len(molecule_mapping_index) +# atoms per molecule +MN = len(molecule_mapping_index[0]) +print('N_atoms:', N,'\nN_molecules:', M,'\nN_atoms_per_molecule:', MN) +assert cg_mapping.shape == (M * bead_number, N) + +# create an edge list +beads_per_molecule = 12 +bonds_per_molecule = beads_per_molecule - 1 # linear polymer +bonds_matrix = np.zeros([bonds_per_molecule * M, 2]) +bonds_matrix[0][1] = 1 +offset = 0 + +# this puts the indices of bonded beads as pairs +# i.e. the edge list of a graph +for i in range(1, bonds_matrix.shape[0]): + bonds_matrix[i][0] = i + i//11 + bonds_matrix[i][1] = i+1 + i//11 + +# make adjacency matrix (N_beads x N_beads) +# adj_mat[i][j] = 0 if beads (i, j) not bonded, 1 if they are +adjacency_matrix = np.zeros([M * 12, M * 12]) +for pair in bonds_matrix: + i, j = int(pair[0]), int(pair[1]) + adjacency_matrix[i][j] = adjacency_matrix[j][i] = 1 + +# create Lennard-Jones energy-calculating layer +class LJLayer(tf.keras.layers.Layer): + def __init__(self, sigma, epsilon): + super().__init__(self, name='lj') + self.start_vals = [sigma, epsilon] + self.w = self.add_weight( + shape=[2], + initializer=tf.constant_initializer([sigma, epsilon]), + constraint=tf.keras.constraints.NonNeg() + ) + # call takes only particle radii (pass in from neighbor list) + # returns energy contribution from LJ interactions + def call(self, r): + r6 = tf.math.divide_no_nan(self.w[0]**6, r**6) + energy = self.w[1] * 4.0 * (r6**2 - r6) + # divide by 2 to avoid double-counting + return energy / 2. + +class BondLayer(tf.keras.layers.Layer): + # harmonic bond potential + def __init__(self, k_b, r0): + # we only have one bond type, so we only need one k & r0 + super().__init__(self, name='bonds') + # set initial values for bond spring constant (k_b) and equilibrium length (r0) + self.start = [k_b, r0] + self.w = self.add_weight( + shape=[2], + initializer=tf.constant_initializer([k_b, r0]), + constraint=tf.keras.constraints.NonNeg() + ) + + def call(self, r): + energy = self.w[0] * (r - self.w[1])**2 + # don't divide by 2 here because we are doing per-bond (not neighbor-list-based) + return energy + +class AngleLayer(tf.keras.layers.Layer): + # harmonic angle potential + def __init__(self, k_a, theta0): + # only one angle type, so we only need one k & theta0 + super().__init__(self, name='angles') + # set initial values for angle spring constant (k) and equilibrium theta + self.start = [k_a, theta0] + self.w = self.add_weight( + shape=[2], + initializer=tf.constant_initializer([k_a, theta0]), + constraint=tf.keras.constraints.NonNeg() + ) + def call(self, theta): + energy = self.w[0] * (theta - self.w[1])**2 + return energy + +class DihedralLayer(tf.keras.layers.Layer): + # harmonic cosine potential + def __init__(self, k_d, phi0): + # only one type of dihedral, so we only need one k & phi0 + super().__init__(self, name='dihedrals') + # set initial values for dihedral spring constant (k) and equilibrium phi + self.start = [k_d, phi0] + self.w = self.add_weight( + shape=[2], + initializer=tf.constant_initializer([k_d, phi0]), + constraint=tf.keras.constraints.NonNeg() + ) + def call(self, phi): + energy = self.w[0] * (tf.math.cos(phi) - tf.math.cos(self.w[1]))**2 + return energy + +class TrajModel(htf.SimModel): + def setup(self, cg_num, adjacency_matrix, CG_NN, rcut): + self.cg_num = cg_num + self.adjacency_matrix = adjacency_matrix + self.CG_NN = CG_NN + #self.cg_mapping = cg_mapping + self.rcut = rcut + self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # set up CG RDF tracking + + self.avg_cg_radii = tf.keras.metrics.MeanTensor() + self.avg_cg_angles = tf.keras.metrics.MeanTensor() + self.avg_cg_dihedrals = tf.keras.metrics.MeanTensor() + + # energy layers + self.lj_energy = LJLayer(1., 1.) + # just a guess at bond length + self.bond_energy = BondLayer(1., 2.) + self.angle_energy = AngleLayer(1., 3.14/2.) + self.dihedral_energy = DihedralLayer(1., 3.14/2.) + + def compute(self, nlist, positions, box): + # calculate the center of mass of a CG bead + box_size = htf.box_size(box) # [16., 16., 16.] + cg_features = htf.compute_cg_graph(DSGPM=False, + infile=None, + adj_mat=self.adjacency_matrix, + cg_beads=self.cg_num) + + radii_tensor = [] + angles_tensor = [] + dihedrals_tensor = [] + + # because these are tensors, can't use list comprehension + for i in range(len(cg_features[0])): + cg_radius = htf.mol_bond_distance(CG=True, + cg_positions=positions, + b1=cg_features[0][i][0], + b2=cg_features[0][i][1] + ) + radii_tensor.append(cg_radius) + self.avg_cg_radii.update_state(radii_tensor) + + for j in range(len(cg_features[1])): + cg_angle = htf.mol_angle(CG=True, + cg_positions=positions, + b1=cg_features[1][j][0], + b2=cg_features[1][j][1], + b3=cg_features[1][j][2] + ) + angles_tensor.append(cg_angle) + self.avg_cg_angles.update_state(angles_tensor) + + for k in range(len(cg_features[2])): + cg_dihedral = htf.mol_dihedral(CG=True, + cg_positions=cg_features[-1], + b1=cg_features[2][k][0], + b2=cg_features[2][k][1], + b3=cg_features[2][k][2], + b4=cg_features[2][k][3], + ) + dihedrals_tensor.append(cg_dihedral) + self.avg_cg_dihedrals.update_state(dihedrals_tensor) + + # create mapped neighbor list + mapped_nlist = nlist# htf.compute_nlist(mapped_pos, self.rcut, self.CG_NN, box_size, True) + # compute RDF for mapped particles + cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut]) + self.avg_cg_rdf.update_state(cg_rdf) + + # now calculate our total energy and train + nlist_r = htf.safe_norm(tensor=mapped_nlist[:, :, :3], axis=2) + lj_energy = self.lj_energy(nlist_r) + lj_energy_total = tf.reduce_sum(input_tensor=lj_energy, axis=1) + # bonds_energy = self.bond_energy(radii_tensor) + # angles_energy = self.angle_energy(angles_tensor) + # dihedrals_energy = self.dihedral_energy(dihedrals_tensor) + # subtotal_energy = tf.reduce_sum(bonds_energy) + tf.reduce_sum(angles_energy) + tf.reduce_sum(dihedrals_energy) + lj_forces = htf.compute_nlist_forces(mapped_nlist, lj_energy_total) + print(lj_forces.shape) + # other_forces = htf.compute_positions_forces(positions=mapped_pos, energy=subtotal_energy) + total_energy = lj_energy # + subtotal_energy + # return lj_forces + other_forces, mapped_pos, total_energy, radii_tensor, angles_tensor, dihedrals_tensor + return lj_forces, positions, total_energy, radii_tensor, angles_tensor, dihedrals_tensor + +nneighbor_cutoff = 32 +model = TrajModel(nneighbor_cutoff=nneighbor_cutoff, + cg_num=12, # beads per molecule, not total + adjacency_matrix=adjacency_matrix, + CG_NN=nneighbor_cutoff, + cg_mapping=cg_mapping, + r_cut=set_rcut, + output_forces=False, + rcut=set_rcut, + check_nlist=False) + +# all the 'None' here is so we only train on the energy +model.compile('Adam', ['MeanSquaredError', None, None, None, None, None]) + +system = simulate.System(molecule='PEEK', para_weight=1.0, + density=1.2, n_compounds=[100], + polymer_lengths=[4], forcefield='gaff', + assert_dihedrals=True, remove_hydrogens=True) + +sim = simulate.Simulation(system, gsd_write=100, mode='cpu', dt=0.0001, r_cut=set_rcut, tf_model=model) + +sim.quench(kT=1., n_steps=1e6, shrink_steps=2e3) \ No newline at end of file From 7d47de880282c7d79bb3b751e19567d7f07c729b Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Tue, 9 Mar 2021 19:06:04 -0700 Subject: [PATCH 12/35] Fixed model input structure, need to test full run --- Notebooks/HTF_Online_CG_Demo.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 240e514..6f6bf42 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -224,9 +224,9 @@ def compute(self, nlist, positions, box): adj_mat=self.adjacency_matrix, cg_beads=self.cg_num) - radii_tensor = [] - angles_tensor = [] - dihedrals_tensor = [] + radii_list = [] + angles_list = [] + dihedrals_list = [] # because these are tensors, can't use list comprehension for i in range(len(cg_features[0])): @@ -235,8 +235,8 @@ def compute(self, nlist, positions, box): b1=cg_features[0][i][0], b2=cg_features[0][i][1] ) - radii_tensor.append(cg_radius) - self.avg_cg_radii.update_state(radii_tensor) + radii_list.append(cg_radius) + self.avg_cg_radii.update_state(radii_list) for j in range(len(cg_features[1])): cg_angle = htf.mol_angle(CG=True, @@ -245,19 +245,19 @@ def compute(self, nlist, positions, box): b2=cg_features[1][j][1], b3=cg_features[1][j][2] ) - angles_tensor.append(cg_angle) - self.avg_cg_angles.update_state(angles_tensor) + angles_list.append(cg_angle) + self.avg_cg_angles.update_state(angles_list) for k in range(len(cg_features[2])): cg_dihedral = htf.mol_dihedral(CG=True, - cg_positions=cg_features[-1], + cg_positions=positions[:,:3], b1=cg_features[2][k][0], b2=cg_features[2][k][1], b3=cg_features[2][k][2], b4=cg_features[2][k][3], ) - dihedrals_tensor.append(cg_dihedral) - self.avg_cg_dihedrals.update_state(dihedrals_tensor) + dihedrals_list.append(cg_dihedral) + self.avg_cg_dihedrals.update_state(dihedrals_list) # create mapped neighbor list mapped_nlist = nlist# htf.compute_nlist(mapped_pos, self.rcut, self.CG_NN, box_size, True) @@ -269,16 +269,16 @@ def compute(self, nlist, positions, box): nlist_r = htf.safe_norm(tensor=mapped_nlist[:, :, :3], axis=2) lj_energy = self.lj_energy(nlist_r) lj_energy_total = tf.reduce_sum(input_tensor=lj_energy, axis=1) - # bonds_energy = self.bond_energy(radii_tensor) - # angles_energy = self.angle_energy(angles_tensor) - # dihedrals_energy = self.dihedral_energy(dihedrals_tensor) + # bonds_energy = self.bond_energy(radii_list) + # angles_energy = self.angle_energy(angles_list) + # dihedrals_energy = self.dihedral_energy(dihedrals_list) # subtotal_energy = tf.reduce_sum(bonds_energy) + tf.reduce_sum(angles_energy) + tf.reduce_sum(dihedrals_energy) lj_forces = htf.compute_nlist_forces(mapped_nlist, lj_energy_total) print(lj_forces.shape) # other_forces = htf.compute_positions_forces(positions=mapped_pos, energy=subtotal_energy) total_energy = lj_energy # + subtotal_energy - # return lj_forces + other_forces, mapped_pos, total_energy, radii_tensor, angles_tensor, dihedrals_tensor - return lj_forces, positions, total_energy, radii_tensor, angles_tensor, dihedrals_tensor + # return lj_forces + other_forces, mapped_pos, total_energy, radii_list, angles_list, dihedrals_list + return lj_forces, positions, total_energy nneighbor_cutoff = 32 model = TrajModel(nneighbor_cutoff=nneighbor_cutoff, From dee13eea25292395acb15af53a87549c3cdbe2d0 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Thu, 11 Mar 2021 15:52:21 -0700 Subject: [PATCH 13/35] Add script for plotting CG params and writing gsd of CG positions --- Notebooks/HTF_Online_CG_Demo.py | 22 ++++++------ Notebooks/plot_CG_results.py | 62 +++++++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+), 10 deletions(-) create mode 100644 Notebooks/plot_CG_results.py diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 6f6bf42..3244db3 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -267,18 +267,20 @@ def compute(self, nlist, positions, box): # now calculate our total energy and train nlist_r = htf.safe_norm(tensor=mapped_nlist[:, :, :3], axis=2) - lj_energy = self.lj_energy(nlist_r) + lj_energy = self.lj_energy(nlist_r) # TODO: something is going on with these indices. lj_energy_total = tf.reduce_sum(input_tensor=lj_energy, axis=1) - # bonds_energy = self.bond_energy(radii_list) - # angles_energy = self.angle_energy(angles_list) - # dihedrals_energy = self.dihedral_energy(dihedrals_list) - # subtotal_energy = tf.reduce_sum(bonds_energy) + tf.reduce_sum(angles_energy) + tf.reduce_sum(dihedrals_energy) + bonds_energy = self.bond_energy(radii_list) + angles_energy = self.angle_energy(angles_list) + dihedrals_energy = self.dihedral_energy(dihedrals_list) + subtotal_energy = tf.reduce_sum(bonds_energy) + tf.reduce_sum(angles_energy) + tf.reduce_sum(dihedrals_energy) lj_forces = htf.compute_nlist_forces(mapped_nlist, lj_energy_total) - print(lj_forces.shape) - # other_forces = htf.compute_positions_forces(positions=mapped_pos, energy=subtotal_energy) - total_energy = lj_energy # + subtotal_energy + other_forces = htf.compute_positions_forces(positions=positions, energy=subtotal_energy) + total_energy = lj_energy + subtotal_energy # return lj_forces + other_forces, mapped_pos, total_energy, radii_list, angles_list, dihedrals_list - return lj_forces, positions, total_energy + # TODO: put back in the bonds angles dihedrals + # TODO: see if we can plot loss over time, get final loss + # TODO: update these outputs to spit out our trained parameters. + return lj_forces + other_forces, positions, total_energy, self.lj_energy.w, self.bond_energy.w, self.angle_energy.w, self.dihedral_energy.w # lj_energy, bonds_energy, angles_energy, dihedrals_energy nneighbor_cutoff = 32 model = TrajModel(nneighbor_cutoff=nneighbor_cutoff, @@ -301,4 +303,4 @@ def compute(self, nlist, positions, box): sim = simulate.Simulation(system, gsd_write=100, mode='cpu', dt=0.0001, r_cut=set_rcut, tf_model=model) -sim.quench(kT=1., n_steps=1e6, shrink_steps=2e3) \ No newline at end of file +sim.quench(kT=1., n_steps=1e2, shrink_steps=2e2) \ No newline at end of file diff --git a/Notebooks/plot_CG_results.py b/Notebooks/plot_CG_results.py new file mode 100644 index 0000000..9cbff9e --- /dev/null +++ b/Notebooks/plot_CG_results.py @@ -0,0 +1,62 @@ +import numpy as np +import matplotlib.pyplot as plt +import hoomd +import gsd +import glob + +param_fnames = sorted(glob.glob("*params.txt")) +print(param_fnames) + +# plot our parameters over time +for fname in param_fnames: + params = np.genfromtxt(fname) + short_name = fname.split('.')[0] # discard file extension + # first dimension is timesteps + plt.figure() + for i, param in enumerate(params[0]): + plt.plot(range(params.shape[0]), params[:,i], label=f'{short_name}[{i}]') + plt.legend() + plt.xlabel('Steps') + plt.ylabel(short_name) + plt.savefig(f'{short_name}.png') + +M = 100 +# create an edge list +beads_per_molecule = 12 +bonds_per_molecule = beads_per_molecule - 1 # linear polymer +bonds_matrix = np.zeros([bonds_per_molecule * M, 2]) # TODO: read the number, not hard-code 100 +bonds_matrix[0][1] = 1 +offset = 0 + +# this puts the indices of bonded beads as pairs +# i.e. the edge list of a graph +for i in range(1, bonds_matrix.shape[0]): + bonds_matrix[i][0] = i + i//11 + bonds_matrix[i][1] = i+1 + i//11 + + +# for writing out the CG trajectory +def make_frame(i, positions, bonds_matrix): + s = gsd.hoomd.Snapshot() + s.configuration.box = [16., 16., 16., 0., 0., 0.] + s.configuration.step = i + s.particles.N = beads_per_molecule * M + s.particles.position = positions + s.bonds.N = bonds_per_molecule * M + s.bonds.group = bonds_matrix + return s + +angle_params = np.genfromtxt(param_fnames[0]) +bond_params = np.genfromtxt(param_fnames[1]) +dihedral_params = np.genfromtxt(param_fnames[2]) +lj_params = np.genfromtxt(param_fnames[3]) + +positions = np.load('cg_positions.npy') +positions = positions[:,:,:3] # remove types + +gsdfile = gsd.hoomd.open(name=f'cg_trajectory.gsd', mode='wb+') + +for i in range(positions.shape[0]): + this_pos = positions[i] + frame = make_frame(i, this_pos, bonds_matrix) + gsdfile.append(frame) \ No newline at end of file From 4c0dbac623194e092821d15526613269a98459d4 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Thu, 22 Apr 2021 16:31:40 -0600 Subject: [PATCH 14/35] Remove old matplotlib import --- Notebooks/HTF_Online_CG_Demo.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 3244db3..290f1c7 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -8,7 +8,6 @@ import hoomd.htf as htf import numpy as np import gsd -import matplotlib.pyplot as plt import os from uli_init.utils.smiles_utils import viz import uli_init.simulate as simulate @@ -294,7 +293,7 @@ def compute(self, nlist, positions, box): check_nlist=False) # all the 'None' here is so we only train on the energy -model.compile('Adam', ['MeanSquaredError', None, None, None, None, None]) +model.compile('Adam', ['MeanAbsoluteError', None, None, None, None, None]) system = simulate.System(molecule='PEEK', para_weight=1.0, density=1.2, n_compounds=[100], From b47d7a43ba2551fdc597c5e9cfa641f72a3580de Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Thu, 22 Apr 2021 18:40:05 -0400 Subject: [PATCH 15/35] remove old matplotlib import --- Notebooks/HTF_Online_CG_Demo.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 3244db3..eede50c 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -8,7 +8,6 @@ import hoomd.htf as htf import numpy as np import gsd -import matplotlib.pyplot as plt import os from uli_init.utils.smiles_utils import viz import uli_init.simulate as simulate @@ -303,4 +302,4 @@ def compute(self, nlist, positions, box): sim = simulate.Simulation(system, gsd_write=100, mode='cpu', dt=0.0001, r_cut=set_rcut, tf_model=model) -sim.quench(kT=1., n_steps=1e2, shrink_steps=2e2) \ No newline at end of file +sim.quench(kT=1., n_steps=1e2, shrink_steps=2e2) From 3623e5982651b0f6533c2e9dd2555acbae26e0b3 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Mon, 3 May 2021 18:16:11 -0600 Subject: [PATCH 16/35] Update with some needed htf packages --- environment.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/environment.yml b/environment.yml index 99a6575..acb40b7 100644 --- a/environment.yml +++ b/environment.yml @@ -16,3 +16,7 @@ dependencies: - signac - signac-flow - pytest + - mdanalysis + - networkx + - tqdm + - json From efd7a709d70ce9f92cd827b62150fd2f69a5684d Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Mon, 3 May 2021 19:11:49 -0600 Subject: [PATCH 17/35] Remove json oops --- environment.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/environment.yml b/environment.yml index d9dd79c..4d1753f 100644 --- a/environment.yml +++ b/environment.yml @@ -20,7 +20,6 @@ dependencies: - pytest - mdanalysis - tqdm - - json - pytest-cov - python=3.7 - scipy=1.6.0 From a4d805cd6a80d27bc2a055b1658efee0d2a85327 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 5 May 2021 15:57:51 -0600 Subject: [PATCH 18/35] fix Online example script after upstream HTF update --- Notebooks/HTF_Online_CG_Demo.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 41d9f77..c8fca0f 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -230,19 +230,21 @@ def compute(self, nlist, positions, box): # because these are tensors, can't use list comprehension for i in range(len(cg_features[0])): cg_radius = htf.mol_bond_distance(CG=True, - cg_positions=positions, + cg_positions=positions[:,:3], b1=cg_features[0][i][0], - b2=cg_features[0][i][1] + b2=cg_features[0][i][1], + box=box ) radii_list.append(cg_radius) self.avg_cg_radii.update_state(radii_list) for j in range(len(cg_features[1])): cg_angle = htf.mol_angle(CG=True, - cg_positions=positions, + cg_positions=positions[:,:3], b1=cg_features[1][j][0], b2=cg_features[1][j][1], - b3=cg_features[1][j][2] + b3=cg_features[1][j][2], + box=box ) angles_list.append(cg_angle) self.avg_cg_angles.update_state(angles_list) @@ -254,6 +256,7 @@ def compute(self, nlist, positions, box): b2=cg_features[2][k][1], b3=cg_features[2][k][2], b4=cg_features[2][k][3], + box=box ) dihedrals_list.append(cg_dihedral) self.avg_cg_dihedrals.update_state(dihedrals_list) From b303b26bdd7f0b50f655526bf5788457838d82d1 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 5 May 2021 20:50:18 -0600 Subject: [PATCH 19/35] Add saving of CG params/energy/positions/forces --- Notebooks/HTF_Online_CG_Demo.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index c8fca0f..76f0a1b 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -306,3 +306,20 @@ def compute(self, nlist, positions, box): sim = simulate.Simulation(system, gsd_write=100, mode='cpu', dt=0.0001, r_cut=set_rcut, tf_model=model) sim.quench(kT=1., n_steps=1e2, shrink_steps=2e2) + +outputs = sim.tfcompute.outputs +cg_forces = outputs[0] +np.save('cg_forces.npy', cg_forces) +cg_positions = outputs[1] +np.save('cg_positions.npy', cg_positions) +cg_energy = outputs[2] +np.save('cg_energy.npy', cg_energy) +lj_energy_params = outputs[3] +np.save('cg_lj_params.npy', lj_energy_params) +bond_energy_params = outputs[4] +np.save('cg_bond_params.npy', bond_energy_params) +angle_energy_params = outputs[5] +np.save('cg_angle_params.npy', angle_energy_params) +dihedral_energy_params = outputs[6] +np.save('cg_dihedral_params.npy', dihedral_energy_params) + From 9734a5ba84d830eaf6b90041a6bf483be60c3601 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 5 May 2021 23:55:02 -0600 Subject: [PATCH 20/35] Fix outputs indexing --- Notebooks/HTF_Online_CG_Demo.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 76f0a1b..a3d4004 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -308,18 +308,16 @@ def compute(self, nlist, positions, box): sim.quench(kT=1., n_steps=1e2, shrink_steps=2e2) outputs = sim.tfcompute.outputs -cg_forces = outputs[0] -np.save('cg_forces.npy', cg_forces) -cg_positions = outputs[1] +cg_positions = outputs[0] np.save('cg_positions.npy', cg_positions) -cg_energy = outputs[2] +cg_energy = outputs[1] np.save('cg_energy.npy', cg_energy) -lj_energy_params = outputs[3] +lj_energy_params = outputs[2] np.save('cg_lj_params.npy', lj_energy_params) -bond_energy_params = outputs[4] +bond_energy_params = outputs[3] np.save('cg_bond_params.npy', bond_energy_params) -angle_energy_params = outputs[5] +angle_energy_params = outputs[4] np.save('cg_angle_params.npy', angle_energy_params) -dihedral_energy_params = outputs[6] +dihedral_energy_params = outputs[5] np.save('cg_dihedral_params.npy', dihedral_energy_params) From 168c83c7b9cda66b4ef4dcb4d91f3eb8da0571ba Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Thu, 6 May 2021 01:55:56 -0400 Subject: [PATCH 21/35] Update plotting from np.genfromtxt to np.load --- Notebooks/plot_CG_results.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Notebooks/plot_CG_results.py b/Notebooks/plot_CG_results.py index 9cbff9e..6d62039 100644 --- a/Notebooks/plot_CG_results.py +++ b/Notebooks/plot_CG_results.py @@ -1,15 +1,15 @@ import numpy as np import matplotlib.pyplot as plt import hoomd -import gsd +import gsd.hoomd import glob -param_fnames = sorted(glob.glob("*params.txt")) +param_fnames = sorted(glob.glob("*params.npy")) print(param_fnames) # plot our parameters over time for fname in param_fnames: - params = np.genfromtxt(fname) + params = np.load(fname) short_name = fname.split('.')[0] # discard file extension # first dimension is timesteps plt.figure() @@ -46,10 +46,10 @@ def make_frame(i, positions, bonds_matrix): s.bonds.group = bonds_matrix return s -angle_params = np.genfromtxt(param_fnames[0]) -bond_params = np.genfromtxt(param_fnames[1]) -dihedral_params = np.genfromtxt(param_fnames[2]) -lj_params = np.genfromtxt(param_fnames[3]) +angle_params = np.load(param_fnames[0]) +bond_params = np.load(param_fnames[1]) +dihedral_params = np.load(param_fnames[2]) +lj_params = np.load(param_fnames[3]) positions = np.load('cg_positions.npy') positions = positions[:,:,:3] # remove types From 3f4855084101bb4f28961152ee7ebb59b49d57a5 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Thu, 10 Jun 2021 18:08:17 -0400 Subject: [PATCH 22/35] Add command line args for plotting CG results. Onlilne demo now picks one-molecule file dynamically by n_monomers, too --- Notebooks/HTF_Online_CG_Demo.py | 20 +++++++++++--------- Notebooks/plot_CG_results.py | 9 +++++++-- 2 files changed, 18 insertions(+), 11 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index a3d4004..42b544e 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -1,5 +1,4 @@ import os -os.environ['CUDA_VISIBLE_DEVICES'] = '-1' import networkx as nx import tensorflow as tf from tensorflow.keras import layers @@ -18,7 +17,7 @@ def get_mol_mapping_idx(filename): '''Takes a filename of a .gsd file WITHOUT the '.gsd', loads that gsd, then loads or creates a molecule mapping index from it.''' # if the mapping doesn't exist, make it - context = hoomd.context.initialize('--mode=cpu') + context = hoomd.context.initialize('--mode=gpu') system = hoomd.init.read_gsd(filename=f'{filename}.gsd') context.sorter.disable() if not os.path.exists(f'{filename}-mapping.npy'): @@ -37,7 +36,11 @@ def get_mol_mapping_idx(filename): # 5) pass in model to uli-init Simulation object # 7) run the hoomd simulation (call the quench method) -one_molecule_fname = '1-length-4-peek-para-only' +set_rcut = 7.0 +n_molecules = 10 +n_monomers = 2 + +one_molecule_fname = f'1-length-{n_monomers}-peek-para-only' system, molecule_mapping_index = get_mol_mapping_idx(one_molecule_fname) graph = nx.Graph() @@ -93,8 +96,7 @@ def get_mol_mapping_idx(filename): bead_number = mapping_arr.shape[0] -set_rcut = 7.0 -fname = '100-length-4-peek-para-only-production' +fname = f'{n_molecules}-length-{n_monomers}-peek-para-only-production' system, molecule_mapping_index = get_mol_mapping_idx(fname) cg_mapping = htf.sparse_mapping([mapping_arr for _ in molecule_mapping_index], @@ -299,13 +301,13 @@ def compute(self, nlist, positions, box): model.compile('Adam', ['MeanAbsoluteError', None, None, None, None, None]) system = simulate.System(molecule='PEEK', para_weight=1.0, - density=1.2, n_compounds=[100], - polymer_lengths=[4], forcefield='gaff', + density=1.2, n_compounds=[n_molecules], + polymer_lengths=[n_monomers], forcefield='gaff', assert_dihedrals=True, remove_hydrogens=True) -sim = simulate.Simulation(system, gsd_write=100, mode='cpu', dt=0.0001, r_cut=set_rcut, tf_model=model) +sim = simulate.Simulation(system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, tf_model=model) -sim.quench(kT=1., n_steps=1e2, shrink_steps=2e2) +sim.quench(kT=1., n_steps=2e5, shrink_steps=1e2) outputs = sim.tfcompute.outputs cg_positions = outputs[0] diff --git a/Notebooks/plot_CG_results.py b/Notebooks/plot_CG_results.py index 6d62039..0b2cf96 100644 --- a/Notebooks/plot_CG_results.py +++ b/Notebooks/plot_CG_results.py @@ -3,6 +3,11 @@ import hoomd import gsd.hoomd import glob +import sys + +if(len(sys.argv) != 2): + print("Error: you must pass the number of particles") + exit(1) param_fnames = sorted(glob.glob("*params.npy")) print(param_fnames) @@ -20,7 +25,7 @@ plt.ylabel(short_name) plt.savefig(f'{short_name}.png') -M = 100 +M = int(sys.argv[1] ) # create an edge list beads_per_molecule = 12 bonds_per_molecule = beads_per_molecule - 1 # linear polymer @@ -59,4 +64,4 @@ def make_frame(i, positions, bonds_matrix): for i in range(positions.shape[0]): this_pos = positions[i] frame = make_frame(i, this_pos, bonds_matrix) - gsdfile.append(frame) \ No newline at end of file + gsdfile.append(frame) From 371a2a5cdb8fc4ac75eaa6dc5c3d18414d7ad589 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 30 Jun 2021 16:02:46 -0400 Subject: [PATCH 23/35] Update online demo file for tf.gather math --- Notebooks/HTF_Online_CG_Demo.py | 107 +++++++++++++++----------------- uli_init/simulate.py | 4 +- 2 files changed, 51 insertions(+), 60 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 42b544e..35e8575 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -36,11 +36,7 @@ def get_mol_mapping_idx(filename): # 5) pass in model to uli-init Simulation object # 7) run the hoomd simulation (call the quench method) -set_rcut = 7.0 -n_molecules = 10 -n_monomers = 2 - -one_molecule_fname = f'1-length-{n_monomers}-peek-para-only' +one_molecule_fname = '1-length-4-peek-para-only' system, molecule_mapping_index = get_mol_mapping_idx(one_molecule_fname) graph = nx.Graph() @@ -96,6 +92,9 @@ def get_mol_mapping_idx(filename): bead_number = mapping_arr.shape[0] +set_rcut = 7.0 +n_molecules = 100 +n_monomers = 4 fname = f'{n_molecules}-length-{n_monomers}-peek-para-only-production' system, molecule_mapping_index = get_mol_mapping_idx(fname) @@ -204,7 +203,7 @@ def setup(self, cg_num, adjacency_matrix, CG_NN, rcut): self.CG_NN = CG_NN #self.cg_mapping = cg_mapping self.rcut = rcut - self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # set up CG RDF tracking + #self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # set up CG RDF tracking self.avg_cg_radii = tf.keras.metrics.MeanTensor() self.avg_cg_angles = tf.keras.metrics.MeanTensor() @@ -216,77 +215,67 @@ def setup(self, cg_num, adjacency_matrix, CG_NN, rcut): self.bond_energy = BondLayer(1., 2.) self.angle_energy = AngleLayer(1., 3.14/2.) self.dihedral_energy = DihedralLayer(1., 3.14/2.) - - def compute(self, nlist, positions, box): - # calculate the center of mass of a CG bead - box_size = htf.box_size(box) # [16., 16., 16.] - cg_features = htf.compute_cg_graph(DSGPM=False, + self.cg_features = htf.compute_cg_graph(DSGPM=False, infile=None, adj_mat=self.adjacency_matrix, cg_beads=self.cg_num) - radii_list = [] - angles_list = [] - dihedrals_list = [] + def compute(self, nlist, positions, box): + # calculate the center of mass of a CG bead + box_size = htf.box_size(box) # [16., 16., 16.] + cg_features = self.cg_features + # angles_list = [] + # dihedrals_list = [] # because these are tensors, can't use list comprehension - for i in range(len(cg_features[0])): - cg_radius = htf.mol_bond_distance(CG=True, - cg_positions=positions[:,:3], - b1=cg_features[0][i][0], - b2=cg_features[0][i][1], - box=box - ) - radii_list.append(cg_radius) - self.avg_cg_radii.update_state(radii_list) - - for j in range(len(cg_features[1])): - cg_angle = htf.mol_angle(CG=True, - cg_positions=positions[:,:3], - b1=cg_features[1][j][0], - b2=cg_features[1][j][1], - b3=cg_features[1][j][2], - box=box - ) - angles_list.append(cg_angle) - self.avg_cg_angles.update_state(angles_list) - - for k in range(len(cg_features[2])): - cg_dihedral = htf.mol_dihedral(CG=True, - cg_positions=positions[:,:3], - b1=cg_features[2][k][0], - b2=cg_features[2][k][1], - b3=cg_features[2][k][2], - b4=cg_features[2][k][3], - box=box - ) - dihedrals_list.append(cg_dihedral) - self.avg_cg_dihedrals.update_state(dihedrals_list) + # b1 and b2 come from tuple returned by compute_cg_graph, + # so need single idx first, but we can slice the tensor + cg_radii = htf.mol_bond_distance(CG=True, + cg_positions=positions[:,:3], + b1=cg_features[0][:, 0], + b2=cg_features[0][:, 1], + box=box) + self.avg_cg_radii.update_state(cg_radii) + + cg_angles = htf.mol_angle(CG=True, + cg_positions=positions[:,:3], + b1=cg_features[1][:, 0], + b2=cg_features[1][:, 1], + b3=cg_features[1][:, 2], + box=box) + self.avg_cg_angles.update_state(cg_angles) + + cg_dihedrals = htf.mol_dihedral(CG=True, + cg_positions=positions[:,:3], + b1=cg_features[2][:, 0], + b2=cg_features[2][:, 1], + b3=cg_features[2][:, 2], + b4=cg_features[2][:, 3], + box=box) + self.avg_cg_dihedrals.update_state(cg_dihedrals) # create mapped neighbor list mapped_nlist = nlist# htf.compute_nlist(mapped_pos, self.rcut, self.CG_NN, box_size, True) # compute RDF for mapped particles - cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut]) - self.avg_cg_rdf.update_state(cg_rdf) + # cg_rdf = htf.compute_rdf(mapped_nlist, [0.1, self.rcut]) + # self.avg_cg_rdf.update_state(cg_rdf) # now calculate our total energy and train nlist_r = htf.safe_norm(tensor=mapped_nlist[:, :, :3], axis=2) lj_energy = self.lj_energy(nlist_r) # TODO: something is going on with these indices. lj_energy_total = tf.reduce_sum(input_tensor=lj_energy, axis=1) - bonds_energy = self.bond_energy(radii_list) - angles_energy = self.angle_energy(angles_list) - dihedrals_energy = self.dihedral_energy(dihedrals_list) + bonds_energy = self.bond_energy(cg_radii) + angles_energy = self.angle_energy(cg_angles) + dihedrals_energy = self.dihedral_energy(cg_dihedrals) subtotal_energy = tf.reduce_sum(bonds_energy) + tf.reduce_sum(angles_energy) + tf.reduce_sum(dihedrals_energy) lj_forces = htf.compute_nlist_forces(mapped_nlist, lj_energy_total) other_forces = htf.compute_positions_forces(positions=positions, energy=subtotal_energy) total_energy = lj_energy + subtotal_energy - # return lj_forces + other_forces, mapped_pos, total_energy, radii_list, angles_list, dihedrals_list - # TODO: put back in the bonds angles dihedrals + # return lj_forces + other_forces, mapped_pos, total_energy, cg_radii, cg_angles, cg_dihedrals # TODO: see if we can plot loss over time, get final loss - # TODO: update these outputs to spit out our trained parameters. - return lj_forces + other_forces, positions, total_energy, self.lj_energy.w, self.bond_energy.w, self.angle_energy.w, self.dihedral_energy.w # lj_energy, bonds_energy, angles_energy, dihedrals_energy + return lj_forces + other_forces, positions, total_energy, self.lj_energy.w, self.bond_energy.w, self.angle_energy.w, self.dihedral_energy.w -nneighbor_cutoff = 32 +nneighbor_cutoff = 64 model = TrajModel(nneighbor_cutoff=nneighbor_cutoff, cg_num=12, # beads per molecule, not total adjacency_matrix=adjacency_matrix, @@ -298,7 +287,8 @@ def compute(self, nlist, positions, box): check_nlist=False) # all the 'None' here is so we only train on the energy -model.compile('Adam', ['MeanAbsoluteError', None, None, None, None, None]) +optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001) +model.compile(optimizer, ['MeanAbsoluteError', None, None, None, None, None]) system = simulate.System(molecule='PEEK', para_weight=1.0, density=1.2, n_compounds=[n_molecules], @@ -307,7 +297,8 @@ def compute(self, nlist, positions, box): sim = simulate.Simulation(system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, tf_model=model) -sim.quench(kT=1., n_steps=2e5, shrink_steps=1e2) +sim.quench(kT=1., n_steps=2e6, shrink_steps=1e5) + outputs = sim.tfcompute.outputs cg_positions = outputs[0] diff --git a/uli_init/simulate.py b/uli_init/simulate.py index 86305a8..a55acec 100644 --- a/uli_init/simulate.py +++ b/uli_init/simulate.py @@ -243,12 +243,12 @@ def quench( integrator.randomize_velocities(seed=self.seed) if self.tf_model is not None: - self.nlist = hoomd.md.nlist.cell(check_period=5) + self.nlist = hoomd.md.nlist.cell(check_period=100) self.tfcompute.attach( self.nlist, train=True, r_cut=self.r_cut, - save_output_period=5 + save_output_period=100 ) try: hoomd.run(n_steps) From 36deb16ef5540b8f2cbae93e72e46291496895e2 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 30 Jun 2021 16:03:58 -0400 Subject: [PATCH 24/35] put several file types generated by online example file in gitignore --- .gitignore | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.gitignore b/.gitignore index c3e17c0..53f83f5 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,9 @@ *.log /src/* *egg-info +*.out +*.error +*.npy +*.txt +*.png +*.svg From 343be3728fef1f81f76d780800b69210f7db3787 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 7 Jul 2021 15:41:26 -0400 Subject: [PATCH 25/35] Add plotting of simulation potential energy vs time --- Notebooks/plot_CG_results.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/Notebooks/plot_CG_results.py b/Notebooks/plot_CG_results.py index 0b2cf96..fced96b 100644 --- a/Notebooks/plot_CG_results.py +++ b/Notebooks/plot_CG_results.py @@ -56,6 +56,18 @@ def make_frame(i, positions, bonds_matrix): dihedral_params = np.load(param_fnames[2]) lj_params = np.load(param_fnames[3]) +log_data = np.genfromtxt('sim_traj.log', skip_header=1) +with open('sim_traj.log', 'r') as f: + headers = f.readline().replace('#','').replace('\n','').split('\t') +potential_idx = headers.index('potential_energy') +potential = log_data[:, potential_idx] +plt.figure() +plt.plot(np.arange(len(potential)), potential) +plt.xlabel('Timestep') +plt.ylabel('Potential Energy') +plt.savefig('potential.png') + + positions = np.load('cg_positions.npy') positions = positions[:,:,:3] # remove types From 8961ce9f281bc7a4bcd46ea8220639f63d5a0cd5 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Tue, 13 Jul 2021 15:04:28 -0600 Subject: [PATCH 26/35] Make TF nlist check period a Simulation param --- uli_init/simulate.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/uli_init/simulate.py b/uli_init/simulate.py index 2e3355e..7ce93e4 100644 --- a/uli_init/simulate.py +++ b/uli_init/simulate.py @@ -42,7 +42,8 @@ def __init__( gsd_write=1e4, log_write=1e3, seed=42, - tf_model = None + tf_model = None, + tf_nlist_check_period = 100 ): self.system_pmd = system.system # Parmed structure @@ -261,12 +262,12 @@ def quench( kT=kT) integrator.randomize_velocities(seed=self.seed) if self.tf_model is not None: - self.nlist = hoomd.md.nlist.cell(check_period=100) + self.nlist = hoomd.md.nlist.cell(check_period=tf_nlist_check_period) self.tfcompute.attach( self.nlist, train=True, r_cut=self.r_cut, - save_output_period=100 + save_output_period=tf_nlist_check_period ) try: hoomd.run(n_steps) From 5718ec39f7f7e41b20e6ca2f28b7c372ac461344 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Tue, 13 Jul 2021 15:19:44 -0600 Subject: [PATCH 27/35] Remove outdated environment include --- environment.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/environment.yml b/environment.yml index 9d9a518..b34f02c 100644 --- a/environment.yml +++ b/environment.yml @@ -13,7 +13,6 @@ dependencies: - pip=21.0 - pytest - mdanalysis - - tqdm - pytest-cov - python=3.7 - rdkit=2021.03.1 From 75f81140662bd06b3e7fec21344b57e608a962fb Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Tue, 13 Jul 2021 16:06:02 -0600 Subject: [PATCH 28/35] Update environment mbuild address --- environment.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/environment.yml b/environment.yml index b34f02c..eaec96d 100644 --- a/environment.yml +++ b/environment.yml @@ -20,5 +20,5 @@ dependencies: - signac=1.6.0 - signac-flow=0.12.0 - pip: - - git+https://github.com/chrisjonesBSU/mbuild.git@origin/fix/axis_transform + - git+https://github.com/mosdef-hub/mbuild - git+https://github.com/cmelab/uli-init.git@0.2.0 From b717914e2260598a6c230b312969687d2e18eaa1 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Tue, 13 Jul 2021 16:17:18 -0600 Subject: [PATCH 29/35] Forgot nohoomd env file too --- environment-nohoomd.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/environment-nohoomd.yml b/environment-nohoomd.yml index 1d952da..95c72e3 100644 --- a/environment-nohoomd.yml +++ b/environment-nohoomd.yml @@ -11,6 +11,7 @@ dependencies: - parmed>=3.4.0 - pip=21.0 - pytest + - mdanalysis - pytest-cov - python=3.7 - rdkit=2021.03.1 @@ -18,5 +19,5 @@ dependencies: - signac=1.6.0 - signac-flow=0.12.0 - pip: - - git+https://github.com/chrisjonesBSU/mbuild.git@origin/fix/axis_transform + - git+https://github.com/mosdef-hub/mbuild - git+https://github.com/cmelab/uli-init.git@0.2.0 From ba652d8024c9b9e1f04285f94b10648eab7652b5 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Fri, 16 Jul 2021 20:56:54 +0000 Subject: [PATCH 30/35] Update demo file for upstream changes. rename Initialize class. --- Notebooks/HTF_Online_CG_Demo.py | 16 ++++++++-------- uli_init/simulate.py | 5 +++-- uli_init/system.py | 4 ++-- 3 files changed, 13 insertions(+), 12 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 35e8575..1b01c0a 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -8,8 +8,8 @@ import numpy as np import gsd import os -from uli_init.utils.smiles_utils import viz -import uli_init.simulate as simulate +from uli_init.simulate import Simulation +from uli_init.system import System # building an HTF model for coarse graining @@ -290,14 +290,14 @@ def compute(self, nlist, positions, box): optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001) model.compile(optimizer, ['MeanAbsoluteError', None, None, None, None, None]) -system = simulate.System(molecule='PEEK', para_weight=1.0, - density=1.2, n_compounds=[n_molecules], - polymer_lengths=[n_monomers], forcefield='gaff', - assert_dihedrals=True, remove_hydrogens=True) +system = System(system_type='pack', molecule='PEEK', para_weight=1.0, + density=1.2, n_compounds=[n_molecules], + polymer_lengths=[n_monomers], forcefield='gaff', + assert_dihedrals=True, remove_hydrogens=True) -sim = simulate.Simulation(system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, tf_model=model) +sim = Simulation(system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, tf_model=model) -sim.quench(kT=1., n_steps=2e6, shrink_steps=1e5) +sim.quench(kT=1., n_steps=5e5, shrink_steps=1e5, shrink_kT=1., shrink_period=1e4) outputs = sim.tfcompute.outputs diff --git a/uli_init/simulate.py b/uli_init/simulate.py index 7ce93e4..a93cf52 100644 --- a/uli_init/simulate.py +++ b/uli_init/simulate.py @@ -60,6 +60,7 @@ def __init__( self.log_write = log_write self.seed = seed self.tf_model = tf_model # pass in a TF model here + self.tf_nlist_check_period = tf_nlist_check_period # how often to ask HTF to update its nlist if tf_model is not None: # only import this if we're using TF @@ -262,12 +263,12 @@ def quench( kT=kT) integrator.randomize_velocities(seed=self.seed) if self.tf_model is not None: - self.nlist = hoomd.md.nlist.cell(check_period=tf_nlist_check_period) + self.nlist = hoomd.md.nlist.cell(check_period=self.tf_nlist_check_period) self.tfcompute.attach( self.nlist, train=True, r_cut=self.r_cut, - save_output_period=tf_nlist_check_period + save_output_period=self.tf_nlist_check_period ) try: hoomd.run(n_steps) diff --git a/uli_init/system.py b/uli_init/system.py index fcb701f..63a2a9c 100644 --- a/uli_init/system.py +++ b/uli_init/system.py @@ -120,7 +120,7 @@ def __init__( "n_compounds and polymer_lengths should be equal length" ) - init = Initialize(system=self, **kwargs) + init = Initializer(system=self, **kwargs) self.system = init.system def sample_from_pdi( @@ -219,7 +219,7 @@ def _recover_mass_dist(self, distribution="weibull"): return mass_dict -class Initialize: +class Initializer: def __init__(self, system, **kwargs): self.system = system if system.type == "pack": From edc2f7b9b03c33b2a033edce70265c47622f4d1e Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Tue, 10 Aug 2021 17:13:33 -0600 Subject: [PATCH 31/35] HTF running, running out of CUDA memory --- Notebooks/HTF_Online_CG_Demo.py | 62 +++++++++++++++++++++++++++++---- uli_init/simulate.py | 40 ++++++++++++++++++--- 2 files changed, 92 insertions(+), 10 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 1b01c0a..d6fc5da 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -197,12 +197,13 @@ def call(self, phi): return energy class TrajModel(htf.SimModel): - def setup(self, cg_num, adjacency_matrix, CG_NN, rcut): + def setup(self, cg_num, adjacency_matrix, + CG_NN, cg_mapping, r_cut, dtype=tf.float32): self.cg_num = cg_num self.adjacency_matrix = adjacency_matrix self.CG_NN = CG_NN - #self.cg_mapping = cg_mapping - self.rcut = rcut + self.cg_mapping = cg_mapping + self.r_cut = r_cut #self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # set up CG RDF tracking self.avg_cg_radii = tf.keras.metrics.MeanTensor() @@ -219,6 +220,7 @@ def setup(self, cg_num, adjacency_matrix, CG_NN, rcut): infile=None, adj_mat=self.adjacency_matrix, cg_beads=self.cg_num) + def compute(self, nlist, positions, box): # calculate the center of mass of a CG bead @@ -276,14 +278,14 @@ def compute(self, nlist, positions, box): return lj_forces + other_forces, positions, total_energy, self.lj_energy.w, self.bond_energy.w, self.angle_energy.w, self.dihedral_energy.w nneighbor_cutoff = 64 + model = TrajModel(nneighbor_cutoff=nneighbor_cutoff, cg_num=12, # beads per molecule, not total adjacency_matrix=adjacency_matrix, CG_NN=nneighbor_cutoff, cg_mapping=cg_mapping, - r_cut=set_rcut, output_forces=False, - rcut=set_rcut, + r_cut=set_rcut, check_nlist=False) # all the 'None' here is so we only train on the energy @@ -295,7 +297,55 @@ def compute(self, nlist, positions, box): polymer_lengths=[n_monomers], forcefield='gaff', assert_dihedrals=True, remove_hydrogens=True) -sim = Simulation(system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, tf_model=model) +# hacky workaround needing box in htf utils function +def center_of_mass_no_box(positions, mapping, name='center-of-mass'): + ''' Computes mapped positions given positions and system-level mapping + by considering PBC. + :param positions: The tensor of particle positions + :type positions: N x 3 tensor + :param mapping: The coarse-grain system-level mapping used to produce + the particles in system + :type mapping: M x N tensor + :param name: The name of the op to add to the TF graph + :type name: string + :return: An [M x 3] mapped particles + ''' + + try: + sorting = hoomd.context.current.sorter.enabled + if sorting: + raise ValueError( + 'You must disable hoomd sorting to use center_of_mass!') + except AttributeError: + pass + + # slice to avoid accidents + positions = positions[:, :3] + # https://en.wikipedia.org/wiki/ + # /Center_of_mass#Systems_with_periodic_boundary_conditions + # Adapted for -L to L boundary conditions + # box dim in hoomd is 2 * L + # make a pretend box just around our particles + xmin, xmax = min(positions[:, 0]), max(positions[:, 0]) + ymin, ymax = min(positions[:, 1]), max(positions[:, 1]) + zmin, zmax = min(positions[:, 2]), max(positions[:, 2]) + box_dim = [xmax - xmin, ymax - ymin, zmax - zmin] + theta = positions / box_dim * 2 * np.pi + xi = tf.math.cos(theta) + zeta = tf.math.sin(theta) + ximean = tf.sparse.sparse_dense_matmul(mapping, xi) + zetamean = tf.sparse.sparse_dense_matmul(mapping, zeta) + thetamean = tf.math.atan2(zetamean, ximean) + return tf.identity(thetamean / np.pi / 2 * box_dim, name=name) + +def get_cg_positions(aa_positions): + mapped_positions_raw = center_of_mass_no_box( + positions=aa_positions, + mapping=cg_mapping + ) + return tf.concat([mapped_positions_raw, tf.ones((mapped_positions_raw.shape[0], 1), dtype=mapped_positions_raw.dtype)], axis=-1, name='cg-pos-input') + +sim = Simulation(system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, tf_model=model, mapping_func=get_cg_positions) sim.quench(kT=1., n_steps=5e5, shrink_steps=1e5, shrink_kT=1., shrink_period=1e4) diff --git a/uli_init/simulate.py b/uli_init/simulate.py index a93cf52..427af99 100644 --- a/uli_init/simulate.py +++ b/uli_init/simulate.py @@ -43,6 +43,7 @@ def __init__( log_write=1e3, seed=42, tf_model = None, + mapping_func = None, tf_nlist_check_period = 100 ): @@ -60,6 +61,7 @@ def __init__( self.log_write = log_write self.seed = seed self.tf_model = tf_model # pass in a TF model here + self.mapping_func = mapping_func # should computes CG positions from AA self.tf_nlist_check_period = tf_nlist_check_period # how often to ask HTF to update its nlist if tf_model is not None: @@ -138,9 +140,32 @@ def quench( init_snap = objs[0] if self.tf_model is not None: + assert self.mapping_func is not None,\ + "If you are doing coarse-graining, you must \ + provide a mapping function (see HTF)" + # save real atom types from initial snapshot + aa_type_list = hoomd_system.particles.get_metadata()['types'] sim.sorter.disable() - - _all = hoomd.group.all() + aa_group, cg_group = self.tfcompute.enable_mapped_nlist( + hoomd_system, + self.mapping_func) + # grab the LJ interactions from mbuild + lj = objs[3] + # get the cg bead type + all_types = hoomd_system.particles.get_metadata()['types'] + cg_types = list(set(all_types) - set(aa_type_list)) + lj.pair_coeff.set(cg_types, all_types, r_cut=False, epsilon=0., sigma=0.) + _all = aa_group + hoomd.dump.gsd( + 'cg_traj.gsd', + period=self.gsd_write, + group=cg_group, + phase=0, + dynamic=['momentum'], + overwrite=False + ) + else: + _all = hoomd.group.all() hoomd.md.integrate.mode_standard(dt=self.dt) hoomd.dump.gsd( @@ -149,7 +174,7 @@ def quench( group=_all, phase=0, dynamic=["momentum"], - overwrite=False, + overwrite=False ) hoomd.analyze.log( "sim_traj.log", @@ -157,7 +182,7 @@ def quench( quantities=self.log_quantities, header_prefix="#", overwrite=True, - phase=0, + phase=0 ) if len([i for i in (shrink_kT, shrink_steps) if i is None]) == 1: raise ValueError( @@ -211,6 +236,13 @@ def quench( epsilon=1.0, r_extrap=0 ) + if self.tf_model is not None: + wall_force.force_coeff.set( + cg_types, + sigma=1.0, + epsilon=1.0, + r_extrap=0 + ) step = 0 start = time.time() while step < shrink_steps: From c41da01b724cb30a335fd956b97661c900d17b89 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Thu, 26 Aug 2021 20:54:45 +0000 Subject: [PATCH 32/35] Try smaller nlists to save memory? --- Notebooks/HTF_Online_CG_Demo.py | 2 +- uli_init/simulate.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index d6fc5da..084647a 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -92,7 +92,7 @@ def get_mol_mapping_idx(filename): bead_number = mapping_arr.shape[0] -set_rcut = 7.0 +set_rcut = 3.0 n_molecules = 100 n_monomers = 4 fname = f'{n_molecules}-length-{n_monomers}-peek-para-only-production' diff --git a/uli_init/simulate.py b/uli_init/simulate.py index 427af99..2f5436a 100644 --- a/uli_init/simulate.py +++ b/uli_init/simulate.py @@ -154,7 +154,7 @@ def quench( # get the cg bead type all_types = hoomd_system.particles.get_metadata()['types'] cg_types = list(set(all_types) - set(aa_type_list)) - lj.pair_coeff.set(cg_types, all_types, r_cut=False, epsilon=0., sigma=0.) + lj.pair_coeff.set(cg_types, all_types, r_cut=self.r_cut, epsilon=0., sigma=0.) _all = aa_group hoomd.dump.gsd( 'cg_traj.gsd', From 3eb4fd0b9dd85bca60216c6dd26cffa1e8404419 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Mon, 30 Aug 2021 13:57:31 -0600 Subject: [PATCH 33/35] Add TF batch size arg to Simulate class --- Notebooks/HTF_Online_CG_Demo.py | 10 +++++----- uli_init/simulate.py | 7 +++++-- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 084647a..8c3b3a1 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -92,7 +92,7 @@ def get_mol_mapping_idx(filename): bead_number = mapping_arr.shape[0] -set_rcut = 3.0 +set_rcut = 2.0 n_molecules = 100 n_monomers = 4 fname = f'{n_molecules}-length-{n_monomers}-peek-para-only-production' @@ -198,11 +198,10 @@ def call(self, phi): class TrajModel(htf.SimModel): def setup(self, cg_num, adjacency_matrix, - CG_NN, cg_mapping, r_cut, dtype=tf.float32): + CG_NN, r_cut, dtype=tf.float32): self.cg_num = cg_num self.adjacency_matrix = adjacency_matrix self.CG_NN = CG_NN - self.cg_mapping = cg_mapping self.r_cut = r_cut #self.avg_cg_rdf = tf.keras.metrics.MeanTensor() # set up CG RDF tracking @@ -292,7 +291,7 @@ def compute(self, nlist, positions, box): optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001) model.compile(optimizer, ['MeanAbsoluteError', None, None, None, None, None]) -system = System(system_type='pack', molecule='PEEK', para_weight=1.0, +sim_system = System(system_type='pack', molecule='PEEK', para_weight=1.0, density=1.2, n_compounds=[n_molecules], polymer_lengths=[n_monomers], forcefield='gaff', assert_dihedrals=True, remove_hydrogens=True) @@ -345,7 +344,8 @@ def get_cg_positions(aa_positions): ) return tf.concat([mapped_positions_raw, tf.ones((mapped_positions_raw.shape[0], 1), dtype=mapped_positions_raw.dtype)], axis=-1, name='cg-pos-input') -sim = Simulation(system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, tf_model=model, mapping_func=get_cg_positions) +sim = Simulation(sim_system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, + tf_model=model, mapping_func=get_cg_positions, tf_batch_size=512) sim.quench(kT=1., n_steps=5e5, shrink_steps=1e5, shrink_kT=1., shrink_period=1e4) diff --git a/uli_init/simulate.py b/uli_init/simulate.py index 2f5436a..a948111 100644 --- a/uli_init/simulate.py +++ b/uli_init/simulate.py @@ -44,7 +44,8 @@ def __init__( seed=42, tf_model = None, mapping_func = None, - tf_nlist_check_period = 100 + tf_nlist_check_period = 100, + tf_batch_size = None ): self.system_pmd = system.system # Parmed structure @@ -63,6 +64,7 @@ def __init__( self.tf_model = tf_model # pass in a TF model here self.mapping_func = mapping_func # should computes CG positions from AA self.tf_nlist_check_period = tf_nlist_check_period # how often to ask HTF to update its nlist + self.tf_batch_size = tf_batch_size if tf_model is not None: # only import this if we're using TF @@ -300,7 +302,8 @@ def quench( self.nlist, train=True, r_cut=self.r_cut, - save_output_period=self.tf_nlist_check_period + save_output_period=self.tf_nlist_check_period, + batch_size=self.tf_batch_size ) try: hoomd.run(n_steps) From 6dd4e3227c3a9c8e526f14c69a7e82656a2618e7 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Mon, 29 Nov 2021 12:18:17 -0700 Subject: [PATCH 34/35] Add make_fg_traj script --- Notebooks/make_fg_traj.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Notebooks/make_fg_traj.py diff --git a/Notebooks/make_fg_traj.py b/Notebooks/make_fg_traj.py new file mode 100644 index 0000000..02bea12 --- /dev/null +++ b/Notebooks/make_fg_traj.py @@ -0,0 +1,16 @@ +'''This script is uses uli_init to generate initial positions + that are loaded in for the HTF_Online_Demo.py script. + The output of this simulation must be renamed to correspond + with the number of polymers and polymer sizes you wish to use.''' + +import uli_init.simulate as simulate +import uli_init.system as system +import hoomd + +system = system.System(molecule='PEEK', para_weight=1.0, system_type='pack', + density=0.8, n_compounds=[100], + polymer_lengths=[4], forcefield='gaff', + assert_dihedrals=True, remove_hydrogens=True) + +sim = simulate.Simulation(system, gsd_write=1, mode='gpu', dt=0.0001) +sim.quench(kT=1., n_steps=1, shrink_steps=1, shrink_kT=1.0, shrink_period=1) From fafc3b6556c21f552e0193a271bca8be9a605256 Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 2 Mar 2022 16:29:19 -0500 Subject: [PATCH 35/35] Fix argument error in trajmodel --- Notebooks/HTF_Online_CG_Demo.py | 61 ++++++++++++++++++--------------- uli_init/simulate.py | 19 ++++++++-- 2 files changed, 50 insertions(+), 30 deletions(-) diff --git a/Notebooks/HTF_Online_CG_Demo.py b/Notebooks/HTF_Online_CG_Demo.py index 8c3b3a1..bb14723 100644 --- a/Notebooks/HTF_Online_CG_Demo.py +++ b/Notebooks/HTF_Online_CG_Demo.py @@ -7,7 +7,6 @@ import hoomd.htf as htf import numpy as np import gsd -import os from uli_init.simulate import Simulation from uli_init.system import System @@ -22,7 +21,7 @@ def get_mol_mapping_idx(filename): context.sorter.disable() if not os.path.exists(f'{filename}-mapping.npy'): molecule_mapping_index = htf.find_molecules(system) - np.save(f'{filename}-mapping.npy', np.array(molecule_mapping_index)) + np.save(f'{filename}-mapping.npy', molecule_mapping_index) # if it does, load from it instead else: molecule_mapping_index = np.load(f'{filename}-mapping.npy') @@ -282,7 +281,6 @@ def compute(self, nlist, positions, box): cg_num=12, # beads per molecule, not total adjacency_matrix=adjacency_matrix, CG_NN=nneighbor_cutoff, - cg_mapping=cg_mapping, output_forces=False, r_cut=set_rcut, check_nlist=False) @@ -328,6 +326,7 @@ def center_of_mass_no_box(positions, mapping, name='center-of-mass'): xmin, xmax = min(positions[:, 0]), max(positions[:, 0]) ymin, ymax = min(positions[:, 1]), max(positions[:, 1]) zmin, zmax = min(positions[:, 2]), max(positions[:, 2]) + print(f'\n\nBOX: [ [{xmin}, {ymin}, {zmin}], [{xmax}, {ymax}, {zmax}] ]') box_dim = [xmax - xmin, ymax - ymin, zmax - zmin] theta = positions / box_dim * 2 * np.pi xi = tf.math.cos(theta) @@ -337,30 +336,38 @@ def center_of_mass_no_box(positions, mapping, name='center-of-mass'): thetamean = tf.math.atan2(zetamean, ximean) return tf.identity(thetamean / np.pi / 2 * box_dim, name=name) -def get_cg_positions(aa_positions): - mapped_positions_raw = center_of_mass_no_box( +def get_cg_positions(aa_positions, box_dims): + mapped_positions_raw = htf.center_of_mass( positions=aa_positions, - mapping=cg_mapping + mapping=cg_mapping, + box_size=tf.cast(box_dims, tf.float32) ) - return tf.concat([mapped_positions_raw, tf.ones((mapped_positions_raw.shape[0], 1), dtype=mapped_positions_raw.dtype)], axis=-1, name='cg-pos-input') - -sim = Simulation(sim_system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut, - tf_model=model, mapping_func=get_cg_positions, tf_batch_size=512) - -sim.quench(kT=1., n_steps=5e5, shrink_steps=1e5, shrink_kT=1., shrink_period=1e4) - - -outputs = sim.tfcompute.outputs -cg_positions = outputs[0] -np.save('cg_positions.npy', cg_positions) -cg_energy = outputs[1] -np.save('cg_energy.npy', cg_energy) -lj_energy_params = outputs[2] -np.save('cg_lj_params.npy', lj_energy_params) -bond_energy_params = outputs[3] -np.save('cg_bond_params.npy', bond_energy_params) -angle_energy_params = outputs[4] -np.save('cg_angle_params.npy', angle_energy_params) -dihedral_energy_params = outputs[5] -np.save('cg_dihedral_params.npy', dihedral_energy_params) + print(f'\n\nIN get_cg_positions mapped_positions_raw is {mapped_positions_raw}\n\n') + cg_pos_input = tf.concat([mapped_positions_raw, tf.ones((mapped_positions_raw.shape[0], 1), dtype=mapped_positions_raw.dtype)], axis=-1, name='cg-pos-input') + print(f'RETURNING {cg_pos_input}') + np.save('aa_positions.npy', aa_positions) + np.save('cg_positions_mapped.npy', mapped_positions_raw) + return cg_pos_input + +sim = Simulation(sim_system, gsd_write=1, mode='gpu', dt=0.005, r_cut=set_rcut, + tf_model=model, mapping_func=get_cg_positions, tf_batch_size=4) + +#sim = Simulation(sim_system, gsd_write=1e4, mode='gpu', dt=0.0001, r_cut=set_rcut) + +sim.quench(kT=1., n_steps=5e5, shrink_steps=1e3, shrink_kT=1., shrink_period=1e4) + + +#outputs = sim.tfcompute.outputs +#cg_positions = outputs[0] +#np.save('cg_positions.npy', cg_positions) +#cg_energy = outputs[1] +#np.save('cg_energy.npy', cg_energy) +#lj_energy_params = outputs[2] +#np.save('cg_lj_params.npy', lj_energy_params) +#bond_energy_params = outputs[3] +#np.save('cg_bond_params.npy', bond_energy_params) +#angle_energy_params = outputs[4] +#np.save('cg_angle_params.npy', angle_energy_params) +#dihedral_energy_params = outputs[5] +#np.save('cg_dihedral_params.npy', dihedral_energy_params) diff --git a/uli_init/simulate.py b/uli_init/simulate.py index a948111..58f2420 100644 --- a/uli_init/simulate.py +++ b/uli_init/simulate.py @@ -47,7 +47,6 @@ def __init__( tf_nlist_check_period = 100, tf_batch_size = None ): - self.system_pmd = system.system # Parmed structure self.r_cut = r_cut self.e_factor = e_factor @@ -138,6 +137,7 @@ def quench( self.auto_scale, nlist=self.nlist ) + hoomd_nlist = objs[2] hoomd_system = objs[1] init_snap = objs[0] @@ -151,6 +151,19 @@ def quench( aa_group, cg_group = self.tfcompute.enable_mapped_nlist( hoomd_system, self.mapping_func) + test_cg_snapshot = hoomd_system.take_snapshot(bonds=True) + #TODO: looks like setting the snap positions wasn't enough. Need to call htf.tf2hoomd before model setup? + print('\n\nBEFORE') + print(f'test_cg_snap positions: {test_cg_snapshot.particles.position}') + print(f'cg_group: {cg_group}, {dir(cg_group)}') + hoomd.run(0) + print('\n\nAFTER') + print(f'test_cg_snap positions: {test_cg_snapshot.particles.position}') + print(f'cg_group: {cg_group}, {dir(cg_group)}') + #mb.formats.gsdwriter.write_gsd(test_snapshot, 'test_snapshot.gsd') + hoomd.dump.gsd('test_cg_snap.gsd', period=None, group=cg_group) + hoomd.dump.gsd('test_aa_snap.gsd', period=None, group=aa_group) + hoomd.dump.gsd('test_full_system_snap.gsd', period=None, group=hoomd.group.all()) # grab the LJ interactions from mbuild lj = objs[3] # get the cg bead type @@ -297,14 +310,14 @@ def quench( kT=kT) integrator.randomize_velocities(seed=self.seed) if self.tf_model is not None: - self.nlist = hoomd.md.nlist.cell(check_period=self.tf_nlist_check_period) self.tfcompute.attach( - self.nlist, + hoomd_nlist, train=True, r_cut=self.r_cut, save_output_period=self.tf_nlist_check_period, batch_size=self.tf_batch_size ) + try: hoomd.run(n_steps) except hoomd.WalltimeLimitReached: