diff --git a/docs/charge.rst b/docs/charge.rst index a3dd1c26..564662c7 100644 --- a/docs/charge.rst +++ b/docs/charge.rst @@ -18,3 +18,4 @@ Primary objects Am1bccCalculator GasteigerCalculator + OPLSChargeCalculator diff --git a/docs/examples.rst b/docs/examples.rst new file mode 100644 index 00000000..0ba645a3 --- /dev/null +++ b/docs/examples.rst @@ -0,0 +1,2 @@ +.. _examples :: +.. mdinclude:: ../examples/README.md diff --git a/docs/figures/PELE_templates_scheme.png b/docs/figures/PELE_templates_scheme.png new file mode 100644 index 00000000..8a94fe26 Binary files /dev/null and b/docs/figures/PELE_templates_scheme.png differ diff --git a/docs/figures/dual_representation.png b/docs/figures/dual_representation.png new file mode 100644 index 00000000..9aff32b9 Binary files /dev/null and b/docs/figures/dual_representation.png differ diff --git a/docs/index.rst b/docs/index.rst index 5ac02c15..d6e1e45e 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -14,6 +14,8 @@ User guide installation releasehistory + usage + examples API documentation diff --git a/docs/installation.rst b/docs/installation.rst index 058c948b..cc682a8d 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -81,3 +81,41 @@ installed and have to be installed manually such as: - AmberTools For this reason, the installation through `conda` is recommended. + + +External dependencies +===================== + +Some of the functionalities of `offpele` require external dependencies. +They are normally included with the standard `conda` installation, as +explained above. However, the Schrodinger toolkit must be installed +manually. It is only required when combining `Open Force Field` parameters +with `OPLS2005` (as it uses the Schrodinger's `ffld_server`). Nevertheless, +in case that Schrodinger dependencies are missing, `offpele` can still be +employed to generate pure `Open Force Field` parameters. + +The easiest way to get a valid Schrodinger installation is downloading +`Free Maestro `_. It can be +installed in both platforms that are supported by `offpele`: Linux and +MacOS. Once installed, `offpele` will need an environment variable to be +set in order to known the Schrodinger's installation path. So, please, +check that the following environment variable is set before running +`offpele` if you plant to work with `OPLS2005` parameters: + +.. code-block:: bash + + $ export SCHRODINGER=/path/to/Schrodinger/installation/ + +For example, in MacOS, a typical installation path is +`/opt/schrodinger/suites2020-2/`. Therefore: + +.. code-block:: bash + + $ export SCHRODINGER=/opt/schrodinger/suites2020-2/ + +This variable must be set every time `offpele` is employed to work with +`OPLS2005` parameters in a new console session. To avoid future concerns about +this issue, you can set the environment variable automatically every time you +initiate a bash session in your console. You can do so by modifying your +`.bashrc`, `.bash_profile` or `.zshrc` (in case of a `zsh` shell) by adding the +line above. diff --git a/docs/releasehistory.rst b/docs/releasehistory.rst index 8eb0d25d..d0e972e1 100644 --- a/docs/releasehistory.rst +++ b/docs/releasehistory.rst @@ -18,19 +18,23 @@ New features - `PR #28 `_: Adds a new method to define a `Molecule` object through a SMILES tag. This molecule can be written as a PDB file later for PELE. - `PR #31 `_: Adds the possibility to combine nonbonding and solvent parameters from OPLS2005 with bonding parameters from OFF. - `PR #36 `_: Minor changes to improve the quality of the code. -- `PR #37 `_: Adds a new partial charge calculator that uses OPLS2005 to assign partial charges. Includes new flags in the CLI from main.py to combine bonding and nonbonding parameters and partial charges from OPLS2005. +- `PR #38 `_: Adds a new partial charge calculator that uses OPLS2005 to assign partial charges. Includes new flags in the CLI from main.py to combine bonding and nonbonding parameters and partial charges from OPLS2005. +- `PR #42 `_: Improves the documentation, adding a section specific for CLI-usage and API examples. +- `PR #46 `_: Adds a tag to Molecule class. Besides, the handling of Molecule names is improved. Both attributes can be set when initiating the molecule. Bugfixes """""""" - `PR #22 `_: Fixes many bugs. For example, the default output name of the solvent parameters template is changed to `ligandParams.txt`, which is the name that PELE expects. - `PR #32 `_: Minor fixes in ToolkitWrapper classes. - `PR #34 `_: Improves the translation of dihedrals coming from the Open Force Fielf Toolkit and corrects the lack of exclusions in PELE 1-4 list that result from Impact's dihedral definitions. +- `PR #46 `_: Prevents molecule to be untagged when loading it from a SMILES tag. Tests added """"""""""" - `PR #31 `_: Adds tests to validate some functions of the new SchrodingerToolkitWrapper. - `PR #34 `_: Adds tests to further validate the assignment of parameters from the Open Force Field Toolkit. -- `PR #37 `_: Adds tests to validate the new OPLS charge calculator. +- `PR #38 `_: Adds tests to validate the new OPLS charge calculator. +- `PR #46 `_: Adds tests to validate the name and tag assignment to Molecule class. 0.2.1 diff --git a/docs/usage.rst b/docs/usage.rst new file mode 100644 index 00000000..e579ce18 --- /dev/null +++ b/docs/usage.rst @@ -0,0 +1,232 @@ +.. _installation :: + +Generate PELE parameter files +***************************** + +The main purpose of `offpele` is to build the parameter files for PELE. Basically, PELE requires two files for each non-standard residue found in the system: + +- `IMPACT template `_: a file containing the atom types and parameters of the ligand. Its job is to link each atom with the corresponding parameters using PDB atom names. Thus, PDB atom names in the input PDB file must match with the expected PDB atom names in the Impact file. This file intrinsically contains the information about the topology and connectivity of each residue. + +- `Rotamer library `_: a file containing the branches that can rotate with respect to a central atomic core. Each branch consists in a set of consecutive rotatable bonds. + +Besides, a third file with the `Solvent parameters` might be required when employing the OBC implicit solvent. + +.. image:: figures/PELE_templates_scheme.png + :width: 400 + :alt: Scheme with all the files that PELE requires to run a simulation + +The `Open Force Field Toolkit `_ is employed to assign the parameters to each atom according to its chemical environment. Besides, the PDB atom names are stored using `RDKit `_. With this dual molecular representation, `offpele` can run the parameterization workflow of Open Force Field while tracking the PDB atom names with RDKit. + +.. image:: figures/dual_representation.png + :width: 400 + :alt: Scheme with the dual molecular representation employed in offpele + + +Basic usage +=========== +The more straightforward way to install `offpele` along with the required dependencies is through the command-line interface built in `main.py `_ module. Therefore, the parameter files for a particular ligand can be obtained with: + +.. code-block:: bash + + $ python -m offpele.main my_ligand.pdb + +.. code-block:: + + ------------------------------------------------------------ + Open Force Field parameterizer for PELE v0.3.0 + ------------------------------------------------------------ + - General: + - Input PDB: my_ligand.pdb + - Output path: None + - Write solvent parameters: False + - DataLocal-like output: False + - Parameterization: + - Force field: openff_unconstrained-1.2.0.offxml + - Charges method: am1bcc + - Use OPLS nonbonding parameters: False + - Use OPLS bonds and angles: False + - Rotamer library: + - Resolution: 30 + - Exclude terminal rotamers: True + ------------------------------------------------------------ + - Loading molecule from RDKit + - Generating rotamer library + - Loading forcefield + - Computing partial charges with am1bcc + - All files were generated successfully + ------------------------------------------------------------ + +Command-line arguments +====================== +Almost all the important settings can be tuned up through command-line +arguments. To obtain the full list of flags you can type: + +.. code-block:: bash + + $ python -m offpele.main --help + +.. code-block:: + + usage: main.py [-h] [-f NAME] [-r INT] [-o PATH] [--with_solvent] + [--as_DataLocal] [-c NAME] [--include_terminal_rotamers] + [--use_OPLS_nonbonding_params] [--use_OPLS_bonds_and_angles] + PDB FILE + + positional arguments: + PDB FILE Path PDB file to parameterize + + optional arguments: + -h, --help show this help message and exit + -f NAME, --forcefield NAME + OpenForceField\'s forcefield name. Default is + openff_unconstrained-1.2.0.offxml + -r INT, --resolution INT + Rotamer library resolution in degrees. Default is 30 + -o PATH, --output PATH + Output path. Default is the current working directory + --with_solvent Generate solvent parameters for OBC + --as_DataLocal Output will be saved following PELE's DataLocal + hierarchy + -c NAME, --charges_method NAME + The name of the method to use to compute charges + --include_terminal_rotamers + Not exclude terminal rotamers when building the + rotamer library + --use_OPLS_nonbonding_params + Use OPLS to set the nonbonding parameters + --use_OPLS_bonds_and_angles + Use OPLS to set the parameters for bonds and angles + +Find below the complete list of command-line arguments in full detail. + +PDB file +-------- +It is a mandatory positional argument that points to the PDB file which +contains ligand to parameterize. + +- Flag: PDB FILE +- Type: string +- Example: the code below will run `offpele` to parameterize the ligand at `path/to/my_ligand.pdb` + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb + +Force field +----------- +It defines the Open Force Field force field to employ to parameterize the ligand. + +- Flag: -f NAME, --forcefield NAME +- Type: string +- Default: 'openff_unconstrained-1.2.0.offxml' +- Example: the code below will run offpele using the forcefield named as 'openff_unconstrained-1.0.0.offxml' + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb -f openff_unconstrained-1.0.0.offxml + +Rotamer library resolution +-------------------------- +It defines the resolution, in degrees, to use in the rotamer library. + +- Flag: -r INT, --resolution INT +- Type: int +- Default: 30 +- Example: the code below will run offpele using a resolution of 60 for the rotamer library + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb -r 60 + +Output path +----------- +It defines the output path where the resulting files will be saved. + +- Flag: -o PATH, --output PATH +- Type: string +- Default: '.', the current working directory +- Example: the code below will save the results into my_custom_folder/ + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb -o my_custom_folder + +Include solvent parameters +-------------------------- +It also generates the OBC solvent parameters and saves them into the output location. + +- Flag: --with_solvent +- Default: False, not include +- Example: the code below will generate and save the OBC solvent parameters + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb --with_solvent + +Save output as DataLocal +------------------------ +It saves the output files following the DataLocal hierarchy expected by PELE. + +- Flag: --as_DataLocal +- Default: False, not save output files as DataLocal +- Example: the code below will generate and save output files following the DataLocal hierarcy of PELE + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb --as_DataLocal + +Charges method +-------------- +It sets the method to compute the partial charges. + +- Flag: -c NAME, --charges_method NAME +- Type: string +- Choices: one of ['gasteiger', 'am1bcc', 'OPLS'] +- Default: 'am1bcc' +- Example: the code below will calculate partial charges using 'gasteiger' method + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb -c gasteiger + +Include terminal rotamers +------------------------- +It always includes terminal rotamers, even if they belong to a terminal methyl group whose rotation is trivial in PELE. + +- Flag: --include_terminal_rotamers +- Default: False, exclude terminal rotamers +- Example: the code below will generate a rotamer library including all terminal rotamers + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb --include_terminal_rotamers + +Parameterize non-bonding terms with OPLS2005 +-------------------------------------------- + .. warning:: + This option requires a valid Schrodinger installation with the ffld_server. An environment variable called `SCHRODINGER` must be set, pointing to the Schrodinger's installation path. + +It uses `OPLS2005` to parameterize the non-bonding terms of the ligand. It also assigns the atom types according to this force field. + +- Flag: --use_OPLS_nonbonding_param +- Default: False, exclude terminal rotamers +- Example: the code below will parameterize the non-bonding terms with OPLS2005 + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb --use_OPLS_nonbonding_param + +Parameterize bonding and angular terms with OPLS2005 +---------------------------------------------------- + .. warning:: + This option requires a valid Schrodinger installation with the ffld_server. An environment variable called `SCHRODINGER` must be set, pointing to the Schrodinger's installation path. + +It uses `OPLS2005` to parameterize the bonds and angle terms of the ligand. + +- Flag: --use_OPLS_bonds_and_angles +- Default: False, exclude terminal rotamers +- Example: the code below will parameterize the non-bonding, bonding and angular terms with OPLS2005 + + .. code-block:: bash + + $ python -m offpele.main path/to/my_ligand.pdb --use_OPLS_nonbonding_param --use_OPLS_bonds_and_angles diff --git a/examples/OFF_parameterization/ANI.pdb b/examples/OFF_parameterization/ANI.pdb new file mode 100644 index 00000000..276400bb --- /dev/null +++ b/examples/OFF_parameterization/ANI.pdb @@ -0,0 +1,26 @@ +HETATM 1 C1 UNL 1 2.707 0.165 -0.078 1.00 0.00 C +HETATM 2 O1 UNL 1 1.710 -0.820 -0.275 1.00 0.00 O +HETATM 3 C2 UNL 1 0.352 -0.469 -0.131 1.00 0.00 C +HETATM 4 C3 UNL 1 -0.647 -1.401 -0.315 1.00 0.00 C +HETATM 5 C4 UNL 1 -1.973 -1.045 -0.172 1.00 0.00 C +HETATM 6 C5 UNL 1 -2.345 0.254 0.161 1.00 0.00 C +HETATM 7 C6 UNL 1 -1.347 1.190 0.345 1.00 0.00 C +HETATM 8 C7 UNL 1 -0.016 0.821 0.198 1.00 0.00 C +HETATM 9 H1 UNL 1 3.654 -0.234 -0.494 1.00 0.00 H +HETATM 10 H2 UNL 1 2.497 1.105 -0.608 1.00 0.00 H +HETATM 11 H3 UNL 1 2.823 0.325 1.034 1.00 0.00 H +HETATM 12 H4 UNL 1 -0.383 -2.426 -0.576 1.00 0.00 H +HETATM 13 H5 UNL 1 -2.775 -1.768 -0.313 1.00 0.00 H +HETATM 14 H6 UNL 1 -3.399 0.508 0.268 1.00 0.00 H +HETATM 15 H7 UNL 1 -1.614 2.218 0.607 1.00 0.00 H +HETATM 16 H8 UNL 1 0.757 1.578 0.349 1.00 0.00 H +CONECT 1 2 9 10 11 +CONECT 2 3 +CONECT 3 4 4 8 +CONECT 4 5 12 +CONECT 5 6 6 13 +CONECT 6 7 14 +CONECT 7 8 8 15 +CONECT 8 16 +END + diff --git a/examples/OFF_parameterization/BNZ.pdb b/examples/OFF_parameterization/BNZ.pdb new file mode 100644 index 00000000..cdcfdcd0 --- /dev/null +++ b/examples/OFF_parameterization/BNZ.pdb @@ -0,0 +1,53 @@ +HEADER HYDROLASE 16-AUG-14 4W52 +REMARK 4 4W52 COMPLIES WITH FORMAT V. 3.30, +REMARK 888 +REMARK 888 WRITTEN BY MAESTRO (A PRODUCT OF SCHRODINGER, LLC) +TITLE T4 LYSOZYME L99A WITH BENZENE BOUND +EXPDTA X-RAY DIFFRACTION +REMARK 2 RESOLUTION. 1.50 ANGSTROMS +REMARK 3 R VALUE : 0.165000 +REMARK 3 FREE R VALUE : 0.182000 +REMARK 200 TEMPERATURE (KELVIN) : 100.00 +REMARK 200 PH : 7.50 +REMARK 350 BIOMOLECULE: 1 +REMARK 350 APPLY THE FOLLOWING TO CHAINS: A +REMARK 350 BIOMT1 1 1.000000 0.000000 0.000000 0.000000 +REMARK 350 BIOMT2 1 0.000000 1.000000 0.000000 0.000000 +REMARK 350 BIOMT3 1 0.000000 0.000000 1.000000 0.000000 +CRYST1 60.350 60.350 96.610 90.00 90.00 120.00 P 32 2 1 6 +HET BNZ L 1 12 +HETNAM BNZ BENZENE +FORMUL 1 BNZ C6 H6 +MODEL 1 +HETATM 1 C1 BNZ L 1 -32.969 6.196 2.877 0.70 15.06 C +HETATM 2 C2 BNZ L 1 -32.945 7.046 3.973 0.70 12.84 C +HETATM 3 C3 BNZ L 1 -33.719 6.798 5.113 0.70 12.24 C +HETATM 4 C4 BNZ L 1 -34.540 5.680 5.143 0.70 13.09 C +HETATM 5 C5 BNZ L 1 -34.545 4.825 4.044 0.70 12.54 C +HETATM 6 C6 BNZ L 1 -33.787 5.069 2.915 0.70 14.23 C +HETATM 7 H1 BNZ L 1 -32.360 6.413 2.012 1.00 0.00 H +HETATM 8 H2 BNZ L 1 -32.318 7.925 3.961 1.00 0.00 H +HETATM 9 H3 BNZ L 1 -33.672 7.473 5.955 1.00 0.00 H +HETATM 10 H4 BNZ L 1 -35.158 5.487 6.007 1.00 0.00 H +HETATM 11 H5 BNZ L 1 -35.156 3.935 4.055 1.00 0.00 H +HETATM 12 H6 BNZ L 1 -33.823 4.399 2.069 1.00 0.00 H +CONECT 1 2 6 7 +CONECT 1 2 +CONECT 2 1 3 8 +CONECT 2 1 +CONECT 3 2 4 9 +CONECT 3 4 +CONECT 4 3 5 10 +CONECT 4 3 +CONECT 5 4 6 11 +CONECT 5 6 +CONECT 6 1 5 12 +CONECT 6 5 +CONECT 7 1 +CONECT 8 2 +CONECT 9 3 +CONECT 10 4 +CONECT 11 5 +CONECT 12 6 +ENDMDL +END diff --git a/examples/OFF_parameterization/OLC.pdb b/examples/OFF_parameterization/OLC.pdb new file mode 100644 index 00000000..f6b63382 --- /dev/null +++ b/examples/OFF_parameterization/OLC.pdb @@ -0,0 +1,117 @@ +REMARK 4 COMPLIES WITH FORMAT V. 3.0, 1-DEC-2006 +REMARK 888 +REMARK 888 WRITTEN BY MAESTRO (A PRODUCT OF SCHRODINGER, LLC) +TITLE MRO_oleic - preprocessed +MODEL 1 +HETATM 1 C2 OLC L 1 4.148 7.353 -18.237 1.00 0.00 C +HETATM 2 C1 OLC L 1 2.819 7.913 -18.760 1.00 0.00 C +HETATM 3 C3 OLC L 1 4.336 5.840 -18.529 1.00 0.00 C +HETATM 4 O1 OLC L 1 1.997 8.332 -17.914 1.00 0.00 O +HETATM 5 O2 OLC L 1 2.619 7.886 -19.995 1.00 0.00 O1- +HETATM 6 C4 OLC L 1 3.226 4.913 -17.967 1.00 0.00 C +HETATM 7 C5 OLC L 1 3.428 3.426 -18.324 1.00 0.00 C +HETATM 8 C6 OLC L 1 2.293 2.492 -17.836 1.00 0.00 C +HETATM 9 C7 OLC L 1 2.536 1.015 -18.229 1.00 0.00 C +HETATM 10 C8 OLC L 1 1.783 -0.056 -17.392 1.00 0.00 C +HETATM 11 C9 OLC L 1 2.501 -1.407 -17.407 1.00 0.00 C +HETATM 12 C10 OLC L 1 2.074 -2.659 -17.133 1.00 0.00 C +HETATM 13 C11 OLC L 1 0.708 -3.141 -16.670 1.00 0.00 C +HETATM 14 C12 OLC L 1 -0.251 -3.573 -17.803 1.00 0.00 C +HETATM 15 C13 OLC L 1 -0.435 -2.432 -18.806 1.00 0.00 C +HETATM 16 C14 OLC L 1 -1.522 -2.562 -19.874 1.00 0.00 C +HETATM 17 C15 OLC L 1 -1.587 -1.234 -20.659 1.00 0.00 C +HETATM 18 C16 OLC L 1 -2.964 -0.881 -21.233 1.00 0.00 C +HETATM 19 C17 OLC L 1 -2.994 0.581 -21.715 1.00 0.00 C +HETATM 20 C18 OLC L 1 -4.370 1.021 -22.222 1.00 0.00 C +HETATM 21 H1 OLC L 1 4.953 7.921 -18.708 1.00 0.00 H +HETATM 22 H2 OLC L 1 4.242 7.560 -17.172 1.00 0.00 H +HETATM 23 H3 OLC L 1 4.417 5.705 -19.610 1.00 0.00 H +HETATM 24 H4 OLC L 1 5.305 5.541 -18.122 1.00 0.00 H +HETATM 25 H5 OLC L 1 3.168 5.041 -16.885 1.00 0.00 H +HETATM 26 H6 OLC L 1 2.260 5.241 -18.354 1.00 0.00 H +HETATM 27 H7 OLC L 1 3.528 3.341 -19.407 1.00 0.00 H +HETATM 28 H8 OLC L 1 4.382 3.100 -17.908 1.00 0.00 H +HETATM 29 H9 OLC L 1 2.207 2.594 -16.755 1.00 0.00 H +HETATM 30 H10 OLC L 1 1.338 2.828 -18.243 1.00 0.00 H +HETATM 31 H11 OLC L 1 2.303 0.878 -19.287 1.00 0.00 H +HETATM 32 H12 OLC L 1 3.609 0.837 -18.162 1.00 0.00 H +HETATM 33 H13 OLC L 1 1.694 0.260 -16.354 1.00 0.00 H +HETATM 34 H14 OLC L 1 0.765 -0.137 -17.754 1.00 0.00 H +HETATM 35 H15 OLC L 1 3.532 -1.332 -17.691 1.00 0.00 H +HETATM 36 H16 OLC L 1 2.801 -3.444 -17.245 1.00 0.00 H +HETATM 37 H17 OLC L 1 0.860 -3.979 -15.988 1.00 0.00 H +HETATM 38 H18 OLC L 1 0.249 -2.379 -16.052 1.00 0.00 H +HETATM 39 H19 OLC L 1 0.119 -4.466 -18.306 1.00 0.00 H +HETATM 40 H20 OLC L 1 -0.682 -1.556 -18.213 1.00 0.00 H +HETATM 41 H21 OLC L 1 -1.314 -3.400 -20.542 1.00 0.00 H +HETATM 42 H22 OLC L 1 -2.477 -2.781 -19.397 1.00 0.00 H +HETATM 43 H23 OLC L 1 -1.295 -0.409 -20.004 1.00 0.00 H +HETATM 44 H24 OLC L 1 -0.835 -1.239 -21.451 1.00 0.00 H +HETATM 45 H25 OLC L 1 -3.211 -1.562 -22.049 1.00 0.00 H +HETATM 46 H26 OLC L 1 -3.725 -1.022 -20.464 1.00 0.00 H +HETATM 47 H27 OLC L 1 -2.697 1.242 -20.897 1.00 0.00 H +HETATM 48 H28 OLC L 1 -2.249 0.727 -22.499 1.00 0.00 H +HETATM 49 H29 OLC L 1 -4.348 2.068 -22.528 1.00 0.00 H +HETATM 50 H30 OLC L 1 -4.680 0.430 -23.084 1.00 0.00 H +HETATM 51 H31 OLC L 1 -5.129 0.919 -21.446 1.00 0.00 H +HETATM 52 H32 OLC L 1 -1.213 -3.839 -17.365 1.00 0.00 H +HETATM 53 H33 OLC L 1 0.515 -2.220 -19.298 1.00 0.00 H +CONECT 1 2 3 21 22 +CONECT 2 1 4 5 +CONECT 2 4 +CONECT 3 1 6 23 24 +CONECT 4 2 +CONECT 4 2 +CONECT 5 2 +CONECT 6 3 7 25 26 +CONECT 7 6 8 27 28 +CONECT 8 7 9 29 30 +CONECT 9 8 10 31 32 +CONECT 10 9 11 33 34 +CONECT 11 10 12 35 +CONECT 11 12 +CONECT 12 11 13 36 +CONECT 12 11 +CONECT 13 12 14 37 38 +CONECT 14 13 15 39 52 +CONECT 15 14 16 40 53 +CONECT 16 15 17 41 42 +CONECT 17 16 18 43 44 +CONECT 18 17 19 45 46 +CONECT 19 18 20 47 48 +CONECT 20 19 49 50 51 +CONECT 21 1 +CONECT 22 1 +CONECT 23 3 +CONECT 24 3 +CONECT 25 6 +CONECT 26 6 +CONECT 27 7 +CONECT 28 7 +CONECT 29 8 +CONECT 30 8 +CONECT 31 9 +CONECT 32 9 +CONECT 33 10 +CONECT 34 10 +CONECT 35 11 +CONECT 36 12 +CONECT 37 13 +CONECT 38 13 +CONECT 39 14 +CONECT 40 15 +CONECT 41 16 +CONECT 42 16 +CONECT 43 17 +CONECT 44 17 +CONECT 45 18 +CONECT 46 18 +CONECT 47 19 +CONECT 48 19 +CONECT 49 20 +CONECT 50 20 +CONECT 51 20 +CONECT 52 14 +CONECT 53 15 +ENDMDL +END diff --git a/examples/OFF_parameterization/parameterize.ipynb b/examples/OFF_parameterization/parameterize.ipynb new file mode 100644 index 00000000..c1f1b935 --- /dev/null +++ b/examples/OFF_parameterization/parameterize.ipynb @@ -0,0 +1,482 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parameterization with the Open Force Field Toolkit\n", + "This notebook shows how to use the API of `offpele` to parameterize a molecule with a force field from the Open Force Field initiative. Then, it generates the three files that PELE requires:\n", + "- Rotamer library\n", + "- Impact template\n", + "- Solvent parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1: benzene\n", + "This example shows how to load and parameterize the benzene molecule with `offpele`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the required classes from `offpele`'s API" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from offpele.topology import Molecule, RotamerLibrary\n", + "from offpele.template import Impact\n", + "from offpele.solvent import OBC2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load `offpele`'s molecule representation with a PDB file of benzene" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading molecule from RDKit\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "03e469885263463d9085a59d899d0a6d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Generating rotamer library\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "molecule = Molecule('BNZ.pdb')\n", + "display(molecule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the Rotamer library file\n", + "The `RotamerLibrary` method handles the rotamer library generation. Here, we are generating it and saving it to a file named __BNZ.rot.assign__." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "rotamer_library = RotamerLibrary(molecule)\n", + "rotamer_library.to_file('BNZ.rot.assign')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameterize with Open Force Field Toolkit and generate the Impact template\n", + "Please, note that before generating the Impact template, we need to parameterize the molecule by calling the `Molecule.parameterize()` method.\n", + "Then, the Impact template, named __bnzz__, can be generated." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading forcefield\n", + " - Computing partial charges with am1bcc\n" + ] + } + ], + "source": [ + "molecule.parameterize('openff_unconstrained-1.2.0.offxml')\n", + "impact = Impact(molecule)\n", + "impact.write('bnzz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the Solvent parameters file\n", + "Please, note that before generating the Solvent parameters file, the molecule has to be previously parameterized. However, as we have already run the parameterization with `Molecule.parameterize()`, we can now skip this step because the molecule is already parameterized. Here, we generate the OBC2 Solvent parameters file, named __ligandParams.txt__." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading solvent parameters\n" + ] + } + ], + "source": [ + "solvent = OBC2(molecule)\n", + "solvent.to_json_file('ligandParams.txt')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2: oleic acid\n", + "This example shows how to load and parameterize the oleic acid molecule with `offpele` with some customized settings." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the required classes from `offpele`'s API" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from offpele.topology import Molecule, RotamerLibrary\n", + "from offpele.template import Impact\n", + "from offpele.solvent import OBC2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load `offpele`'s molecule representation with a PDB file of oleic acid" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading molecule from RDKit\n", + " - Generating rotamer library\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "molecule = Molecule('OLC.pdb', rotamer_resolution=60)\n", + "display(molecule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the Rotamer library file\n", + "We are generating the Rotamer library and saving it to a file named __OLC.rot.assign__. Please, note that in this case the employed rotamer resolution is 60 degrees because we set the __rotamer_resolution__ to __60__ when initializing the `Molecule` class." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "rotamer_library = RotamerLibrary(molecule)\n", + "rotamer_library.to_file('OLC.rot.assign')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameterize with Open Force Field Toolkit and generate the Impact template\n", + "Parameters from the __openff_unconstrained-1.2.0.offxml__ force field are assigned to the molecule. We can use another method to compute partial charges rather than the default one. Here, we are using the __gasteiger__ method. Then, the Impact template, named __olcz__, is generated." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading forcefield\n", + " - Computing partial charges with gasteiger\n" + ] + } + ], + "source": [ + "molecule.parameterize('openff_unconstrained-1.2.0.offxml',\n", + " charges_method='gasteiger')\n", + "impact = Impact(molecule)\n", + "impact.write('olcz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the Solvent parameters file\n", + "We generate the OBC2 Solvent parameters file, named __ligandParams.txt__." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading solvent parameters\n" + ] + } + ], + "source": [ + "solvent = OBC2(molecule)\n", + "solvent.to_json_file('ligandParams.txt')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3: anisole\n", + "This example shows how to load and parameterize the anisole molecule with `offpele` from a SMILES tag." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the required classes from `offpele`'s API" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from offpele.topology import Molecule, RotamerLibrary\n", + "from offpele.template import Impact\n", + "from offpele.solvent import OBC2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load `offpele`'s molecule representation with a PDB file of anisole" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Constructing molecule from a SMILES tag with RDKit\n", + " - Generating rotamer library\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "molecule = Molecule(smiles='COc1ccccc1')\n", + "display(molecule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Save PDB file for PELE\n", + "PELE still needs a PDB file to run a simulation. `offpele` can extract a PDB file with the structure of the molecule with PDB atom names correctly assigned." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "molecule.to_pdb_file('ANI.pdb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the Rotamer library file\n", + "We are generating the Rotamer library and saving it to a file named __ANI.rot.assign__." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "rotamer_library = RotamerLibrary(molecule)\n", + "rotamer_library.to_file('ANI.rot.assign')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameterize with Open Force Field Toolkit and generate the Impact template\n", + "Parameters from the __openff_unconstrained-1.2.0.offxml__ force field are assigned to the molecule. Then, the Impact template, named __aniz__, is generated." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading forcefield\n", + " - Computing partial charges with am1bcc\n" + ] + } + ], + "source": [ + "molecule.parameterize('openff_unconstrained-1.2.0.offxml')\n", + "impact = Impact(molecule)\n", + "impact.write('aniz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate the Solvent parameters file\n", + "We generate the OBC2 Solvent parameters file, named ligandParams.txt." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading solvent parameters\n" + ] + } + ], + "source": [ + "solvent = OBC2(molecule)\n", + "solvent.to_json_file('ligandParams.txt')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/OPLS_parameterization/parameterize.ipynb b/examples/OPLS_parameterization/parameterize.ipynb new file mode 100644 index 00000000..af79d3b5 --- /dev/null +++ b/examples/OPLS_parameterization/parameterize.ipynb @@ -0,0 +1,386 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parameterization with the Open Force Field Toolkit\n", + "This notebook shows how to use the API of `offpele` to combine the parameters from OPLS2005 and force fields from the Open Force Field initiative. There are several possible combinations that are displayed below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1: Open Force Field parameters with OPLS2005 charges\n", + "This example shows how to parameterize a molecule by combining the parameters from the Open Force Field initiative with OPLS2005 partial charges." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the required classes from `offpele`'s API" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from offpele.topology import Molecule\n", + "from offpele.template import Impact" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `offpele` requires the Schrodinger Toolkit to use the OPLS2005 parameters\n", + "To indicate the path to the Schrodinger's installation `offpele` needs the following environment variable to be set." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2020-2/'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load `offpele`'s molecule representation with a PDB file of anthracene" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Constructing molecule from a SMILES tag with RDKit\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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": "d41770c93cdb445b9020de31daf8bdce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Generating rotamer library\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "molecule = Molecule(smiles='c1ccc2cc3ccccc3cc2c1')\n", + "display(molecule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameterize with `Open Force Field Toolkit` and `ffld_server`, and generate the Impact template\n", + "Please, note that to use OPLS2005 partial charges from OPLS2005 we need to select the `OPLS` option in the `charges_method` parameter when calling the `Molecule.parameterize()` function.\n", + "Then, the Impact template, named __antz__, can be generated." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading forcefield\n", + " - Computing partial charges with OPLS\n" + ] + } + ], + "source": [ + "molecule.parameterize('openff_unconstrained-1.2.0.offxml',\n", + " charges_method='OPLS')\n", + "impact = Impact(molecule)\n", + "impact.write('antz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2: Open Force Field parameters with OPLS2005 non-bonding parameters\n", + "This example shows how to parameterize a molecule by combining the parameters from the Open Force Field initiative with OPLS2005 non-bonding terms. This combination of parameters allows PELE to use its SGB implicit solvent model (which requires OPLS2005 atom types to be assigned)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the required classes from `offpele`'s API" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from offpele.topology import Molecule\n", + "from offpele.template import Impact" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `offpele` requires the Schrodinger Toolkit to use the OPLS2005 parameters\n", + "To indicate the path to the Schrodinger's installation `offpele` needs the following environment variable to be set." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2020-2/'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load `offpele`'s molecule representation with a PDB file of aldicarb" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Constructing molecule from a SMILES tag with RDKit\n", + " - Generating rotamer library\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAACWCAIAAADCEh9HAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO2deVyTZ7r+r4RAwr4vIWyymgRFZbUgonXDutSttlqd2mlrW3vGTqftOTPnNz112pkuM9Nl2ukyta2jVttxV1xrFRQXVkVJAmGRNWEnEAhLtt8fbwgBQbaEJT7fD58275s3eZ6Aud5nue/rpmm1WhAIBAJhtNAnugMEAoEwtSEySiAQCGOCyCiBQCCMCSKjBAKBMCYYE90BAuEhQy5Hezvs7GBnN9FdIRgHIqMEwrjQ3o5r13D3LtradGccHRERgblzwWJNaM8IY4VGAp4IBJNTWorDh9HRMcBT9vbYuBEczrj3iWA0iIwSCCamogJ790Kt7nNSqwWNpnvMZOLZZ+HhMf5dIxgFIqMPB0olysrQ0ACNBo6O8PeHvf1E9+nhQKXC55+jpQXoK5398PTE9u2DPkuY3JC1UXNHrcbVq7h5E11dvSdpNPB4WLwYjo4T17OHg7w8nYYC+fX1r5w5k/rMM9RhUWPj1mPHbjz3HADU1qKwENOnT1AvCWOCBDyZNR0d+P57pKX10VAAWi0EAnz9NaqqJqhnDw0ikf5hW3d3jkSiP1QolVkGh4ZXEqYWREbNF60WP/2E6upBL+jowIED+rESwSTU1hr/SsIkg0zqzZdbt1BePsQ1HR04dw4bN45Lhx5KursNjzpVqm3Hj1OPm/pt3CuV49YpgnEho1HzJSOD+n9+XV3Snj3600WNjXN37+69rKAAMtn49uxhom+MPY1Gi+ZwqB9+v615W9tx7RjBeJDRqJkil6Oujno4xJIcgNJSzJkznr17iPD1RVOT/ohpYfFydDT1OK+m5sNr1/pcSZiakNGomWLw1TXyxYQRMWvWsC6j0YZ7JWHyQUajDwUPWpIjmJSAAISFobCQOqL1RIbWtLXVt7f3honOng139wnoHsEYkNGomeLsbHj0oCW5+y4mGJnVq6kMpTgfn9bf/x7A55mZ7L/97URhofKttwDA1xfLlk1sHwljgYxGzRQHB7i5oaGBOnrQkhyAwMBx7t3DhbU1tm1DSgoEAupEuIcHgEwqFs3aGlu2wNJyAjtIGCNkNGq+xMYO67LQUDIaNTksFtavxwsvIDoaQJS3twWdfrumpkulQkdH/3R7wlSDyKj5MmeOfvNXo9X+IyNDIpcDoNEMMreZTDKdHD/YbCxfDicnOysrrptbt1p9u6YGAKTSie4ZYUwQGTVf6HRs3AhLyzgfn8VBQTvPnj1RUABgpqenbkmOycRTT5Gh6HjD4QCI4XCgn9c/INOMMBUgMmrWqNVQKtu6uy+UlNBptNWGzhehodi+Hf7+E9e5hxUio2YH2WIya4RCAGeKijqUynn+/t729mCxsGQJpk2Dk9NEd+5hhcMBEOvjA72MEoOYKQ6RUbNGKARwRCgEsI7LBYDISMyePbGdetjx9gadPsPDw9bKqqixsVGhcAXQ2goHh4nuGWGUkEm9+dLWhqqqTpXqbHExDVhDySj1X8IEwmDAw8OCTp/t5aUFsqnEXDKvn8oQGTVfRCJoteeKi+VdXdEcjp+jIxwc4O090d0ikOVRc4PIqPkiEkE/o+fxAIDHI2UqJgVERs0LIqNmikKB8nKlWn26qAj6hVEyo58kGOwyZVACKpGAVEWbspAtpnGksRG5uSgrQ2srmEy4u4PLRXg46Ca4mRUUQKO5WFra3NExy8sryMUFtrbEim2y4O4OJjPAycnTzq62ra1MJgtwckJ9vfGLg2q1kEpRXY3ubjCZ4HDAZhu5CQKR0XFCo8Evv+DGjd4RR1sbGhtRUICrV7F2rfH/cVMzepEI+hk9l0tm9JMFGg1sNsrKor29U8TizOrqACcnVFcbWUYLC3Hxot5XQYeHB5YsQVCQMRt66CGTetOj1eLIEVy/PvCsraEBe/YYOXKwsxP37qk1mpOFhdDP6CkxJUwSTL08+ssv+PHH/hoKoK4O+/fjyhVjtvXQQ2TU9Ny8ScVvDkp3Nw4d6l+8cyyIxVCrU8vK6tvbw9zcuO7usLZ+KBKWVCp0dk50J4aHgYxmUDdRI8poRgbS0x90weXLuHXLaM099JBJvYnp7kZaGvUwv65u0DLlra3IyEBionEapaLuRSIAT/D5ADB9uklWYCcJCgVu3oRIpBt8WVrC3x9RUQgLm+ieDU7PLhMNyJVKVRoNo64OSqURHPPa2vDLL0Nfdv48pk+HtfVYmyOQ0ajJKSjQDzOHqImUl2ecFru7UVKi0WqPFxTgYZjRFxbis89w9WrvBFapRHExfvwRP/wweQenDg6wt3disYJdXRVKZX5dHTQa41g95eToi4w+qJphVxdu3zZCcwQioyZn+DO1pibjVOgsKoJKdb2yUiqXT3N2jvDyApOJadOM8M6TkMJC/PTToFpZXIy9eydv4WJqQGrE5VG5HGIxcnP1J4a4cxcXj6k5Qg9kUm9i2tsNj+6viaTRagHQqT30f/wDPj7g8xEePvpyuwZ59BuoQWhYGCwsRvluk5n2dhw/PkS4pVSKixeRnDxefRoJHA4KCmI4nP137mRWV78QGYmsLDg6juDv1dWF2lpUVqKiAlVVUCj0z2i02o4h7x/NzWPoPaEXIqMmhsk0PKJqIlGPq1pbTxcVXSgp2XL0aHJIyAYeb1lwsGVlJSorcf68Tk95PNjbj6A5lQrFxVqt9mi/UCez5Pp1ahz6oEVnANnZSEgY2a9xfLCzQ7/N+uZmHDoER0c89hhCQgZ4iUaD2lpUVEAigVSK+nrDJ6VyebZEkiOV5kgkN6qqts2atY7HI9UMxwEioybGy8vw6P6aSJfv3WtQKPbl5e3Ly3OzsXl8+vR1PN7CadOsDPU0LAxcLlxchm6uuBjd3VkSSUVLi4+DQ7S3NywtzTZIsKe00RBTV40GIhFiYsa5d0NQVYWzZwHM8vJiMhiCurrWri4H6qbb0oIDB/DYY4iKAoDmZlRUQCqFRAKJxLDiCPXBM6urM6qrM6urK1taDFsok8kw0J279wpilmgkiIyamOnTce4cNJrBnv9g8eKtERGHhMJDAoGwvn53bu7u3FwnFmtxUNCK0NB1XK4tpacXL4LDAZcLHm8Av3q1Gvn5EIlw7x56ZvTreTwajYbQUPMsl9bRAUo1hpNDOdmqdCgU+PFHdHcDYDIYMz09s6qrc6XSpICA3mtOn0ZuLhobqcso1BpNQUMDNd7MkUqzqqu7DVTVnsmc6ekZyWZHensn+vsHODndrKp6UDVDc72/jjtERk2MvT2iopCZSR0ZlkHS10Tie3jwPTzeTkoqbW4+VVh4SCi8XlFxSCA4JBC8mJLy6LRpG/j8NdOn21dXo7oaFy/C3R08Hvh8XWXz6mocPYqmJv0795nRGzremxP6bSUaDQMtOvfBiDG5RuHKFcNF81gOJ6u6OrO6uo+MQqf+Erk8p2eqnl5RITPYT2PQ6Tx390hv7wQ/v3hfX667O13/D2zIu4uVFXGeNRZERk3PokWoqEBNjb5MOQBotb01kQAEBaGmJhDYGRe3My6uTCY7UVBA6WmKWJwiFm9nMBYFBm7g81eHhTnW1yMtDWlpcHaGlxcVbK9v7XZNTXFTk6ed3VwfHwDIzwefb4ZpoDY2hkcPmroCkys6UqPpF9wWbbg8Csi7uvJqa3MkkmuVlVfLy2va2gwvZtvbR7LZCX5+8X5+kWy2teFUg06Hqyv8/NDZqV/xGPDODQCLF/f7HRJGDZFR02Npia1bcfgwSkt7T+r/PVtZYeVKhIdDq0VlJYRCCAQBPXpa2dJyVCRKEYtTy8ooPbWg0+N8fDbweE+Gh3tigM1Waka/lsu1oOLtCwtx/Tri48fhg44rTCZcXdHYqDt6wNQVutCi0dPUhNJStLaCwYCXFwIDwRj5F0cu161vlpT0i9Caw2YDuHTv3tZjxzKrq8UNDYYjSXdb2xgOR//j0u+WYGcHPz/4+YHNhre3rmNaLeztcfNmnzu3YTXDefN0C68EY0BkdFywtsbTT0MkQnY2Kip0g0dHR3C5mDtXVz2CRtN9H5YuRUUFRCKIRL49etqgUJwpKjokEJwvKblWUXGtouJ3Fy5QerqBz/c22IbW2ZEY7s5fvYqoqH4xA+bAzJm4fHnoyywtRx+r0NSEs2f7x1daWyMxEbGxQ4zxqWgkqRQVFSgv7xf6Rk3Vr1VWpldU5EqlAORdXfvy8gBYWljM9PSM9/WN9PaOZLN57u6Gg0jY2cHbWyeavr4DD7RpNCxdCh8fXLzYPxjZxQVLlkzq/K4pCJHR8YJGA48HHg8aDRQKWFnBymrQK/394e+PZctQXw+BAPn5bsDWiIitERFNHR0pYvEhgeBCj56+dv78XF/flaGh63k8lUYjqq93tbGZb7jK1tWF7Gw88shopvY1NaiqQlcXLC3h7Q0OZxKtD8TGIjsbcjl11NTRQY3U+kxdASQkjHJSX16OgwcHWFft6MD58ygrw4YNfQI8NRo0NqKiQrex3tBguEBZ196eWV2t/2k2WMCl02iOLFZLZ+daLvf/JSbO8PRkGGbuWlrCy6tXOqkF8eFABcxVVqK6Gu3tsLMDhwMfn0n0FzQXaFpiFjsloPRUKNSHCso6O08WFh4Vic4XF3eqVABogI+DQ2Vra3Jw8P516/rP/phMeHjovo0eHvDwGCLG+949XLiAmpo+J11c8Oijkyi1tLISe/ZAo/k8M/O35869NX/+H+fP73NBSAiefHI0fgLNzfj66yH2piIjMX++LvqdCuRUqfRPaiyUCkfpd+ck1yuqMqqqyvqOCjkODtQkPZbDifL2/uXevTU//hjp7Z39wgt9mli0CHFx5pk9YUYQGZ1qNDdDLIZAgMpK6kSHUnmxtPSQUHi8oEDe1WVrZdXe3Y2evQhqYsj38AjsFyZlYQEXF90Ax3BZjeL6dfz886B9iI3F0qWTZVDzySdoaUnasyetrOzg+vVPhof3PhUVhWXLRqlBBw9CLB7pi7psmttcKhSOEoWTtN1RoqWrnnvc7XZVAwA7K6sILy/Dv0ifF6pUXn/7m6yzs/C//ivU1VV31toar702mnVYwvhCZHTKUl0NymZCq6UUTVRfz/vnP5kMRiSbnVdb224QbwjAy85uDps9m82ew2bP9vKa1k9VqU1eSk87OvSuVIPy6KNISDDq5xkVtbX46qsGhYL9t79Z0Ol1b7zhQG09BQYiMhKenqN828ZGfP65/kjudq/eP0vuVmYj83apnuFaFaF/qpvVqnCubneqbneqUjhJ1Ra9o1ealm4t97yxJ5TW4hTD4fSJRhqIbceP77l9+08LFvQOqBctMsO9QXOE3OimLBwO7O0hl+tHhafEYgBP8Pl716xB33jDjOrqmra2M0VFZ3oigRyYzBk9odqRbPZ0NzeL+nrU1+POnWG1npqK8PCJT4PpKdun0miSQ0IcmEyw2eg3Lx4FBvFSGrqydM5hTsGjnIJHZR7iipmnmAqnDvu6VveSdqdqJUtu+Dpmh7NtM8emmWMr49i0sOkaS25gz3P6GxW1kSgQ9LtXPRkevuf27QN37+pkNDAQc+eO9YMQxgUio1OZmTNhENmjKwLasyvtbW/vHRa2smdP1lBVc6RSqVxO7VBRz9pZWYW5ufHc3SlhjfL2ZjEYD8pVV6uRnY1Fi8bpkw6GgbOqMS0BDXLVOxzqNBbdzlKuhdLa895cGuigodWjWOZZCMBCxbSWe9rI2HZNfnaN/pbddn3eh9pV9/ODr2//ZZOkJFha4tIlfYbbo4GBHra2BQ0Nd2prZ3p6IjranC1izQsio1OZRx7BrVuUr09Va2tWdbWdldWS+zP8HB2hUNyvqrlS6S2pNFcqvVVTUy6T5UgkORIJFXPDZDBWhYW9Nnfug3LVS0omWEYbG1FfL+vsTCsrs7Sw0H00o2RtGXgj2co41q1eggX/dKgNsW/0d62aaaG01tBUzhK+rYzDbHft80KqbBwlmj4+Q8S3x8cjLAw3bkAsRlsbg05fx+N9mZX1U37+TE9PiERmm4FmdhAZncrY2GD9euzfD43msFCoBZaHhFj3y6APC8PGjQDQ0ID6etTVQSpFZaU34G1vvyI0lLqqpbPzbl2dfrha0NBgOeRQaEibtfJyiESor4dSCQcHTJuG8HBjhq8KhQCOFxR0q9VLg4NdrK3h4QE3NyO8c1/5C725tcVDLHctl4Rdrphxmp+2w6EhSL8kDU9PBATolpXd3Ea28+bmhpUrASA3F6dObeTzv8zK+jE//92FC2kFBVCpyP7SlID8kaY406bB1hZyuW5GbzilpdEQG4vFi3VfbHd3XTI+hT6pRipFdbUjkODnl+Dnp3uyq0ve3V3R0vKgXPUHbE42N+PECZSX9zkpEODiRSxZYrRUbgNnVd2M3liWgN7e+octnoVKK4Vb5WxnKR/5ySXRP9UG3PQVLtP9Vh0d8eKLRmgxPBxnz87z9+c4OJQ2N2dJJDEcDvbuRWgoeLxhmXsRJg4io1OcmhrI5bVtbTeqqlgMRnJwMAB4eOi2qh8wNLO3h709ekajvaqak4O2Nnsm057JrGhpeVCu+v1GUxT19dizx9BCuJfOTpw8ieZmLFw4is/aB5kMNTXyrq6LpaUWdPpqav5rrIBWyhZLqQSgtlBKpl+y6nBwaAjU0jVauhqGw02q1NXYsbJCSAhdJHqCz//4xo0f8/NjOBxQ5l6XLiEiAsuWmWEemrlAZHSKIxIBOCoSqTWalaGh9tTanN6xePjoVdXGhvLBpBixzZpSiR9/HFhD9Vy9Ci+vsUqeUAjglFjcqVIlBQR42NrCxcVodd5ZLMTGUsU1XSR8haOkbNZxGuhamsa6xdNb3BOQZGVlzM10pRLAk+HhH9+4cbyg4KOlS3XntVrcvg2JBL/6FTETmZyQrcApjuFWtVG87mfOBIs19GUWFgN7W2RmUpZ9DyqmBuDChQd4sA6LnlAn6D+4cXOr5s+nLLe1dHWT7x3bFk5w1lMzftkZkvm0hbInPWzFCsrB3ghkZ1OZ+9He3vvWru2fywSgrg5HjgzLXJUw7hAZncrU16OhoVGhoLaqH6PKToxxe5fFwrJl+qM+NmswmM4mJg48qe+ppzaEI31LSx+/q5Eil6OqSqFUni8poQGPG3dGT8FgYNYsAK1upUqrtm5Wi3WLF03TM3uzsMCqVZgxwzhtdXXpSyIL6ut35+bqE3n73H5KS1FYaJwWCUaFyOhURiQCcLygQKXRLAoMdLa2hqcnXF2HfN0QRERQa5f9bda8vHQ2a1FRmDdvgBe2txu6Rw9BT8jqaBAKAZwtKmrv7p7r6+vj4AAnp371WoxAURGAZrYIgHNNj0YzGAgPx4svGtPzWCjUW+cNcfvJyTFaowTjQdZGpzImCj4HMG8e2GxcuNCvaBocHbFwIWbOHPhV8j4pPUM40tfVjb571Iy+31KGcXP8OztRVqalaVo8CwE4SbkAsGoVZs40vlFIv5CGB1+pD7QiTBqIjE5ZmptRW9vSyWxU/O98/wO6rWojFgENDkZQECQSVFWhrQ22tvDygr//g77DfUNWB9zlF9bXB7u4WFlYoLAQ332HhITeaIFh0t6Oioouleq0WAwTzegBFBZCrZa73VNZKazbPFhtbrC2RkSESTKLWlsNjx50+1Eq0dU1rMVrwjhCZHTKotuqDsusXvNoYKKbzV64uo7AjHI40GjgcEZgHe/srI8TwkC7/Eq1Onn//m61entU1G/j4hwrK3HwILy8EBeHmTOHO8gqKIBWe6GkpLWrK8rbO9DZGfb2Y/W3vx+hEIDMWwTASdIz4DVRdmbfGPshCqIQ07zJB1kbnbLogs+5ANZxhYDxYhhHDZ3+4KFlRUuLI4tV09a2KzU18NNP37p8ub69HTU1OH4c//wnbt0yLCo1KAMGJxh3ntvdjdJS0LRU4ryz1Kix/ffT9+ZH3X6on439/qZOTuZZ53WKQ2R0atLaColEobS8UBJEp2lXTy8ETPk9Hz4JCXpFu7+YWpCLy52XXrr67LMrQkObOjreSUvz/fjjrceOiRsb0diIkyfx8cdITe1XqqgPnZ0oK1Oq1acKCwGsMdGMXiyGStXmUqFkypntrtZyT7BYmDbNyK3oGX5JD1L8Y1JCZHRqIhQCSBGHKpSW8X6V3vZyk2xVjwIvLyQl4f5dfoMyqAl+fqc2bcp+4YUtEREqjWZfXh73889XHjiQRdW6SEvDxx/j3Ll+G1bQalFejjNnoNFcunevqaNjhqdnmJsbbGzg62vkTyESAWj2EkI/FA0NNeFsmrLO62HQWp4MBuLiTNUHwhgga6NTk0k4o9eTmAiNBleuDBwr7u6OoCDk5UV6e+9ds+at+fM/y8j4V04OVfc03s/vv+PjV4aFISMD2dng85GYCBcX3LqFtDT9Vkyf4ASjL1kqlSgqArQydgH0oU6mrpuyahW++QZdXQ+4/WDx4ok3eCUMBJHRKUhbG6qqOlWMs8UhNGjXcAuAyTGj15OUhJAQXLmC4uLebCUXF0RHIzoaFhZYuBC5ubhxIxj4NDn59/PmfZWd/cnNm9cqKlZVVMxhs3fGxW2eMcPizh3cvQs7O8ORqVqjOVFQAGA9JW1GHyQWF0OpbHeu7ma1WCmcbGRsWFkNnPlqRFxdsWULfvwRfavS66DR8OijiIkxbR8Io4XI6BREJIJWe644WN5lFcOp9nNsgYODoSnRpIDDwVNPQalEUxM0Gtja6upIU1haIjYW0dG4exfXrnkBbyclvTZ37ve3bn1w7VquVPqrY8f+lJb2XzEx26OiWHoN1WpBo12tqKhrbw91ddWVM8rMRGCgMRcNDWf0NVyAhpCQ8TCs43Dw0ku4cgW3b/eW0qPREBSEpCTjhyIQjAeR0SmILp2cC2AdTwSYYKvaWFhaPqggEp2OiAjMnImiIqSnO1RW7oyLezEq6ieB4N0rV4oaG189d+69q1dfjI5+NS7OicWiPiOVR7/ecJZ9+jSCgoyjdGo1VcmukVUFfdT9uFVCtbHBsmVYsgS1tejoAIMBDw8SJTr5IVtMUw2FAuXlSjX9dFEogLVcETCO33NTQKMhNBTPPott2xAaymQwtkZEFLzyysmnnory9q5tb9+Vmur/8cc7z56VyOVarfZ4QQH0oU7U8qtcTi0WG4HSUnR13ZJKZ62u+OR1XzuZLxgMUPaD4wadDjYbgYHw8yMaOiUgo9Gpg1qN8nLk5ECjuVga3NzBmuVVE+zSBFtb429VTwjUhnVTEzIz6dnZK8PCVoaFpVdUfJCeniIW/yMj4+ucnAUBAVWtrQFOTrOpsAT9GLykZNAU1REhFAI4LBQCcFSwoaUhOBhWVkZ4Z4L5QmR0KqDVIjsbaWlob6dOHBHxMPln9KPDxQXLliEhAZmZuHo1wc8v4amncmtqPrl588Ddu+eKiy3odKVG8+G1a+t5vCC9LbxAAAB8PoKDR79xr9FQM/qjprApGJDWVmRlQSxGYyO0Wjg5ITgY0dHGKYVCGC9InfpJj1qNI0eo9VDdCQ2N/ffX69tthDv+yXVvQHz8xFfoNAVqNd591/DEUaFww6FDdBpNpdEAoAExPj7ruNx1PF6g3rXP2hohIeDzERQ04k380lLs2yeoqwv/4gs3Gxvp668zGAy88YapZtY5OTh/3rB8ng46HYmJSEw0q7ujWUNGo5Oes2cNNZTi+9XH0yv8uO4NAHD9OoKCTJhjM1FYWMDJCTIZdaTRav96/bpGq30lJmZRYOAhofB4QUFGVVVGVdWbP//Mc3ffwOc/wefz3N1x5w7u3AGLhcBAhIaCyx3urNwgzXQNl8ug0xEUZCoNvXEDFy4M/JRGg9RUKBRITjZJ0wRjQ0ajk5uqKnz77dCXubhgxw4zLGt+5gyysqiH/8jI2Hn2rK+jo3DHDjsrKwCdKtXPJSWHhMKThYUtPfmjgc7OK0JDN/D5+vJ8VJkj8HgICRk0Ib2mBqWlSE2FUhnx5Zd3amvPPf300uBgrFplTF9RPRIJdu8e2sr+iScmVzgwYRDIaHRyk5FB/T9Xyn4p5bF3Fl5eElQCoKLFccvRNWnb9ugua2pCUZEZJlzHxSEnB2q1tK3trcuXAXyWnGzXM7RkWVhQ21BqjeZGVdUhgeAngaC0ufkfGRn/yMgIcHJaFRa2gc+P9/WlCQQQCMBgIDAQPB6mT+8tD1dTgzNnUFlJHRU1Nt6prXVisRZMmwY63VS/0suXKQ3Nr6t75cyZ1Gee0be+9dixG/pSWpcuYfp0MrWf/BAZndyUlFD/l3dZZVZzXkxZIXj5n9aWqk4VI1vi3f9K85NRKyvQ6dBoXjlzpqWzcy2Xu9qwRAqlLzSahYUFVR36o6VLKT09LBSWyWSUnvo6Oq6ZPn1lWFhSQABDLIZYDBoNPj7g88FiISUFKpX+LakZ/aqwMCsLC9DpAyxcjh2FQv9nHcLrvqEBNTVgs43fB4JRITI6ienqQkcHgG61Raea4efY4mLd8ae0+e8t+mWAi5ubx7t748C5c1CpzhYVHRWJ7JnMT+9fK2QysX49OByIxRAKLUpKKD39eNmy65WVKWLxYaGwpKmJ0lM3G5vkkJANPN6y4GBLqnbxffSpkadS4cABPP+8kVOYpNIRVKaTSIiMTn6IjE5SJBJcS6Wnn12WI/XOlbJfisqyoGu/WXky/rtfb55518piGL6cU52SEggECqVyx5kzAN5duNDH3r73WQYDfD4WLICjIwBERCAiAp2dVN03ukhE6en7ixYJ6uoOCYU/5ucXNjTsy8vbl5fnYm39WGjoBh5vaXCwlcFufmVLS45EYmdltUSfQV9Xh4wMxMcb83P1tQEcotTK/WcIkw8io5OFujpkZvb+NDcDsARiAdBp2nqFLYDZ7Jod0ZnbT634dvXJ/q8fsE7n1EWlwunTAP546dK95uYob+8dlKdJcjJsbGBnBzZ7gP0iFgs8Hng8rFiBe/cgEKCggO/hwffweCv2NQkAABjsSURBVDspidLTQwKBsL6e0lMnFmtxUNCK0NB1XK6tldVhoVALrAgNZRkOP7Oy8Mgjxlyg7Lv1P4TXfU+JUMJkhsjohKFQKHJzczMzMyWSoCNHVpeV9XmWw0FMDGJt82MscqK8JblSdnqFH4BdC1LDv3h5d+6c/m9naguicSY1Fc3Nd2prP8vMtKDTv1650oJOx9y5iIoa1sstLREaitBQqFQoLYVAgMJCQz09KhIdEYnyamoOCQSHBIJXzpxZHhJyu6YG+hk9dE4oaGmBTGbMuxSbDRpNP6+/v9RKn4snm+MMYSCIjBqN/Pz8V155JTU1lTosKiraunXrjRs39Beo1eqCgoKcHrKzs7u6ugDExq4pK1ttZ4eICERGIjISCQkIDAQAVDnh2zLDVmwslV8+lrJs/9M2lkoAVa0OzqwOWy97UEXqzYO6Oty4odFqt586pVSrX5s7dw6bDUdHzJ8/4rdiMHR6qtWishJCIfLzKT394/z5ZTLZiYKCQ0Lh9YqKn/LzLWg0GvBdbq5CqVwdFuaoHzZ+/71ukOvra4RhqY0NvL1RXT30la6uk8KKmzAUREaNRltbW45BGXGFQpGVlSWTyS5dupSRkZGZmZmTkyM38M1kMBizZ8+OjY195JFHv/12EPdhHx9ERSE72/Dc0uCSTTPuniicLqx3X7b/6RketSfOWDLMJmhUq0VKCjSazzMzb1ZV+To67lqwAACWLx9TGSIaTZezv3QpKitx4QKqqwOcnHbGxe2MiyuXyX53/vwRkYgGnC0uPltczGQwFgUGruNyV4WFuQLIyEBGBpycEBY2Vj1taUFTE4CLpaUsBmNQr3sAjz5Kop2mBERGTcudO3fWrVunP2Sz2ZGRkZGRkQkJCY888oiNjc3Qb5GcDIViPoSlOz/Vn/th3VEAJU3O3WqLM0Uhz7yNffvM5RuXk4PKSqlc3idQlM8fcR3mwaD0NCYGx47pz/k7OTV1dgL4csUKa0vLQwLB+ZKS02LxabHYgk6P8/HZwONt4PO90aOnDg7gchEaioCAkWU9qFT4z3/Q0XGuuHjFgQOJ/v7N//3f+if7eN1HR5PY+6kCkVFj0tnZuW3bNupxU1MTgMjIyOTk5Ojo6JiYmJiYGPdRFECm07F+PXJykJbWzxo9KMIu5T+KBU/Y/vAD/Pzwl78Y4zOMPxoNCgtRXAyZDGo1qqoA9AkUZTKxdKmRGw0OhoWFvhBpg0JxtbycyWA8GR7uyGJtjYho6uhIEYsPCQQXSkquVVRcq6h47fz5ub6+K0ND1/N4QejRUzs7cLngchEQMPB9rLUVIhFqatDdDXt7SCSQSIoaG586fFit0SwICLC4X4XpdMybN5oVDMIEQZJBjcbNmzcTExM/+eQT6rCqqurDDz9UGYR2jxWNBuXlqK2FUgkbG/j7Uz5Aly5h+XJ0deHjj/Hqq0ZrbZwoL8fJk9QkV8/ZoqLlP/xgz2QKd+zwcXDA8uXo2YQxJgaZpt/k5Lxw6tRjoaEpmzb1u0rW2flzSckpsfioSNTe3U2dpFL4N82YEerqqrvufkuU7m78/DNyc3vLqAAA5F1dc7/9VlBX9/j06Uc3bqTRaHB0RFsbNBo4OyMoCDExxOFpakFk1GjcvHlz8eLF+tXPvLy8yMhIY8ro4Bw8iKef1j144olxaNBICIU4cqSfygCY//33V8rLP01O/k1sLLy98dxzJlmw6OrC7t1oaACwbP/+88XF361eva1fBr2trd6csEOpvFhaSlmiyHuKfPSxRKGgLFECApCTg9rafm1qtdoNhw4dEQq57u43n3vOgRpok3qfUxwio0ZjAmUUwF//ijffhJUVUlKwePH4tDk2Ghrw9dcY6PfT3t39dU7OzthYCzodmzaZMAhBLsfBg7J79zz/+leNVit9/XU3w9XqqCgsX46WFhQWQiDQZz0NbYlCRUoNxB8vXXr3yhUXa+uM558PdnHBzJlYs8ZUn44wXpC1UWPSf9d1HDd93ngDNTX46COsX4/UVJPYEhmZn3+mNHQIe447d0woo/b2eO65k7t2davVi4OCdBpKo8HfHwkJulBcJyfExiI2Fi0tEAohErGqqoZridL3H8AxkejPV65Y0On7164NdnEBnT5F7niEISCjUfNBq8Uzz2DvXnh44Nq18S4gNDLa2vDRR1QI+s2qqsV798r/8Afqmbyamsh//Uul37Cm001onAwAWL169cmTJ7/65JPta9aAwYCra6//04AoFCgqglCoLx+t19NDQqG0Zzri5+j4uN4ShU4X1dfH7d7d2tX18bJlr+pn8StWIDLSdB+NMD6Q0aj5QKNh927U1uL8eSQnIz39QUU5J5jKyuHac2g0qK42XY5WW1vbzz//TKfTVz3xxHBNQGxsdCn8HR33W6Kkl5cfEYmOikQVLS3U+NTb3j45JORsUVFrV9eWiIhXDVdCS0qIjJoBREbNCktLHDqEpCTk5uKNN25/+WWIra3tRHdqIAzSEDCkPUffi41LSkpKR0dHYmIiexRGStbWvZYohYUQi+lFRYkBAYkBAZ8mJ1Mp/Afv3hU3Nn6bm8tiMBh0ulqjOVVY2GuJIhLhu+90If1m5orwMEFk1Nywt8fp09ixI3XfvgWNjcuPHz9uOZbkn+Ejk2HnTqSmQi7HjBnYtQtJSYNe3Nd6bgh7DuP61PXlyJEjAAxTJEYDi6XTU6USxcX4z38A6FP4c6XSZfv317e3Azhw9+6Bu3edra1Xhoau4/GWBAWxKMu+ixfh7g4eDzNmQB9ERZgiEBk1Q7y88OGHvteueZ45c2bbtm379u0bj82upCS4u+PYMbi44MABLF2KK1cQGzvwxR4ehkdD2HP0vdiIdHR0nD17lkajrTHWdrmlJbhcuLqisVF/juvm1tzRwaDT77z00oWSkkNC4bWKir15eXvz8mwsLRdOm7aBz18zfbp9fT3S0pCWptNTPh+jSNYgTARERs2ToKCglJSUBQsW/PDDD76+vu+9955p28vLQ14eKivh4wMAf/gDfvkFR48OKqMcDuzthzVbd3ExnZqcO3euvb09Li7O19fXmO/L5SI9XX+UV1ur0mgivLy47u5cd/edcXGGligpYnGKWLydwVgUGLiBz18dFuZoqKdcLni8gRe529tx+zbu3YNMBgsLeHjoFgfMxl1h6kBk1GyJioo6ceLE8uXL33//fU9Pz1eNm+HU3o7cXJ03am0tli5FVJROQynWrcMXX+CDDwZ+OY2GhAScPdtzNLg9x7x5pjMLMM6M/n5iY5GVhZ4Q/VtSKYDZBl5NekuUypaWoyJRilicWlZG6ak+hf/J8HBPAPX1uHJlAEuUjAz88kufGid1dcjPR1oa1qwh9nrjDAl4MnMOHjz49NNPa7Xaf//731u2bBn9G6nVKChATo7uJysLPZmRALBlCxQKHD7ce2b3buzaNWChDh1aLfbvR2npgxoNC8PGjSaS0a6uLk9Pz5aWluLi4iCjRwIIhTh8mIpGeOHUqW9ycnRJWXqsrGBlpTdJaFAozhQVUZYoSrUaQB9LFL3tP2WJ0tYGgWDQpi0tsXkz/P2N/IkIg0Nk1Pz561//+uabb1pZWaWkpCweSby3trKSlpGhG3Lm5PQxRrG0xIwZiI1FTAxiYnDmDN59F/X1vV52GzeipQXnzj2oge5uHD6MfhtKerhcrF1ruv2l06dPr1ixYs6cOYb2hsYkPx9Hj0KrjfrXv3IkkqvPPttb89ndHU8+CRcX1NdDIEB+vn4t1dASpVutBkCn0XotUVxchtW0jQ127MBw/MMIxoDI6EPB7373u48++sjBwSE1NXX24BlOcrk8Ly+PcpW+evXqP93dl/eYdwAAm63zlI6Px5w5fb6ldXUICsLrr+OPfwSdjsuXsXIljh7FkiVD9Eyrxd27uHkTUmnvSQ4HjzwCvQu9aXj22We///77P//5z3/oifw3Mkol3ntPqVI5vPdet1ot+5//sWcy4eaGqChERcGgBhQASKUQiSAU6vX0AZYoT4WHh7m5DZH9NXfu0L98gpEgMvpQoNVqn3nmmb1797q7u1+7di2kJ71SqVTm5eVl9lBYWKgxMAr58/LlfwAQHa0bcj7YdujKFWzZgoYG2NmhsxNffIHNm/Hll7Cywq9/PXQX29t1Pk+uruMwjFKpVGw2u6GhQSQSTTcs2mxEKivx3Xe3a2pmf/VVmJtbwSuvwMEBv/3tEK9qboZYbJjC39bdfVosPiISnSkq0uvpbDb7/+bPf/ro0UGzv2xs8Prr5uJBO9khW0wPBffu3fvVr35VU1Nz4cKFJUuWvPnmm4WFhZmZmbdu3eo0KFTJYrHmzJkT08PIVgwTE1FejvJydHYiJAR0OrKz8fLLYDDg7o5Vq4Z4ua0txjFT4PLlyw0NDXw+31QaClDj61ypFMAcKrZ/OBH+zs66FH6ZjLJEsaus3BgevjE83NASpbKlxe3BNxuFAk1NJAR1fCAy+lDw9ddff/jhh6+99lpDQ0NJScnLL7+sfyowMDA+Pp7y5I+OjmY+OJ18SAx3NqKi8PbbePttPPkkLlxAQsKY3tmoUHv069evN2EbNTXot00/okQpQ0uUggKIxayyMsoSpUulEjc2tiuVQ2R/tbcTGR0fiIw+FFCqsXbt2jfffLOsrOz999/ncrl2dnbPP//8aAz5h8///R8aG/HZZ1ixAleuYOZME7Y1bDQazcmTJ2GKUCdDRjcavR9HR52eKhQ4cQJiMZPBmOHpebOqaojsLyurMfWfMGxIpK75c+vWrZKSEi8vr7lz53p6esbGxh47dszNze1///d/X3/9dZM3/8knWLcOLS1YvhwVFSZvbhikp6dLpdKQkJAZM2aYqg21GvX1Gq32Tm0tgNljkVE9Njbo22Eq+4v62cjn97mYwSAW+uMGkVHzRz8UpRvktxw+fBjAqiGXLMcOnY79+zFvHqqrsXw5mptN3uJQmCrq3pC6OqjVhQ0Nbd3dAU5OLtbWsLWFPvxz1AQHD7c8akiISb0ICIYQGTV/jh49ir6qUV1dnZGRYWNjs2zZsvHoAYuFU6cQEQGBAMuXQ6EYj0YBAPcHomi12mPHjmGqzOj7wWIZVhwZNPuLRkNiohGaIwwPIqNmjlAoFIlEbm5uiQbfq2PHjmk0muTk5PGz0XN0REoKfH1x82bd6x/2VOQ0Pu3t7enp6Z9++unWrVv5fP63337b74KMjIzKykpfX99Ikxp9SqUAbtXUwFgzej2JieBwAMT5+LT+/vf6032KMy9cCIPcU4KpIcN+M4eavD/++OMMgyneeMxq78fHB+fOVfzmbxHf/89TwBdfGOddVSpVfn6+PvRVKBSqDUT61q1b/a6nPvuGDRtM63p1/2jUWLrGYODpp3H4MEpKBniWTsfChYiPN05bhOFBZNTMuV8xGxoa0tPTmUzmY489Nt694fGkf/5O+Si+/BJsNv74x1G+jUSiy+y/dg1yuTwjozcvi8Fg8Hi8yMjIhISE+Ph4Lpfb77XjMaPXalFXp9Vqb9fUwLiTegoWC5s3QyBAZiaqqnR1BJhMhIUhPt50voKEwSAyas6UlpbeuXPHyclp4cKF+pNHjx5VqVTJyckODg7j36XYWPz4I9aswVtvwcUFO3YM61UymS6zX28ppcfW1nn6dF5UlC5rYNasWQ8Ifc3NzaWCFuJMWtO4vh5K5T2ZrLmjw9POzsvODkwmnJyM2QSNhvBwhIdDpYJcDgsL2NuTnKWJgsioOXPo0CEAq1atsjIIIZyYGb0BK1bgiy/wwgvYuRNsNtauHfols2ejrKz30MNDl55K/Tg7D2531Bf9Z6eb1JTTYEYfRXnWsdmm0jgGg1QfmXCIjJoz9yumTCZLTU21tLRcuXLlxPULzz8PiQRvv42nnx5WflNSEoqKdKIZG4tp00bWnFqtFggEmZmZ33zzDcbhFmKQv2T8GT1h8kFk1GyprKzMzs62s7MzNMc7fvx4d3f30qVLXYZpuWYyRpTf9P33I35/iUSS00N6erpMJgPAYDBYLFaboeOfKTAYjY4mDZQw1SAyarZYnj37TXy8MCTE2tpaf3LCZ/SGfPIJJBIcOYLly3H9OvRunKOjpaUlKysrIyOD2rKvqakxfDY4ODgmJqatre3kyZO//vWv796962mi8tNaLTUavW0Y7UTCj8waIqNmi9fevb++dg07d+rPyOXyixcvWlhYrF69egI7pofKb6qrQ0PDaF6uVOL2bd2mk0CQlJt7xTDY3s3NLcYAV1dXABqNZvHixZcuXdq+ffvxHlMPI9PcjK6u6tbWmrY2Z2trf0dHWFqSvEzzhsiomVJTgxs3YG2N5GT9OdWFC/tiYi67uHhMmpgYFgsnTkCrxTDXGKhQp2vXkJ6O3FzoXY1mzZrNYFyfOXOm3q2Kx+PdHxlKp9P//e9/R0REnDhx4ttvv/31cIxQR0pZGXpm9JFsNo1Gg5cX2UM3b4iMmilHjkCjwbJlhiaezgcOrL9yZf3nn09gv+6H2mfOzcVLL+Gdd3SW7RUV2LIFaWmor+8T6kQ5O1PQ6eDxdPtOc+f+D5//oeUw8s19fHw+++yzzZs379y5c968eaGhoUb7JKWlSEuj7Ff65C+ROsnmDpFRM+XIEQAwXANVKHD+PGg0TI4ZfT/kcmRm4sUXIRDA2hqdncjOxvPPY/fuPpd5e/fu10dFwSDydQQLnZs2bUpJSTl48ODmzZuvX78+HPEdAq0WFy7g5k39iT42o4WFeOQRYv1pxpCcenOkoQFXr4LJxIoVvSfPnkV7O+bO7VMGeTLh5wcXF/zpT71n/P1hZ4f4ePzmN/j3v5Gfj+pqHDuG3/8eCxdiLNkDX3zxhZ+fX3Z29vvvvz/2nuOXXww1FMDioKA1XK7ODLS9HXv3or3dCA0RJiWkFpM5sns3nn8ejz2GlJTek5s24eBB/P3veO21ievZoKSlYds2HDmC+HhkZsLKCrNno74eTGb/4m/G4sqVKwsWLKDT6enp6bGGpY9HSnV1/zHzgISHY3IESBCMDhmNmiP3z+i7unD6NAA8/vjEdGl4zJ6NHTuwfTuowno2NqbSUACJiYmvvvqqSqXavHnzmCJJ09Op/+fX1SXt2aM/XdTYONdQXgWCyeC1SjAFREbNDpkMly6BwYBhntKFC2htRVQUAgMnrmfDYtcuSKXDGt6Nnb/85S8zZ84sKSl54403RvkWajWKi6mHbd3dORKJ/hmFUpllcAitFmLx6PtKmMQQGTU7Tp5EdzeSkvrEKt4/Pp2s2Njgyy/x97+PR1tMJvPAgQMsFuurr75KMVwAGT4yGVSq4V48uvhYwqSH7NSbHfcrplKJU6cAYM2aienSCFm6FJs24cSJ8WiLz+e/8847b7zxxrPPPjua1Ka+BtRDlOocvuASphRkNGpetLXh559Bp/eJarp8GU1NmDEDYWET17MhmD8fpaW9hz/8AFMnvut57bXXFi5cWF9fv3379hG/uG95JapUJ/XDvz/HYey1mAiTEiKj5sXp0+joQEJCHy+MqTOjnxDodPrevXtdXFxOnDixe6SLstbWhjbJDyrVCcDff8ydJUxGiIyaFzEx2LULL7/ce0atBjXNJDI6OBwO57PPPgPw6quvike6ETRnzrAuc3ae/Pt7hNFBZNS8mDYNb72FjRt7z1y9iro6hIYiPHziujUF2LRp01NPPdXe3r5582alUjmCV0ZF6Qekg5bqBJCcTDLrzRUSfm/u1NbiwAHY2+O55ya6K5MdmUwWERFRUVGxa9eut/RVNodDczP27EFr66AXLFpEysyZMURGzQuZDDt3IjUVcjlmzMCuXUhKmug+TSWuXr2alJQ0mtSmtjacPo2Cgv7n7e2xbBl4PCN2kjDZIDJqXsyaBXd3fPABXFxw4AB27cKVKxhLpuPDx+9+97uPPvooKCjo9u3bdnZ2I3txbS1EIqqkHRwcEBCA6dPBIGGFZg6RUTMiLw+zZqGystd85NFHERWFDz6Y0G5NMbq6umJiYu7cufPiiy9++eWXE90dwhSAbDGZEWfOICqqj4HTunW6VHrCsDFCahPhIYPIqBlRVtY/MtHKCi0tE9SbKQyfz3/33XfRU7qKQHgwZNXGjAgNxTvvQKmE3of4559xfxA4YRj89re/nTZt2popkj5LmFjIaNSM2LIFajX+8hedzdzlyzh9enK6i05+6HR6aGjoggUL9GeKiormzp07gV0iTFqIjJoRHh44fRrffQd7e3h64vHH8fXXutpGhJHT1taWk5OjP1QoFFlZWRPYH8KkhUzqzYvERJSXo7wcnZ0ICQGd3CYJBJNDZNQcIRYYRqKzs3Pbtm3U4ybDqqQEggFERgmEQaHRaNHR0dTjqqqq0yR6jDAQJPyeQBiYmzdvLl68WC6XU4d5eXmRkZEqYr1MuA+ydkYgEAhjgsgogTAo/Y3viNMdYSDIpJ5AIBDGBBmNEggEwpggMkogEAhjgsgogUAgjAkiowQCgTAmiIwSCATCmCAySiAQCGPi/wMtrmcVKy7cwgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "molecule = Molecule(smiles='CC(C)(/C=N\\OC(=O)NC)SC')\n", + "display(molecule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameterize with `Open Force Field Toolkit` and `ffld_server`, and generate the Impact template\n", + "To work with OPLS2005 non-bonding parameters, we need to call `Molecule.parameterize()` with an extra parameter, `use_OPLS_nonbonding_params`, set to `True`. Then, the Impact template, named __aldz__, can be generated." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading forcefield\n", + " - Computing partial charges with am1bcc\n" + ] + } + ], + "source": [ + "molecule.parameterize('openff_unconstrained-1.2.0.offxml',\n", + " use_OPLS_nonbonding_params=True)\n", + "impact = Impact(molecule)\n", + "impact.write('antz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3: OPLS2005 non-bonding parameters and bond and angle terms with Open Force Field torsions\n", + "This example shows how to parameterize a molecule by combining the parameters from the OPLS2005 with dihedrals from the Open Force Field initiative. This combination of parameters also allows PELE to use its SGB implicit solvent model (which requires OPLS2005 atom types to be assigned)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the required classes from `offpele`'s API" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from offpele.topology import Molecule\n", + "from offpele.template import Impact" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `offpele` requires the Schrodinger Toolkit to use the OPLS2005 parameters\n", + "To indicate the path to the Schrodinger's installation `offpele` needs the following environment variable to be set." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['SCHRODINGER'] = '/opt/schrodinger/suites2020-2/'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load `offpele`'s molecule representation with a PDB file of diazinon" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Constructing molecule from a SMILES tag with RDKit\n", + " - Generating rotamer library\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "molecule = Molecule(smiles='CCOP(=S)(OCC)Oc1cc(nc(n1)C(C)C)C')\n", + "display(molecule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameterize with `Open Force Field Toolkit` and `ffld_server`, and generate the Impact template\n", + "To work with OPLS2005 non-bonding parameters, we need to call `Molecule.parameterize()` with two extra parameters, `use_OPLS_nonbonding_params` and `use_OPLS_bonds_and_angles`, both set to `True`. Then, the Impact template, named __diaz__, can be generated." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Loading forcefield\n", + " - Computing partial charges with am1bcc\n" + ] + } + ], + "source": [ + "molecule.parameterize('openff_unconstrained-1.2.0.offxml',\n", + " use_OPLS_nonbonding_params=True,\n", + " use_OPLS_bonds_and_angles=True)\n", + "impact = Impact(molecule)\n", + "impact.write('diaz')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 00000000..ab06ccb9 --- /dev/null +++ b/examples/README.md @@ -0,0 +1,10 @@ +# Examples + +The following examples are available in the [offpele repository](https://github.com/martimunicoy/offpele/tree/master/examples): + +## Summary +- [molecular_representations](https://github.com/martimunicoy/offpele/tree/master/examples/molecular_representations): it shows and compares the different methods that can be used to represent molecules in `offpele`. +- [OFF_parameterization](https://github.com/martimunicoy/offpele/tree/master/examples/OFF_parameterization): it shows how to use `offpele` to assign parameters with the `Open Force Field Toolkit`. +- [OPLS_parameterization](https://github.com/martimunicoy/offpele/tree/master/examples/OPLS_parameterization): it shows how to use `offpele` to combine parameters from Schrodinger's `OPLS2005` force field with the ones from the `Open Force Field Toolkit`. + +[//]: # (include rotamer examples) diff --git a/offpele/examples/Molecule.ipynb b/examples/molecular_representations/PDB-SMILES_comparison.ipynb similarity index 97% rename from offpele/examples/Molecule.ipynb rename to examples/molecular_representations/PDB-SMILES_comparison.ipynb index 6109a13d..f8d6c5a0 100644 --- a/offpele/examples/Molecule.ipynb +++ b/examples/molecular_representations/PDB-SMILES_comparison.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Molecule definitions\n", + "# Molecular representations\n", "This notebook shows the two available methods that can be used to define a molecule object in `offpele`. It can accept either a PDB file or a SMILES tag." ] }, @@ -46,23 +46,23 @@ "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - " - Loading molecule from RDKit\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" ] }, { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "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" + " - Loading molecule from RDKit\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "640c0e21cd1c4a7088cd0c8a0735cc27", + "model_id": "468b8abf0d1a48f286b975a02b836141", "version_major": 2, "version_minor": 0 }, @@ -82,19 +82,16 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 3, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "m = Molecule(AMMONIUM_PDB)\n", - "m2 = copy(m.rdkit_molecule)\n", - "AllChem.Compute2DCoords(m2)\n", - "m2" + "display(m)" ] }, { @@ -114,19 +111,16 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 4, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "m = Molecule(smiles='[NH4+]')\n", - "m2 = copy(m.rdkit_molecule)\n", - "AllChem.Compute2DCoords(m2)\n", - "m2" + "display(m)" ] }, { @@ -153,19 +147,16 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 5, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "m = Molecule(MALONATE_PDB)\n", - "m2 = copy(m.rdkit_molecule)\n", - "AllChem.Compute2DCoords(m2)\n", - "m2" + "display(m)" ] }, { @@ -185,19 +176,16 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 6, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "m = Molecule(smiles='O=C([O-])CC(O)=O')\n", - "m2 = copy(m.rdkit_molecule)\n", - "AllChem.Compute2DCoords(m2)\n", - "m2" + "display(m)" ] }, { @@ -224,19 +212,16 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 7, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "m = Molecule(TRIMETHYLGLYCINE_PDB)\n", - "m2 = copy(m.rdkit_molecule)\n", - "AllChem.Compute2DCoords(m2)\n", - "m2" + "display(m)" ] }, { @@ -256,19 +241,16 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 8, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ "m = Molecule(smiles='C[N+](C)(C)CC(=O)[O-]')\n", - "m2 = copy(m.rdkit_molecule)\n", - "AllChem.Compute2DCoords(m2)\n", - "m2" + "display(m)" ] } ], diff --git a/offpele/examples/Parameterize.ipynb b/offpele/examples/Parameterize.ipynb deleted file mode 100644 index 2ff1273b..00000000 --- a/offpele/examples/Parameterize.ipynb +++ /dev/null @@ -1,237 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from offpele.topology import Molecule, RotamerLibrary\n", - "from offpele.template import Impact\n", - "from offpele.solvent import OBC2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "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" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " - Loading molecule from RDKit\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6611b69506ef4041b8db2a94d1575718", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " - Generating rotamer library\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "097ca2c09122475abd7c336b65412aef", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "NGLWidget()" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " - Loading forcefield\n", - " - Computing partial charges with am1bcc\n" - ] - } - ], - "source": [ - "NAME = 'BNZ'\n", - "EXTENSION = '.pdb'\n", - "FORCEFIELD = 'openff_unconstrained-1.1.1.offxml'\n", - "CHARGES_METHOD = 'am1bcc'\n", - "\n", - "# Load molecule\n", - "molecule = Molecule('../data/ligands/' + NAME.upper() + EXTENSION,\n", - " rotamer_resolution=30)\n", - "display(molecule.off_molecule)\n", - "\n", - "# Generate its rotamer library\n", - "rotamer_library = RotamerLibrary(molecule)\n", - "rotamer_library.to_file('../data/templates/' + NAME.upper() + '.rot.assign')\n", - "\n", - "# Generate its parameters and template file\n", - "molecule.parameterize(FORCEFIELD, charges_method=CHARGES_METHOD)\n", - "impact = Impact(molecule)\n", - "impact.write('../data/templates/' + NAME.lower() + 'z')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " - Loading molecule from RDKit\n", - " - Generating rotamer library\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "96d4741edabc48899e798d00ce079009", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "NGLWidget()" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " - Loading forcefield\n", - " - Computing partial charges with gasteiger\n" - ] - } - ], - "source": [ - "NAME = 'OLC'\n", - "EXTENSION = '.pdb'\n", - "FORCEFIELD = 'openff_unconstrained-1.1.1.offxml' \n", - "CHARGES_METHOD = 'gasteiger'\n", - "\n", - "# Load molecule\n", - "molecule = Molecule('../data/ligands/' + NAME.upper() + EXTENSION,\n", - " rotamer_resolution=30)\n", - "display(molecule.off_molecule)\n", - "\n", - "# Generate its rotamer library\n", - "rotamer_library = RotamerLibrary(molecule)\n", - "rotamer_library.to_file('../data/templates/' + NAME.upper() + '.rot.assign')\n", - "\n", - "# Generate its parameters and template file\n", - "molecule.parameterize(FORCEFIELD, charges_method=CHARGES_METHOD)\n", - "impact = Impact(molecule)\n", - "impact.write('../data/templates/' + NAME.lower() + 'z')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " - Loading molecule from RDKit\n", - " - Generating rotamer library\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "abe2a90957b94339ab25c332d2ef0030", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "NGLWidget()" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " - Loading forcefield\n", - " - Computing partial charges with am1bcc\n", - " - Loading solvent parameters\n" - ] - } - ], - "source": [ - "NAME = 'TOL'\n", - "EXTENSION = '.pdb'\n", - "FORCEFIELD = 'openff_unconstrained-1.1.1.offxml'\n", - "CHARGES_METHOD = 'am1bcc'\n", - "\n", - "# Load molecule\n", - "molecule = Molecule('../data/ligands/' + NAME.upper() + EXTENSION,\n", - " rotamer_resolution=30)\n", - "display(molecule.off_molecule)\n", - "\n", - "# Generate its rotamer library\n", - "rotamer_library = RotamerLibrary(molecule)\n", - "rotamer_library.to_file('../data/templates/' + NAME.upper() + '.rot.assign')\n", - "\n", - "# Generate its parameters and template file\n", - "molecule.parameterize(FORCEFIELD, charges_method=CHARGES_METHOD)\n", - "impact = Impact(molecule)\n", - "impact.write('../data/templates/' + NAME.lower() + 'z')\n", - "\n", - "# Generate its solvent parameters\n", - "solvent = OBC2(molecule)\n", - "solvent.to_json_file('ligandParams.txt')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.8" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/offpele/main.py b/offpele/main.py index 177a8ed4..2b42b9e5 100644 --- a/offpele/main.py +++ b/offpele/main.py @@ -187,11 +187,11 @@ def run_offpele(pdb_file, forcefield=DEFAULT_OFF_FORCEFIELD, print(' - DataLocal-like output:', as_datalocal) print(' - Parameterization:') print(' - Force field:', forcefield) - print(' - Rotamer library resolution:', resolution) print(' - Charges method:', charges_method) print(' - Use OPLS nonbonding parameters:', use_OPLS_nb_params) print(' - Use OPLS bonds and angles:', use_OPLS_bonds_and_angles) print(' - Rotamer library:') + print(' - Resolution:', resolution) print(' - Exclude terminal rotamers:', exclude_terminal_rotamers) print('-' * 60) diff --git a/offpele/template/impact.py b/offpele/template/impact.py index 60d91f57..72b7f223 100644 --- a/offpele/template/impact.py +++ b/offpele/template/impact.py @@ -148,7 +148,7 @@ def _write_resx(self, file): File to write to """ # template name - file.write('{:5}'.format(self.molecule.name)) + file.write('{:5}'.format(self.molecule.tag)) # number of non bonding parameters file.write('{:6d}'.format(len(self.molecule.atoms))) # number of bond parameters diff --git a/offpele/tests/test_molecule.py b/offpele/tests/test_molecule.py index f65ae8aa..c56a57b2 100644 --- a/offpele/tests/test_molecule.py +++ b/offpele/tests/test_molecule.py @@ -54,3 +54,60 @@ def test_good_init_parameterization(self): molecule = Molecule(ligand_path) molecule.parameterize(FORCEFIELD_NAME) + + def test_molecule_name_assignment(self): + """ + It tests the molecule name assignment. + """ + # Look for an empty name when dummy Molecule is loaded + molecule = Molecule() + assert molecule.name == '', 'Unexpected atom name' + + # Look for the PDB name when a Molecule is loaded from a PDB file + ligand_path = get_data_file_path('ligands/BNZ.pdb') + molecule = Molecule(ligand_path) + assert molecule.name == 'BNZ', 'Unexpected atom name' + + # Look for benzene name when a Molecule is loaded from a PDB file + # with a custom name + ligand_path = get_data_file_path('ligands/BNZ.pdb') + molecule = Molecule(ligand_path, name='benzene') + 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') + 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') + assert molecule.name == 'benzene', 'Unexpected atom name' + + def test_molecule_tag_assignment(self): + """ + It tests the molecule tag assignment. + """ + # Look for UNK tag when dummy Molecule is loaded + molecule = Molecule() + assert molecule.tag == 'UNK', 'Unexpected atom tag' + + # Look for the PDB residue name as a tag when a Molecule is loaded + # from a PDB file + ligand_path = get_data_file_path('ligands/BNZ.pdb') + molecule = Molecule(ligand_path) + assert molecule.tag == 'BNZ', 'Unexpected atom tag' + + # Look for BEN tag when a Molecule is loaded from a PDB file with + # a custom name + ligand_path = get_data_file_path('ligands/BNZ.pdb') + molecule = Molecule(ligand_path, tag='BEN') + assert molecule.tag == 'BEN', 'Unexpected atom tag' + + # Look for UNK tag when a Molecule is loaded from a SMILES tag + molecule = Molecule(smiles='c1ccccc1') + 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') + assert molecule.tag == 'BNZ', 'Unexpected atom tag' diff --git a/offpele/topology/molecule.py b/offpele/topology/molecule.py index 01c2a1ee..1af1d697 100644 --- a/offpele/topology/molecule.py +++ b/offpele/topology/molecule.py @@ -447,7 +447,7 @@ class Molecule(object): """ def __init__(self, path=None, smiles=None, rotamer_resolution=30, - exclude_terminal_rotamers=True): + exclude_terminal_rotamers=True, name='', tag='UNK'): """ It initializes a Molecule object through a PDB file or a SMILES tag. @@ -464,6 +464,10 @@ def __init__(self, path=None, smiles=None, rotamer_resolution=30, exclude_terminal_rotamers : bool Whether to exclude terminal rotamers when generating the rotamers library or not + name : str + The molecule name + tag : str + The molecule tag. It must be a 3-character string Examples -------- @@ -482,9 +486,11 @@ def __init__(self, path=None, smiles=None, rotamer_resolution=30, >>> from offpele.topology import Molecule >>> molecule = Molecule(smiles='Cc1ccccc1') - >>> molecule.parameterize('openff_unconstrained-1.1.1.offxml') + >>> molecule.parameterize('openff_unconstrained-1.2.0.offxml') """ + self._name = name + self._tag = tag self._rotamer_resolution = rotamer_resolution self._exclude_terminal_rotamers = exclude_terminal_rotamers @@ -507,7 +513,6 @@ def __init__(self, path=None, smiles=None, rotamer_resolution=30, def _initialize(self): """It initializes an empty molecule.""" - self._name = '' self._forcefield = None self._atoms = list() self._bonds = list() @@ -543,9 +548,16 @@ def _initialize_from_pdb(self, path): # RDKit must generate stereochemistry specifically from 3D coords rdkit_toolkit.assign_stereochemistry_from_3D(self) - # Set molecule name according to PDB's residue name - name = rdkit_toolkit.get_residue_name(self) - self.set_name(name) + # Set molecule name according to PDB name + if self.name == '': + from pathlib import Path + name = Path(path).stem + self.set_name(name) + + # Set molecule tag according to PDB's residue name + if self.tag == 'UNK': + tag = rdkit_toolkit.get_residue_name(self) + self.set_tag(tag) openforcefield_toolkit = OpenForceFieldToolkitWrapper() @@ -570,9 +582,9 @@ def _initialize_from_smiles(self, smiles): # RDKit must generate stereochemistry specifically from 3D coords # rdkit_toolkit.assign_stereochemistry_from_3D(self) - # Set molecule name according to PDB's residue name - name = rdkit_toolkit.get_residue_name(self) - self.set_name(name) + # Set molecule name according to the SMILES tag + if self.name == '': + self.set_name(smiles) openforcefield_toolkit = OpenForceFieldToolkitWrapper() @@ -595,12 +607,27 @@ def set_name(self, name): name : str The name to set to the molecule """ - if isinstance(name, str) and len(name) > 2: - name = name[0:3].upper() - self._name = name + assert isinstance(name, str), 'Invalid type for a name, it must be ' \ + + 'a string' + + self._name = name + + def set_tag(self, tag): + """ + It sets the tag of the molecule. It must be a 3-character string. - if self.off_molecule: - self.off_molecule.name = name + Parameters + ---------- + tag : str + The tag to set to the molecule. It must be a 3-character string + """ + # Some previous checks + assert len(tag) == 3, 'Invalid tag length, it must be a ' \ + + '3-character string' + assert isinstance(tag, str), 'Invalid type for a tag, it must be ' \ + + 'a string' + + self._tag = tag.upper() def parameterize(self, forcefield, charges_method=None, use_OPLS_nonbonding_params=False, @@ -673,43 +700,6 @@ def parameterize(self, forcefield, charges_method=None, if use_OPLS_bonds_and_angles: self.add_OPLS_bonds_and_angles() - # To do: consider removing this function - def plot_rotamer_graph(self): - """It plots the rotamer graph in screen.""" - try: - from rdkit import Chem - except ImportError: - raise Exception('RDKit Python API not found') - - # Find rotatable bond ids as in Lipinski module in RDKit - # https://github.com/rdkit/rdkit/blob/1bf6ef3d65f5c7b06b56862b3fb9116a3839b229/rdkit/Chem/Lipinski.py#L47 - rot_bonds_atom_ids = self._rdkit_molecule.GetSubstructMatches( - Chem.MolFromSmarts('[!$(*#*)&!D1]-&!@[!$(*#*)&!D1]')) - - graph = self._compute_rotamer_graph(rot_bonds_atom_ids) - - rot_edges = [(u, v) for (u, v, d) in graph.edges(data=True) - if d['weight'] == 1] - nrot_edges = [(u, v) for (u, v, d) in graph.edges(data=True) - if d['weight'] == 0] - - import networkx as nx - - pos = nx.circular_layout(graph) - - nx.draw_networkx_nodes(graph, pos, node_size=400) - nx.draw_networkx_edges(graph, pos, edgelist=rot_edges, - width=4) - nx.draw_networkx_edges(graph, pos, edgelist=nrot_edges, - width=4, alpha=0.5, edge_color='b', - style='dashed') - nx.draw_networkx_labels(graph, pos, font_size=10, - font_family='sans-serif') - - import matplotlib.pyplot as plt - plt.axis('off') - plt.show() - def assert_parameterized(self): """ It checks that the molecule has been parameterized, raises an @@ -1312,6 +1302,18 @@ def name(self): """ return self._name + @property + def tag(self): + """ + Molecule's tag. + + Returns + ------- + tag : str + The tag of this Molecule object + """ + return self._tag + @property def forcefield(self): """ diff --git a/offpele/utils/toolkits.py b/offpele/utils/toolkits.py index 3ce6391c..3d81faea 100644 --- a/offpele/utils/toolkits.py +++ b/offpele/utils/toolkits.py @@ -1117,6 +1117,15 @@ def __init__(self): """ super().__init__() + if "SCHRODINGER" not in os.environ: + import logging + logging.warning("Schrodinger Toolkit requires the environment " + + "variable SCHRODINGER to be previously set, " + + "pointing to the Schrodinger's installation " + + "path. For more information, please, refer to " + + "https://martimunicoy.github.io/offpele/installation.html#external-dependencies", + ) + if not self.is_available(): raise ToolkitUnavailableException( 'The required toolkit {} is not '.format(self.toolkit_name)