diff --git a/docs/releasehistory.rst b/docs/releasehistory.rst index cd1e561b..3f959641 100644 --- a/docs/releasehistory.rst +++ b/docs/releasehistory.rst @@ -7,6 +7,19 @@ Releases follow the ``major.minor.micro`` scheme recommended by `PEP440 `_: Adds support for the new explicit hydrogens flag + +Tests added +""""""""""" +- `PR #146 `_: New test to check new explicit hydrogens flag + 1.3.2 - Migration and support for openff.toolkit --------------------------------------------------------- diff --git a/examples/OFF_parameterization/parameterize.ipynb b/examples/OFF_parameterization/parameterize.ipynb index 56f02590..6ef0af67 100644 --- a/examples/OFF_parameterization/parameterize.ipynb +++ b/examples/OFF_parameterization/parameterize.ipynb @@ -66,34 +66,42 @@ " - Assigning stereochemistry from 3D coordinates\n", " - Setting molecule name to 'benzene'\n", " - Setting molecule tag to 'BNZ'\n", - " - Representing molecule with the Open Force Field Toolkit\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2b60a5496a7e4336a5a3b88b2b7d3c6a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + " - Representing molecule with the Open Force Field Toolkit\n", " - Generating rotamer library\n", " - Core set to the center of the molecule\n" ] }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -210,7 +218,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " - Loading solvent parameters\n" + " - Generating solvent parameters\n" ] } ], @@ -281,9 +289,107 @@ }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -398,7 +504,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " - Loading solvent parameters\n" + " - Generating solvent parameters\n" ] } ], @@ -450,9 +556,44 @@ }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -460,7 +601,7 @@ } ], "source": [ - "molecule = Molecule(smiles='COc1ccccc1')\n", + "molecule = Molecule(smiles='COc1ccccc1', hydrogens_are_explicit=False)\n", "display(molecule)" ] }, @@ -582,7 +723,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " - Loading solvent parameters\n" + " - Generating solvent parameters\n" ] } ], @@ -608,7 +749,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -626,7 +767,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -635,7 +776,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -658,59 +799,59 @@ "\n", "\n", " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "\n", "\n", @@ -755,7 +896,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -764,7 +905,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -784,7 +925,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -795,7 +936,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -804,7 +945,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -815,7 +956,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ @@ -824,7 +965,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -842,7 +983,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -851,7 +992,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -866,13 +1007,6 @@ "solvent = OBC2(topology)\n", "solvent.to_file('ligandParams.txt')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/examples/OPLS_parameterization/parameterize.ipynb b/examples/OPLS_parameterization/parameterize.ipynb index 5d036916..543385ec 100644 --- a/examples/OPLS_parameterization/parameterize.ipynb +++ b/examples/OPLS_parameterization/parameterize.ipynb @@ -31,7 +31,7 @@ "outputs": [], "source": [ "import os\n", - "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2020-2/'" + "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2021-1/'" ] }, { @@ -62,34 +62,64 @@ " - Initializing molecule from a SMILES tag\n", " - Loading molecule from RDKit\n", " - Setting molecule name to 'c1ccc2cc3ccccc3cc2c1'\n", - " - Representing molecule with the Open Force Field Toolkit\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "041ae9aeaa3a4d58b8c0c6accf25a71f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + " - Representing molecule with the Open Force Field Toolkit\n", " - Generating rotamer library\n", " - Core set to the center of the molecule\n" ] }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -97,7 +127,7 @@ } ], "source": [ - "molecule = Molecule(smiles='c1ccc2cc3ccccc3cc2c1')\n", + "molecule = Molecule(smiles='c1ccc2cc3ccccc3cc2c1', hydrogens_are_explicit=False)\n", "display(molecule)" ] }, @@ -173,7 +203,7 @@ "outputs": [], "source": [ "import os\n", - "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2020-2/'" + "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2021-1/'" ] }, { @@ -211,9 +241,71 @@ }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -221,7 +313,7 @@ } ], "source": [ - "molecule = Molecule(smiles='CC(C)(/C=N\\OC(=O)NC)SC')\n", + "molecule = Molecule(smiles='CC(C)(/C=N\\OC(=O)NC)SC', hydrogens_are_explicit=False)\n", "display(molecule)" ] }, @@ -333,7 +425,7 @@ "outputs": [], "source": [ "import os\n", - "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2020-2/'" + "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2021-1/'" ] }, { @@ -373,9 +465,100 @@ }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -383,7 +566,8 @@ } ], "source": [ - "molecule = Molecule(smiles='CCOP(=S)(OCC)Oc1cc(nc(n1)C(C)C)C')\n", + "molecule = Molecule(smiles='CCOP(=S)(OCC)Oc1cc(nc(n1)C(C)C)C',\n", + " hydrogens_are_explicit=False)\n", "display(molecule)" ] }, diff --git a/examples/molecular_representations/PDB-SMILES_comparison.ipynb b/examples/molecular_representations/PDB-SMILES_comparison.ipynb index 412296e7..27cfe925 100644 --- a/examples/molecular_representations/PDB-SMILES_comparison.ipynb +++ b/examples/molecular_representations/PDB-SMILES_comparison.ipynb @@ -54,34 +54,35 @@ " - Assigning stereochemistry from 3D coordinates\n", " - Setting molecule name to 'ammonium'\n", " - Setting molecule tag to 'UNL'\n", - " - Representing molecule with the Open Force Field Toolkit\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "67b6b888b5a143b08e6d612f92203b66", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + " - Representing molecule with the Open Force Field Toolkit\n", " - Generating rotamer library\n", " - Core set to the center of the molecule\n" ] }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -112,9 +113,28 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAACWCAIAAADCEh9HAAAABmJLR0QA/wD/AP+gvaeTAAAHAElEQVR4nO3dX2iV9R/A8c/Zz05Km8jqauCGmBCN2BFEtGtnN1pdSH/oB4E3RUiSIST9EUwirJXCjHUhSBQjCUG7qGTXERXoCGGgN8swClHbJGm4zu9CsV/2nJl+4DmP4/W62s7zPed8GON9nvOcP0+t2WwGALero90DANzZZBQgRUYBUmQUIEVGAVIWtHsA+MuZM2fOnz+/ZMmSvr6+wgWTk5MXL17s7u5eunRpybNBK/ZGqZCdO3c2Go1t27a1WrBt27ZGo7Fz584yp4K5yShAiowCpMgoQIqMAqTIKECKjAKkeN8olXP48OGOjuIHeF9IRgXJKJVTr9e7uroKN01PT8/MzJQ8D8zNk3oqZ8OGDeda2LBhQ7ungxvJKECKjAKkyChAiowCpMgoQIqMAqR43ygV0t/fv27duoGBgVYLBgYGpqam+vv7y5wK5lbzsRCq7Oqb7ev1ersHgZZklEqr1WrhM6BUm2OjACkyCpAiowApMgqQIqMAKTIKkCKjACkyCpAiowApMgqQIqMAKTIKkCKjACkyCpAiowApMgqQIqMAKTIKkCKjACnODEqldXRcafcIcBNOaUel1WoREf5JqTJP6gFSZBQgRUYBUmQUIEVGAVJkFCBFRgFSZBQgRUYBUmQUIEVGAVJkFCBFRgFSZBQgRUYBUmQUIEVGAVJkFCDFuZiotKmpdk8AN+NcTPPWxMTE559/Xq/Xt27dWrhgfHz82LFjXV1dzz//fMmztXL8eBw7FhHxyCPRaBQsOHAgzp2L9etj5cprl5w9G++9Fzt2xL33ljfn/xsZGZmenl6/fv3AwEDhgn379s3MzGzcuPGBBx4oeTZK0mSeGh0djYjOzs5WC0ZGRiKip6enzKnmtn9/M6IZ0ezvb87MFCzo729GNPfv/+uS48ebEc3Tp0ub8UY9PT0RMTIy0mpBZ2dnRIyOjpY5FWVybJQqOnkyhobaPQT8O46NUjnd3XHhQrz5Zjz5ZCxbVrzmwoX49NOIiJ9+iogYHY377ouI2LTp2g9QGhmlclasiL6+OHQoXnghvviieM3UVBw+HBExPR0R8dVXsWhRRMS6dTJK2WSUKnrrrThyJL78Mj77LDZtKljQ13ftxagTJ2Llyjh4MJYvL3lGuMaxUapo+fJ46aWIiBdfjN9+a/c0MCd7o/Pc7Ozs2NhY4aaJiYmSh7klr74aH30UZ8/GG2/Evn0tl9Xr0dsbd91V4mRFJiYmWv2dZ2dnSx6GksnoPHf58uXBwcGbLms0GuPj45k76u099eOP92du4eef//ZrZ2cMDcXTT8fwcDzzTKxeXXytBx+Mycm/XXLkSDz++C3f+8MP//frrz+51Wtdvnz56g979+7du3fvLd8r84KMznMLFix44oknCjedPn3622+/LXmeW/LUU3HgQIyNxZYt8c030VHhQ1CrV6++//7iR5FDhw5duXKl5Hkok4zOcwsXLvzkk+KdrA8//PB6Rk+cOFHiULfggw/ioYfiu+/i4MHYvPlfXeWxx+K2Ppr3ccTHt3G1qzZv3vzcc88Vbjp69OilS5du+5apvgo/vkPEihXx8ssRETt2eK2JipJRqu6112LZsvj113jnnXaPAkVklKpbtCiuvnjz/vtx7ly7p4F/kFHuAI8+Ghs3xu+/xy+/tHsU+AcZ5c4wPBz33NPuIaCIjHJn6O2NV15p9xBQxBue5q1Go7Fnz556vd5qwZo1a/bs2dPV1VXmVHNbuzbefjt6eoq3bt8ed98df/4Za9eWO9acXn/99enp6TVr1rRasHv37pmZmUbh11AzL/j2eyrt6hc4VSn1cCMZpdJqtYi4vbfTQ0kcGwVIkVGAFBkFSJFRgBQZBUiRUYAUGQVIkVGAFBkFSJFRgBQZBUiRUYAUGQVIkVGAFBkFSJFRgBQZBUiRUYAUp7Sj0jo6ZiMi4j9tngNacy4mKq1Wq0WE/1KqzJN6gBQZBUiRUYAUGQVIkVGAFBkFSJFRgBQZBUiRUYAUGQVIkVGAFBkFSJFRgBQZBUiRUYAUGQVIkVGAFBkFSJFRgBSntKPS/vjjj3aPADdhb5QKGRoaGhwc3LVr1/VL6vV6vV6//uuuXbsGBweHhobaMR0UszdKhZw8eXJsbGzx4sWtFoyPj4+NjS1durTMqWBu9kYBUmQUIEVGAVJkFCBFRgFSvFJP5fzwww/bt29vtankYeCmZJTKOXXq1LvvvtvuKeDfklEqZ9WqVVu2bCncNDw8/P3335c8D8xNRqmc3t7eZ599tnDT0aNHZZSq8RITQIqMAqTIKECKjAKkyChAiowCpNSazWa7Z4Brzpw5c/78+SVLlvT19RUumJycvHjxYnd3t68cpTpkFCDFk3qAFBkFSJFRgBQZBUiRUYCU/wGqNY5xzFzfPAAAAHl6VFh0cmRraXRQS0wgcmRraXQgMjAyMC4wOS4xAAB4nHu/b+09BiDgAWJGBghgBWIWIG5gZFdQAomzMDJogCQYcdHcIL1MDAzMII0iDOIwkxhYbfI0Vc6e8VkC4R6wR2Lvnz5NQRXEKnEQUQXJgdgTVnYuBcmB2GIA1wQU7RbkKvAAAACUelRYdE1PTCByZGtpdCAyMDIwLjA5LjEAAHic41IAgSAX78wSBTgwcuHiUlAwVVAwUVAwwIosLS0VwowMDAy4QOoN9IAsoLCCLpwFE/NTwNCMxVCwKYZ6prhM8cA0BQsCmaILN0WBAlOQ9GKYR4JbEOFCvimGwOgAk1COMTLHBJljCuX4Kig4e7iDORAMEnH1c+ECAOQ0S/Bo1+UEAAAAdHpUWHRTTUlMRVMgcmRraXQgMjAyMC4wOS4xAAB4nFWKsQ3AIAwEV0kJCrYwGGLEAlRZAFFmC4YPWGlS/Ev3972Nfp/D9Das1soxDWFywMjspTxAl6sR8xULK/wN7DNhLEFkLdlVwiDpgy0rBIwiPuuifztf6Cgbcz2L2GMAAAAASUVORK5CYII=\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -122,7 +142,7 @@ } ], "source": [ - "m = Molecule(smiles='[NH4+]')\n", + "m = Molecule(smiles='[NH4+]', hydrogens_are_explicit=False)\n", "display(m)" ] }, @@ -154,9 +174,40 @@ }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -187,9 +238,40 @@ }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -197,7 +279,7 @@ } ], "source": [ - "m = Molecule(smiles='O=C([O-])CC(O)=O')\n", + "m = Molecule(smiles='O=C([O-])CC(O)=O', hydrogens_are_explicit=False)\n", "display(m)" ] }, @@ -229,9 +311,56 @@ }, { "data": { - "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -262,9 +391,56 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAACWCAIAAADCEh9HAAAABmJLR0QA/wD/AP+gvaeTAAAXV0lEQVR4nO3de1CTV94H8F/CHU0ANQkX8bKgbu2ICCWg9VK30hVtlVa3s9X1hlbX24zVbS1WnN23u3atCq5TpVp63cW6oqO7arvirkJ1VAJ4pWNxRUWRBMIlCUhCQpL3j4eNEbVSkycPz5Pv5w8mz0nIOXTab885z3nOEdntdgIAgKcl5roBAAD8hhgFAHAJYhQAwCWIUQAAlyBGAQBcghiFnq66ulqtVjuXXLt2rbGxkav2AHSBGIWebvXq1Vu2bHEumTlzZkFBAVftAegCMQoA4BLEKACAS3y5bgDAk127dm3fvn2OS71ez2FjALpAjAIPXL16dc+ePY5LnU7HYWMAukCMAg9Mnz5969atjsu4uDgOGwPQBeZGAQBcghgFAHAJYhR6OoVC0bdvX+eS/v37S6VSrtoD0IUI+40CX1y+fLmiokKpVMbGxnLdFoD70BsF3sjNzZ09e3ZhYSHXDQF4AGIUeEMulxNRfX091w0BeABiFHgDMQo9E2IUeEOhUBBRXV0d1w0BeABiFHgDvVHomRCjwBvojULPhBgF3mBiFL1R6GmwbhT4JDAwsL293Wg0BgYGct0WgE7ojQKfyGQyQocUehjEKPAJpkehB0KMAp/gZj30QIhR4BP0RqEHQowCn6A3Cj0QYhT4BDEKPRBiFPgEg3rogRCjwCdYgQ89EGIU+IQZ1KM3Cj0KYhT45CkG9bdv3z59+rRzydWrVy9cuODmloEXQ4wCn8hkMrFY3NjYaLVau/krR44cWbFihXPJrl27PvjgAxZaB14KMQp84uPj06dPH6vV2tjYyHVbADohRsFt8vPzL1686Fzy0UcfVVdXu7cW3KyHnsaX6waAcGRnZ8+fPz8+Pt5RkpmZOWTIkIEDB7qxFrlc/v333/+km/VarTYnJ8dxeeHCBSaLAdwCMQo888TeqM1mq6ysVKlUKpXq/Pnzs2bNMpvN169fd3xAp9MhRsGNEKPAM49cOqrT6crKyk6fPl1eXn727FnnmdMJEyZERUXt2LHDUbJq1ara2lqPNRgEDzEK7rR3794rV644Ltvb24lo5syZer1eIpH4+vpKpVIfHx/mZ0hIiFgsDg0NFYlEYWFhIpEoNDRULBaHhIQwn/H19ZVIJH5+fr1793Z8J7N0tKam5tSpUyqVqqSkpKSk5Pbt287NGDBggFKpTE5OTk5OPn/+vKf+evBSiFFwydq1a2tqavLz85nLyMhIlUoVGRk5ZcoUIhKLxUR08uTJpqYmFyvy9/fv1atXQEAAs9QpJydn69atjnelUmlSUhKTm0qlMjw83PGWc6wDsAExCi6xWCxMl5Mxfvx4o9EYFxfHLNXMzMwkokOHDrW3txsMBqvVqtfrbTabTqez2+3Nzc12u515rdPpbDabXq+3Wq0Gg6Gjo6OlpcVisbS2tprN5nv37pnNZrPZzNQSHBxsNBqHDx+emJiYmJg4duzYUaNGMZH9sMjIyMTEROeSmJiY0NBQtv6JgPdBjALrxo0b5/qXtLe3t7W1mUyms2fPzpgxIzExsaysrDu/mJ6enp6e7lyycuVK19sD4IAYBVe1tbUxi0PNZnNTU5PRaGSjloCAgICAACJKSEggIq1Wy0YtAE8BMQquOnnyZEpKChG1trZu37793r17ycnJzFsLFiyIjo52b3XY5Al6GsQouGrq1Kn79+93XL788suO19u3b3d7dUFBQb17925tbTUYDFKp1O3fD/BT4WFQ4B+2nwetqanpsoKqqqoKj5/C4yBGBcFopLt3yWTiuh0ewva4fuPGjevWrXMuWbJkyccff8xSdcB3iFGeu3OHXnmFpFJ65hkKCaEZM0ij4bpNrMPmzdCjYG6Uz4xGmjSJhg2jO3coPJzu3KH582nyZCotJT8/zzTh/fffd2z9abFYrly5kpeXx/aUJTZ5gh4FMcpn+/eTVksqFYWEEBFFR1N+PsXE0JEj9OqrnmlCr169HK9feumloqKiY8eOvfTSS6xW6oHzQaurq//+9787LhHZ8CMQo3x2+TKlpHRmKCM8nEaNojNnPBajzhISEoqKilQqFWIUvApilM/UapLLuxYqFNTczEVrSKlUElFJSQnbFXlgUD9+/Pi//e1vjstJkyaxVxfwHW4x8VlkJD0cJRoN9enDRWuIWXXvgRj1QG8UoPsQo3w2YgSVlJDBcL+kvp4uXqTnn+ekOYMGDVIoFFqt9tatW6xWFBHxzIQJpX37fsZqLQDdhBjls5kzqW9fysggnY6IqKGB5s2joUNp6tTOD5SXk93uyRYlJSUR+x1SmUxeXPzcyZOxLH2/XC533mqPiKKiovpw1MeHng8xymdBQXT8OOn1JJNRVBRFRJCvL33zDfn6EhFt3EhKJW3b5skWMdOjKpWK1VpCQ8nfn/R6th44+P3vf79ly5arV6++/vrrWVlZRPTll19iXyh4HMQozw0aRMePk1ZL331HjY10+DBFRHS+lZBAdjtlZtLlyx5rjmemR0UiksmIiFjd5qm2tragoODMmTMs1gGCgBgVhNBQiomhLoveJ0+mN9+k9naaNctjz4kqlUqxWFxeXm6xWFitiDmSjtVlSCaTiYiCgoJYrAMEATEqIHfv0vr1D0yGZmfT0KH0/feUleWZJoSGhg4ZMsRkMlVUVLBakQdilNk4NTAwkMU6QBAQo0Jhs9GLL9Kf/kR/+cv9wl69aM8e8vOj7Gw6ccIzDfHM6lFmvSyrS56YGEVvFJ4IMSoUYjF9+CER0bvvPjAZmphI771HNhvNnUsunyvXHcz0KNt3mTzWG0WMwhMhRgVk2rRHT4a+9x6lpNDdu7RkiQdaIZjeKEtzowaD4c6dO84ljY2NGi/Yl0vAEKPCkpPTORm6YcP9Ql9fys8niYT276evv2a7CfHx8UFBQT/88IPB+bkAd+Pv3OjXX3/NnD7tsHHjxuXLl7u3FvAkxKiwOCZDt259YDL0Zz8j5lT3pUupuprVJvj5+Y0cOdJms3Xz5M6ng7lR6DkQo4KTmEjr1pHNRvPmPTAZ+uabNG0a6fX2jAybzcZqEzwwrseCJ+g5sMOTEK1fT8eO0blztGQJFRTcL8/LM6emvtvUFJmd/bvf/Y69+j1wl4l3g3qTyaTVatvb24mopaXl6NGjjrdu3rwpEoncUgtwAjEqRMxkaHx852ToG290lstkJzdt2paW5n/1ampq6siRI1mq3wO90X79KC2NHnzw3c1+0qDeaDQ2Nzer1era2tpHvtBoNHa7fcyYMXPnzm1sbNzm9JDutWvXnnvuObb+DGAfYlSgmMnQxYtp6VIaM4YGDmSKf/nLXzKns82aNausrIylEWtMTEy/fv3UavWdO3fcfk49EW3YQM8+S99803lZWUkFBbR+PRHRrl1uW4/gGNRbrVatVqvVajUaTV1dnVarraurc7zQaDSObuaPCAgIkMlkzBZ/gwYNOn78uOOtNWvWsL0nFrBKZPfsDkDgUenp9I9/qOfMUXzxhVjcOQ/e1taWkJBQWVm5evXqrcx9JxZMmTLl22+/3b9//4wZM9z+5RIJWSx06RING0ZE9M03lJHReZTf1KnkNFzuFqPRqNVq1Wq1Vqutr69nXmi12uPHj2u12pCQEIPB8MT/TCQSSUREhEwmk8lkERERcrlcJpOFh4c7XoSGhjKf3LVr10cffXTlyhXH7zIxeuDAgZ/Wbugx0BsVtE8+OW61TsnP/yAuzjEZGhwcvGfPnpSUlJycnNTU1MmTJ7NRs1Kp/Pbbb0tKStiIUSJKSaGVK6mw8H5JeTnl5tKVK7RoEY0bR/PmdZbrdKTRkFZL9fX3X6jV5OPzw5Ur02tra1tbWx9XS0BAgF6vJ6LAwMDIyMiIiIiwsLCHX/Tv3z/E+SgX8DKIUUGTyWwrVliPHl2/fr3zZGhCQkJWVtaGDRsWLVp0+fJlNnbSZPsu07p1NH/+AxO/iYmUl0dTp1JeHhHRe+/RV1+RVkuPG21HRvaqrb1G/xtuh4eHKxQKmUymUCjCw8NlMtmZM2d27tw5e/bsr776ytGXd11wcHDfvn2dSyQSiaOvCnyEQb3wLVu2LDc3d/jw4c6ToTabbeLEid99991rr73GxnCyqampX79+wcHBOp3O1/cp/29tNJJWS2o1abWdL+rrac0aGj6cCgvphx9o3Tq6epXOnLk/qP/Xv4jpXq9a1bm7gERCEREkk5Fc3vlCJqOICFIorP36XQ8PD39cR/LcuXOjR48eMWLEZQ/uNAh8hBgVPsdk6FtvvZWdne0ov3nzZnx8vMFg+Otf//qb3/zG7fXGxsZWVVVdunQpLi7ukR9obm523KhpaRlx69awLuPuR462//Mfmj6dCgspJYXGjaNRoygt7X6MOqjV1NFBMhk99YKl9vb2kJAQi8Wi0+kkEslTfgt4AQzqhY+ZDB09evS2bdtSU1PT0tKY8sGDB+fk5CxcuHDFihXjxo0b+L+7+W5htVpHjhxZVVX1+eefJyYmPvI2t/Pd7QkTcoqLh3X5koAAkskoPJwUCpLJSKEghYIGD+58VySinTspOZke2XDH7tVPLSAgIC4urrS09Pz58xMmTHD160C40Bv1Fn/84x+zsrKioqIuXbrkPDf3+uuvFxQUjB07tqioyMfHp5vfZjKZmpqafmSlpFar7ejoCAwMND1+x2jm7jZzLzsubh7RdGa4LZd3pufjbttIJFRYSKNHExGtXk1ffkl+fl17o26xYsWKHTt2bNq06Z133nH/t4NQoDfqLdatW/fvf/+7uLh48eLFzpOhO3fuPHXqVGBgYEtLi+NGh/Nwm1kXWV9f73ihVqt/5O42QywWS6VSg8EQERExceJEuVzOnBPHrJ1k1ga55QGhP/yB9u2jjg7Xv+kRkpOTd+zYwfamf8B36I16kYcnQ2tra/fu3VtZWdne3u487jabzT/+VYGBgV3WRTpuczMv5HL57t27ly5d+tvf/jY3N9e9f8iGDbRoEQ0Y0Hl54gSdOdO5/N69Kisrf/7zn/fv37/L1nYAztAb9SLOk6Fjx47VaDS7du364osvHv5kYGDgIxdIOl5EREQ88TFw9g7h+L//IyKyWmnBAmpupsOH6Re/cHslRERDhw4NCwurqampra2NjIxkpQ7gP8Sod8nIyDhy5MjBgwcXLFgglUr/+c9/Jicnp6enO4bbzAu3ZB/bG835+NDBg9TaSgZD19P83EUkEiUlJRUWFqpUqvT0dFbqAP5DjHqd3bt319bWzp8/PyMjIzg4+PDhwzLmtGJ388B+nQoFtbZSXR1bMUpESqWysLCwpKQEMQqPg/1GvU6/fv3OnTt34sQJm82WkZHBUoaSR/br9MDmzZ45Wgp4DTHqjWpqavbu3evj47Nq1Sr2avHAAcUe2HWUidHS0lKr1cpiNcBnGNR7o61bt5rN5lmzZsXExLBXi2cG9cRyb1Qmk02bNi06OrqtrQ3PMsEjIUa9TlNTU15eHhGxugE+eSRGmUE9e73REydOvPXWW5cuXXKUfPrpp4cPHz506BBbVQIPYVDvdXbs2NHa2pqWljZq1ChWK/JYjLLXG21ra+uyYtRgMKjVarbqA35CjHoXk8m0c+dOIlq7dq0H6iKPDOpZnRsFeCIM6r3Lp59+qtFokpKSPLDXhgB6owznbQE6WHrsFPgMMepFrFZrTk4OEWVmZnqgOmHcqW9ubu7Vq5fj0m63JyUlsVgf8BAG9V5k3759VVVVw4YNmz59ugeqmzBhwq9+9Sv21qWSR+7Uh4WFWZ2wd3oV8Bd6o17Dbp+Zm9v/hRfq5s1z45EYD9u8eXNVVdXHH3/84YcfMiXLly+Pjo5+99133V5XaCj5+5NORybT02/PDOAixKjXOHbM79SpceHh9Otfs1pPQ0NDl3vZarWapRlSkYgmTTpw797NhoaM/v3df6IUQHdgUO81Nm0iIlq9WmDdNo1mY3Hx2xrNDa4bAt4LvVHvUFpKRUUkldLixR6ozW63O9/RZnVPW7lcTkT17MyPvvDCC2fPnnUumTdvHvYogS7QG/UOf/4zEdHy5Y89l8OtDh8+7OeE1Wd+FAoFEdWxc7e+d+/ew4Y9cEJUnz59BjtOgwIgIsSoV6ispEOHKCCAVq70TIXTpk1zvrv96quvslcXq71RgO7AoN4LbN5MNhvNn++G0zK7jdXFAM4Qo8A59EaFTqOh/Hzy8aE1a7huCitYHdQDdAdiVOiys8lkotdeoyFDuG4KK5gYRW8UOISTQQXNYKABA0ivp9JSeu45z9SpVqtNJpPzfZhbt275+/uzdCTcxYsXR40aFRcX57ydHYAnYW5U0HbuJL2eJk3yWIYSUcRDM7CDBg1ir7qnGNRbLBaLxRIcHOwoaW9vt9vtrD7+DwKGQb1w2e30ySdERO+8w3VTWCSTycRicUNDQ/cP+fj888+VSqVzyfr169944w0WWgdeATEqXCIRnT1L27dTairXTWGRr68vs3tIU1MT120BL4UYFZaaGpo7l8LDyd+fhg2jvDxatozrNrGO2USqvLxco9E0NzebzWauWwTeBXOjAqLX0/jxNHw4HTtGkZF07hwtW0bV1ZSdTR980PmZ998nkYjTVj7C2rVrhwwZsmjRIkfJ7Nmz58yZM3ny5Mf9yo0bN06fPl1eXl5eXn7t2rWgoKC0tDTnD/Tu3dvPz4/5KZFIfH19pVKpj49PSEiIUqk0mUxlZWWOD2O9FLgCMSogu3ZRRwcdOEABAUREr7xCvXvTiy/S6tU0e3bnZ3pehhJRRUWFr+8D/yqWlpamPjgXUVtbW1JSolKpSkpKysrKWlpaHG+JxWKj0SiXy0Uikdlsbm1ttVgsra2tRNTc3PxwdYmJiTU1NRkZGY4SjUbz/PPPu/mvAq+BGBWQ8nKaOrUzQxkTJ1LfvnTqFDl19PjCbDYXFxeXlJQw6VlTU+P87uDBg5OTk5VKpVKpzM/Pz83NzczMXLVqleMDLS0tHR0dBoPBarUyP/V6vc1m0+l0dXV1sbGxly9fdnz47bffvn79uuf+NhAWxKiA3L5Nzz7btTAqirRaLlrjqlu3bi1ZssRxKZVKR4wYkZiYOHbs2PHjxzPrnBhFRUX00Ap85kz5sLCwh7959+7dLLUZvBNiVEDkcnr4bnVDA0mlXLTmp9m2bdsnzPIsIiJqamoaOHBgcnJyUlIS0+UcOnSo6DEzEnisHriFGBWQZ56hEyceKKmqIrWa+HAE28KFC99xWt86fvz4gICAc+fOded38Vg9cAsLngRk4UKqqKDs7M5Lg4GWLaPRo+nBpeY9k0Qi6e+kyx2nH/dTe6OLFy+uqKhwLtm8efPBgwe7XyOAM8SogAwZQvv305YtNGAAjRlD0dFkMlFBAdfNYh16o8AtDOqFZcoUqq6mCxfIYKBBgyg2lusGeQJiFLiFHZ6Ae2VlZVKpdOjQoY6S4uLi2NjYqKiobn6DRCJpbW3V6/VSPtxPA4FBjIIQxMTE3Lhx47///W+sd3TAoUfB3CgIAcb1wCHEKAgBlo4ChxCjIATojQKHEKMgBIhR4BBiFIQAg3rgEGIUhAAxChxCjIIQYFAPHEKMghAgRoFDiFEQAgzqgUN4igmEgDll3mw2G41GHDcPHobeKAiBSCRizgfV8nOrf+A1xCgIBMb1wBXEKAgE7jIBVxCjIBCIUeAKYhQEAoN64ApiFAQCMQpcwSEiIBAvv/xyZGRkfHw81w0Br4N1o8B7n3322dGjRw8cOOAoycrKMhqNW7Zs4bBV4D3QGwXe0+l0d+/edS7RarVtbW1ctQe8DeZGAQBcgt4oCIHdbrdYLI5Lm83GYWPA2yBGQQhUKpW/v79zyZw5c7hqDHgbDOpBCJKTk21OlixZwnWLwIugNwoCIRKJuG4CeCn0RgEAXIIYBQBwCZbfA+81NDTodLrY2FhHyd27d202W3R0NIetAu+BGAUAcAkG9QAALkGMAgC4BDEKAOASxCgAgEsQowAALvl/bGBkjQvRCEcAAAFVelRYdHJka2l0UEtMIHJka2l0IDIwMjAuMDkuMQAAeJx7v2/tPQYg4AFiRgYIEAZiISBuYGRTSADSLMzsCkogeRYYH41mYlPQANLMLBwQmolDQQtI/2dmZGQACTBQneYGOpaRiYGRGegoBhZWBlY2DSZWdgUGDgYGTgYGLgYmbgYmHgYmXgZmPgZmfgZmAQYWQQYWIQYRBnGYLxmEv9+Yafe/cb89iPM78K5djAyDNYhdnypg/5hx/34Qu2DaN/uKTxx2IHbx2/b9Uz+y7AOxN01XPnDuYyuYzbUt6kBWbjnYnCApnwN3e8+D9b7Yr2P3I9HeAcSOCZ9qL6R5Hazme87M/eYix8BsRiUj+1eK9gdA7KbGnfYWjw+B9dbsnLXv24prYLbhmygHh0/tYDcclGN3mN9qDRY/Wv7LXii3CWzOiXPd+7+9aYSI/16/30FjNVhcDAAT7FpSjc5A+AAAAWh6VFh0TU9MIHJka2l0IDIwMjAuMDkuMQAAeJydlE1OxDAMhfc9RS5A5J/EidcMYiTEILHgDuy5v3CSabEEIzSuUtWvaT49O3G3NK7308vnVzouOm1bQk3YU4I/h6qmDwKAbXwPmQHqiDAXFVrvbBbSY7qF8ONKKUy8ryVwlMtvSrlJqVLG2ofhhYJeMCtJXWuRuYUo5gDEymiRUUh7jEK5VsFFIUGJUTgXbGWtVdlzm5S3eyjYFVduQvgPBW/uEUqfNaWsCsVRzvfsEYq0FUkHDVEsD9Qui1JLqzEvkEVrX7tluHBGpSgvV5VIYhmNbpznfuxRaxDzYueF4HrurRWCdaGMiLxcNaYgxbqxSl8RoMYyGt2oe10Aa5jCrejyYj8GilCsL2h1xzYj9qJ4UQ9hkRzCojbnr6IfM/ZQJxC8wENwQvKCvfhxUBJWL8SL5rxh92J38JrS4/l5Gp33+HH0UcMx83Q5bd+ROwA41JnZcwAAATt6VFh0U01JTEVTIHJka2l0IDIwMjAuMDkuMQAAeJxdT7tuAjEQ/JWUh+Kz9m0blIqGNCH96YooFVIQKKHk47NrGu4ayzM7OzM7Heb9MB3mTX+mj9d5eMbxWeEnuB/ejpvpOM4v9wEyWi2AiXJrwJp2kBlAKifM0gydQddYCcIqNEm70ZlWTZxRKdJiSZjILEEGwKZSKUg1AR+PYUXUza1pZUyj57mDhLv40EKkrjG3jwqErXNWCnCoXCPF/ZG5cEk7zkJgwZCpehxlRPQQXy9MCrVvqZXqPQFr094cDBuHCKlVqg+ut4sPKjwO5CK1+KKnoad5X1XDvkiGhk55AywcNzcz9VlQnoPYixN6q036ul3On7+X6xby6e/9fP05fZ9uGbe0hLyEtoRlCesS4soacYVXWSgrrAt8/wcdn5WhkKJaWwAAAABJRU5ErkJggg==\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -272,7 +448,7 @@ } ], "source": [ - "m = Molecule(smiles='C[N+](C)(C)CC(=O)[O-]')\n", + "m = Molecule(smiles='C[N+](C)(C)CC(=O)[O-]', hydrogens_are_explicit=False)\n", "display(m)" ] } @@ -293,7 +469,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.8" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/examples/rotamers/core_constraints.ipynb b/examples/rotamers/core_constraints.ipynb index 049e7683..a78588f0 100644 --- a/examples/rotamers/core_constraints.ipynb +++ b/examples/rotamers/core_constraints.ipynb @@ -37,33 +37,15 @@ " - Initializing molecule from a SMILES tag\n", " - Loading molecule from RDKit\n", " - Representing molecule with the Open Force Field Toolkit\n", - "Warning: Unable to load toolkit 'OpenEye Toolkit'. The Open Force Field Toolkit does not require the OpenEye Toolkits, and can use RDKit/AmberTools instead. However, if you have a valid license for the OpenEye Toolkits, consider installing them for faster performance and additional file format support: https://docs.eyesopen.com/toolkits/python/quickstart-python/linuxosx.html OpenEye offers free Toolkit licenses for academics: https://www.eyesopen.com/academic-licensing\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f963188257ca4e30872f4d49f993d777", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ " - Generating rotamer library\n", - " - Core forced to contain atom C1\n" + " - Core forced to contain atom: C1 \n" ] } ], "source": [ "mol = Molecule(smiles='CCCC', name='butane', tag='BUT',\n", - " exclude_terminal_rotamers=False, core_constraint=0)" + " exclude_terminal_rotamers=False, core_constraints=[0, ],\n", + " hydrogens_are_explicit=False)" ] }, { @@ -73,9 +55,37 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAACWCAIAAADCEh9HAAAABmJLR0QA/wD/AP+gvaeTAAAFXUlEQVR4nO3cv26SbRzH4ZvK4J9BZ116AAbiEXAGbMxdSboQBibqCZiQrg2LR+DkDgszeAZ0UNOkJHYQO1h5ByfxrcL7e/PcwHNdm/ezfLV5PsXcCZXVapUA+K+Ocg8A2G8yChAiowAhMgoQIqMAITIKECKjACEyChBSzT2ANBqNJpNJrVZrNptrj66urobDYUqp3+/nmHYvmwuwd4PLa0Vu3W43pXRycvL7o+l0mlKqVCqFj/oLmwuwd4NLy3/qAUJkFCBERgFCZBQgxE39rhiPx+12e+3w+vo6y5gN2VyAvRtcQjK6Ky4vLy8uLnKv2I7NBdi7wSUko7ui0Wicnp6uHc7n816vl2XPJmwuwN4NLiEZ3RXHx8etVmvtcDabZRmzIZsLsHeDS8gVE0CIjAKEyChAiIwChMhofkdHv/wUbm9vF4vFcrlMKVWrO3oHuLb55uZmsVjc3d2lPdl8d3e3WCxubm5+/nE3N6/9Iy+Xy8VicXt7m3Z1cHnl/m4U1g0Gg5RSp9PJPWQL9Xo9pTSdTnMP2dTPb0iq1+u5h2yh0+mklAaDQe4hrPNpFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCqrkH/P9Go9FkMqnVas1mc+3R1dXVcDhMKfX7/RzT4MCV8+07wE+j79+/Pzs7e/fu3e+PPn/+fHZ29vr16+JXQRmU8+07wIwCFElGAUJkFCDkAK+YNvTixYtPnz7lXnGv8/Pz8/Pz3Cu28+rVq9wTtvPhw4dKpZJ7xXa63W6328294l88f/7848ePuVfkcbAZHY/H7XZ77fD6+jrLGCiV0r19q4Pz19/VlUol98Y/GQwGKaVOp5N7yBbq9XpKaTqd5h6yqel0mlKq1+u5h2yh0+mklAaDQe4hf7Lvb99/c7CfRhuNxunp6drhfD7v9XpZ9kB5lO3tO9iMHh8ft1qttcPZbJZlDJRK2d4+N/UAITIKECKjACEyChBygBk9Orr3L1WtHuyVGuyCcr59B5jRN2/erFart2/f/v7o5cuXq9Xqx48fhY+CUijn23eAGQUokowChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKEBIZbVa5d7AL25vb79+/fro0aPHjx/n3rKpm5ub79+/P3v27MGDB7m3bOTu7u7Lly/VavXp06e5t2xquVx++/btyZMnDx8+zL2FX8goQEg19wDSaDSaTCa1Wq3ZbK49urq6Gg6HKaV+v59j2r1sLsDeDS6vFbl1u92U0snJye+PptNpSqlSqRQ+6i9sLsDeDS4tV0wAITIKECKjACEyChDipn5XjMfjdru9dnh9fZ1lzIZsLsDeDS4hGd0Vl5eXFxcXuVdsx+YC7N3gEpLRXdFoNE5PT9cO5/N5r9fLsmcTNhdg7waXkIzuiuPj41artXY4m82yjNmQzQXYu8El5IoJIERGAUJkFCBERgFCZDS/o6N7fwrV6o7eAdpcgL0bXFq+bxQgxKdRgBAZBQiRUYAQGQUIkVGAEBkFCPkHyTHqc63bLBYAAAAASUVORK5CYII=\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -105,7 +115,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -115,45 +125,55 @@ " - Initializing molecule from a SMILES tag\n", " - Loading molecule from RDKit\n", " - Representing molecule with the Open Force Field Toolkit\n", - "Warning: Unable to load toolkit 'OpenEye Toolkit'. The Open Force Field Toolkit does not require the OpenEye Toolkits, and can use RDKit/AmberTools instead. However, if you have a valid license for the OpenEye Toolkits, consider installing them for faster performance and additional file format support: https://docs.eyesopen.com/toolkits/python/quickstart-python/linuxosx.html OpenEye offers free Toolkit licenses for academics: https://www.eyesopen.com/academic-licensing\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f963188257ca4e30872f4d49f993d777", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ " - Generating rotamer library\n", - " - Core forced to contain atom C1\n" + " - Core forced to contain atom: C1 \n" ] } ], "source": [ "mol = Molecule(smiles='CCCC', name='butane', tag='BUT',\n", - " exclude_terminal_rotamers=False, core_constraint=' C1 ')" + " exclude_terminal_rotamers=False, core_constraints=[' C1 ', ],\n", + " hydrogens_are_explicit=False)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAACWCAIAAADCEh9HAAAABmJLR0QA/wD/AP+gvaeTAAAFXUlEQVR4nO3cv26SbRzH4ZvK4J9BZ116AAbiEXAGbMxdSboQBibqCZiQrg2LR+DkDgszeAZ0UNOkJHYQO1h5ByfxrcL7e/PcwHNdm/ezfLV5PsXcCZXVapUA+K+Ocg8A2G8yChAiowAhMgoQIqMAITIKECKjACEyChBSzT2ANBqNJpNJrVZrNptrj66urobDYUqp3+/nmHYvmwuwd4PLa0Vu3W43pXRycvL7o+l0mlKqVCqFj/oLmwuwd4NLy3/qAUJkFCBERgFCZBQgxE39rhiPx+12e+3w+vo6y5gN2VyAvRtcQjK6Ky4vLy8uLnKv2I7NBdi7wSUko7ui0Wicnp6uHc7n816vl2XPJmwuwN4NLiEZ3RXHx8etVmvtcDabZRmzIZsLsHeDS8gVE0CIjAKEyChAiIwChMhofkdHv/wUbm9vF4vFcrlMKVWrO3oHuLb55uZmsVjc3d2lPdl8d3e3WCxubm5+/nE3N6/9Iy+Xy8VicXt7m3Z1cHnl/m4U1g0Gg5RSp9PJPWQL9Xo9pTSdTnMP2dTPb0iq1+u5h2yh0+mklAaDQe4hrPNpFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCZBQgREYBQmQUIERGAUJkFCBERgFCqrkH/P9Go9FkMqnVas1mc+3R1dXVcDhMKfX7/RzT4MCV8+07wE+j79+/Pzs7e/fu3e+PPn/+fHZ29vr16+JXQRmU8+07wIwCFElGAUJkFCDkAK+YNvTixYtPnz7lXnGv8/Pz8/Pz3Cu28+rVq9wTtvPhw4dKpZJ7xXa63W6328294l88f/7848ePuVfkcbAZHY/H7XZ77fD6+jrLGCiV0r19q4Pz19/VlUol98Y/GQwGKaVOp5N7yBbq9XpKaTqd5h6yqel0mlKq1+u5h2yh0+mklAaDQe4hf7Lvb99/c7CfRhuNxunp6drhfD7v9XpZ9kB5lO3tO9iMHh8ft1qttcPZbJZlDJRK2d4+N/UAITIKECKjACEyChBygBk9Orr3L1WtHuyVGuyCcr59B5jRN2/erFart2/f/v7o5cuXq9Xqx48fhY+CUijn23eAGQUokowChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKECIjAKEyChAiIwChMgoQIiMAoTIKEBIZbVa5d7AL25vb79+/fro0aPHjx/n3rKpm5ub79+/P3v27MGDB7m3bOTu7u7Lly/VavXp06e5t2xquVx++/btyZMnDx8+zL2FX8goQEg19wDSaDSaTCa1Wq3ZbK49urq6Gg6HKaV+v59j2r1sLsDeDS6vFbl1u92U0snJye+PptNpSqlSqRQ+6i9sLsDeDS4tV0wAITIKECKjACEyChDipn5XjMfjdru9dnh9fZ1lzIZsLsDeDS4hGd0Vl5eXFxcXuVdsx+YC7N3gEpLRXdFoNE5PT9cO5/N5r9fLsmcTNhdg7waXkIzuiuPj41artXY4m82yjNmQzQXYu8El5IoJIERGAUJkFCBERgFCZDS/o6N7fwrV6o7eAdpcgL0bXFq+bxQgxKdRgBAZBQiRUYAQGQUIkVGAEBkFCPkHyTHqc63bLBYAAAAASUVORK5CYII=\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -166,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -191,7 +211,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.8" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/peleffy/data/tests/ethane_noH.pdb b/peleffy/data/tests/ethane_noH.pdb new file mode 100644 index 00000000..050d9e85 --- /dev/null +++ b/peleffy/data/tests/ethane_noH.pdb @@ -0,0 +1,5 @@ +HETATM 1 C1 UNK 1 0.755 0.000 0.000 1.00 0.00 C +HETATM 2 C2 UNK 1 -0.755 0.000 0.000 1.00 0.00 C +CONECT 1 2 +END + diff --git a/peleffy/forcefield/forcefield.py b/peleffy/forcefield/forcefield.py index fa1e6112..bafae21c 100644 --- a/peleffy/forcefield/forcefield.py +++ b/peleffy/forcefield/forcefield.py @@ -404,9 +404,7 @@ def _get_parameters(self, molecule): openff_parameters = self._openff.parameterize(molecule, charge_method='dummy') - print(openff_parameters['sigmas']) oplsff_parameters = self._oplsff.parameterize(molecule) - print(oplsff_parameters['sigmas']) if self._nonbonding == 'openff': hybrid_parameters['atom_names'] = openff_parameters['atom_names'] diff --git a/peleffy/tests/test_molecule.py b/peleffy/tests/test_molecule.py index 341742d7..0cec6a97 100644 --- a/peleffy/tests/test_molecule.py +++ b/peleffy/tests/test_molecule.py @@ -32,7 +32,7 @@ def test_smiles_initialization(self): """ It checks the initialization from a SMILES tag. """ - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) # Save it with tempfile.TemporaryDirectory() as tmpdir: @@ -59,12 +59,13 @@ def test_molecule_name_assignment(self): assert molecule.name == 'benzene', 'Unexpected atom name' # Look for the SMILES name when a Molecule is loaded from a SMILES tag - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) assert molecule.name == 'c1ccccc1', 'Unexpected atom name' # Look for benzene name when a Molecule is loaded from a SMILES tag # with a custom name - molecule = Molecule(smiles='c1ccccc1', name='benzene') + molecule = Molecule(smiles='c1ccccc1', name='benzene', + hydrogens_are_explicit=False) assert molecule.name == 'benzene', 'Unexpected atom name' def test_molecule_tag_assignment(self): @@ -88,12 +89,13 @@ def test_molecule_tag_assignment(self): assert molecule.tag == 'BEN', 'Unexpected atom tag' # Look for UNK tag when a Molecule is loaded from a SMILES tag - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) assert molecule.tag == 'UNK', 'Unexpected atom tag' # Look for BNZ tag when a Molecule is loaded from a SMILES tag with # a custom tag - molecule = Molecule(smiles='c1ccccc1', tag='BNZ') + molecule = Molecule(smiles='c1ccccc1', tag='BNZ', + hydrogens_are_explicit=False) assert molecule.tag == 'BNZ', 'Unexpected atom tag' def test_PDB_connectivity_template(self): @@ -198,7 +200,7 @@ def check_residue_name(name): check_residue_name('TAG') # Checking default tag assignment from SMILES - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) with tempfile.TemporaryDirectory() as tmpdir: with temporary_cd(tmpdir): assert molecule.tag == 'UNK', 'Unexpected molecule tag' @@ -206,7 +208,8 @@ def check_residue_name(name): check_residue_name('UNK') # Checking custom tag assignment from SMILES - molecule = Molecule(smiles='c1ccccc1', tag='BEN') + molecule = Molecule(smiles='c1ccccc1', tag='BEN', + hydrogens_are_explicit=False) with tempfile.TemporaryDirectory() as tmpdir: with temporary_cd(tmpdir): assert molecule.tag == 'BEN', 'Unexpected molecule tag' @@ -214,7 +217,7 @@ def check_residue_name(name): check_residue_name('BEN') # Checking second custom tag assignment from SMILES - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) with tempfile.TemporaryDirectory() as tmpdir: with temporary_cd(tmpdir): molecule.set_tag('BNZ') @@ -281,11 +284,13 @@ def test_undefined_stereo(self): # This should crash due to an undefined stereochemistry error with pytest.raises(UndefinedStereochemistryError): - mol = Molecule(smiles='CN(C)CCC=C1c2ccccc2CCc3c1cccc3') + mol = Molecule(smiles='CN(C)CCC=C1c2ccccc2CCc3c1cccc3', + hydrogens_are_explicit=False) # This now should work mol = Molecule(smiles='CN(C)CCC=C1c2ccccc2CCc3c1cccc3', - allow_undefined_stereo=True) + allow_undefined_stereo=True, + hydrogens_are_explicit=False) # And we can parameterize it ff = OpenForceField('openff_unconstrained-1.2.1.offxml') @@ -330,7 +335,9 @@ def test_from_openff(self): """ from openff.toolkit.topology import Molecule as OpenFFMolecule - openff_molecule = OpenFFMolecule.from_smiles('C(C(=O)[O-])C(=O)[OH]') + openff_molecule = \ + OpenFFMolecule.from_smiles('C(C(=O)[O-])C(=O)[OH]', + hydrogens_are_explicit=False) molecule = Molecule.from_openff(openff_molecule) @@ -350,6 +357,75 @@ def test_from_openff(self): assert molecule.graph is not None, \ 'Molecule\' graph should be initialized' + def test_explicit_hydrogens(self): + """ + It checks initialization of a Molecule with the explicit hydrogens + flag. + """ + + # Load ethane from SMILES with implicit hydrogen atoms + molecule = Molecule(smiles='CC') + atom_names = molecule.get_pdb_atom_names() + + for atom_name in atom_names: + assert 'H' not in atom_name, 'Unexpected H in molecule without ' \ + + 'explicit hydrogen atoms and hydrogens_are_explicit ' \ + + 'set to True' + + # Load ethane from SMILES without explicit hydrogen atoms + molecule = Molecule(smiles='CC', hydrogens_are_explicit=False) + atom_names = molecule.get_pdb_atom_names() + + found_hydrogen = False + for atom_name in atom_names: + if 'H' in atom_name: + found_hydrogen = True + break + + assert found_hydrogen, 'Hydrogen not found regardless of setting ' \ + + 'hydrogens_are_explicit to False' + + # Load ethane from SMILES with explicit hydrogen atoms + molecule = Molecule(smiles='[H]C([H])([H])C([H])([H])([H])', + hydrogens_are_explicit=True) + atom_names = molecule.get_pdb_atom_names() + + found_hydrogen = False + for atom_name in atom_names: + if 'H' in atom_name: + found_hydrogen = True + break + + assert found_hydrogen, 'Hydrogen not found regardless of being ' \ + + 'explicitly defined in the SMILES tag' + + # Load ethane from PDB with implicit hydrogen atoms + pdb_path = get_data_file_path('tests/ethane_noH.pdb') + molecule = Molecule(pdb_path, + hydrogens_are_explicit=True) + atom_names = molecule.get_pdb_atom_names() + + for atom_name in atom_names: + assert 'H' not in atom_name, 'Unexpected H in molecule without ' \ + + 'explicit hydrogen atoms and hydrogens_are_explicit ' \ + + 'set to True' + + # Load ethane from PDB without explicit hydrogen atoms + pdb_path = get_data_file_path('tests/ethane_noH.pdb') + molecule = Molecule(pdb_path, + hydrogens_are_explicit=False) + atom_names = molecule.get_pdb_atom_names() + + found_hydrogen = False + for atom_name in atom_names: + if 'H' in atom_name: + found_hydrogen = True + break + + assert found_hydrogen, 'Hydrogen not found regardless of setting ' \ + + 'hydrogens_are_explicit to False' + + def test_pdb_fixer(self): """ It checks the PDB fixer prior parsing a PDB input file for @@ -443,7 +519,7 @@ def test_molecule_display(self): from IPython.display import display - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) # This should not raise any Exception display(molecule) diff --git a/peleffy/tests/test_parameters.py b/peleffy/tests/test_parameters.py index 1ee641cf..a996b127 100644 --- a/peleffy/tests/test_parameters.py +++ b/peleffy/tests/test_parameters.py @@ -314,7 +314,7 @@ def test_OFF_parameters(self): MAX_THRESHOLD = 1e-3 # Load benzene ring - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) # Parameterize ff = OpenForceField(FORCEFIELD_NAME) @@ -369,7 +369,7 @@ def test_Impact_writable_parameters(self): """ # Load benzene ring - molecule = Molecule(smiles='CC=O') + molecule = Molecule(smiles='CC=O', hydrogens_are_explicit=False) # Parameterize ff = OpenForceField(FORCEFIELD_NAME) @@ -407,7 +407,7 @@ def test_OFF_parameters(self): MAX_THRESHOLD = 1e-3 # Load benzene ring - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) # Parameterize ff = OpenForceField(FORCEFIELD_NAME) @@ -475,7 +475,7 @@ def test_Impact_writable_parameters(self): """ # Load benzene ring - molecule = Molecule(smiles='CC=O') + molecule = Molecule(smiles='CC=O', hydrogens_are_explicit=False) # Parameterize ff = OpenForceField(FORCEFIELD_NAME) @@ -515,7 +515,7 @@ def test_OFF_parameters(self): """ # Load molecule - molecule = Molecule(smiles='C=CC(=O)O') + molecule = Molecule(smiles='C=CC(=O)O', hydrogens_are_explicit=False) # Parameterize ff = OpenForceField(FORCEFIELD_NAME) @@ -635,7 +635,7 @@ def test_Impact_writable_parameters(self): """ # Load benzene ring - molecule = Molecule(smiles='CC=O') + molecule = Molecule(smiles='CC=O', hydrogens_are_explicit=False) # Parameterize ff = OpenForceField(FORCEFIELD_NAME) @@ -793,7 +793,8 @@ def test_nonstandard_dihedrals_writable_parameters(self): It checks the writable representation of non standard dihedrals. """ # Load molecule - molecule = Molecule(smiles='c1c(c(n(n1)S(=O)(=O)C))O') + molecule = Molecule(smiles='c1c(c(n(n1)S(=O)(=O)C))O', + hydrogens_are_explicit=False) # Parameterize ff = OpenForceField(FORCEFIELD_NAME) diff --git a/peleffy/tests/test_toolkits.py b/peleffy/tests/test_toolkits.py index 1e460131..31d28d29 100644 --- a/peleffy/tests/test_toolkits.py +++ b/peleffy/tests/test_toolkits.py @@ -110,7 +110,7 @@ def test_get_Schrodinger_parameters(self): from peleffy.utils.toolkits import ToolkitUnavailableException # Load benzene ring - molecule = Molecule(smiles='c1ccccc1') + molecule = Molecule(smiles='c1ccccc1', hydrogens_are_explicit=False) # Load OPLS2005 force field opls2005 = OPLS2005ForceField() diff --git a/peleffy/tests/test_utils.py b/peleffy/tests/test_utils.py index 22142674..def730cf 100644 --- a/peleffy/tests/test_utils.py +++ b/peleffy/tests/test_utils.py @@ -172,7 +172,8 @@ def test_non_datalocal_paths(self): from peleffy.forcefield import OpenForceField # Load benzene molecule - molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ') + molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ', + hydrogens_are_explicit=False) # Load force field openff = OpenForceField('openff_unconstrained-1.2.1.offxml') @@ -225,7 +226,8 @@ def test_datalocal_paths_for_openff(self): from peleffy.forcefield import OpenForceField # Load benzene molecule - molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ') + molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ', + hydrogens_are_explicit=False) # Load force field openff = OpenForceField('openff_unconstrained-1.2.1.offxml') @@ -289,7 +291,8 @@ def test_datalocal_paths_for_opls(self): from peleffy.forcefield import OPLS2005ForceField # Load benzene molecule - molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ') + molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ', + hydrogens_are_explicit=False) # Load force field opls2005 = OPLS2005ForceField() @@ -358,7 +361,8 @@ def test_datalocal_paths_for_offopls(self): from peleffy.forcefield import OpenFFOPLS2005ForceField # Load benzene molecule - molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ') + molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ', + hydrogens_are_explicit=False) molecule._forcefield = OpenFFOPLS2005ForceField('OPLS2005') # Load force field @@ -484,7 +488,8 @@ def test_folder_creation(self): from peleffy.forcefield import OpenForceField # Load benzene molecule - molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ') + molecule = Molecule(smiles='c1ccccc1', name='benzene', tag='BNZ', + hydrogens_are_explicit=False) # Load force field openff = OpenForceField('openff_unconstrained-1.2.1.offxml') diff --git a/peleffy/topology/molecule.py b/peleffy/topology/molecule.py index a11ada18..c1391569 100644 --- a/peleffy/topology/molecule.py +++ b/peleffy/topology/molecule.py @@ -19,7 +19,8 @@ class Molecule(object): def __init__(self, path=None, smiles=None, pdb_block=None, rotamer_resolution=30,exclude_terminal_rotamers=True, name='', tag='UNK', connectivity_template=None, core_constraints=[], - allow_undefined_stereo=False, fix_pdb=True): + allow_undefined_stereo=False, hydrogens_are_explicit=True, + fix_pdb=True): """ It initializes a Molecule object through a PDB file or a SMILES tag. @@ -52,6 +53,10 @@ def __init__(self, path=None, smiles=None, pdb_block=None, Whether to allow a molecule with undefined stereochemistry to be defined or try to assign the stereochemistry and raise a complaint if not possible. Default is False + hydrogens_are_explicit : bool + Whether the input molecule has explicit information about + hydrogen atoms or not. Otherwise, they will be added when + the molecule is built. Default is True fix_pdb : bool Activates or deactivate the PDB fixer that is executed prior parsing it @@ -113,6 +118,14 @@ def __init__(self, path=None, smiles=None, pdb_block=None, >>> molecule = Molecule('molecule_with_undefined_stereochemistry.pdb', allow_undefined_stereo=True) + Load a molecule with no explicit hydrogen atoms and ask the builder + to add them + + >>> from peleffy.topology import Molecule + + >>> molecule = Molecule('molecule_with_implicit_hydrogen.pdb', + hydrogens_are_explicit=False) + Display the molecular representation in a Jupyter Notebook >>> from peleffy.topology import Molecule @@ -129,6 +142,7 @@ def __init__(self, path=None, smiles=None, pdb_block=None, self._connectivity_template = connectivity_template self._core_constraints = core_constraints self._allow_undefined_stereo = allow_undefined_stereo + self._hydrogens_are_explicit = hydrogens_are_explicit self._fix_pdb = fix_pdb # Deactivate OpenForceField toolkit warnings @@ -299,7 +313,9 @@ def _initialize_from_pdb(self, path): logger.info(' - Loading molecule from RDKit') rdkit_toolkit = RDKitToolkitWrapper() - self._rdkit_molecule = rdkit_toolkit.from_pdb_block(pdb_block) + self._rdkit_molecule = \ + rdkit_toolkit.from_pdb_block(pdb_block, + self.hydrogens_are_explicit) # Use RDKit template, if any, to assign the connectivity to # the current Molecule object @@ -328,7 +344,9 @@ def _initialize_from_pdb(self, path): logger.info(' - Representing molecule with the Open Force Field ' + 'Toolkit') openforcefield_toolkit = OpenForceFieldToolkitWrapper() - self._off_molecule = openforcefield_toolkit.from_rdkit(self) + self._off_molecule = \ + openforcefield_toolkit.from_rdkit(self, + self.hydrogens_are_explicit) def _initialize_from_smiles(self, smiles): """ @@ -345,7 +363,8 @@ def _initialize_from_smiles(self, smiles): logger.info(' - Loading molecule from RDKit') rdkit_toolkit = RDKitToolkitWrapper() - self._rdkit_molecule = rdkit_toolkit.from_smiles(smiles) + self._rdkit_molecule = \ + rdkit_toolkit.from_smiles(smiles, self.hydrogens_are_explicit) # TODO not sure if stereochemistry assignment from 3D is still necessary # RDKit must generate stereochemistry specifically from 3D coords @@ -359,7 +378,9 @@ def _initialize_from_smiles(self, smiles): logger.info(' - Representing molecule with the Open Force Field ' + 'Toolkit') openforcefield_toolkit = OpenForceFieldToolkitWrapper() - self._off_molecule = openforcefield_toolkit.from_rdkit(self) + self._off_molecule = \ + openforcefield_toolkit.from_rdkit(self, + self.hydrogens_are_explicit) def _initialize_from_pdb_block(self, pdb_block): """ @@ -377,7 +398,9 @@ def _initialize_from_pdb_block(self, pdb_block): logger.info(' - Loading molecule from RDKit') rdkit_toolkit = RDKitToolkitWrapper() - self._rdkit_molecule = rdkit_toolkit.from_pdb_block(pdb_block) + self._rdkit_molecule = \ + rdkit_toolkit.from_pdb_block(pdb_block, + self.hydrogens_are_explicit) # Use RDKit template, if any, to assign the connectivity to # the current Molecule object @@ -399,7 +422,9 @@ def _initialize_from_pdb_block(self, pdb_block): logger.info(' - Representing molecule with the Open Force Field ' + 'Toolkit') openforcefield_toolkit = OpenForceFieldToolkitWrapper() - self._off_molecule = openforcefield_toolkit.from_rdkit(self) + self._off_molecule = \ + openforcefield_toolkit.from_rdkit(self, + self.hydrogens_are_explicit) def _build_rotamers(self): """It builds the rotamers of the molecule.""" @@ -508,7 +533,8 @@ def get_conformer(self): def from_rdkit(rdkit_molecule, rotamer_resolution=30, exclude_terminal_rotamers=True, name='', tag='UNK', connectivity_template=None, core_constraints=[], - allow_undefined_stereo=False): + allow_undefined_stereo=False, + hydrogens_are_explicit=True): """ It initializes and returns a peleffy Molecule representation from an RDKit molecular representation. @@ -540,6 +566,10 @@ def from_rdkit(rdkit_molecule, rotamer_resolution=30, Whether to allow a molecule with undefined stereochemistry to be defined or try to assign the stereochemistry and raise a complaint if not possible. Default is False + hydrogens_are_explicit : bool + Whether the input molecule has explicit information about + hydrogen atoms or not. Otherwise, they will be added when + the molecule is built. Default is True Returns ------- @@ -566,7 +596,8 @@ def from_rdkit(rdkit_molecule, rotamer_resolution=30, name=name, tag=tag, connectivity_template=connectivity_template, core_constraints=core_constraints, - allow_undefined_stereo=allow_undefined_stereo) + allow_undefined_stereo=allow_undefined_stereo, + hydrogens_are_explicit=hydrogens_are_explicit) logger = Logger() @@ -578,7 +609,9 @@ def from_rdkit(rdkit_molecule, rotamer_resolution=30, logger.info(' - Representing molecule with the Open Force Field ' + 'Toolkit') openforcefield_toolkit = OpenForceFieldToolkitWrapper() - molecule._off_molecule = openforcefield_toolkit.from_rdkit(molecule) + molecule._off_molecule = \ + openforcefield_toolkit.from_rdkit(molecule, + hydrogens_are_explicit) molecule._build_rotamers() @@ -588,7 +621,8 @@ def from_rdkit(rdkit_molecule, rotamer_resolution=30, def from_openff(openff_molecule, rotamer_resolution=30, exclude_terminal_rotamers=True, name='', tag='UNK', connectivity_template=None, core_constraints=[], - allow_undefined_stereo=False): + allow_undefined_stereo=False, + hydrogens_are_explicit=True): """ It initializes and returns a peleffy Molecule representation from an OpenForceField molecular representation. @@ -620,6 +654,10 @@ def from_openff(openff_molecule, rotamer_resolution=30, Whether to allow a molecule with undefined stereochemistry to be defined or try to assign the stereochemistry and raise a complaint if not possible. Default is False + hydrogens_are_explicit : bool + Whether the input molecule has explicit information about + hydrogen atoms or not. Otherwise, they will be added when + the molecule is built. Default is True Returns ------- @@ -649,7 +687,8 @@ def from_openff(openff_molecule, rotamer_resolution=30, name=name, tag=tag, connectivity_template=connectivity_template, core_constraints=core_constraints, - allow_undefined_stereo=allow_undefined_stereo) + allow_undefined_stereo=allow_undefined_stereo, + hydrogens_are_explicit=hydrogens_are_explicit) logger = Logger() @@ -722,6 +761,21 @@ def allow_undefined_stereo(self): """ return self._allow_undefined_stereo + @property + def hydrogens_are_explicit(self): + """ + Whether the input molecule has explicit information about + hydrogen atoms or not. Otherwise, they will be added when + the molecule is built + + Returns + ------- + allow_undefined_stereo : bool + The current configuration towards the hydrogen treatment + of this molecule + """ + return self._hydrogens_are_explicit + @property def fix_pdb(self): """ diff --git a/peleffy/utils/toolkits.py b/peleffy/utils/toolkits.py index 4b0cc6e2..8cf07420 100644 --- a/peleffy/utils/toolkits.py +++ b/peleffy/utils/toolkits.py @@ -98,7 +98,7 @@ def is_available(): except ImportError: return False - def from_pdb(self, path): + def from_pdb(self, path, hydrogens_are_explicit=True): """ It initializes an RDKit's Molecule object from a PDB file. @@ -106,6 +106,10 @@ def from_pdb(self, path): ---------- path : str The path to the molecule's PDB file + hydrogens_are_explicit : bool + Whether the SMILES tag has explicit information about + hydrogen atoms or not. Otherwise, they will be added when + the molecule is built. Default is True Returns ------- @@ -114,9 +118,15 @@ def from_pdb(self, path): """ from rdkit import Chem - return Chem.rdmolfiles.MolFromPDBFile(path, removeHs=False) + molecule = Chem.rdmolfiles.MolFromPDBFile(path, removeHs=False) - def from_pdb_block(self, pdb_block): + # Add hydrogens to molecule + if not hydrogens_are_explicit: + molecule = Chem.AddHs(molecule) + + return molecule + + def from_pdb_block(self, pdb_block, hydrogens_are_explicit=True): """ It initializes an RDKit's Molecule object from a PDB block. @@ -124,6 +134,10 @@ def from_pdb_block(self, pdb_block): ---------- pdb_block : str The PDB block to built the molecule with + hydrogens_are_explicit : bool + Whether the SMILES tag has explicit information about + hydrogen atoms or not. Otherwise, they will be added when + the molecule is built. Default is True Returns ------- @@ -132,16 +146,26 @@ def from_pdb_block(self, pdb_block): """ from rdkit import Chem - return Chem.rdmolfiles.MolFromPDBBlock(pdb_block, removeHs=False) + molecule = Chem.rdmolfiles.MolFromPDBBlock(pdb_block, removeHs=False) - def from_smiles(self, smiles): + # Add hydrogens to molecule + if not hydrogens_are_explicit: + molecule = Chem.AddHs(molecule) + + return molecule + + def from_smiles(self, smiles, hydrogens_are_explicit=True): """ It initializes an RDKit's Molecule object from a SMILES tag. Parameters ---------- smiles : str - The SMILES tag to construct the molecule structure with. + The SMILES tag to construct the molecule structure with + hydrogens_are_explicit : bool + Whether the SMILES tag has explicit information about + hydrogen atoms or not. Otherwise, they will be added when + the molecule is built. Default is True Returns ------- @@ -150,10 +174,14 @@ def from_smiles(self, smiles): """ from rdkit.Chem import AllChem as Chem - molecule = Chem.MolFromSmiles(smiles) + molecule = Chem.MolFromSmiles(smiles, sanitize=False) + + Chem.SanitizeMol(molecule, + Chem.SANITIZE_ALL ^ Chem.SANITIZE_ADJUSTHS ^ Chem.SANITIZE_SETAROMATICITY) # Add hydrogens to molecule - molecule = Chem.AddHs(molecule) + if not hydrogens_are_explicit: + molecule = Chem.AddHs(molecule) # Generate 3D coordinates Chem.EmbedMolecule(molecule) @@ -787,7 +815,7 @@ def is_available(): except ImportError: return False - def from_rdkit(self, molecule): + def from_rdkit(self, molecule, hydrogens_are_explicit=True): """ It initializes an OpenForceField's Molecule object from an RDKit molecule. @@ -796,6 +824,10 @@ def from_rdkit(self, molecule): ---------- molecule : an peleffy.topology.Molecule The peleffy's Molecule object + hydrogens_are_explicit : bool + Whether the SMILES tag has explicit information about + hydrogen atoms or not. Otherwise, they will be added when + the molecule is built. Default is True Returns ------- @@ -807,7 +839,8 @@ def from_rdkit(self, molecule): rdkit_molecule = molecule.rdkit_molecule return Molecule.from_rdkit( rdkit_molecule, - allow_undefined_stereo=molecule.allow_undefined_stereo) + allow_undefined_stereo=molecule.allow_undefined_stereo, + hydrogens_are_explicit=molecule.hydrogens_are_explicit) def get_forcefield(self, forcefield_name): """