# Meeko: preparation of small molecules for AutoDock
[](https://shields.io/)
[](https://pypi.python.org/pypi/ansicolortags/)
Meeko reads an RDKit molecule object and writes a PDBQT string (or file)
for [AutoDock-Vina](https://github.com/ccsb-scripps/AutoDock-Vina)
and [AutoDock-GPU](https://github.com/ccsb-scripps/AutoDock-GPU).
It converts the docking output to RDKit molecules and
SD files, without loss of bond orders.
Meeko is developed by the [Forli lab](https://forlilab.org/) at the
[Center for Computational Structural Biology (CCSB)](https://ccsb.scripps.edu)
at [Scripps Research](https://www.scripps.edu/).
## Usage notes
Meeko does not calculate 3D coordinates or assign protonation states.
Input molecules must have explicit hydrogens.
Sampling of macrocycle conformers ([paper](https://doi.org/10.1017/qrd.2022.18))
is enabled by default.
SDF format strongly preferred over Mol2.
See
[this discussion](https://github.com/rdkit/rdkit/discussions/3647)
and RDKit issues
[1755](https://github.com/rdkit/rdkit/issues/1755) and
[917](https://github.com/rdkit/rdkit/issues/917).
## API changes in v0.5
Class `MoleculePreparation` no longer has method `write_pdbqt_string()`.
Instead, `MoleculePreparation.prepare()` returns a list of `MoleculeSetup` objects
that must be passed, individually, to `PDBQTWriterLegacy.write_string()`.
```python
from meeko import MoleculePreparation
from meeko import PDBQTWriterLegacy
preparator = MoleculePreparation()
mol_setups = preparator.prepare(rdkit_molecule_3D_with_Hs)
for setup in mol_setups:
pdbqt_string, is_ok, error_msg = PDBQTWriterLegacy.write_string(setup)
if is_ok:
print(pdbqt_string, end="")
```
Argument `keep_nonpolar_hydrogens` is replaced by `merge_these_atom_types`, both in the Python
interface and for script `mk_prepare_ligand.py`.
The default is `merge_these_atom_types=("H",)`, which
merges hydrogens typed `"H"`, keeping the current default behavior.
To keep all hydrogens, set `merge_these_atom_types` to an empty
list when initializing `MoleculePreparation`, or pass no atom types
to `--merge_these_atom_types` from the command line:
```sh
mk_prepare_ligand.py -i molecule.sdf --merge_these_atom_types
```
## Dependencies
* Python (>=3.5)
* Numpy
* Scipy
* RDKit
* ProDy (optionally, for covalent docking)
Conda or Miniconda can install the dependencies:
```bash
conda install -c conda-forge numpy scipy rdkit
pip install prody # optional. pip recommended at http://prody.csb.pitt.edu/downloads/
```
## Installation (from PyPI)
```bash
$ pip install meeko
```
If using conda, `pip` installs the package in the active environment.
## Installation (from source)
You'll get the develop branch, which may be ahead of the latest release.
```bash
$ git clone https://github.com/forlilab/Meeko
$ cd Meeko
$ pip install .
```
Optionally include `--editable`. Changes in the original package location
take effect immediately without the need to run `pip install .` again.
```bash
$ pip install --editable .
```
## Examples using the command line scripts
#### 1. make PDBQT files
AutoDock-GPU and Vina read molecules in the PDBQT format. These can be prepared
by Meeko from SD files, or from Mol2 files, but SDF is strongly preferred.
```console
mk_prepare_ligand.py -i molecule.sdf -o molecule.pdbqt
mk_prepare_ligand.py -i multi_mol.sdf --multimol_outdir folder_for_pdbqt_files
```
#### 2. convert docking results to SDF
AutoDock-GPU and Vina write docking results in the PDBQT format. The DLG output
from AutoDock-GPU contains docked poses in PDBQT blocks.
Meeko generates RDKit molecules from PDBQT files (or strings) using the SMILES
string in the REMARK lines. The REMARK lines also have the mapping of atom indices
between SMILES and PDBQT. SD files with docked coordinates are written
from RDKit molecules.
```console
mk_export.py molecule.pdbqt -o molecule.sdf
mk_export.py vina_results.pdbqt -o vina_results.sdf
mk_export.py autodock-gpu_results.dlg -o autodock-gpu_results.sdf
```
Making RDKit molecules from SMILES is safer than guessing bond orders
from the coordinates, specially because the PDBQT lacks hydrogens bonded
to carbon. As an example, consider the following conversion, in which
OpenBabel adds an extra double bond, not because it has a bad algorithm,
but because this is a nearly impossible task.
```console
$ obabel -:"C1C=CCO1" -o pdbqt --gen3d | obabel -i pdbqt -o smi
[C]1=[C][C]=[C]O1
```
## Python tutorial
#### 1. making PDBQT strings for Vina or for AutoDock-GPU
```python
from meeko import MoleculePreparation
from meeko import PDBQTWriterLegacy
from rdkit import Chem
input_molecule_file = "example/BACE_macrocycle/BACE_4.sdf"
# there is one molecule in this SD file, this loop iterates just once
for mol in Chem.SDMolSupplier(input_molecule_file, removeHs=False):
preparator = MoleculePreparation()
mol_setups = preparator.prepare(mol)
for setup in mol_setups:
setup.show() # optional
pdbqt_string = PDBQTWriterLegacy.write_string(setup)
```
At this point, `pdbqt_string` can be written to a file for
docking with AutoDock-GPU or Vina, or passed directly to Vina within Python
using `set_ligand_from_string(pdbqt_string)`. For context, see
[the docs on using Vina from Python](https://autodock-vina.readthedocs.io/en/latest/docking_python.html).
#### 2. RDKit molecule from docking results
```python
from meeko import PDBQTMolecule
from meeko import RDKitMolCreate
fn = "autodock-gpu_results.dlg"
pdbqt_mol = PDBQTMolecule.from_file(fn, is_dlg=True, skip_typing=True)
rdkitmol_list = RDKitMolCreate.from_pdbqt_mol(pdbqt_mol)
```
The length of `rdkitmol_list` is one if there are no sidechains and only one
ligand was docked.
If multiple ligands and/or sidechains are docked simultaneously, each will be
an individual RDKit molecule in `rdkitmol_list`.
Sidechains are truncated at the C-alpha.
Note that docking multiple
ligands simultaneously is only available in Vina, and it differs from docking
multiple ligands one after the other. Each failed creation of an RDKit molecule
for a ligand or sidechain results in a `None` in `rdkitmol_list`.
For Vina's output PDBQT files, omit `is_dlg=True`.
```python
pdbqt_mol = PDBQTMolecule.from_file("vina_results.pdbqt", skip_typing=True)
rdkitmol_list = RDKitMolCreate.from_pdbqt_mol(pdbqt_mol)
```
When using Vina from Python, the output string can be passed directly.
See [the docs](https://autodock-vina.readthedocs.io/en/latest/docking_python.html)
for context on the `v` object.
```python
vina_output_string = v.poses()
pdbqt_mol = PDBQTMolecule(vina_output_string, is_dlg=True, skip_typing=True)
rdkitmol_list = RDKitMolCreate.from_pdbqt_mol(pdbqt_mol)
```
#### 3. Initializing MoleculePreparation from a dictionary (or JSON)
This is useful for saving and loading configuration files with json.
```python
import json
from meeko import MoleculePreparation
mk_config = {"hydrate": True} # any arguments of MoleculePreparation.__init__
print(json.dumps(mk_config), file=open('mk_config.json', 'w'))
with open('mk_config.json') as f:
mk_config = json.load(f)
preparator = MoleculePreparation.from_config(mk_config)
```
The command line tool `mk_prepare_ligand.py` can read the json files using
option `-c` or `--config`.
## Possibly useful configurations of MoleculePreparation
Here we create an instance of MoleculePreparation that attaches pseudo
waters to the ligand ([see paper on hydrated docking](https://pubs.acs.org/doi/abs/10.1021/jm2005145)),
keeps macrocycles rigid (generally a bad idea),
and keeps conjugated bonds and amide bonds rigid.
By default, most amides are kept rigid, except for tertiary amides with
different substituents on the nitrogen.
```python
preparator = MoleculePreparation(
hydrate=True,
rigid_macrocycles=True,
rigidify_bonds_smarts = ["C=CC=C", "[CX3](=O)[NX3]"],
rigidify_bonds_indices = [(1, 2), (0, 2)],
)
```
The same can be done with the command line script. Note that indices of the
atoms in the SMARTS are 0-based for the Python API but
1-based for the command line script:
```console
mk_prepare_ligand.py\
--hydrate\
--rigid_macrocycles\
--rigidify_bonds_smarts "C=CC=C"\
--rigidify_bonds_indices 2 3\
--rigidify_bonds_smarts "[CX3](=O)[NX3]"\
--rigidify_bonds_indices 1 3
```
## Docking covalent ligands as flexible sidechains
The input ligand must be the product of the reaction and contain the
atoms of the flexible sidechain up to (and including) the C-alpha.
For example, if the ligand is an acrylamide (smiles: `C=CC(=O)N`) reacting
with a cysteine (sidechain smiles: `CCS`), then the input ligand for
Meeko must correspond to smiles `CCSCCC(=O)N`.
Meeko will align the ligand atoms that match the C-alpha and C-beta of
the protein sidechain. Options `--tether_smarts` and `--tether_smarts_indices`
define these atoms. For a cysteine, `--tether_smarts "SCC"` and
`--tether_smarts_indices 3 2` would work, although it is safer to define
a more spefic SMARTS to avoid matching the ligand more than once. The first
index (3 in this example) defines the C-alpha, and the second index defines
the C-beta.
For the example in this repository, which is based on PDB entry 7aeh,
the following options prepare the covalently bound ligand for tethered docking:
```console
cd example/covalent_docking
mk_prepare_ligand.py\
-i ligand_including_cys_sidechain.sdf\
--receptor protein.pdb\
--rec_residue ":CYS:6"\
--tether_smarts "NC(=O)C(O)(C)SCC"\
--tether_smarts_indices 9 8\
-o prepared.pdbqt
```
## Reactive Docking
### 1. Prepare protein with waterkit
Follow `wk_prepare_receptor.py` instructions and run with `--pdb`.
The goal of this step is to perform essential fixes to the protein
(such as missing atoms), to add hydrogens, and to follow the Amber
naming scheme for atoms and residues, e.g., `HIE` or `HID`
instead of `HIS`.
### 2. Prepare protein pdbqt
Here, `wk.pdb` was written by waterkit.
Here, `wk.pdb` was written by waterkit. The example below will center a gridbox of specified size on the given reactive residue.
```console
$ mk_prepare_receptor.py\
--pdb wk.pdb\
-o receptor.pdbqt\
--flexres " :ARG:348"\
--reactive_flexres " :SER:308"
--reactive_flexres " :SER:308"\
--box_center_on_reactive_res\
--box_size 40 40 40 # x y z (angstroms)
```
A manual box center can be specified with `--box_center`.
Reactive parameters can also be modified:
```sh
--r_eq_12 R_EQ_12 r_eq for reactive atoms (1-2 interaction)
--eps_12 EPS_12 epsilon for reactive atoms (1-2 interaction)
--r_eq_13_scaling R_EQ_13_SCALING
r_eq scaling for 1-3 interaction across reactive atoms
--r_eq_14_scaling R_EQ_14_SCALING
r_eq scaling for 1-4 interaction across reactive atoms
```
Receptor preparation can't handle heteroatoms for the moment.
Also nucleic acids, ions, and post-translational modifications (e.g.
phosphorilation) are not supported. Only the 20 standard amino acids
can be parsed, and it is required to have Amber atom names and
hydrogens. No atoms can be missing.
### 3. Run autogrid
Make affinity maps for the `_rigid.pdbqt` part of the receptor.
Make affinity maps for the `_rigid.pdbqt` part of the receptor. `mk_prepare_receptor.py` will prepare the GPF for you.
### 4. Write ligand PDBQT
mk_prepare_ligand.py -i sufex1.sdf --reactive_smarts "S(=O)(=O)F" --reactive_smarts_idx 1 -o sufex1.pdbqt\
### 5. Configure AD-GPU for reactive docking
For reactive docking there are two options that need to be passed to AutoDock-GPU:
For reactive docking there are an additional option that needs to be passed to AutoDock-GPU:
```console
--import_dpf
```
The `--derivtype` option, if needed, was written by `mk_prepare_receptor.py` to a file suffixed with `.derivtype`.
The filename to be passed to `--import_dpf` was written by `mk_prepare_receptor.py`
and it is suffixed with `reactive_config`.
```sh
ADGPU -I *.reactive_config -L sufex1.pdbqt -N sufex1_docked_ -F *_flex.pdbqt -C 1
Raw data
{
"_id": null,
"home_page": "https://github.com/ccsb-scripps/meeko",
"name": "meeko",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.5",
"maintainer_email": "",
"keywords": "molecular modeling,drug design,docking,autodock",
"author": "Forli Lab",
"author_email": "forli@scripps.edu",
"download_url": "https://files.pythonhosted.org/packages/78/17/8947c029c13d2f55f3a4833e17722dd275f94b10a7c32914374981eb8c8e/meeko-0.5.0.tar.gz",
"platform": null,
"description": "# Meeko: preparation of small molecules for AutoDock\n\n[](https://shields.io/)\n[](https://pypi.python.org/pypi/ansicolortags/)\n\nMeeko reads an RDKit molecule object and writes a PDBQT string (or file)\nfor [AutoDock-Vina](https://github.com/ccsb-scripps/AutoDock-Vina)\nand [AutoDock-GPU](https://github.com/ccsb-scripps/AutoDock-GPU).\nIt converts the docking output to RDKit molecules and\nSD files, without loss of bond orders.\n\nMeeko is developed by the [Forli lab](https://forlilab.org/) at the\n[Center for Computational Structural Biology (CCSB)](https://ccsb.scripps.edu)\nat [Scripps Research](https://www.scripps.edu/).\n\n\n## Usage notes\n\nMeeko does not calculate 3D coordinates or assign protonation states.\nInput molecules must have explicit hydrogens.\n\nSampling of macrocycle conformers ([paper](https://doi.org/10.1017/qrd.2022.18))\nis enabled by default.\n\nSDF format strongly preferred over Mol2.\nSee\n[this discussion](https://github.com/rdkit/rdkit/discussions/3647)\nand RDKit issues\n[1755](https://github.com/rdkit/rdkit/issues/1755) and\n[917](https://github.com/rdkit/rdkit/issues/917).\n\n\n## API changes in v0.5\n\nClass `MoleculePreparation` no longer has method `write_pdbqt_string()`.\nInstead, `MoleculePreparation.prepare()` returns a list of `MoleculeSetup` objects\nthat must be passed, individually, to `PDBQTWriterLegacy.write_string()`.\n```python\nfrom meeko import MoleculePreparation\nfrom meeko import PDBQTWriterLegacy\n\npreparator = MoleculePreparation()\nmol_setups = preparator.prepare(rdkit_molecule_3D_with_Hs)\nfor setup in mol_setups:\n pdbqt_string, is_ok, error_msg = PDBQTWriterLegacy.write_string(setup)\n if is_ok:\n print(pdbqt_string, end=\"\")\n```\n\nArgument `keep_nonpolar_hydrogens` is replaced by `merge_these_atom_types`, both in the Python\ninterface and for script `mk_prepare_ligand.py`.\nThe default is `merge_these_atom_types=(\"H\",)`, which\nmerges hydrogens typed `\"H\"`, keeping the current default behavior.\nTo keep all hydrogens, set `merge_these_atom_types` to an empty\nlist when initializing `MoleculePreparation`, or pass no atom types\nto `--merge_these_atom_types` from the command line:\n```sh\nmk_prepare_ligand.py -i molecule.sdf --merge_these_atom_types\n``` \n\n## Dependencies\n\n* Python (>=3.5)\n* Numpy\n* Scipy\n* RDKit\n* ProDy (optionally, for covalent docking)\n\nConda or Miniconda can install the dependencies:\n```bash\nconda install -c conda-forge numpy scipy rdkit\npip install prody # optional. pip recommended at http://prody.csb.pitt.edu/downloads/\n```\n\n## Installation (from PyPI)\n```bash\n$ pip install meeko\n```\nIf using conda, `pip` installs the package in the active environment.\n\n## Installation (from source)\nYou'll get the develop branch, which may be ahead of the latest release.\n```bash\n$ git clone https://github.com/forlilab/Meeko\n$ cd Meeko\n$ pip install .\n```\n\nOptionally include `--editable`. Changes in the original package location\ntake effect immediately without the need to run `pip install .` again.\n```bash\n$ pip install --editable .\n```\n\n\n## Examples using the command line scripts\n\n#### 1. make PDBQT files\nAutoDock-GPU and Vina read molecules in the PDBQT format. These can be prepared\nby Meeko from SD files, or from Mol2 files, but SDF is strongly preferred.\n```console\nmk_prepare_ligand.py -i molecule.sdf -o molecule.pdbqt\nmk_prepare_ligand.py -i multi_mol.sdf --multimol_outdir folder_for_pdbqt_files\n```\n\n#### 2. convert docking results to SDF\nAutoDock-GPU and Vina write docking results in the PDBQT format. The DLG output\nfrom AutoDock-GPU contains docked poses in PDBQT blocks.\nMeeko generates RDKit molecules from PDBQT files (or strings) using the SMILES\nstring in the REMARK lines. The REMARK lines also have the mapping of atom indices\nbetween SMILES and PDBQT. SD files with docked coordinates are written\nfrom RDKit molecules.\n\n```console\nmk_export.py molecule.pdbqt -o molecule.sdf\nmk_export.py vina_results.pdbqt -o vina_results.sdf\nmk_export.py autodock-gpu_results.dlg -o autodock-gpu_results.sdf\n```\n\nMaking RDKit molecules from SMILES is safer than guessing bond orders\nfrom the coordinates, specially because the PDBQT lacks hydrogens bonded\nto carbon. As an example, consider the following conversion, in which\nOpenBabel adds an extra double bond, not because it has a bad algorithm,\nbut because this is a nearly impossible task.\n```console\n$ obabel -:\"C1C=CCO1\" -o pdbqt --gen3d | obabel -i pdbqt -o smi\n[C]1=[C][C]=[C]O1\n```\n\n## Python tutorial\n\n#### 1. making PDBQT strings for Vina or for AutoDock-GPU\n\n```python\nfrom meeko import MoleculePreparation\nfrom meeko import PDBQTWriterLegacy\nfrom rdkit import Chem\n\ninput_molecule_file = \"example/BACE_macrocycle/BACE_4.sdf\"\n\n# there is one molecule in this SD file, this loop iterates just once\nfor mol in Chem.SDMolSupplier(input_molecule_file, removeHs=False):\n preparator = MoleculePreparation()\n mol_setups = preparator.prepare(mol)\n for setup in mol_setups:\n setup.show() # optional\n pdbqt_string = PDBQTWriterLegacy.write_string(setup)\n```\nAt this point, `pdbqt_string` can be written to a file for\ndocking with AutoDock-GPU or Vina, or passed directly to Vina within Python\nusing `set_ligand_from_string(pdbqt_string)`. For context, see\n[the docs on using Vina from Python](https://autodock-vina.readthedocs.io/en/latest/docking_python.html).\n\n\n#### 2. RDKit molecule from docking results\n\n```python\nfrom meeko import PDBQTMolecule\nfrom meeko import RDKitMolCreate\n\nfn = \"autodock-gpu_results.dlg\"\npdbqt_mol = PDBQTMolecule.from_file(fn, is_dlg=True, skip_typing=True)\nrdkitmol_list = RDKitMolCreate.from_pdbqt_mol(pdbqt_mol)\n```\nThe length of `rdkitmol_list` is one if there are no sidechains and only one\nligand was docked.\nIf multiple ligands and/or sidechains are docked simultaneously, each will be\nan individual RDKit molecule in `rdkitmol_list`.\nSidechains are truncated at the C-alpha.\nNote that docking multiple\nligands simultaneously is only available in Vina, and it differs from docking\nmultiple ligands one after the other. Each failed creation of an RDKit molecule\nfor a ligand or sidechain results in a `None` in `rdkitmol_list`.\n\nFor Vina's output PDBQT files, omit `is_dlg=True`.\n```python\npdbqt_mol = PDBQTMolecule.from_file(\"vina_results.pdbqt\", skip_typing=True)\nrdkitmol_list = RDKitMolCreate.from_pdbqt_mol(pdbqt_mol)\n```\n\nWhen using Vina from Python, the output string can be passed directly.\nSee [the docs](https://autodock-vina.readthedocs.io/en/latest/docking_python.html)\nfor context on the `v` object.\n```python\nvina_output_string = v.poses()\npdbqt_mol = PDBQTMolecule(vina_output_string, is_dlg=True, skip_typing=True)\nrdkitmol_list = RDKitMolCreate.from_pdbqt_mol(pdbqt_mol)\n```\n\n#### 3. Initializing MoleculePreparation from a dictionary (or JSON)\n\nThis is useful for saving and loading configuration files with json.\n```python\nimport json\nfrom meeko import MoleculePreparation\n\nmk_config = {\"hydrate\": True} # any arguments of MoleculePreparation.__init__\nprint(json.dumps(mk_config), file=open('mk_config.json', 'w'))\nwith open('mk_config.json') as f:\n mk_config = json.load(f)\npreparator = MoleculePreparation.from_config(mk_config)\n```\nThe command line tool `mk_prepare_ligand.py` can read the json files using\noption `-c` or `--config`.\n\n\n## Possibly useful configurations of MoleculePreparation\n\nHere we create an instance of MoleculePreparation that attaches pseudo\nwaters to the ligand ([see paper on hydrated docking](https://pubs.acs.org/doi/abs/10.1021/jm2005145)),\nkeeps macrocycles rigid (generally a bad idea),\nand keeps conjugated bonds and amide bonds rigid. \nBy default, most amides are kept rigid, except for tertiary amides with\ndifferent substituents on the nitrogen.\n\n```python\npreparator = MoleculePreparation(\n hydrate=True,\n rigid_macrocycles=True,\n rigidify_bonds_smarts = [\"C=CC=C\", \"[CX3](=O)[NX3]\"],\n rigidify_bonds_indices = [(1, 2), (0, 2)],\n)\n```\n\nThe same can be done with the command line script. Note that indices of the\natoms in the SMARTS are 0-based for the Python API but\n1-based for the command line script:\n```console\nmk_prepare_ligand.py\\\n --hydrate\\\n --rigid_macrocycles\\\n --rigidify_bonds_smarts \"C=CC=C\"\\\n --rigidify_bonds_indices 2 3\\\n --rigidify_bonds_smarts \"[CX3](=O)[NX3]\"\\\n --rigidify_bonds_indices 1 3\n```\n\n## Docking covalent ligands as flexible sidechains\n\nThe input ligand must be the product of the reaction and contain the\natoms of the flexible sidechain up to (and including) the C-alpha.\nFor example, if the ligand is an acrylamide (smiles: `C=CC(=O)N`) reacting\nwith a cysteine (sidechain smiles: `CCS`), then the input ligand for\nMeeko must correspond to smiles `CCSCCC(=O)N`.\n\nMeeko will align the ligand atoms that match the C-alpha and C-beta of\nthe protein sidechain. Options `--tether_smarts` and `--tether_smarts_indices`\ndefine these atoms. For a cysteine, `--tether_smarts \"SCC\"` and\n`--tether_smarts_indices 3 2` would work, although it is safer to define\na more spefic SMARTS to avoid matching the ligand more than once. The first\nindex (3 in this example) defines the C-alpha, and the second index defines\nthe C-beta. \n\nFor the example in this repository, which is based on PDB entry 7aeh,\nthe following options prepare the covalently bound ligand for tethered docking:\n```console\ncd example/covalent_docking\n\nmk_prepare_ligand.py\\\n -i ligand_including_cys_sidechain.sdf\\\n --receptor protein.pdb\\\n --rec_residue \":CYS:6\"\\\n --tether_smarts \"NC(=O)C(O)(C)SCC\"\\\n --tether_smarts_indices 9 8\\\n -o prepared.pdbqt\n```\n\n## Reactive Docking\n\n### 1. Prepare protein with waterkit\nFollow `wk_prepare_receptor.py` instructions and run with `--pdb`.\nThe goal of this step is to perform essential fixes to the protein\n(such as missing atoms), to add hydrogens, and to follow the Amber\nnaming scheme for atoms and residues, e.g., `HIE` or `HID`\ninstead of `HIS`.\n\n### 2. Prepare protein pdbqt\nHere, `wk.pdb` was written by waterkit.\nHere, `wk.pdb` was written by waterkit. The example below will center a gridbox of specified size on the given reactive residue.\n\n```console\n $ mk_prepare_receptor.py\\\n --pdb wk.pdb\\\n -o receptor.pdbqt\\\n --flexres \" :ARG:348\"\\\n --reactive_flexres \" :SER:308\"\n --reactive_flexres \" :SER:308\"\\\n --box_center_on_reactive_res\\\n --box_size 40 40 40 # x y z (angstroms)\n```\nA manual box center can be specified with `--box_center`.\nReactive parameters can also be modified:\n```sh\n --r_eq_12 R_EQ_12 r_eq for reactive atoms (1-2 interaction)\n --eps_12 EPS_12 epsilon for reactive atoms (1-2 interaction)\n --r_eq_13_scaling R_EQ_13_SCALING\n r_eq scaling for 1-3 interaction across reactive atoms\n --r_eq_14_scaling R_EQ_14_SCALING\n r_eq scaling for 1-4 interaction across reactive atoms\n```\n\nReceptor preparation can't handle heteroatoms for the moment.\nAlso nucleic acids, ions, and post-translational modifications (e.g.\nphosphorilation) are not supported. Only the 20 standard amino acids\ncan be parsed, and it is required to have Amber atom names and\nhydrogens. No atoms can be missing.\n\n### 3. Run autogrid\n\nMake affinity maps for the `_rigid.pdbqt` part of the receptor.\nMake affinity maps for the `_rigid.pdbqt` part of the receptor. `mk_prepare_receptor.py` will prepare the GPF for you.\n\n### 4. Write ligand PDBQT\nmk_prepare_ligand.py -i sufex1.sdf --reactive_smarts \"S(=O)(=O)F\" --reactive_smarts_idx 1 -o sufex1.pdbqt\\\n\n### 5. Configure AD-GPU for reactive docking\n\nFor reactive docking there are two options that need to be passed to AutoDock-GPU:\nFor reactive docking there are an additional option that needs to be passed to AutoDock-GPU:\n ```console\n --import_dpf\n ```\n\nThe `--derivtype` option, if needed, was written by `mk_prepare_receptor.py` to a file suffixed with `.derivtype`.\n\nThe filename to be passed to `--import_dpf` was written by `mk_prepare_receptor.py`\nand it is suffixed with `reactive_config`.\n```sh\nADGPU -I *.reactive_config -L sufex1.pdbqt -N sufex1_docked_ -F *_flex.pdbqt -C 1\n",
"bugtrack_url": null,
"license": "LGPL-2.1",
"summary": "Python package for preparing small molecule for docking",
"version": "0.5.0",
"project_urls": {
"Homepage": "https://github.com/ccsb-scripps/meeko"
},
"split_keywords": [
"molecular modeling",
"drug design",
"docking",
"autodock"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "0f97aaae239d66f408f0d58c949bf4bc7c62add39fbf9ff22733fb087937ca82",
"md5": "d5625c658903afadf39e29103319fecb",
"sha256": "f591f95fce7b0faa8836bedf5f357d0c56a8fc64e195407d9e6642302b5e5585"
},
"downloads": -1,
"filename": "meeko-0.5.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "d5625c658903afadf39e29103319fecb",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.5",
"size": 144407,
"upload_time": "2023-07-28T23:51:35",
"upload_time_iso_8601": "2023-07-28T23:51:35.153082Z",
"url": "https://files.pythonhosted.org/packages/0f/97/aaae239d66f408f0d58c949bf4bc7c62add39fbf9ff22733fb087937ca82/meeko-0.5.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "78178947c029c13d2f55f3a4833e17722dd275f94b10a7c32914374981eb8c8e",
"md5": "a25d1d4d1c9f8789ed3f384c199f7bcb",
"sha256": "2215072ff893935fd56f6eac869e1877d7eb296eaf68cc9d2a74a9260cad80fa"
},
"downloads": -1,
"filename": "meeko-0.5.0.tar.gz",
"has_sig": false,
"md5_digest": "a25d1d4d1c9f8789ed3f384c199f7bcb",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.5",
"size": 110941,
"upload_time": "2023-07-28T23:51:36",
"upload_time_iso_8601": "2023-07-28T23:51:36.356840Z",
"url": "https://files.pythonhosted.org/packages/78/17/8947c029c13d2f55f3a4833e17722dd275f94b10a7c32914374981eb8c8e/meeko-0.5.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-07-28 23:51:36",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "ccsb-scripps",
"github_project": "meeko",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "meeko"
}
JSON
