+ SurfDock +
+ +# Model Introduction + +SurfDock is a surface-informed diffusion generative model for protein–ligand complex prediction and structure-based virtual screening. The model incorporates protein surface geometry and chemical information into the diffusion-based docking process to generate and screen protein–small-molecule binding conformations. + +Paper: + +> **SurfDock is a surface-informed diffusion generative model for reliable and accurate protein–ligand complex prediction** +> Duanhua Cao, Mingan Chen, Rui Zhang, et al. +> *Nature Methods*, 2024 +> DOI: https://doi.org/10.1038/s41592-024-02516-y + +# Model Description + +SurfDock is a surface-informed diffusion generative model for protein–ligand complex prediction and structure-based virtual screening. The model first preprocesses the target protein structure and computes geometric and physicochemical information on the protein surface. In parallel, it uses ESM to extract protein sequence representations, providing both structural and sequence information for subsequent ligand conformation generation. + +During inference, SurfDock uses a diffusion generative model to sample candidate ligand conformations within the protein binding site, and then evaluates and ranks the generated poses using a pose confidence model. For virtual screening tasks, a screening score model can be further applied to rescore candidate protein–ligand conformations, producing results that are better suited for downstream ranking and screening. + +By integrating protein surface information, protein language model representations, and diffusion-based conformation generation, SurfDock can be used for protein–ligand docking, candidate binding pose generation, pose scoring, and structure-based virtual screening. + +# Use Cases + +| Use Case | Description | +| --- | --- | +| Protein–ligand docking | Predict the binding conformation of a ligand within a protein binding site | +| Structure-based virtual screening | Perform batch docking and scoring for small-molecule libraries | +| Ligand conformation generation | Sample candidate binding poses using a diffusion model | +| Protein surface modeling | Use protein surface geometry and physicochemical information to assist docking | + + +# Usage Instructions + +## 1. OneCode Usage + +You can use the OneCode online environment for intelligent one-click AI4S programming: + +[Try intelligent one-click AI4S programming](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home) + +## 2. Manual Installation and Usage + +### Hardware Requirements + +- SurfDock involves computationally intensive diffusion sampling, ESM representation extraction, and graph neural network computation. GPU/DCU acceleration is recommended. + +### Environment Setup + +#### DCU Environment + +```bash +# Activate DTK and CONDA first +conda create -n onescience311 python=3.11 -y +conda activate onescience311 + +pip install onescience[bio] \ + -i http://mirrors.onescience.ai:3141/pypi/simple/ \ + --trusted-host mirrors.onescience.ai +``` + +### Environment Notes + +- During actual execution, if dependencies are missing or version incompatibilities occur, refer to the dependency versions declared in `environment.yaml` in the repository root and install or adjust the corresponding dependencies as needed. +- SurfDock's protein surface processing pipeline depends on PyMesh. If the current Python version is not fully compatible with the upstream PyMesh package, compatibility adjustments should be made according to the actual call relationships. + + +### Weights and Data Preparation + +#### SurfDock Model Weights + +The current repository already includes the main model weights required for inference: + +```text +weight/ +├── docking/ +│ ├── best_ema_inference_epoch_model.pt +│ └── model_parameters.yml +├── posepredict/ +│ ├── best_model.pt +│ └── model_parameters.yml +└── screen/ + ├── best_model.pt + └── model_parameters.yml +``` + +Therefore, after downloading the complete repository, you generally do not need to download the main SurfDock model weights separately. + +Check: + +```bash +ls -lh weight/docking/ +ls -lh weight/posepredict/ +ls -lh weight/screen/ +``` + +#### ESM Model + +SurfDock uses ESM to extract protein sequence representations. + +Official installation method: + +```bash +git clone https://github.com/facebookresearch/esm model/esm +cd model/esm +pip install -e . +cd ../.. +``` + +The official inference script uses: + +```text +esm2_t33_650M_UR50D +``` + +and runs: + +```bash +python model/esm/scripts/extract.py \ + "esm2_t33_650M_UR50D" \ + input.fasta \ + output_dir \ + --repr_layers 33 \ + --include "per_tok" \ + --truncation_seq_length 4096 +``` + +to extract protein residue-level embeddings. + +- If the current environment cannot access the internet, it is recommended to cache the corresponding ESM weights in advance. `esm2_t33_650M_UR50D` requires the following two files: + +```text +https://dl.fbaipublicfiles.com/fair-esm/models/esm2_t33_650M_UR50D.pt +https://dl.fbaipublicfiles.com/fair-esm/regression/esm2_t33_650M_UR50D-contact-regression.pt +``` + +After downloading, it is recommended to place them in the current user's Torch Hub checkpoints cache directory: + +```text +~/.cache/torch/hub/checkpoints/ +``` + +The final file paths should be: + +```text +~/.cache/torch/hub/checkpoints/esm2_t33_650M_UR50D.pt +~/.cache/torch/hub/checkpoints/esm2_t33_650M_UR50D-contact-regression.pt +``` + +#### PDBBind Data + +If you need to retrain SurfDock, you must obtain PDBBind separately. According to the official instructions, the preprocessed data previously provided by EquiBind is no longer publicly distributed due to PDBBind licensing restrictions, so users need to obtain and process the data themselves through the official PDBBind channels. + +After processing, place the data in: + +```text +model/data/PDBBind_processed/ +``` +`model/data/splits/` contains data split information and is not equivalent to the complete PDBBind dataset. + +## 3. Quick Start + +### Download the Model Package + +```bash +hf download \ + OneScience-Group/SurfDock \ + --local-dir ./SurfDock + +cd SurfDock +``` +- SurfDock uses ESM to extract protein sequence representations, so the ESM model must be downloaded separately. See the Weights and Data Preparation section for details. + +# Example Data + +The current repository already provides docking and screening examples: + +```text +model/data/eval_sample_dirs/ +model/data/Screen_sample_dirs/ +``` + +When using your own data, organize the protein and ligand inputs according to the example directory structure, and modify the following paths in the corresponding bash scripts: + +```text +data_dir +surface_out_dir +out_csv_file +Screen_lib_path +docking_out_dir +``` + +as needed. + +# Inference Examples + +The following commands are assumed to be executed from the SurfDock repository root directory. + +## Protein–Ligand Docking Example + +Run: + +```bash +cd scripts/bash_scripts/test_scripts +bash eval_samples.sh +``` + +The script mainly performs the following steps automatically: + +```text +1. Preprocess the protein structure +2. Compute the protein surface +3. Build the inference input CSV +4. Extract ESM embeddings +5. Run SurfDock diffusion sampling +6. Save docking results +``` + +Before running, it is recommended to check: + +```bash +vim scripts/bash_scripts/test_scripts/eval_samples.sh +``` + +Pay particular attention to: + +```text +gpu_string +data_dir +surface_out_dir +out_csv_file +esmbedding_dir +docking_out_dir +``` + +Users also need to adjust the `CUDA_VISIBLE_DEVICES` and `accelerate launch` settings in the script according to the actual adaptation method. + +## Virtual Screening Example + +Run: + +```bash +cd scripts/bash_scripts/test_scripts +bash screen_pipeline.sh +``` + +Before running, check: + +```bash +vim scripts/bash_scripts/test_scripts/screen_pipeline.sh +``` + +Modify the following as needed: + +```text +gpu_string +data_dir +surface_out_dir +out_csv_file +esmbedding_dir +Screen_lib_path +docking_out_dir +``` + +Here, `Screen_lib_path` specifies the small-molecule library to be screened, for example the official sample: + +```text +model/data/Screen_sample_dirs/test_samples/1a0q/1a0q_ligand_for_Screen.sdf +``` + +The screening workflow is mainly: + +```text +Protein preprocessing + ↓ +Protein surface computation + ↓ +ESM embedding + ↓ +SurfDock generates candidate conformations + ↓ +Screen model rescoring + ↓ +Output screening results +``` + +## Skip Completed Protein Preprocessing + +This parameter can be modified in the following two scripts: + +```text +scripts/bash_scripts/test_scripts/eval_samples.sh +scripts/bash_scripts/test_scripts/screen_pipeline.sh +``` + +The scripts use: + +```bash +target_have_processed=true +``` + +to control whether target preprocessing is skipped. When set to `true`, the scripts skip target protein preprocessing steps such as OpenBabel/reduce and proceed directly to subsequent surface computation, CSV construction, ESM embedding, and inference. + +To reprocess the target protein: + +```bash +target_have_processed=false +``` + +When set to `false`, the scripts rerun the target protein preprocessing steps. + +## Generate ESM Embeddings Separately + +First, build the FASTA file: + +```bash +python model/datasets/esm_embedding_preparation.py \ + --out_file ./protein.fasta \ + --protein_ligand_csv ./input.csv +``` + +Extract ESM representations: + +```bash +python model/esm/scripts/extract.py \ + "esm2_t33_650M_UR50D" \ + ./protein.fasta \ + ./esm_embedding_output \ + --repr_layers 33 \ + --include "per_tok" \ + --truncation_seq_length 4096 +``` + +Extract pocket embeddings: + +```bash +python model/datasets/get_pocket_embedding.py \ + --protein_pocket_csv ./input.csv \ + --embeddings_dir ./esm_embedding_output \ + --pocket_emb_save_dir ./esm_embedding_pocket_output +``` + +Merge them into the `.pt` file required for SurfDock inference: + +```bash +python model/datasets/esm_pocket_embeddings_to_pt.py \ + --esm_embeddings_path ./esm_embedding_pocket_output \ + --output_path ./esm2_pocket_embeddings.pt +``` + +# Training Instructions + +## Retraining SurfDock + +Retraining requires preparing the PDBBind data first and completing protein surface and ESM embedding preprocessing. + +The training-related scripts are located in: + +```text +scripts/bash_scripts/train_SurfDock_docking_module/ +``` + +First, prepare the ESM embedding files required for training by following the "Generate ESM Embeddings Separately" section. The training script in the current repository is located at: + +```text +scripts/bash_scripts/train_SurfDock_docking_module/train_SurfDock.sh +``` + +After completing the ESM embeddings, check the data, model, and output paths in `train_SurfDock.sh`, then run: + +```bash +cd scripts/bash_scripts/train_SurfDock_docking_module +bash train_SurfDock.sh +``` + +## Retraining SurfScore + +The SurfScore training script is located at: + +```text +scripts/bash_scripts/train_SurfScore/train_SurfScore.sh +``` + +Before running, check the PDBBind data, cache, ESM embedding, output directory, and GPU parameters in the script, then run: + +```bash +cd scripts/bash_scripts/train_SurfScore +bash train_SurfScore.sh +``` + +# Output Description + +## Docking Output + +The docking results from `eval_samples.sh` are saved in the directory specified by `docking_out_dir` in the script. + +The main outputs include: + +```text +Generated protein–ligand conformations +Confidence/scoring results +Runtime logs +Intermediate CSV +ESM embeddings +Protein surface files +``` + +## Screening Output + +`screen_pipeline.sh` generates the screening results in `docking_out_dir` and uses: + +```text +weight/screen/best_model.pt +``` + +to rescore the docking poses. + +The final results can be used to rank and screen candidate small molecules. + +# OneScience Official Information + +| Platform | OneScience Main Repository | Skills Repository | +| --- | --- | --- | +| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills | +| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills | + + +# Citation and License + +- The official SurfDock source code repository is released under the **MIT License**, which permits use, modification, distribution, sublicensing, and commercial use. The original copyright notice and MIT License text should be retained when copying or distributing the software. +- PDBBind data is governed by its own license and terms of use. SurfDock's MIT License does not automatically apply to PDBBind data. +- This repository is a **DCU-adapted version** of SurfDock, with adjustments to parts of the runtime environment, dependency configuration, and execution workflow. The use of the repository code, model weights, and related data remains subject to the licenses and terms of use of their respective original projects. diff --git a/conf/params_example/example.yml b/conf/params_example/example.yml new file mode 100644 index 0000000000000000000000000000000000000000..5cebb5859df6174cb638239b3d53af25a0187cab --- /dev/null +++ b/conf/params_example/example.yml @@ -0,0 +1,146 @@ +# This file is used to explain the meaning of the SurfDock parameters. +# If you want to learn more about the options available for these parameters, please refer ./utils/parsing.py file +# If the user wants to retrain the model, they can pick the right parameters to optimize in their own way +## General arguments +# CUDA optimization parameter for faster training +cudnn_benchmark: true +# use pin_memory or not in linux system +pin_memory: false +# restart dir for training, which storge the model and optimizer +restart_dir: ~/SurfDock/workdir/project_surface_V3_PDBBind_ema_model_pocket_8A +# restart learning rate +restart_lr: null + +## dataset +# training data dir +data_dir: ~/PDBBIND/PDBBind_pocket_8A/ +# cache path for training data, if you just use SurfDock, you can ignore this +cache_path: ~/PDBBIND/cache_Surface_PDBBIND_pocket_8A +# esm embedding path,if this is set then the LM embeddings at that path will be used for the receptor features +esm_embeddings_path: ~/PDBBIND/esm_embedding/esm_embedding_pocket_for_train/esm2_3billion_embeddings.pt +# dataset split file +split_test: ~/data/splits/timesplit_test +split_train: ~/data/splits/timesplit_no_lig_overlap_train +split_val: ~/data/splits/timesplit_no_lig_overlap_val +# use rmsd matching or not,use default value is fine +matching: true +# Differential evolution maxiter parameter in matching +matching_maxiter: 20 +# the number of workers for dataloader +num_dataloader_workers: 1 +# the number of complexes to inference in validation set +num_inference_complexes: 500 +# the number of workers for training +num_workers: 1 + +## model +# if you want to use dynamic max cross, you can set this to true. this parameter can set a different max cross distance for each timestep +dynamic_max_cross: true +# scale the noise by sigma or not +scale_by_sigma: true +# Maximum sigma for rotational component +rot_sigma_max: 1.55 +# Minimum sigma for rotational component +rot_sigma_min: 0.03 +# Maximum sigma for torsional component +tor_sigma_max: 3.14 +# Minimum sigma for torsional component +tor_sigma_min: 0.0314 +# Maximum sigma for translational component +tr_sigma_max: 5.0 +# Minimum sigma for translational component +tr_sigma_min: 0.1 +# the weight of torsional component loss +tor_weight: 0.33 +# the weight of translational component loss +tr_weight: 0.33 +# the weight of rotational component loss +rot_weight: 0.33 +# diffusion model type , default value is surface_score_model,when train a scoring model, you can use mdn_model +model_type: surface_score_model +# diffusion model version, use default value is 3 +model_version: version3 +# training epochs +n_epochs: 2000 +# number of gaussians which used to MDN module for socring module +n_gaussians: 20 +# use no batch norm or not +no_batch_norm: false +# use torsion or not ,default value is false +no_torsion: false +# the layer number of the model +num_conv_layers: 6 +# the dimension of the scalar embedding in e3nn +ns: 48 +# the dimension of the vector embedding in e3nn +nv: 10 +# use the second order representation or not +use_second_order_repr: false +# embedding type +embedding_type: sinusoidal +# max number of neighbors for each atom in ligand graph +max_radius: 5.0 +batch_size: 12 # batch size +# the radius of the receptor graph +receptor_radius: 15.0 +# max number of neighbors for each C-alpha atom(residue graph) +c_alpha_max_neighbors: 24 +# Maxximum inter-distance about different node types +cross_max_distance: 80 +# cross distance embed dimension +cross_distance_embed_dim: 32 +# intra-distance embed dimension +distance_embed_dim: 32 +# Size of the embedding of the diffusion time +sigma_embed_dim: 32 +# Parameter of the diffusion time embedding +embedding_scale: 1000 +# dropout rate for dropout layer in diffusion module +dropout: 0.1 +# the dropout rate for scoring module +mdn_dropout: 0.1 +# use the ema model or not +use_ema: false +# exponential moving average rate +ema_rate: 0.999 +# learning rate ,use default value is fine +lr: 0.001 +# the learning rate scheduler +scheduler: plateau +# the weight decay factor, use default value is fine +w_decay: 0.0 +# the patience of the learning rate scheduler +scheduler_patience: 50 +# earlystop goal use max or min +inference_earlystop_goal: max +# inference earlystop metric +inference_earlystop_metric: valinf_rmsds_lt2 +# denoise steps in inference stage +inference_steps: 20 +# the early stop goal for training scoring module +mdn_early_stop_patience: 30 +# remove hydrogen or not +remove_hs: true +# validation inference frequency,default is 20 epochs +val_inference_freq: 20 +# top-N atoms with the smallest distances with surface node for mdn calculate in scoring model +topN: 1 +# predict bond type or not in training scoring model stage +bond_type_prediction: true +# atom type prediction or not in training scoring model stage +atom_type_prediction: true + +## wandb log +# use wandb to log or not +wandb: true +# wandb dir +wandb_dir: ~/wandb/SurfDock +# the project name in wandb +project: SurfDock_V3_PDBBind_ema_model_pocket_8A +# the run name in wandb +run_name: project_surface_V3_PDBBind_ema_model_pocket_8A +# dir of log files +log_dir: ~/wandb/SurfDock/workdir + + + diff --git a/config.json b/config.json new file mode 100644 index 0000000000000000000000000000000000000000..fcdffc4e97ee119afdf67ed89536f5371baca191 --- /dev/null +++ b/config.json @@ -0,0 +1,17 @@ +{ + "directories": { + "conf": "Environment files and example parameter files", + "model": "SurfDock source modules, bundled data, surface tools, and assets", + "scripts": "Python entry points and shell workflows", + "weight": "Pretrained SurfDock, pose prediction, and screening weights" + }, + "entrypoints": { + "inference": "scripts/inference_accelerate.py", + "evaluate": "scripts/evaluate_accelarate.py", + "score_in_place": "scripts/evaluate_score_in_place.py", + "train_docking": "scripts/train_accelarete.py", + "train_score": "scripts/train_mdn_accelarete.py" + }, + "source": "model", + "weights": "weight" +} diff --git a/environment.yaml b/environment.yaml new file mode 100644 index 0000000000000000000000000000000000000000..90dbd744d241f931a8a662a8b35e96e9bd5ba488 --- /dev/null +++ b/environment.yaml @@ -0,0 +1,434 @@ +name: SurfDock +channels: + - mx + - pyg + - pytorch + - nvidia + - defaults + - conda-forge +dependencies: + - _libgcc_mutex=0.1=conda_forge + - _openmp_mutex=4.5=2_kmp_llvm + - aiohttp=3.9.3=py310h2372a71_1 + - aiosignal=1.3.1=pyhd8ed1ab_0 + - ambertools=22.5=py310hd182041_0 + - annotated-types=0.6.0=pyhd8ed1ab_0 + - anyio=4.3.0=pyhd8ed1ab_0 + - archspec=0.2.3=pyhd8ed1ab_0 + - argon2-cffi=23.1.0=pyhd8ed1ab_0 + - argon2-cffi-bindings=21.2.0=py310h2372a71_4 + - arpack=3.7.0=hdefa2d7_2 + - arrow=1.3.0=pyhd8ed1ab_0 + - asttokens=2.4.1=pyhd8ed1ab_0 + - astunparse=1.6.3=pyhd8ed1ab_0 + - async-lru=2.0.4=pyhd8ed1ab_0 + - async-timeout=4.0.3=pyhd8ed1ab_0 + - attrs=23.2.0=pyh71513ae_0 + - babel=2.13.1=pyhd8ed1ab_0 + - beautifulsoup4=4.12.3=pyha770c72_0 + - biopandas=0.4.1=pyhd8ed1ab_1 + - blas=2.116=mkl + - blas-devel=3.9.0=16_linux64_mkl + - bleach=6.1.0=pyhd8ed1ab_0 + - blosc=1.21.5=hc2324a3_1 + - boltons=24.0.0=pyhd8ed1ab_0 + - boost=1.78.0=py310hcb52e73_5 + - boost-cpp=1.78.0=h2c5509c_4 + - brotli=1.1.0=hd590300_1 + - brotli-bin=1.1.0=hd590300_1 + - brotli-python=1.1.0=py310hc6cd4ac_1 + - bson=0.5.9=py_0 + - bzip2=1.0.8=hd590300_5 + - c-ares=1.28.1=hd590300_0 + - c-blosc2=2.14.4=hb4ffafa_1 + - ca-certificates=2024.8.30=hbcca054_0 + - cached-property=1.5.2=hd8ed1ab_1 + - cached_property=1.5.2=pyha770c72_1 + - cachetools=5.3.3=pyhd8ed1ab_0 + - cairo=1.18.0=h3faef2a_0 + - certifi=2024.8.30=pyhd8ed1ab_0 + - cffi=1.16.0=py310h2fee648_0 + - charset-normalizer=3.3.2=pyhd8ed1ab_0 + - colorama=0.4.6=pyhd8ed1ab_0 + - comm=0.2.2=pyhd8ed1ab_0 + - conda=24.5.0=py310h06a4308_0 + - conda-libmamba-solver=24.1.0=pyhd8ed1ab_0 + - conda-package-handling=2.2.0=pyh38be061_0 + - conda-package-streaming=0.9.0=pyhd8ed1ab_0 + - contourpy=1.2.1=py310hd41b1e2_0 + - cuda-cudart=12.1.105=0 + - cuda-cupti=12.1.105=0 + - cuda-libraries=12.1.0=0 + - cuda-nvrtc=12.1.105=0 + - cuda-nvtx=12.1.105=0 + - cuda-opencl=12.4.127=0 + - cuda-runtime=12.1.0=0 + - cudatoolkit=11.8.0=h4ba93d1_13 + - cycler=0.12.1=pyhd8ed1ab_0 + - cython=3.0.10=py310hc6cd4ac_0 + - debugpy=1.8.1=py310hc6cd4ac_0 + - decorator=5.1.1=pyhd8ed1ab_0 + - defusedxml=0.7.1=pyhd8ed1ab_0 + - distro=1.9.0=pyhd8ed1ab_0 + - entrypoints=0.4=pyhd8ed1ab_0 + - exceptiongroup=1.2.0=pyhd8ed1ab_2 + - executing=2.0.1=pyhd8ed1ab_0 + - expat=2.6.2=h59595ed_0 + - ffmpeg=4.3=hf484d3e_0 + - fftw=3.3.10=nompi_hc118613_108 + - filelock=3.13.4=pyhd8ed1ab_0 + - fmt=10.2.1=h00ab1b0_0 + - font-ttf-dejavu-sans-mono=2.37=hab24e00_0 + - font-ttf-inconsolata=3.000=h77eed37_0 + - font-ttf-source-code-pro=2.038=h77eed37_0 + - font-ttf-ubuntu=0.83=h77eed37_1 + - fontconfig=2.14.2=h14ed4e7_0 + - fonts-conda-ecosystem=1=0 + - fonts-conda-forge=1=0 + - fonttools=4.51.0=py310h2372a71_0 + - fqdn=1.5.1=pyhd8ed1ab_0 + - freetype=2.12.1=h267a509_2 + - frozendict=2.4.2=py310h5eee18b_0 + - frozenlist=1.4.1=py310h2372a71_0 + - fsspec=2024.3.1=pyhca7485f_0 + - gmp=6.3.0=h59595ed_1 + - gmpy2=2.1.2=py310h3ec546c_1 + - gnutls=3.6.13=h85f3911_1 + - greenlet=3.0.3=py310hc6cd4ac_0 + - h11=0.14.0=pyhd8ed1ab_0 + - h2=4.1.0=pyhd8ed1ab_0 + - hdf4=4.2.15=h9772cbc_5 + - hdf5=1.14.3=nompi_h4f84152_100 + - hpack=4.0.0=pyh9f0ad1d_0 + - httpcore=1.0.5=pyhd8ed1ab_0 + - httpx=0.27.0=pyhd8ed1ab_0 + - hyperframe=6.0.1=pyhd8ed1ab_0 + - icu=73.2=h59595ed_0 + - idna=3.6=pyhd8ed1ab_0 + - importlib-metadata=7.1.0=pyha770c72_0 + - importlib_metadata=7.1.0=hd8ed1ab_0 + - importlib_resources=6.4.0=pyhd8ed1ab_0 + - ipykernel=6.29.3=pyhd33586a_0 + - ipython=8.22.2=pyh707e725_0 + - ipywidgets=8.1.2=pyhd8ed1ab_0 + - isoduration=20.11.0=pyhd8ed1ab_0 + - jedi=0.19.1=pyhd8ed1ab_0 + - jinja2=3.1.3=pyhd8ed1ab_0 + - joblib=1.4.0=pyhd8ed1ab_0 + - jpeg=9e=h166bdaf_2 + - json5=0.9.24=pyhd8ed1ab_0 + - jsonpatch=1.33=pyhd8ed1ab_0 + - jsonpointer=2.4=py310hff52083_3 + - jsonschema=4.21.1=pyhd8ed1ab_0 + - jsonschema-specifications=2023.12.1=pyhd8ed1ab_0 + - jsonschema-with-format-nongpl=4.21.1=pyhd8ed1ab_0 + - jupyter-lsp=2.2.5=pyhd8ed1ab_0 + - jupyter_client=8.6.1=pyhd8ed1ab_0 + - jupyter_core=5.7.2=py310hff52083_0 + - jupyter_events=0.10.0=pyhd8ed1ab_0 + - jupyter_server=2.14.0=pyhd8ed1ab_0 + - jupyter_server_terminals=0.5.3=pyhd8ed1ab_0 + - jupyterlab=4.1.6=pyhd8ed1ab_0 + - jupyterlab_pygments=0.3.0=pyhd8ed1ab_1 + - jupyterlab_server=2.26.0=pyhd8ed1ab_0 + - jupyterlab_widgets=3.0.10=pyhd8ed1ab_0 + - keyutils=1.6.1=h166bdaf_0 + - kiwisolver=1.4.5=py310hd41b1e2_1 + - krb5=1.21.2=h659d440_0 + - lame=3.100=h166bdaf_1003 + - lcms2=2.12=hddcbb42_0 + - ld_impl_linux-64=2.40=h41732ed_0 + - lerc=3.0=h9c3ff4c_0 + - libaec=1.1.3=h59595ed_0 + - libarchive=3.7.2=h2aa1ff5_1 + - libblas=3.9.0=16_linux64_mkl + - libbrotlicommon=1.1.0=hd590300_1 + - libbrotlidec=1.1.0=hd590300_1 + - libbrotlienc=1.1.0=hd590300_1 + - libcblas=3.9.0=16_linux64_mkl + - libcublas=12.1.0.26=0 + - libcufft=11.0.2.4=0 + - libcufile=1.9.1.3=0 + - libcurand=10.3.5.147=0 + - libcurl=8.7.1=hca28451_0 + - libcusolver=11.4.4.55=0 + - libcusparse=12.0.2.55=0 + - libdeflate=1.10=h7f98852_0 + - libedit=3.1.20191231=he28a2e2_2 + - libev=4.33=hd590300_2 + - libexpat=2.6.2=h59595ed_0 + - libffi=3.4.2=h7f98852_5 + - libgcc=14.2.0=h77fa898_1 + - libgcc-ng=14.2.0=h69a702a_1 + - libgfortran-ng=13.2.0=h69a702a_5 + - libgfortran5=13.2.0=ha4646dd_5 + - libglib=2.80.0=hf2295e7_4 + - libgomp=14.2.0=h77fa898_1 + - libhwloc=2.9.3=default_h554bfaf_1009 + - libiconv=1.17=hd590300_2 + - libjpeg-turbo=2.0.0=h9bf148f_0 + - liblapack=3.9.0=16_linux64_mkl + - liblapacke=3.9.0=16_linux64_mkl + - libmamba=1.5.8=had39da4_0 + - libmambapy=1.5.8=py310h39ff949_0 + - libnetcdf=4.9.2=nompi_h9612171_113 + - libnghttp2=1.58.0=h47da74e_1 + - libnpp=12.0.2.50=0 + - libnsl=2.0.1=hd590300_0 + - libnvjitlink=12.1.105=0 + - libnvjpeg=12.1.1.14=0 + - libpng=1.6.43=h2797004_0 + - libsodium=1.0.18=h36c2ea0_1 + - libsolv=0.7.28=hfc55251_2 + - libsqlite=3.45.2=h2797004_0 + - libssh2=1.11.0=h0841786_0 + - libstdcxx-ng=13.2.0=h7e041cc_5 + - libtiff=4.3.0=h0fcbabc_4 + - libuuid=2.38.1=h0b41bf4_0 + - libwebp-base=1.3.2=hd590300_1 + - libxcb=1.15=h0b41bf4_0 + - libxcrypt=4.4.36=hd590300_1 + - libxml2=2.12.6=h232c23b_1 + - libxslt=1.1.39=h76b75d6_0 + - libzip=1.10.1=h2629f0a_3 + - libzlib=1.2.13=hd590300_5 + - lightning-utilities=0.11.2=pyhd8ed1ab_0 + - llvm-openmp=15.0.7=h0cdce71_0 + - loguru=0.7.2=py310hff52083_2 + - lxml=5.1.0=py310hcfd0673_0 + - lz4-c=1.9.4=hcb278e6_0 + - lzo=2.10=h516909a_1000 + - mamba=1.5.8=py310h51d5547_0 + - markupsafe=2.1.5=py310h2372a71_0 + - matplotlib-base=3.8.4=py310h62c0568_0 + - matplotlib-inline=0.1.6=pyhd8ed1ab_0 + - mda-xdrlib=0.2.0=pyhd8ed1ab_0 + - mdtraj=1.9.9=py310h523e8d7_1 + - menuinst=2.0.2=py310hff52083_0 + - mistune=3.0.2=pyhd8ed1ab_0 + - mkl=2022.1.0=h84fe81f_915 + - mkl-devel=2022.1.0=ha770c72_916 + - mkl-include=2022.1.0=h84fe81f_915 + - mpc=1.3.1=hfe3b2da_0 + - mpfr=4.2.1=h9458935_1 + - mpmath=1.3.0=pyhd8ed1ab_0 + - multidict=6.0.5=py310h2372a71_0 + - munkres=1.1.4=pyh9f0ad1d_0 + - nbclient=0.10.0=pyhd8ed1ab_0 + - nbconvert-core=7.16.3=pyhd8ed1ab_1 + - nbformat=5.10.4=pyhd8ed1ab_0 + - ncurses=6.4.20240210=h59595ed_0 + - nest-asyncio=1.6.0=pyhd8ed1ab_0 + - netcdf-fortran=4.6.1=nompi_hacb5139_103 + - nettle=3.6=he412f7d_0 + - networkx=3.2=pyhd8ed1ab_0 + - notebook=7.1.2=pyhd8ed1ab_0 + - notebook-shim=0.2.4=pyhd8ed1ab_0 + - ocl-icd=2.3.2=hd590300_1 + - ocl-icd-system=1.0.0=1 + - olefile=0.47=pyhd8ed1ab_0 + - openbabel=3.1.1=py310hbff9852_9 + - openff-amber-ff-ports=0.0.4=pyhca7485f_0 + - openff-forcefields=2024.03.0=pyhca7485f_0 + - openff-interchange=0.3.25=pyhd8ed1ab_1 + - openff-interchange-base=0.3.25=pyhd8ed1ab_1 + - openff-models=0.1.2=pyhca7485f_0 + - openff-toolkit=0.15.2=pyhd8ed1ab_0 + - openff-toolkit-base=0.15.2=pyhd8ed1ab_0 + - openff-units=0.2.2=pyhca7485f_0 + - openff-utilities=0.1.12=pyhd8ed1ab_0 + - openh264=2.1.1=h780b84a_0 + - openjpeg=2.5.0=h7d73246_0 + - openmm=8.1.1=py310h43b6314_1 + - openmmforcefields=0.12.0=pyhd8ed1ab_0 + - openssl=3.4.0=hb9d3cd8_0 + - overrides=7.7.0=pyhd8ed1ab_0 + - packaging=24.0=pyhd8ed1ab_0 + - packmol=20.010=h86c2bf4_0 + - pandas=2.1.2=py310hcc13569_0 + - pandocfilters=1.5.0=pyhd8ed1ab_0 + - panedr=0.8.0=pyhd8ed1ab_0 + - parmed=4.2.2=py310hc6cd4ac_1 + - parso=0.8.4=pyhd8ed1ab_0 + - pcre2=10.43=hcad00b1_0 + - pdbfixer=1.9=pyh1a96a4e_0 + - perl=5.32.1=7_hd590300_perl5 + - pexpect=4.9.0=pyhd8ed1ab_0 + - pickleshare=0.7.5=py_1003 + - pillow=8.4.0=py310h07f4688_0 + - pint=0.23=pyhd8ed1ab_0 + - pip=24.0=pyhd8ed1ab_0 + - pixman=0.43.2=h59595ed_0 + - pkgutil-resolve-name=1.3.10=pyhd8ed1ab_1 + - platformdirs=4.2.0=pyhd8ed1ab_0 + - pluggy=1.4.0=pyhd8ed1ab_0 + - plyfile=1.0.1=pyhd8ed1ab_0 + - prody=2.4.0=py310heca2aa9_0 + - prometheus_client=0.20.0=pyhd8ed1ab_0 + - prompt-toolkit=3.0.42=pyha770c72_0 + - psutil=5.9.8=py310h2372a71_0 + - pthread-stubs=0.4=h36c2ea0_1001 + - ptyprocess=0.7.0=pyhd3deb0d_0 + - pure_eval=0.2.2=pyhd8ed1ab_0 + - py-cpuinfo=9.0.0=pyhd8ed1ab_0 + - pybind11-abi=4=hd8ed1ab_3 + - pycairo=1.26.0=py310hda9f760_0 + - pycosat=0.6.6=py310h2372a71_0 + - pycparser=2.22=pyhd8ed1ab_0 + - pydantic=2.7.0=pyhd8ed1ab_0 + - pydantic-core=2.18.1=py310hcb5633a_0 + - pyedr=0.8.0=pyhd8ed1ab_0 + - pyg=2.5.2=py310_torch_2.2.0_cu121 + - pygments=2.17.2=pyhd8ed1ab_0 + - pyparsing=3.1.2=pyhd8ed1ab_0 + - pysocks=1.7.1=pyha2e5f31_6 + - pytables=3.9.2=py310hd76cd5d_2 + - python=3.10.0=h543edf9_3_cpython + - python-constraint=1.4.0=py_0 + - python-dateutil=2.9.0=pyhd8ed1ab_0 + - python-fastjsonschema=2.19.1=pyhd8ed1ab_0 + - python-json-logger=2.0.7=pyhd8ed1ab_0 + - python-tzdata=2024.1=pyhd8ed1ab_0 + - python_abi=3.10=4_cp310 + - pytorch=2.2.2=py3.10_cuda12.1_cudnn8.9.2_0 + - pytorch-cuda=12.1=ha16c6d3_5 + - pytorch-mutex=1.0=cuda + - pytz=2024.1=pyhd8ed1ab_0 + - pyyaml=6.0.1=py310h2372a71_1 + - pyzmq=25.1.2=py310h795f18f_0 + - readline=8.2=h8228510_1 + - reduce=3.24=0 + - referencing=0.34.0=pyhd8ed1ab_0 + - reportlab=3.5.68=py310h94fcab3_1 + - reproc=14.2.4.post0=hd590300_1 + - reproc-cpp=14.2.4.post0=h59595ed_1 + - requests=2.31.0=pyhd8ed1ab_0 + - rfc3339-validator=0.1.4=pyhd8ed1ab_0 + - rfc3986-validator=0.1.1=pyh9f0ad1d_0 + - rpds-py=0.18.0=py310hcb5633a_0 + - ruamel.yaml=0.18.6=py310h2372a71_0 + - ruamel.yaml.clib=0.2.8=py310h2372a71_0 + - scipy=1.8.1=py310hdfbd76f_2 + - send2trash=1.8.3=pyh0d859eb_0 + - setuptools=69.2.0=pyhd8ed1ab_0 + - six=1.16.0=pyh6c4a22f_0 + - smirnoff99frosst=1.1.0=pyh44b312d_0 + - snappy=1.2.0=hdb0a2a9_1 + - sniffio=1.3.1=pyhd8ed1ab_0 + - soupsieve=2.5=pyhd8ed1ab_1 + - sqlalchemy=2.0.29=py310h2372a71_0 + - sqlite=3.45.2=h2c6b66d_0 + - stack_data=0.6.2=pyhd8ed1ab_0 + - sympy=1.12=pypyh9d50eac_103 + - tbb=2021.11.0=h00ab1b0_1 + - terminado=0.18.1=pyh0d859eb_0 + - threadpoolctl=3.4.0=pyhc1e730c_0 + - tinycss2=1.2.1=pyhd8ed1ab_0 + - tinydb=4.8.0=pyhd8ed1ab_0 + - tk=8.6.13=noxft_h4845f30_101 + - tomli=2.0.1=pyhd8ed1ab_0 + - torch-ema=0.3=pyhd8ed1ab_0 + - torchaudio=2.2.2=py310_cu121 + - torchmetrics=1.2.1=pyhd8ed1ab_0 + - torchtriton=2.2.0=py310 + - torchvision=0.17.2=py310_cu121 + - tornado=6.4=py310h2372a71_0 + - tqdm=4.66.2=pyhd8ed1ab_0 + - traitlets=5.14.2=pyhd8ed1ab_0 + - truststore=0.8.0=pyhd8ed1ab_0 + - types-python-dateutil=2.9.0.20240316=pyhd8ed1ab_0 + - typing-extensions=4.11.0=hd8ed1ab_0 + - typing_extensions=4.11.0=pyha770c72_0 + - typing_utils=0.1.0=pyhd8ed1ab_0 + - tzdata=2024a=h0c530f3_0 + - unicodedata2=15.1.0=py310h2372a71_0 + - uri-template=1.3.0=pyhd8ed1ab_0 + - urllib3=2.2.1=pyhd8ed1ab_0 + - validators=0.28.0=pyhd8ed1ab_0 + - wcwidth=0.2.13=pyhd8ed1ab_0 + - webcolors=1.13=pyhd8ed1ab_0 + - webencodings=0.5.1=pyhd8ed1ab_2 + - websocket-client=1.7.0=pyhd8ed1ab_0 + - wheel=0.43.0=pyhd8ed1ab_1 + - widgetsnbextension=4.0.10=pyhd8ed1ab_0 + - xmltodict=0.13.0=pyhd8ed1ab_0 + - xorg-kbproto=1.0.7=h7f98852_1002 + - xorg-libice=1.1.1=hd590300_0 + - xorg-libsm=1.2.4=h7391055_0 + - xorg-libx11=1.8.9=h8ee46fc_0 + - xorg-libxau=1.0.11=hd590300_0 + - xorg-libxdmcp=1.1.3=h7f98852_0 + - xorg-libxext=1.3.4=h0b41bf4_2 + - xorg-libxrender=0.9.11=hd590300_0 + - xorg-libxt=1.3.0=hd590300_1 + - xorg-renderproto=0.11.1=h7f98852_1002 + - xorg-xextproto=7.3.0=h0b41bf4_1003 + - xorg-xproto=7.0.31=h7f98852_1007 + - xz=5.2.6=h166bdaf_0 + - yaml=0.2.5=h7f98852_2 + - yaml-cpp=0.8.0=h59595ed_0 + - yarl=1.9.4=py310h2372a71_0 + - zeromq=4.3.5=h59595ed_1 + - zipp=3.17.0=pyhd8ed1ab_0 + - zlib=1.2.13=hd590300_5 + - zlib-ng=2.0.7=h0b41bf4_0 + - zstandard=0.22.0=py310h1275a96_0 + - zstd=1.5.5=hfc55251_0 + - pip: + - accelerate==0.15.0 + - amberlite==22.0 + - amberutils==21.0 + - appdirs==1.4.4 + - biopython==1.79 + - click==8.1.7 + - dimorphite-dl==1.3.2 + - docker-pycreds==0.4.0 + - e3nn==0.5.1 + - et-xmlfile==1.1.0 + - fair-esm==2.0.1 + - fasteners==0.19 + - gitdb==4.0.11 + - gitpython==3.1.43 + - griddataformats==1.0.2 + - gsd==3.2.1 + - huggingface-hub==0.17.3 + - jupyter==1.0.0 + - jupyter-console==6.6.3 + - mdanalysis==2.4.0 + - mmpbsa-py==16.0 + - mmtf-python==1.1.3 + - mrcfile==1.5.0 + - msgpack==1.0.8 + - numexpr==2.10.0 + - numpy==1.24.4 + - openpyxl==3.1.3 + - opt-einsum==3.3.0 + - opt-einsum-fx==0.1.4 + - packmol-memgen==1.2.3rc0 + - pdb4amber==22.0 + - posebusters==0.2.13 + - prefetch-generator==1.0.3 + - protobuf==4.25.3 + - pyg-lib==0.4.0+pt22cu121 + - pymesh==1.0.2 + - pymesh2==0.3.1 + - pympler==1.0.1 + - pytraj==2.0.6 + - qtconsole==5.5.2 + - qtpy==2.4.1 + - rdkit==2023.3.1 + - rdkit-pypi==2022.9.5 + - regex==2023.12.25 + - sander==22.0 + - scikit-learn==1.3.2 + - sentry-sdk==1.45.0 + - setproctitle==1.3.3 + - smmap==5.0.1 + - spyrmsd==0.7.0 + - tokenizers==0.13.3 + - torch-cluster==1.6.3+pt22cu121 + - torch-scatter==2.1.2+pt22cu121 + - torch-sparse==0.6.18+pt22cu121 + - torch-spline-conv==1.2.2+pt22cu121 + - transformers==4.29.2 + - wandb==0.16.1 diff --git a/model/comp_surface/prepare_target/__init_.py b/model/comp_surface/prepare_target/__init_.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/model/comp_surface/prepare_target/computeAPBS.py b/model/comp_surface/prepare_target/computeAPBS.py new file mode 100644 index 0000000000000000000000000000000000000000..6d41637000d1eb57794977034193c5421732fad8 --- /dev/null +++ b/model/comp_surface/prepare_target/computeAPBS.py @@ -0,0 +1,116 @@ +import os +import numpy +from subprocess import Popen, PIPE +import pymesh +import tempfile + +from default_config.global_vars import apbs_bin, pdb2pqr_bin, multivalue_bin +import random + +""" +Modified from: +computeAPBS.py: Wrapper function to compute the Poisson Boltzmann electrostatics for a surface using APBS. +Pablo Gainza - LPDI STI EPFL 2019 +""" + +def computeAPBS(vertices, pdb_file, tmp_file_base,clear=False): + """ + Calls APBS, pdb2pqr, and multivalue and returns the charges per vertex + """ + if not clear: + pdb2pqr = pdb2pqr_bin + " --ff=parse --whitespace --noopt --apbs-input %s %s"# + tempfile.mktemp() + # pdb2pqr = pdb2pqr_bin + " --clean --whitespace --noopt --apbs-input %s %s"# + tempfile.mktemp() # 上一行由于确实太多办法计算表面的时候再用这个 + else: + pdb2pqr = pdb2pqr_bin + " --clean --whitespace --noopt --apbs-input %s %s"# + tempfile.mktemp() # 上一行由于确实太多办法计算表面的时候再用这个 + make_pqr = pdb2pqr % (pdb_file, tmp_file_base) + os.system(make_pqr) + print('os.system(make_pqr)',os.system(make_pqr)) + + apbs = apbs_bin + " %s" + make_apbs = apbs % (tmp_file_base+".in") + # os.system(make_apbs) + print(make_apbs) + print('os.system(make_apbs)',os.system(make_apbs)) + + vertfile = open(tmp_file_base + ".csv", "w") + for vert in vertices: + vertfile.write("{},{},{}\n".format(vert[0], vert[1], vert[2])) + vertfile.close() + + multivalue = multivalue_bin + " %s %s %s" + make_multivalue = multivalue % (tmp_file_base+".csv", tmp_file_base+".dx", tmp_file_base+"_out.csv") + # print(make_multivalue) + try: + os.system(make_multivalue) + except Exception as e: + print(e) + + + # Read the charge file + chargefile = open(tmp_file_base + "_out.csv") + charges = numpy.array([0.0] * len(vertices)) + for ix, line in enumerate(chargefile.readlines()): + charges[ix] = float(line.split(",")[3]) + # os.system("rm " + tmp_file_base + "*") + # os.system("rm io.mc") + + return charges + + + +""" ORIGINAL FUNCTION +''' +computeAPBS.py: Wrapper function to compute the Poisson Boltzmann electrostatics for a surface using APBS. +Pablo Gainza - LPDI STI EPFL 2019 +This file is part of MaSIF. +Released under an Apache License 2.0 +''' + +def computeAPBS(vertices, pdb_file, tmp_file_base = tempfile.mktemp()): + + #Calls APBS, pdb2pqr, and multivalue and returns the charges per vertex + + #fields = tmp_file_base.split("/")[0:-1] + #directory = "/".join(fields) + "/" + fields = tmp_file_base + directory = str(fields) + "/" + filename_base = tmp_file_base.split("/")[-1] + pdbname = pdb_file.split("/")[-1] + args = [ + pdb2pqr_bin, + "--ff=parse", + "--whitespace", + "--noopt", + "--apbs-input", + pdbname, + filename_base, + ] + p2 = Popen(args, stdout=PIPE, stderr=PIPE, cwd=directory) + stdout, stderr = p2.communicate() + + args = [apbs_bin, filename_base + ".in"] + p2 = Popen(args, stdout=PIPE, stderr=PIPE, cwd=directory) + stdout, stderr = p2.communicate() + + vertfile = open(directory + "/" + filename_base + ".csv", "w") + for vert in vertices: + vertfile.write("{},{},{}\n".format(vert[0], vert[1], vert[2])) + vertfile.close() + + args = [ + multivalue_bin, + filename_base + ".csv", + filename_base + ".dx", + filename_base + "_out.csv", + ] + p2 = Popen(args, stdout=PIPE, stderr=PIPE, cwd=directory) + stdout, stderr = p2.communicate() + + # Read the charge file + chargefile = open(tmp_file_base + "_out.csv") + charges = numpy.array([0.0] * len(vertices)) + for ix, line in enumerate(chargefile.readlines()): + charges[ix] = float(line.split(",")[3]) + + return charges +""" \ No newline at end of file diff --git a/model/comp_surface/prepare_target/computeCharges.py b/model/comp_surface/prepare_target/computeCharges.py new file mode 100644 index 0000000000000000000000000000000000000000..c4799c944c60d1e12e57b67e6d53596a28328cdd --- /dev/null +++ b/model/comp_surface/prepare_target/computeCharges.py @@ -0,0 +1,219 @@ +from Bio.PDB import * +import numpy as np +from sklearn.neighbors import KDTree + +""" +Modified from: +computeCharges.py - MaSIF +Pablo Gainza - LPDI STI EPFL 2019 +""" + +""" +computeCharges.py: Wrapper function to compute hydrogen bond potential (free electrons/protons) in the surface +Pablo Gainza - LPDI STI EPFL 2019 +This file is part of MaSIF. +Released under an Apache License 2.0 +""" + +from default_config.chemistry import ( + polarHydrogens, + radii, + acceptorAngleAtom, + acceptorPlaneAtom, + hbond_std_dev, + donorAtom, +) + +# Compute vertex charges based on hydrogen bond potential. +# pdb_filename: The filename of the protonated protein. +# vertices: The surface vertices of the protonated protein +# The name of each vertex in the format, example: B_125_x_ASN_ND2_Green +# where B is chain, 125 res id, x the insertion, ASN aatype, ND2 the name of the +# atom, and green is not used anymore. +def computeCharges(pdb_filename, vertices, names): + parser = PDBParser(QUIET=True) + struct = parser.get_structure(pdb_filename, pdb_filename + ".pdb") + residues = {} + for res in struct.get_residues(): + chain_id = res.get_parent().get_id() + if chain_id == "": + chain_id = " " + residues[(chain_id, res.get_id())] = res + + #atoms = Selection.unfold_entities(struct, "A") + atoms = struct.get_atoms() + satisfied_CO, satisfied_HN = computeSatisfied_CO_HN(atoms) + + charge = np.array([0.0] * len(vertices)) + # Go over every vertex + for ix, name in enumerate(names): + fields = name.split("_") + chain_id = fields[0] + if chain_id == "": + chain_id = " " + if fields[2] == "x": + fields[2] = " " + res_id = (" ", int(fields[1]), fields[2]) + aa = fields[3] + atom_name = fields[4] + # Ignore atom if it is BB and it is already satisfied. + if atom_name == "H" and res_id in satisfied_HN: + continue + if atom_name == "O" and res_id in satisfied_CO: + continue + # Compute the charge of the vertex + charge[ix] = computeChargeHelper( + atom_name, residues[(chain_id, res_id)], vertices[ix] + ) + + return charge + + +# Compute the charge of a vertex in a residue. +def computeChargeHelper(atom_name, res, v): + res_type = res.get_resname() + # Check if it is a polar hydrogen. + if isPolarHydrogen(atom_name, res): + donor_atom_name = donorAtom[atom_name] + a = res[donor_atom_name].get_coord() # N/O + b = res[atom_name].get_coord() # H + # Donor-H is always 180.0 degrees, = pi + angle_deviation = computeAngleDeviation(a, b, v, np.pi) + angle_penalty = computeAnglePenalty(angle_deviation) + return 1.0 * angle_penalty + # Check if it is an acceptor oxygen or nitrogen + elif isAcceptorAtom(atom_name, res): + acceptor_atom = res[atom_name] + b = acceptor_atom.get_coord() + a = res[acceptorAngleAtom[atom_name]].get_coord() + # 120 degress for acceptor + angle_deviation = computeAngleDeviation(a, b, v, 2 * np.pi / 3) + # TODO: This should not be 120 for all atoms, i.e. for HIS it should be + # ~125.0 + angle_penalty = computeAnglePenalty(angle_deviation) + plane_penalty = 1.0 + if atom_name in acceptorPlaneAtom: + try: + d = res[acceptorPlaneAtom[atom_name]].get_coord() + except: + return 0.0 + plane_deviation = computePlaneDeviation(d, a, b, v) + plane_penalty = computeAnglePenalty(plane_deviation) + return -1.0 * angle_penalty * plane_penalty + # Compute the + return 0.0 + + +# Compute the absolute value of the deviation from theta +def computeAngleDeviation(a, b, c, theta): + return abs(calc_angle(Vector(a), Vector(b), Vector(c)) - theta) + + +# Compute the angle deviation from a plane +def computePlaneDeviation(a, b, c, d): + dih = calc_dihedral(Vector(a), Vector(b), Vector(c), Vector(d)) + dev1 = abs(dih) + dev2 = np.pi - abs(dih) + return min(dev1, dev2) + + +# angle_deviation from ideal value. TODO: do a more data-based solution +def computeAnglePenalty(angle_deviation): + # Standard deviation: hbond_std_dev + return max(0.0, 1.0 - (angle_deviation / (hbond_std_dev)) ** 2) + + +def isPolarHydrogen(atom_name, res): + if atom_name in polarHydrogens[res.get_resname()]: + return True + else: + return False + + +def isAcceptorAtom(atom_name, res): + if atom_name.startswith("O"): + return True + else: + if res.get_resname() == "HIS": + if atom_name == "ND1" and "HD1" not in res: + return True + if atom_name == "NE2" and "HE2" not in res: + return True + return False + + +# Compute the list of backbone C=O:H-N that are satisfied. These will be ignored. +def computeSatisfied_CO_HN(atoms): + ns = NeighborSearch(atoms) + satisfied_CO = set() + satisfied_HN = set() + for atom1 in atoms: + res1 = atom1.get_parent() + if atom1.get_id() == "O": + neigh_atoms = ns.search(atom1.get_coord(), 2.5, level="A") + for atom2 in neigh_atoms: + if atom2.get_id() == "H": + res2 = atom2.get_parent() + # Ensure they belong to different residues. + if res2.get_id() != res1.get_id(): + # Compute the angle N-H:O, ideal value is 180 (but in + # helices it is typically 160) 180 +-30 = pi + angle_N_H_O_dev = computeAngleDeviation( + res2["N"].get_coord(), + atom2.get_coord(), + atom1.get_coord(), + np.pi, + ) + # Compute angle H:O=C, ideal value is ~160 +- 20 = 8*pi/9 + angle_H_O_C_dev = computeAngleDeviation( + atom2.get_coord(), + atom1.get_coord(), + res1["C"].get_coord(), + 8 * np.pi / 9, + ) + ## Allowed deviations: 30 degrees (pi/6) and 20 degrees + # (pi/9) + if ( + angle_N_H_O_dev - np.pi / 6 < 0 + and angle_H_O_C_dev - np.pi / 9 < 0.0 + ): + satisfied_CO.add(res1.get_id()) + satisfied_HN.add(res2.get_id()) + return satisfied_CO, satisfied_HN + + +# Compute the charge of a new mesh, based on the charge of an old mesh. +# Use the top vertex in distance, for now (later this should be smoothed over 3 +# or 4 vertices) +def assignChargesToNewMesh(new_vertices, old_vertices, old_charges, seeder_opts): + dataset = old_vertices + testset = new_vertices + new_charges = np.zeros(len(new_vertices)) + if seeder_opts["feature_interpolation"]: + num_inter = 4 # Number of interpolation features + # Assign k old vertices to each new vertex. + kdt = KDTree(dataset) + dists, result = kdt.query(testset, k=num_inter) + # Square the distances (as in the original pyflann) + dists = np.square(dists) + # The size of result is the same as new_vertices + for vi_new in range(len(result)): + vi_old = result[vi_new] + dist_old = dists[vi_new] + # If one vertex is right on top, ignore the rest. + if dist_old[0] == 0.0: + new_charges[vi_new] = old_charges[vi_old[0]] + continue + + total_dist = np.sum(1 / dist_old) + for i in range(num_inter): + new_charges[vi_new] += ( + old_charges[vi_old[i]] * (1 / dist_old[i]) / total_dist + ) + else: + # Assign k old vertices to each new vertex. + kdt = KDTree(dataset) + dists, result = kdt.query(testset) + new_charges = old_charges[result] + return new_charges + diff --git a/model/comp_surface/prepare_target/computeHydrophobicity.py b/model/comp_surface/prepare_target/computeHydrophobicity.py new file mode 100644 index 0000000000000000000000000000000000000000..dc24c2237be151dfc895d9322c7a5f34678f961e --- /dev/null +++ b/model/comp_surface/prepare_target/computeHydrophobicity.py @@ -0,0 +1,39 @@ +import numpy as np + +""" +Taken from: +computeHydrophobicity.py - MaSIF +Pablo Gainza - LPDI STI EPFL 2019 +""" + +# Kyte Doolittle scale +kd_scale = {} +kd_scale["ILE"] = 4.5 +kd_scale["VAL"] = 4.2 +kd_scale["LEU"] = 3.8 +kd_scale["PHE"] = 2.8 +kd_scale["CYS"] = 2.5 +kd_scale["MET"] = 1.9 +kd_scale["ALA"] = 1.8 +kd_scale["GLY"] = -0.4 +kd_scale["THR"] = -0.7 +kd_scale["SER"] = -0.8 +kd_scale["TRP"] = -0.9 +kd_scale["TYR"] = -1.3 +kd_scale["PRO"] = -1.6 +kd_scale["HIS"] = -3.2 +kd_scale["GLU"] = -3.5 +kd_scale["GLN"] = -3.5 +kd_scale["ASP"] = -3.5 +kd_scale["ASN"] = -3.5 +kd_scale["LYS"] = -3.9 +kd_scale["ARG"] = -4.5 + +# For each vertex in names, compute +def computeHydrophobicity(names): + hp = np.zeros(len(names)) + for ix, name in enumerate(names): + aa = name.split("_")[3] + hp[ix] = kd_scale[aa] + return hp + diff --git a/model/comp_surface/prepare_target/computeMSMS.py b/model/comp_surface/prepare_target/computeMSMS.py new file mode 100644 index 0000000000000000000000000000000000000000..aa7d5ea0fad2cdb6fc95399baea3acbafd9f005d --- /dev/null +++ b/model/comp_surface/prepare_target/computeMSMS.py @@ -0,0 +1,53 @@ +import os +from subprocess import Popen, PIPE + +from input_output.read_msms import read_msms +from triangulation.xyzrn import output_pdb_as_xyzrn +from default_config.global_vars import msms_bin +from default_config.masif_opts import masif_opts +import random + +""" +Modified from: +computeMSMS.py - MaSIF +Pablo Gainza - LPDI STI EPFL 2019 +""" + +# Pablo Gainza LPDI EPFL 2017-2019 +# Calls MSMS and returns the vertices. +# Special atoms are atoms with a reduced radius. +import time +def computeMSMS(pdb_file, protonate=True, one_cavity=None): + randnum = random.randint(1,10000000) #+ time.time() + os.getpid() + file_base = masif_opts['tmp_dir']+"/msms_"+str(randnum) + out_xyzrn = file_base+".xyzrn" + + if protonate: + output_pdb_as_xyzrn(pdb_file, out_xyzrn) + else: + print("Error - pdb2xyzrn is deprecated.") + sys.exit(1) + # Now run MSMS on xyzrn file + FNULL = open(os.devnull, 'w') + if one_cavity is not None: + args = [msms_bin, "-density", "3.0", "-hdensity", "3.0", "-probe", "1.5",\ + "-one_cavity", str(1), str(one_cavity),\ + "-if",out_xyzrn,"-of",file_base, "-af", file_base] + else: + args = [msms_bin, "-density", "3.0", "-hdensity", "3.0", "-probe",\ + "1.5", "-all_components", "-if",out_xyzrn,"-of",file_base, "-af", file_base] + #print msms_bin+" "+`args` + p2 = Popen(args, stdout=PIPE, stderr=PIPE) + stdout, stderr = p2.communicate() + print(stdout, stderr) + + vertices, faces, normals, names = read_msms(file_base) + areas = {} + ses_file = open(file_base+".area") + next(ses_file) # ignore header line + for line in ses_file: + fields = line.split() + areas[fields[3]] = fields[1] + # os.system("rm " + file_base + "*") + return vertices, faces, normals, names, areas + diff --git a/model/comp_surface/prepare_target/computeTargetMesh.py b/model/comp_surface/prepare_target/computeTargetMesh.py new file mode 100644 index 0000000000000000000000000000000000000000..e77eada58aba825f1ba5e1125bdfdf4b3f965d50 --- /dev/null +++ b/model/comp_surface/prepare_target/computeTargetMesh.py @@ -0,0 +1,254 @@ +import os +import sys +import numpy as np +import shutil +import pymesh +import Bio.PDB +from Bio.PDB import * +from rdkit import Chem +import warnings +warnings.filterwarnings("ignore") +from IPython.utils import io +from sklearn.neighbors import KDTree +from scipy.spatial import distance + +sys.path.append('/home/caoduanhua/DeepDock') +import deepdock +sys.path.insert(0, deepdock.__path__[0]+'/masif/source') + +from default_config.masif_opts import masif_opts +from deepdock.prepare_target.compute_normal import compute_normal +from deepdock.prepare_target.computeAPBS import computeAPBS +from deepdock.prepare_target.computeCharges import computeCharges, assignChargesToNewMesh +from deepdock.prepare_target.computeHydrophobicity import computeHydrophobicity +from deepdock.prepare_target.computeMSMS import computeMSMS +from deepdock.prepare_target.fixmesh import fix_mesh +from deepdock.prepare_target.save_ply import save_ply +from deepdock.utils.mol2graph import * + +def compute_inp_surface(target_filename, ligand_filename,out_dir = None, dist_threshold=10): + # try: + sufix = '_'+str(dist_threshold+5)+'A.pdb' + # out_filename = os.path.splitext(target_filename)[0] + if out_dir is not None: + out_filename = os.path.join(out_dir,target_filename.split('/')[-2]) + os.makedirs(out_filename,exist_ok=True) + sufix = '/' + os.path.splitext(target_filename)[0].split('/')[-1] + '_'+str(dist_threshold+5)+'A.pdb' + else: + out_filename = os.path.splitext(target_filename)[0] + if os.path.exists(out_filename+f"/{sufix.split('.')[0]}.ply"): + print('have done skip!') + return 0 + input_filename = os.path.splitext(target_filename)[0] + # Get atom coordinates + # try: + if ligand_filename.endswith('.mol2'): + mol = Chem.MolFromMol2File(ligand_filename, sanitize=False, cleanupSubstructures=False) + if ligand_filename.endswith('.sdf'): + # print('mol2 faild try sdf') + mol = Chem.SDMolSupplier(ligand_filename, sanitize=False,removeHs = False)[0] + g = mol_to_nx(mol) + atomCoords = np.array([g.nodes[i]['pos'].tolist() for i in g.nodes]) + + # Read protein and select aminino acids in the binding pocket + parser = Bio.PDB.PDBParser(QUIET=True) # QUIET=True avoids comments on errors in the pdb. + + structures = parser.get_structure('target', input_filename+'.pdb') + structure = structures[0] # 'structures' may contain several proteins in this case only one. + + atoms = Bio.PDB.Selection.unfold_entities(structure, 'A') + ns = Bio.PDB.NeighborSearch(atoms) + + close_residues= [] + for a in atomCoords: + close_residues.extend(ns.search(a, dist_threshold+5, level='R')) + close_residues = Bio.PDB.Selection.uniqueify(close_residues) + + class SelectNeighbors(Select): + def accept_residue(self, residue): + if residue in close_residues: + if all(a in [i.get_name() for i in residue.get_unpacked_list()] for a in ['N', 'CA', 'C', 'O']) or residue.resname=='HOH': + return True + else: + return False + else: + return False + + pdbio = PDBIO() + pdbio.set_structure(structure) + pdbio.save(out_filename+sufix, SelectNeighbors()) + + # Identify closes atom to the ligand + structures = parser.get_structure('target', out_filename+sufix) + structure = structures[0] # 'structures' may contain several proteins in this case only one. + atoms = Bio.PDB.Selection.unfold_entities(structure, 'A') + + #dist = [distance.euclidean(atomCoords.mean(axis=0), a.get_coord()) for a in atoms] + #atom_idx = np.argmin(dist) + #dist = [[distance.euclidean(ac, a.get_coord()) for ac in atomCoords] for a in atoms] + #atom_idx = np.argsort(np.min(dist, axis=1))[0] + # Compute MSMS of surface w/hydrogens, + try: + dist = [distance.euclidean(atomCoords.mean(axis=0), a.get_coord()) for a in atoms] + atom_idx = np.argmin(dist) + vertices1, faces1, normals1, names1, areas1 = computeMSMS(out_filename+sufix,\ + protonate=True, one_cavity=atom_idx) + + # Find the distance between every vertex in binding site surface and each atom in the ligand. + kdt = KDTree(atomCoords) + d, r = kdt.query(vertices1) + assert(len(d) == len(vertices1)) + iface_v = np.where(d <= dist_threshold)[0] + faces_to_keep = [idx for idx, face in enumerate(faces1) if all(v in iface_v for v in face)] + + # Compute "charged" vertices + if masif_opts['use_hbond']: + vertex_hbond = computeCharges(input_filename, vertices1, names1) + + # For each surface residue, assign the hydrophobicity of its amino acid. + if masif_opts['use_hphob']: + vertex_hphobicity = computeHydrophobicity(names1) + + # If protonate = false, recompute MSMS of surface, but without hydrogens (set radius of hydrogens to 0). + vertices2 = vertices1 + faces2 = faces1 + + # Fix the mesh. + mesh = pymesh.form_mesh(vertices2, faces2) + mesh = pymesh.submesh(mesh, faces_to_keep, 0) + with io.capture_output() as captured: + regular_mesh = fix_mesh(mesh, masif_opts['mesh_res']) + + except: + try: + dist = [[distance.euclidean(ac, a.get_coord()) for ac in atomCoords] for a in atoms] + atom_idx = np.argsort(np.min(dist, axis=1))[0] + vertices1, faces1, normals1, names1, areas1 = computeMSMS(out_filename+sufix,\ + protonate=True, one_cavity=atom_idx) + + # Find the distance between every vertex in binding site surface and each atom in the ligand. + kdt = KDTree(atomCoords) + d, r = kdt.query(vertices1) + assert(len(d) == len(vertices1)) + iface_v = np.where(d <= dist_threshold)[0] + faces_to_keep = [idx for idx, face in enumerate(faces1) if all(v in iface_v for v in face)] + + # Compute "charged" vertices + if masif_opts['use_hbond']: + vertex_hbond = computeCharges(input_filename, vertices1, names1) + + # For each surface residue, assign the hydrophobicity of its amino acid. + if masif_opts['use_hphob']: + vertex_hphobicity = computeHydrophobicity(names1) + + # If protonate = false, recompute MSMS of surface, but without hydrogens (set radius of hydrogens to 0). + vertices2 = vertices1 + faces2 = faces1 + + # Fix the mesh. + mesh = pymesh.form_mesh(vertices2, faces2) + mesh = pymesh.submesh(mesh, faces_to_keep, 0) + with io.capture_output() as captured: + regular_mesh = fix_mesh(mesh, masif_opts['mesh_res']) + + except: + vertices1, faces1, normals1, names1, areas1 = computeMSMS(out_filename+sufix,\ + protonate=True, one_cavity=None) + + # Find the distance between every vertex in binding site surface and each atom in the ligand. + kdt = KDTree(atomCoords) + d, r = kdt.query(vertices1) + assert(len(d) == len(vertices1)) + iface_v = np.where(d <= dist_threshold)[0] + faces_to_keep = [idx for idx, face in enumerate(faces1) if all(v in iface_v for v in face)] + + # Compute "charged" vertices + if masif_opts['use_hbond']: + vertex_hbond = computeCharges(input_filename, vertices1, names1) + + # For each surface residue, assign the hydrophobicity of its amino acid. + if masif_opts['use_hphob']: + vertex_hphobicity = computeHydrophobicity(names1) + + # If protonate = false, recompute MSMS of surface, but without hydrogens (set radius of hydrogens to 0). + vertices2 = vertices1 + faces2 = faces1 + + # Fix the mesh. + mesh = pymesh.form_mesh(vertices2, faces2) + mesh = pymesh.submesh(mesh, faces_to_keep, 0) + with io.capture_output() as captured: + regular_mesh = fix_mesh(mesh, masif_opts['mesh_res']) + + # Compute the normals + vertex_normal = compute_normal(regular_mesh.vertices, regular_mesh.faces) + # Assign charges on new vertices based on charges of old vertices (nearest + # neighbor) + + if masif_opts['use_hbond']: + vertex_hbond = assignChargesToNewMesh(regular_mesh.vertices, vertices1,\ + vertex_hbond, masif_opts) + + if masif_opts['use_hphob']: + vertex_hphobicity = assignChargesToNewMesh(regular_mesh.vertices, vertices1,\ + vertex_hphobicity, masif_opts) + + if masif_opts['use_apbs']: + vertex_charges = computeAPBS(regular_mesh.vertices, out_filename+sufix, out_filename+"_temp") + + # Compute the principal curvature components for the shape index. + regular_mesh.add_attribute("vertex_mean_curvature") + H = regular_mesh.get_attribute("vertex_mean_curvature") + regular_mesh.add_attribute("vertex_gaussian_curvature") + K = regular_mesh.get_attribute("vertex_gaussian_curvature") + elem = np.square(H) - K + # In some cases this equation is less than zero, likely due to the method that computes the mean and gaussian curvature. + # set to an epsilon. + elem[elem<0] = 1e-8 + k1 = H + np.sqrt(elem) + k2 = H - np.sqrt(elem) + # Compute the shape index + si = (k1+k2)/(k1-k2) + si = np.arctan(si)*(2/np.pi) + + # Convert to ply and save. + save_ply(out_filename+f"/{sufix.split('.')[0]}.ply", regular_mesh.vertices,\ + regular_mesh.faces, normals=vertex_normal, charges=vertex_charges,\ + normalize_charges=True, hbond=vertex_hbond, hphob=vertex_hphobicity,\ + si=si) + os.system("rm " + f"{out_dir}/{target_filename.split('/')[-2]}*") + return 0 + # except: + # return target_filename + + +if __name__ == "__main__": + from joblib import delayed,Parallel + + + surface_dist = 10 + data_dir = '~/dockingModelTestDataset/' + + out_dir = ' ' + # 在out_dir 文件夹下执行 + sys.path.append(out_dir) + from tqdm import tqdm + import glob + args_list = [] + for protein in tqdm(os.listdir(data_dir)): + if os.path.isdir(os.path.join(data_dir,protein)): + + if protein in ['3TGG']: + + target_filename = os.path.join(data_dir,protein,f'{protein}_PRO.pdb') + if os.path.exists(os.path.join(data_dir,protein,f'{protein}_LIG_raw.sdf')): + ligand_filename = os.path.join(data_dir,protein,f'{protein}_LIG_raw.sdf') + else: + print(glob.glob(os.path.join(data_dir,protein,f'*_LIG.sdf'))) + print(protein) + ligand_filename = glob.glob(os.path.join(data_dir,protein,'*_LIG.sdf'))[0] + args_list.append((target_filename,ligand_filename)) + + results = Parallel(n_jobs = 30)(delayed(compute_inp_surface)(target_filename, ligand_filename,out_dir, dist_threshold=surface_dist-5) for (target_filename, ligand_filename) in tqdm(args_list)) + + print('sucess num : ',len([i for i in results if i == 0]),'all num : ',len(results)) \ No newline at end of file diff --git a/model/comp_surface/prepare_target/computeTargetMesh_test_samples.py b/model/comp_surface/prepare_target/computeTargetMesh_test_samples.py new file mode 100644 index 0000000000000000000000000000000000000000..60a4c2dd577cb72c1750f7396894b67bec010bb9 --- /dev/null +++ b/model/comp_surface/prepare_target/computeTargetMesh_test_samples.py @@ -0,0 +1,262 @@ +import os +import sys +import numpy as np +import shutil +import glob +import pymesh +import Bio.PDB +from Bio.PDB import * +from rdkit import Chem +import warnings +warnings.filterwarnings("ignore") +from IPython.utils import io +from sklearn.neighbors import KDTree +from scipy.spatial import distance + +from default_config.masif_opts import masif_opts +from compute_normal import compute_normal +from computeAPBS import computeAPBS +from computeCharges import computeCharges, assignChargesToNewMesh +from computeHydrophobicity import computeHydrophobicity +from computeMSMS import computeMSMS +from fixmesh import fix_mesh +from save_ply import save_ply +from mol2graph import * + + +def compute_inp_surface(target_filename, ligand_filename,out_dir = None, dist_threshold=10): + try: + + sufix = '_'+str(dist_threshold)+'A.pdb' + # out_filename = os.path.splitext(target_filename)[0] + if out_dir is not None: + out_filename = os.path.join(out_dir,ligand_filename.split('/')[-2]) + os.makedirs(out_filename,exist_ok=True) + sufix = '/' + os.path.splitext(target_filename)[0].split('/')[-1] + '_'+str(dist_threshold)+'A.pdb' + else: + out_filename = os.path.splitext(ligand_filename)[0] + if os.path.exists(out_filename+f"/{sufix.split('.pdb')[0]}.ply"): + print('have done skip!') + return 0 + input_filename = os.path.splitext(target_filename)[0] + # Get atom coordinates + # try: + # mol = Chem.MolFromMol2File(ligand_filename, sanitize=False, cleanupSubstructures=False) + # except: + # print('mol2 faild try sdf') + if ligand_filename.endswith('.sdf'): + mol = Chem.SDMolSupplier(ligand_filename, sanitize=False)[0] + elif ligand_filename.endswith('.pdb'): + mol = Chem.MolFromPDBFile(ligand_filename, sanitize=False) + g = mol_to_nx(mol) + atomCoords = np.array([g.nodes[i]['pos'].tolist() for i in g.nodes]) + + # Read protein and select aminino acids in the binding pocket + parser = Bio.PDB.PDBParser(QUIET=True) # QUIET=True avoids comments on errors in the pdb. + + structures = parser.get_structure('target', input_filename+'.pdb') + structure = structures[0] # 'structures' may contain several proteins in this case only one. + + atoms = Bio.PDB.Selection.unfold_entities(structure, 'A') + ns = Bio.PDB.NeighborSearch(atoms) + + close_residues= [] + for a in atomCoords: + close_residues.extend(ns.search(a, dist_threshold, level='R')) + close_residues = Bio.PDB.Selection.uniqueify(close_residues) + + class SelectNeighbors(Select): + def accept_residue(self, residue): + if residue in close_residues: + if all(a in [i.get_name() for i in residue.get_unpacked_list()] for a in ['N', 'CA', 'C', 'O']) or residue.resname=='HOH': + return True + else: + return False + else: + return False + + pdbio = PDBIO() + pdbio.set_structure(structure) + pdbio.save(out_filename+sufix, SelectNeighbors()) + + # Identify closes atom to the ligand + structures = parser.get_structure('target', out_filename+sufix) + structure = structures[0] # 'structures' may contain several proteins in this case only one. + atoms = Bio.PDB.Selection.unfold_entities(structure, 'A') + + #dist = [distance.euclidean(atomCoords.mean(axis=0), a.get_coord()) for a in atoms] + #atom_idx = np.argmin(dist) + #dist = [[distance.euclidean(ac, a.get_coord()) for ac in atomCoords] for a in atoms] + #atom_idx = np.argsort(np.min(dist, axis=1))[0] + + # Compute MSMS of surface w/hydrogens, + try: + dist = [distance.euclidean(atomCoords.mean(axis=0), a.get_coord()) for a in atoms] + atom_idx = np.argmin(dist) + vertices1, faces1, normals1, names1, areas1 = computeMSMS(out_filename+sufix,\ + protonate=True, one_cavity=atom_idx) + + # Find the distance between every vertex in binding site surface and each atom in the ligand. + kdt = KDTree(atomCoords) + d, r = kdt.query(vertices1) + assert(len(d) == len(vertices1)) + iface_v = np.where(d <= dist_threshold-5)[0] + faces_to_keep = [idx for idx, face in enumerate(faces1) if all(v in iface_v for v in face)] + + # Compute "charged" vertices + if masif_opts['use_hbond']: + vertex_hbond = computeCharges(input_filename, vertices1, names1) + + # For each surface residue, assign the hydrophobicity of its amino acid. + if masif_opts['use_hphob']: + vertex_hphobicity = computeHydrophobicity(names1) + + # If protonate = false, recompute MSMS of surface, but without hydrogens (set radius of hydrogens to 0). + vertices2 = vertices1 + faces2 = faces1 + + # Fix the mesh. + mesh = pymesh.form_mesh(vertices2, faces2) + mesh = pymesh.submesh(mesh, faces_to_keep, 0) + with io.capture_output() as captured: + regular_mesh = fix_mesh(mesh, masif_opts['mesh_res']) + + except: + try: + dist = [[distance.euclidean(ac, a.get_coord()) for ac in atomCoords] for a in atoms] + atom_idx = np.argsort(np.min(dist, axis=1))[0] + vertices1, faces1, normals1, names1, areas1 = computeMSMS(out_filename+sufix,\ + protonate=True, one_cavity=atom_idx) + + # Find the distance between every vertex in binding site surface and each atom in the ligand. + kdt = KDTree(atomCoords) + d, r = kdt.query(vertices1) + assert(len(d) == len(vertices1)) + iface_v = np.where(d <= dist_threshold-5)[0] + faces_to_keep = [idx for idx, face in enumerate(faces1) if all(v in iface_v for v in face)] + + # Compute "charged" vertices + if masif_opts['use_hbond']: + vertex_hbond = computeCharges(input_filename, vertices1, names1) + + # For each surface residue, assign the hydrophobicity of its amino acid. + if masif_opts['use_hphob']: + vertex_hphobicity = computeHydrophobicity(names1) + + # If protonate = false, recompute MSMS of surface, but without hydrogens (set radius of hydrogens to 0). + vertices2 = vertices1 + faces2 = faces1 + + # Fix the mesh. + mesh = pymesh.form_mesh(vertices2, faces2) + mesh = pymesh.submesh(mesh, faces_to_keep, 0) + with io.capture_output() as captured: + regular_mesh = fix_mesh(mesh, masif_opts['mesh_res']) + + except: + vertices1, faces1, normals1, names1, areas1 = computeMSMS(out_filename+sufix,\ + protonate=True, one_cavity=None) + + # Find the distance between every vertex in binding site surface and each atom in the ligand. + kdt = KDTree(atomCoords) + d, r = kdt.query(vertices1) + assert(len(d) == len(vertices1)) + iface_v = np.where(d <= dist_threshold-5)[0] + faces_to_keep = [idx for idx, face in enumerate(faces1) if all(v in iface_v for v in face)] + + # Compute "charged" vertices + if masif_opts['use_hbond']: + vertex_hbond = computeCharges(input_filename, vertices1, names1) + + # For each surface residue, assign the hydrophobicity of its amino acid. + if masif_opts['use_hphob']: + vertex_hphobicity = computeHydrophobicity(names1) + + # If protonate = false, recompute MSMS of surface, but without hydrogens (set radius of hydrogens to 0). + vertices2 = vertices1 + faces2 = faces1 + + # Fix the mesh. + mesh = pymesh.form_mesh(vertices2, faces2) + mesh = pymesh.submesh(mesh, faces_to_keep, 0) + with io.capture_output() as captured: + regular_mesh = fix_mesh(mesh, masif_opts['mesh_res']) + + # Compute the normals + vertex_normal = compute_normal(regular_mesh.vertices, regular_mesh.faces) + # Assign charges on new vertices based on charges of old vertices (nearest + # neighbor) + + if masif_opts['use_hbond']: + vertex_hbond = assignChargesToNewMesh(regular_mesh.vertices, vertices1,\ + vertex_hbond, masif_opts) + + if masif_opts['use_hphob']: + vertex_hphobicity = assignChargesToNewMesh(regular_mesh.vertices, vertices1,\ + vertex_hphobicity, masif_opts) + + if masif_opts['use_apbs']: + vertex_charges = computeAPBS(regular_mesh.vertices, out_filename+sufix, out_filename+"_temp") + + # Compute the principal curvature components for the shape index. + regular_mesh.add_attribute("vertex_mean_curvature") + H = regular_mesh.get_attribute("vertex_mean_curvature") + regular_mesh.add_attribute("vertex_gaussian_curvature") + K = regular_mesh.get_attribute("vertex_gaussian_curvature") + elem = np.square(H) - K + # In some cases this equation is less than zero, likely due to the method that computes the mean and gaussian curvature. + # set to an epsilon. + elem[elem<0] = 1e-8 + k1 = H + np.sqrt(elem) + k2 = H - np.sqrt(elem) + # Compute the shape index + si = (k1+k2)/(k1-k2) + si = np.arctan(si)*(2/np.pi) + + # Convert to ply and save. + save_ply(out_filename+f"/{sufix.split('.pdb')[0]}.ply", regular_mesh.vertices,\ + regular_mesh.faces, normals=vertex_normal, charges=vertex_charges,\ + normalize_charges=True, hbond=vertex_hbond, hphob=vertex_hphobicity,\ + si=si) + + return 0 + except: + return target_filename + + +if __name__ == "__main__": + from joblib import delayed,Parallel + # arguments + from argparse import ArgumentParser, Namespace, FileType + parser = ArgumentParser() + parser.add_argument('--data_dir', type=str, default='~/SurfDock/model/data/test_samples', help='') + parser.add_argument('--out_dir', type=str, default='~/SurfDock/model/data/test_samples_8A_surface', help='') + parser.add_argument('--n_jobs',type=int, default=1, help='Number of parallel jobs (-1 for all CPUs)') + args = parser.parse_args() + os.makedirs(args.out_dir,exist_ok=True) + + sys.path.append(args.out_dir) + from tqdm import tqdm + args_list = [] + for protein in tqdm(os.listdir(args.data_dir)): + if os.path.exists(os.path.join(args.out_dir,protein,f'{protein}_protein_processed_obabel_reduce_obabel.pdb')): + target_filename = os.path.join(args.out_dir,protein,f'{protein}_protein_processed_obabel_reduce_obabel.pdb') + elif os.path.exists(os.path.join(args.data_dir,protein,f'{protein}_protein_processed.pdb')): + target_filename = os.path.join(args.data_dir,protein,f'{protein}_protein_processed.pdb') + print(f'{protein} use {target_filename}; Please check this protein file was processed by openbabel reduce! in protein_process') + else: + print(f'{protein} not exists , Please check file name or path') + continue + ligand_filename = os.path.join(args.data_dir,protein,f'{protein}_ligand.sdf') + if not os.path.exists(ligand_filename): + ligand_filename = os.path.join(args.data_dir,protein,f'{protein}_ligand.mol2') + args_list.append((target_filename,ligand_filename)) + print(f'number {len(args_list)} need to processed.....') + results = Parallel(n_jobs = args.n_jobs,backend = 'multiprocessing')(delayed(compute_inp_surface)(target_filename, ligand_filename,args.out_dir, dist_threshold=8) for (target_filename, ligand_filename) in tqdm(args_list)) + # print(results) + # Find all files in args.out_dir that end with _temp + + files = glob.glob(os.path.join(args.out_dir, '*_temp*')) + glob.glob(os.path.join(args.out_dir, '*msms*')) + # Delete all found files + for f in files: + os.remove(f) diff --git a/model/comp_surface/prepare_target/compute_normal.py b/model/comp_surface/prepare_target/compute_normal.py new file mode 100644 index 0000000000000000000000000000000000000000..002a6d2814f6b0bc1e5688a844abe653e115aebe --- /dev/null +++ b/model/comp_surface/prepare_target/compute_normal.py @@ -0,0 +1,78 @@ +import numpy as np +from numpy.matlib import repmat +""" +compute_normal.py: Compute the normals of a closed shape. +Pablo Gainza - LPDI STI EPFL 2019 +This file is part of MaSIF, based on previous matlab code by Gabriel Peyre, converted to Python by Pablo Gainza +""" + +### +from default_config.global_vars import epsilon as eps + +""" +Taken from: +compute_normal.py - MaSIF +Pablo Gainza - LPDI STI EPFL 2019 +""" + + +def compute_normal(vertex, face): + + """ + compute_normal - compute the normal of a triangulation + vertex: 3xn matrix of vertices + face: 3xm matrix of face indices. + + normal,normalf = compute_normal(vertex,face) + + normal(i,:) is the normal at vertex i. + normalf(j,:) is the normal at face j. + + Copyright (c) 2004 Gabriel Peyr + Converted to Python by Pablo Gainza LPDI EPFL 2017 + """ + + vertex = vertex.T + face = face.T + nface = np.size(face, 1) + nvert = np.size(vertex, 1) + normal = np.zeros((3, nvert)) + # unit normals to the faces + normalf = crossp( + vertex[:, face[1, :]] - vertex[:, face[0, :]], + vertex[:, face[2, :]] - vertex[:, face[0, :]], + ) + sum_squares = np.sum(normalf ** 2, 0) + d = np.sqrt(sum_squares) + d[d < eps] = 1 + normalf = normalf / repmat(d, 3, 1) + # unit normal to the vertex + normal = np.zeros((3, nvert)) + for i in np.arange(0, nface): + f = face[:, i] + for j in np.arange(3): + normal[:, f[j]] = normal[:, f[j]] + normalf[:, i] + + # normalize + d = np.sqrt(np.sum(normal ** 2, 0)) + d[d < eps] = 1 + normal = normal / repmat(d, 3, 1) + # enforce that the normal are outward + vertex_means = np.mean(vertex, 0) + v = vertex - repmat(vertex_means, 3, 1) + s = np.sum(np.multiply(v, normal), 1) + if np.sum(s > 0) < np.sum(s < 0): + # flip + normal = -normal + normalf = -normalf + return normal.T + + +def crossp(x, y): + + # x and y are (m,3) dimensional + z = np.zeros((x.shape)) + z[0, :] = np.multiply(x[1, :], y[2, :]) - np.multiply(x[2, :], y[1, :]) + z[1, :] = np.multiply(x[2, :], y[0, :]) - np.multiply(x[0, :], y[2, :]) + z[2, :] = np.multiply(x[0, :], y[1, :]) - np.multiply(x[1, :], y[0, :]) + return z diff --git a/model/comp_surface/prepare_target/default_config/README.md b/model/comp_surface/prepare_target/default_config/README.md new file mode 100644 index 0000000000000000000000000000000000000000..925ce6bbadbbcf0df01b9a6bb95980e30313be4c --- /dev/null +++ b/model/comp_surface/prepare_target/default_config/README.md @@ -0,0 +1,3 @@ +### source/default_config/ +Contains MaSIF's default configuration options, and other parameters such as atom radiuses, the definition of polar hydrogens, +and the name of environment variables with external programs used by MaSIF. diff --git a/model/comp_surface/prepare_target/default_config/__init__.py b/model/comp_surface/prepare_target/default_config/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/model/comp_surface/prepare_target/default_config/chemistry.py b/model/comp_surface/prepare_target/default_config/chemistry.py new file mode 100644 index 0000000000000000000000000000000000000000..3e1b2c9abbfdd03c2b8ac58e159160616340f4e9 --- /dev/null +++ b/model/comp_surface/prepare_target/default_config/chemistry.py @@ -0,0 +1,152 @@ +# chemistry.py: Chemical parameters for MaSIF. +# Pablo Gainza - LPDI STI EPFL 2018-2019 +# Released under an Apache License 2.0 + +import numpy as np + +# radii for atoms in explicit case. +radii = {} +radii["N"] = "1.540000" +radii["N"] = "1.540000" +radii["O"] = "1.400000" +radii["C"] = "1.740000" +radii["H"] = "1.200000" +radii["S"] = "1.800000" +radii["P"] = "1.800000" +radii["Z"] = "1.39" +radii["X"] = "0.770000" ## Radii of CB or CA in disembodied case. +# This polar hydrogen's names correspond to that of the program Reduce. +polarHydrogens = {} +polarHydrogens["ALA"] = ["H"] +polarHydrogens["GLY"] = ["H"] +polarHydrogens["SER"] = ["H", "HG"] +polarHydrogens["THR"] = ["H", "HG1"] +polarHydrogens["LEU"] = ["H"] +polarHydrogens["ILE"] = ["H"] +polarHydrogens["VAL"] = ["H"] +polarHydrogens["ASN"] = ["H", "HD21", "HD22"] +polarHydrogens["GLN"] = ["H", "HE21", "HE22"] +polarHydrogens["ARG"] = ["H", "HH11", "HH12", "HH21", "HH22", "HE"] +polarHydrogens["HIS"] = ["H", "HD1", "HE2"] +polarHydrogens["TRP"] = ["H", "HE1"] +polarHydrogens["PHE"] = ["H"] +polarHydrogens["TYR"] = ["H", "HH"] +polarHydrogens["GLU"] = ["H"] +polarHydrogens["ASP"] = ["H"] +polarHydrogens["LYS"] = ["H", "HZ1", "HZ2", "HZ3"] +polarHydrogens["PRO"] = [] +polarHydrogens["CYS"] = ["H"] +polarHydrogens["MET"] = ["H"] + +hbond_std_dev = np.pi / 3 + +# Dictionary from an acceptor atom to its directly bonded atom on which to +# compute the angle. +acceptorAngleAtom = {} +acceptorAngleAtom["O"] = "C" +acceptorAngleAtom["O1"] = "C" +acceptorAngleAtom["O2"] = "C" +acceptorAngleAtom["OXT"] = "C" +acceptorAngleAtom["OT1"] = "C" +acceptorAngleAtom["OT2"] = "C" +# Dictionary from acceptor atom to a third atom on which to compute the plane. +acceptorPlaneAtom = {} +acceptorPlaneAtom["O"] = "CA" +# Dictionary from an H atom to its donor atom. +donorAtom = {} +donorAtom["H"] = "N" +# Hydrogen bond information. +# ARG +# ARG NHX +# Angle: NH1, HH1X, point and NH2, HH2X, point 180 degrees. +# radii from HH: radii[H] +# ARG NE +# Angle: ~ 120 NE, HE, point, 180 degrees +donorAtom["HH11"] = "NH1" +donorAtom["HH12"] = "NH1" +donorAtom["HH21"] = "NH2" +donorAtom["HH22"] = "NH2" +donorAtom["HE"] = "NE" + +# ASN +# Angle ND2,HD2X: 180 +# Plane: CG,ND2,OD1 +# Angle CG-OD1-X: 120 +donorAtom["HD21"] = "ND2" +donorAtom["HD22"] = "ND2" +# ASN Acceptor +acceptorAngleAtom["OD1"] = "CG" +acceptorPlaneAtom["OD1"] = "CB" + +# ASP +# Plane: CB-CG-OD1 +# Angle CG-ODX-point: 120 +acceptorAngleAtom["OD2"] = "CG" +acceptorPlaneAtom["OD2"] = "CB" + +# GLU +# PLANE: CD-OE1-OE2 +# ANGLE: CD-OEX: 120 +# GLN +# PLANE: CD-OE1-NE2 +# Angle NE2,HE2X: 180 +# ANGLE: CD-OE1: 120 +donorAtom["HE21"] = "NE2" +donorAtom["HE22"] = "NE2" +acceptorAngleAtom["OE1"] = "CD" +acceptorAngleAtom["OE2"] = "CD" +acceptorPlaneAtom["OE1"] = "CG" +acceptorPlaneAtom["OE2"] = "CG" + +# HIS Acceptors: ND1, NE2 +# Plane ND1-CE1-NE2 +# Angle: ND1-CE1 : 125.5 +# Angle: NE2-CE1 : 125.5 +acceptorAngleAtom["ND1"] = "CE1" +acceptorAngleAtom["NE2"] = "CE1" +acceptorPlaneAtom["ND1"] = "NE2" +acceptorPlaneAtom["NE2"] = "ND1" + +# HIS Donors: ND1, NE2 +# Angle ND1-HD1 : 180 +# Angle NE2-HE2 : 180 +donorAtom["HD1"] = "ND1" +donorAtom["HE2"] = "NE2" + +# TRP Donor: NE1-HE1 +# Angle NE1-HE1 : 180 +donorAtom["HE1"] = "NE1" + +# LYS Donor NZ-HZX +# Angle NZ-HZX : 180 +donorAtom["HZ1"] = "NZ" +donorAtom["HZ2"] = "NZ" +donorAtom["HZ3"] = "NZ" + +# TYR acceptor OH +# Plane: CE1-CZ-OH +# Angle: CZ-OH 120 +acceptorAngleAtom["OH"] = "CZ" +acceptorPlaneAtom["OH"] = "CE1" + +# TYR donor: OH-HH +# Angle: OH-HH 180 +donorAtom["HH"] = "OH" +acceptorPlaneAtom["OH"] = "CE1" + +# SER acceptor: +# Angle CB-OG-X: 120 +acceptorAngleAtom["OG"] = "CB" + +# SER donor: +# Angle: OG-HG-X: 180 +donorAtom["HG"] = "OG" + +# THR acceptor: +# Angle: CB-OG1-X: 120 +acceptorAngleAtom["OG1"] = "CB" + +# THR donor: +# Angle: OG1-HG1-X: 180 +donorAtom["HG1"] = "OG1" + diff --git a/model/comp_surface/prepare_target/default_config/global_vars.py b/model/comp_surface/prepare_target/default_config/global_vars.py new file mode 100644 index 0000000000000000000000000000000000000000..fb0617af92897135be4bde1d20bdcbaa57677ca2 --- /dev/null +++ b/model/comp_surface/prepare_target/default_config/global_vars.py @@ -0,0 +1,32 @@ +import os +from pathlib import Path +import sys + +epsilon = 1.0e-6 + +PROJECT_ROOT = Path(__file__).resolve().parents[4] +TOOLS_ROOT = PROJECT_ROOT / "model" / "comp_surface" / "tools" +if (TOOLS_ROOT / "transfer").exists(): + TOOLS_ROOT = TOOLS_ROOT / "transfer" + +msms_bin = str(TOOLS_ROOT / "APBS-3.4.1.Linux" / "bin" / "msms") +pdb2pqr_bin = str(TOOLS_ROOT / "pdb2pqr-linux-bin64-2.1.1" / "pdb2pqr") +apbs_bin = str(TOOLS_ROOT / "APBS-3.4.1.Linux" / "bin" / "apbs") +multivalue_bin = str(TOOLS_ROOT / "APBS-3.4.1.Linux" / "share" / "apbs" / "tools" / "bin" / "multivalue") + +os.environ["MSMS_BIN"] = msms_bin +os.environ["PDB2PQR_BIN"] = pdb2pqr_bin +os.environ["APBS_BIN"] = apbs_bin +os.environ["MULTIVALUE_BIN"] = multivalue_bin + +for name, path in { + "MSMS_BIN": msms_bin, + "PDB2PQR_BIN": pdb2pqr_bin, + "APBS_BIN": apbs_bin, + "MULTIVALUE_BIN": multivalue_bin, +}.items(): + if not os.path.exists(path): + print(f"ERROR: {name} does not exist: {path}", file=sys.stderr) + +class NoSolutionError(Exception): + pass diff --git a/model/comp_surface/prepare_target/default_config/masif_opts.py b/model/comp_surface/prepare_target/default_config/masif_opts.py new file mode 100644 index 0000000000000000000000000000000000000000..06509e6789111b15ff5f0f0b488f24e2fd81f0e2 --- /dev/null +++ b/model/comp_surface/prepare_target/default_config/masif_opts.py @@ -0,0 +1,83 @@ +import tempfile + +masif_opts = {} +# Default directories +masif_opts["raw_pdb_dir"] = "data_preparation/00-raw_pdbs/" +masif_opts["pdb_chain_dir"] = "data_preparation/01-benchmark_pdbs/" +masif_opts["ply_chain_dir"] = "data_preparation/01-benchmark_surfaces/" +masif_opts["tmp_dir"] = tempfile.gettempdir() +masif_opts["ply_file_template"] = masif_opts["ply_chain_dir"] + "/{}_{}.ply" + +# Surface features +masif_opts["use_hbond"] = True +masif_opts["use_hphob"] = True +masif_opts["use_apbs"] = True +masif_opts["compute_iface"] = True +# Mesh resolution. Everything gets very slow if it is lower than 1.0 +masif_opts["mesh_res"] = 1.0 +masif_opts["feature_interpolation"] = True + + +# Coords params +masif_opts["radius"] = 12.0 + +# Neural network patch application specific parameters. +masif_opts["ppi_search"] = {} +masif_opts["ppi_search"]["training_list"] = "lists/training.txt" +masif_opts["ppi_search"]["testing_list"] = "lists/testing.txt" +masif_opts["ppi_search"]["max_shape_size"] = 200 +masif_opts["ppi_search"]["max_distance"] = 12.0 # Radius for the neural network. +masif_opts["ppi_search"][ + "masif_precomputation_dir" +] = "data_preparation/04b-precomputation_12A/precomputation/" +masif_opts["ppi_search"]["feat_mask"] = [1.0] * 5 +masif_opts["ppi_search"]["max_sc_filt"] = 1.0 +masif_opts["ppi_search"]["min_sc_filt"] = 0.5 +masif_opts["ppi_search"]["pos_surf_accept_probability"] = 1.0 +masif_opts["ppi_search"]["pos_interface_cutoff"] = 1.0 +masif_opts["ppi_search"]["range_val_samples"] = 0.9 # 0.9 to 1.0 +masif_opts["ppi_search"]["cache_dir"] = "nn_models/sc05/cache/" +masif_opts["ppi_search"]["model_dir"] = "nn_models/sc05/all_feat/model_data/" +masif_opts["ppi_search"]["desc_dir"] = "descriptors/sc05/all_feat/" +masif_opts["ppi_search"]["gif_descriptors_out"] = "gif_descriptors/" +# Parameters for shape complementarity calculations. +masif_opts["ppi_search"]["sc_radius"] = 12.0 +masif_opts["ppi_search"]["sc_interaction_cutoff"] = 1.5 +masif_opts["ppi_search"]["sc_w"] = 0.25 + +# Neural network patch application specific parameters. +masif_opts["site"] = {} +masif_opts["site"]["training_list"] = "lists/training.txt" +masif_opts["site"]["testing_list"] = "lists/testing.txt" +masif_opts["site"]["max_shape_size"] = 100 +masif_opts["site"]["n_conv_layers"] = 3 +masif_opts["site"]["max_distance"] = 9.0 # Radius for the neural network. +masif_opts["site"][ + "masif_precomputation_dir" +] = "data_preparation/04a-precomputation_9A/precomputation/" +masif_opts["site"]["range_val_samples"] = 0.9 # 0.9 to 1.0 +masif_opts["site"]["model_dir"] = "nn_models/all_feat_3l/model_data/" +masif_opts["site"]["out_pred_dir"] = "output/all_feat_3l/pred_data/" +masif_opts["site"]["out_surf_dir"] = "output/all_feat_3l/pred_surfaces/" +masif_opts["site"]["feat_mask"] = [1.0] * 5 + +# Neural network ligand application specific parameters. +masif_opts["ligand"] = {} +masif_opts["ligand"]["assembly_dir"] = "data_preparation/00b-pdbs_assembly" +masif_opts["ligand"]["ligand_coords_dir"] = "data_preparation/00c-ligand_coords" +masif_opts["ligand"][ + "masif_precomputation_dir" +] = "data_preparation/04a-precomputation_12A/precomputation/" +masif_opts["ligand"]["max_shape_size"] = 200 +masif_opts["ligand"]["feat_mask"] = [1.0] * 5 +masif_opts["ligand"]["train_fract"] = 0.9 * 0.8 +masif_opts["ligand"]["val_fract"] = 0.1 * 0.8 +masif_opts["ligand"]["test_fract"] = 0.2 +masif_opts["ligand"]["tfrecords_dir"] = "data_preparation/tfrecords" +masif_opts["ligand"]["max_distance"] = 12.0 +masif_opts["ligand"]["n_classes"] = 7 +masif_opts["ligand"]["feat_mask"] = [1.0, 1.0, 1.0, 1.0, 1.0] +masif_opts["ligand"]["costfun"] = "dprime" +masif_opts["ligand"]["model_dir"] = "nn_models/all_feat/" +masif_opts["ligand"]["test_set_out_dir"] = "test_set_predictions/" + diff --git a/model/comp_surface/prepare_target/fix_pdb.py b/model/comp_surface/prepare_target/fix_pdb.py new file mode 100644 index 0000000000000000000000000000000000000000..01e30af9dd5d739960389d955bdcabff15283084 --- /dev/null +++ b/model/comp_surface/prepare_target/fix_pdb.py @@ -0,0 +1,22 @@ +from pdbfixer import PDBFixer +from openmm.app import PDBFile + + + +# Load the PDB file + +fixer = PDBFixer(filename='your_file.pdb') + +# Find missing residues +fixer.findMissingResidues() + +# Replace nonstandard residues +fixer.findNonstandardResidues() +fixer.replaceNonstandardResidues() + +# Find missing atoms and add them +fixer.findMissingAtoms() +fixer.addMissingAtoms() + +# Write the fixed PDB file +PDBFile.writeFile(fixer.topology, fixer.positions, open('fixed_pdb.pdb', 'w')) \ No newline at end of file diff --git a/model/comp_surface/prepare_target/fixmesh.py b/model/comp_surface/prepare_target/fixmesh.py new file mode 100644 index 0000000000000000000000000000000000000000..1d7065fe0d4d1aaa76bc739bb31a7a43c79116a5 --- /dev/null +++ b/model/comp_surface/prepare_target/fixmesh.py @@ -0,0 +1,71 @@ +import numpy as np +from numpy.linalg import norm +import pymesh + +""" +Modified from: +fixmesh.py - MaSIF +Pablo Gainza - LPDI STI EPFL 2019 +""" + +""" +fixmesh.py: Regularize a protein surface mesh. +- based on code from the PyMESH documentation. +""" + +def fix_mesh(mesh, resolution, detail="normal"): + bbox_min, bbox_max = mesh.bbox; + diag_len = norm(bbox_max - bbox_min); + if detail == "normal": + target_len = diag_len * 5e-3; + elif detail == "high": + target_len = diag_len * 2.5e-3; + elif detail == "low": + target_len = diag_len * 1e-2; + + target_len = resolution + #print("Target resolution: {} mm".format(target_len)); + # PGC 2017: Remove duplicated vertices first + mesh, _ = pymesh.remove_duplicated_vertices(mesh, 0.001) + + + count = 0; + print("Removing degenerated triangles") + mesh, __ = pymesh.remove_degenerated_triangles(mesh, 100); + mesh, __ = pymesh.split_long_edges(mesh, target_len); + num_vertices = mesh.num_vertices; + while True: + mesh, __ = pymesh.collapse_short_edges(mesh, 1e-6); + mesh, __ = pymesh.collapse_short_edges(mesh, target_len, + preserve_feature=True); + mesh, __ = pymesh.remove_obtuse_triangles(mesh, 150.0, 100); + if mesh.num_vertices == num_vertices: + break; + + num_vertices = mesh.num_vertices; + #print("#v: {}".format(num_vertices)); + count += 1; + if count > 10: break; + + mesh = pymesh.resolve_self_intersection(mesh); + mesh, __ = pymesh.remove_duplicated_faces(mesh); + #mesh = pymesh.compute_outer_hull(mesh); + + ############ Added by Oscar Mendez Lucio ############## + mesh = pymesh.compute_outer_hull(mesh, all_layers=True); + num_nodes = [i.num_nodes for i in mesh] + mesh = mesh[np.argmax(num_nodes)] + ############################################################ + + mesh, __ = pymesh.remove_duplicated_faces(mesh); + mesh, __ = pymesh.remove_obtuse_triangles(mesh, 179.0, 5); + mesh, __ = pymesh.remove_isolated_vertices(mesh); + mesh, _ = pymesh.remove_duplicated_vertices(mesh, 0.001) + + ############ Added by Oscar Mendez Lucio ############## + mesh = pymesh.separate_mesh(mesh) + num_nodes = [i.num_nodes for i in mesh] + mesh = mesh[np.argmax(num_nodes)] + ############################################################ + + return mesh diff --git a/model/comp_surface/prepare_target/input_output/README.md b/model/comp_surface/prepare_target/input_output/README.md new file mode 100644 index 0000000000000000000000000000000000000000..96c958dc3ca4d6020c277c60b5c1de4c16136222 --- /dev/null +++ b/model/comp_surface/prepare_target/input_output/README.md @@ -0,0 +1,2 @@ +### source/input_output/ +Contains functions to read/write surface files, protonate PDBs and extract PDB chains. diff --git a/model/comp_surface/prepare_target/input_output/__init__.py b/model/comp_surface/prepare_target/input_output/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/model/comp_surface/prepare_target/input_output/extractHelix.py b/model/comp_surface/prepare_target/input_output/extractHelix.py new file mode 100644 index 0000000000000000000000000000000000000000..81d7bd7d84de4b0c0b366bef3da2b6d37b65e779 --- /dev/null +++ b/model/comp_surface/prepare_target/input_output/extractHelix.py @@ -0,0 +1,32 @@ +from Bio.PDB import * + +# Exclude disordered atoms. +class NotDisordered(Select): + def accept_atom(self, atom): + return not atom.is_disordered() or atom.get_altloc() == 'A' + +def extractHelix(helix, infilename, outfilename, chain_ids=None, includeWaters=False,\ + invert=False): + parser = PDBParser(QUIET=True) + struct = parser.get_structure(infilename, infilename) + model = Selection.unfold_entities(struct, 'M')[0] + chains = Selection.unfold_entities(struct, 'C') + # Select residues to extract and build new structure + structBuild = StructureBuilder.StructureBuilder() + structBuild.init_structure("output") + structBuild.init_seg(" ") + structBuild.init_model(0) + outputStruct = structBuild.get_structure() + for chain in model: + if chain.get_id() in chain_ids: + structBuild.init_chain(chain.get_id()) + for residue in chain: + het = residue.get_id() + if het[0] == ' ' and het in helix: + outputStruct[0][chain.get_id()].add(residue) + + # Output the selected residues + pdbio = PDBIO() + pdbio.set_structure(outputStruct) + pdbio.save(outfilename, select=NotDisordered()) + diff --git a/model/comp_surface/prepare_target/input_output/extractPDB.py b/model/comp_surface/prepare_target/input_output/extractPDB.py new file mode 100644 index 0000000000000000000000000000000000000000..82ecc3a562cbc0704d7f348a77c5725c7fcae1f0 --- /dev/null +++ b/model/comp_surface/prepare_target/input_output/extractPDB.py @@ -0,0 +1,69 @@ +""" +extractPDB.py: Extract selected chains from a PDB and save the extracted chains to an output file. +Pablo Gainza - LPDI STI EPFL 2019 +Released under an Apache License 2.0 +""" +from Bio.PDB import * + +from Bio.SeqUtils import IUPACData +PROTEIN_LETTERS = [x.upper() for x in IUPACData.protein_letters_3to1.keys()] + +# Exclude disordered atoms. +class NotDisordered(Select): + def accept_atom(self, atom): + return not atom.is_disordered() or atom.get_altloc() == "A" or atom.get_altloc() == "1" + + +def find_modified_amino_acids(path): + """ + Contributed by github user jomimc - find modified amino acids in the PDB (e.g. MSE) + """ + res_set = set() + for line in open(path, 'r'): + if line[:6] == 'SEQRES': + for res in line.split()[4:]: + res_set.add(res) + for res in list(res_set): + if res in PROTEIN_LETTERS: + res_set.remove(res) + return res_set + + +def extractPDB( + infilename, outfilename, chain_ids=None +): + # extract the chain_ids from infilename and save in outfilename. + parser = PDBParser(QUIET=True) + struct = parser.get_structure(infilename, infilename) + model = Selection.unfold_entities(struct, "M")[0] + chains = Selection.unfold_entities(struct, "C") + # Select residues to extract and build new structure + structBuild = StructureBuilder.StructureBuilder() + structBuild.init_structure("output") + structBuild.init_seg(" ") + structBuild.init_model(0) + outputStruct = structBuild.get_structure() + + # Load a list of non-standard amino acid names -- these are + # typically listed under HETATM, so they would be typically + # ignored by the orginal algorithm + modified_amino_acids = find_modified_amino_acids(infilename) + + for chain in model: + if ( + chain_ids == None + or chain.get_id() in chain_ids + ): + structBuild.init_chain(chain.get_id()) + for residue in chain: + het = residue.get_id() + if het[0] == " ": + outputStruct[0][chain.get_id()].add(residue) + elif het[0][-3:] in modified_amino_acids: + outputStruct[0][chain.get_id()].add(residue) + + # Output the selected residues + pdbio = PDBIO() + pdbio.set_structure(outputStruct) + pdbio.save(outfilename, select=NotDisordered()) + diff --git a/model/comp_surface/prepare_target/input_output/protonate.py b/model/comp_surface/prepare_target/input_output/protonate.py new file mode 100644 index 0000000000000000000000000000000000000000..e674d7bfc1ac8923b26428f57b42911b1f707788 --- /dev/null +++ b/model/comp_surface/prepare_target/input_output/protonate.py @@ -0,0 +1,32 @@ +""" +protonate.py: Wrapper method for the reduce program: protonate (i.e., add hydrogens) a pdb using reduce + and save to an output file. +Pablo Gainza - LPDI STI EPFL 2019 +Released under an Apache License 2.0 +""" + +from subprocess import Popen, PIPE +from IPython.core.debugger import set_trace +import os + + +def protonate(in_pdb_file, out_pdb_file): + # protonate (i.e., add hydrogens) a pdb using reduce and save to an output file. + # in_pdb_file: file to protonate. + # out_pdb_file: output file where to save the protonated pdb file. + + # Remove protons first, in case the structure is already protonated + args = ["reduce", "-Trim", in_pdb_file] + p2 = Popen(args, stdout=PIPE, stderr=PIPE) + stdout, stderr = p2.communicate() + outfile = open(out_pdb_file, "w") + outfile.write(stdout.decode('utf-8').rstrip()) + outfile.close() + # Now add them again. + args = ["reduce", "-HIS", out_pdb_file] + p2 = Popen(args, stdout=PIPE, stderr=PIPE) + stdout, stderr = p2.communicate() + outfile = open(out_pdb_file, "w") + outfile.write(stdout.decode('utf-8')) + outfile.close() + diff --git a/model/comp_surface/prepare_target/input_output/read_msms.py b/model/comp_surface/prepare_target/input_output/read_msms.py new file mode 100644 index 0000000000000000000000000000000000000000..9ab24f774e980f1b3331cafe33fcf361b980a3db --- /dev/null +++ b/model/comp_surface/prepare_target/input_output/read_msms.py @@ -0,0 +1,60 @@ +import numpy as np +""" +read_msms.py: Read an msms output file that was output by MSMS (MSMS is the program we use to build a surface) +Pablo Gainza - LPDI STI EPFL 2019 +Released under an Apache License 2.0 +""" + +def read_msms(file_root): + # read the surface from the msms output. MSMS outputs two files: {file_root}.vert and {file_root}.face + + vertfile = open(file_root + ".vert") + meshdata = (vertfile.read().rstrip()).split("\n") + vertfile.close() + + # Read number of vertices. + count = {} + header = meshdata[2].split() + count["vertices"] = int(header[0]) + ## Data Structures + vertices = np.zeros((count["vertices"], 3)) + normalv = np.zeros((count["vertices"], 3)) + atom_id = [""] * count["vertices"] + res_id = [""] * count["vertices"] + for i in range(3, len(meshdata)): + fields = meshdata[i].split() + vi = i - 3 + vertices[vi][0] = float(fields[0]) + vertices[vi][1] = float(fields[1]) + vertices[vi][2] = float(fields[2]) + normalv[vi][0] = float(fields[3]) + normalv[vi][1] = float(fields[4]) + normalv[vi][2] = float(fields[5]) + atom_id[vi] = fields[7] + res_id[vi] = fields[9] + count["vertices"] -= 1 + + # Read faces. + facefile = open(file_root + ".face") + meshdata = (facefile.read().rstrip()).split("\n") + facefile.close() + + # Read number of vertices. + header = meshdata[2].split() + count["faces"] = int(header[0]) + faces = np.zeros((count["faces"], 3), dtype=int) + normalf = np.zeros((count["faces"], 3)) + + for i in range(3, len(meshdata)): + fi = i - 3 + fields = meshdata[i].split() + faces[fi][0] = int(fields[0]) - 1 + faces[fi][1] = int(fields[1]) - 1 + faces[fi][2] = int(fields[2]) - 1 + count["faces"] -= 1 + + assert count["vertices"] == 0 + assert count["faces"] == 0 + + return vertices, faces, normalv, res_id + diff --git a/model/comp_surface/prepare_target/input_output/read_ply.py b/model/comp_surface/prepare_target/input_output/read_ply.py new file mode 100644 index 0000000000000000000000000000000000000000..7811b4463677c230b0d7a12fc5b7e2e877abb058 --- /dev/null +++ b/model/comp_surface/prepare_target/input_output/read_ply.py @@ -0,0 +1,53 @@ +import pymesh +import numpy +""" +read_ply.py: Read a ply file from disk using pymesh and load the attributes used by MaSIF. +Pablo Gainza - LPDI STI EPFL 2019 +Released under an Apache License 2.0 +""" + +def read_ply(filename): + # Read a ply file from disk using pymesh and load the attributes used by MaSIF. + # filename: the input ply file. + # returns data as tuple. + mesh = pymesh.load_mesh(filename) + + attributes = mesh.get_attribute_names() + if "vertex_nx" in attributes: + nx = mesh.get_attribute("vertex_nx") + ny = mesh.get_attribute("vertex_ny") + nz = mesh.get_attribute("vertex_nz") + + normals = numpy.column_stack((nx, ny, nz)) + else: + normals = None + if "vertex_charge" in attributes: + charge = mesh.get_attribute("vertex_charge") + else: + charge = numpy.array([0.0] * len(mesh.vertices)) + + if "vertex_cb" in attributes: + vertex_cb = mesh.get_attribute("vertex_cb") + else: + vertex_cb = numpy.array([0.0] * len(mesh.vertices)) + + if "vertex_hbond" in attributes: + vertex_hbond = mesh.get_attribute("vertex_hbond") + else: + vertex_hbond = numpy.array([0.0] * len(mesh.vertices)) + + if "vertex_hphob" in attributes: + vertex_hphob = mesh.get_attribute("vertex_hphob") + else: + vertex_hphob = numpy.array([0.0] * len(mesh.vertices)) + + return ( + mesh.vertices, + mesh.faces, + normals, + charge, + vertex_cb, + vertex_hbond, + vertex_hphob, + ) + diff --git a/model/comp_surface/prepare_target/input_output/save_ply.py b/model/comp_surface/prepare_target/input_output/save_ply.py new file mode 100644 index 0000000000000000000000000000000000000000..de24ae35f33b8195159bd1751c0687e043d8c4f7 --- /dev/null +++ b/model/comp_surface/prepare_target/input_output/save_ply.py @@ -0,0 +1,58 @@ +import pymesh +import numpy +""" +read_ply.py: Save a ply file to disk using pymesh and load the attributes used by MaSIF. +Pablo Gainza - LPDI STI EPFL 2019 +Released under an Apache License 2.0 +""" + + +def save_ply( + filename, + vertices, + faces=[], + normals=None, + charges=None, + vertex_cb=None, + hbond=None, + hphob=None, + iface=None, + normalize_charges=False, +): + """ Save vertices, mesh in ply format. + vertices: coordinates of vertices + faces: mesh + """ + mesh = pymesh.form_mesh(vertices, faces) + if normals is not None: + n1 = normals[:, 0] + n2 = normals[:, 1] + n3 = normals[:, 2] + mesh.add_attribute("vertex_nx") + mesh.set_attribute("vertex_nx", n1) + mesh.add_attribute("vertex_ny") + mesh.set_attribute("vertex_ny", n2) + mesh.add_attribute("vertex_nz") + mesh.set_attribute("vertex_nz", n3) + if charges is not None: + mesh.add_attribute("charge") + if normalize_charges: + charges = charges / 10 + mesh.set_attribute("charge", charges) + if hbond is not None: + mesh.add_attribute("hbond") + mesh.set_attribute("hbond", hbond) + if vertex_cb is not None: + mesh.add_attribute("vertex_cb") + mesh.set_attribute("vertex_cb", vertex_cb) + if hphob is not None: + mesh.add_attribute("vertex_hphob") + mesh.set_attribute("vertex_hphob", hphob) + if iface is not None: + mesh.add_attribute("vertex_iface") + mesh.set_attribute("vertex_iface", iface) + + pymesh.save_mesh( + filename, mesh, *mesh.get_attribute_names(), use_float=True, ascii=True + ) + diff --git a/model/comp_surface/prepare_target/mol2graph.py b/model/comp_surface/prepare_target/mol2graph.py new file mode 100644 index 0000000000000000000000000000000000000000..4049f8206dd5f0963fb0b9908c556590a6eeef5a --- /dev/null +++ b/model/comp_surface/prepare_target/mol2graph.py @@ -0,0 +1,153 @@ +import numpy as np +from rdkit.Chem import AllChem, Draw, Descriptors, rdMolTransforms +import rdkit.Chem as Chem +import rdkit.Chem.rdMolDescriptors as rdMolDescriptors +import rdkit.Chem.EState as EState +import rdkit.Chem.rdPartialCharges as rdPartialCharges +import rdkit.Chem.rdChemReactions as rdRxns +import copy +att_dtype = np.float32 + +import networkx as nx + + +def oneHotVector(val, lst): + '''Converts a value to a one-hot vector based on options in lst''' + if val not in lst: + val = lst[-1] + return map(lambda x: x == val, lst) + +def mol_to_nx(mol): + G = nx. Graph() + + # Globals. + G.graph["features"] = np.array([None], dtype = np.float32) + atomCoords = mol.GetConformer().GetPositions() + + for i, atom in enumerate(mol.GetAtoms()): + if atom.GetAtomicNum() == 1: continue + G.add_node(atom.GetIdx(), + pos = atomCoords[i], + x=np.array(list(oneHotVector(atom.GetAtomicNum(), + [4, 5, 6, 7, 8, 9, 12, 14, 15, 16, 17, 23, 26, 27, 29, 30, 33, 34, 35, 44, 45, 51, 53, 75, 76, 77, 78, 80])), + dtype = np.float32)) + + for bond in mol.GetBonds(): + if mol.GetAtomWithIdx(bond.GetBeginAtomIdx()).GetAtomicNum() == 1: continue + if mol.GetAtomWithIdx(bond.GetEndAtomIdx()).GetAtomicNum() == 1: continue + isConjugated = 1 if bond.GetIsConjugated() and not bond.GetIsAromatic() else 0 + G.add_edge(bond.GetBeginAtomIdx(), + bond.GetEndAtomIdx(), + edge_attr=np.array(list(oneHotVector(bond.GetBondTypeAsDouble(), + [1.0, 1.5, 2.0, 3.0, 99.0]))+[isConjugated], + dtype = np.float32)) + ''' + try: + conf = mol.GetConformer() + for i in range(0, mol.GetNumAtoms()-1): + for j in range(i+1,mol.GetNumAtoms()): + if mol.GetBondBetweenAtoms(i,j)==None: + ShortestPath = Chem.rdmolops.GetShortestPath(mol, i,j) + dist=Chem.rdMolTransforms.GetBondLength(conf,i,j) + if (dist <= 10. and len(ShortestPath) > 4): + G.add_edge(i, j, bond_type=None, features=np.array([0.,0.,0.,0.,0.,dist], dtype = np.float32)) + except:pass + ''' + return G + + +def get_bonds(mol_list, bidirectional=True): + atom_counter=0 + bonds = [] + dist = [] + for m in mol_list: + for x in m.GetBonds(): + conf = m.GetConformer() + bonds.extend([(x.GetBeginAtomIdx()+atom_counter, x.GetEndAtomIdx()+atom_counter)]) + dist.extend([rdMolTransforms.GetBondLength(conf,x.GetBeginAtomIdx(), x.GetEndAtomIdx())]) + if bidirectional: + bonds.extend([(x.GetEndAtomIdx()+atom_counter, x.GetBeginAtomIdx()+atom_counter)]) + dist.extend([rdMolTransforms.GetBondLength(conf,x.GetEndAtomIdx(), x.GetBeginAtomIdx())]) + atom_counter += m.GetNumAtoms() + return bonds, dist + + +def get_angles(mol_list, bidirectional=True): + atom_counter = 0 + bendList = [] + angleList = [] + for m in mol_list: + bendSmarts = '*~*~*' + bendQuery = Chem.MolFromSmarts(bendSmarts) + matches = m.GetSubstructMatches(bendQuery) + conf = m.GetConformer() + for match in matches: + idx0 = match[0] + idx1 = match[1] + idx2 = match[2] + bendList.append((idx0+atom_counter, idx1+atom_counter, idx2+atom_counter)) + angleList.append(rdMolTransforms.GetAngleRad(conf, idx0, idx1, idx2)) + if bidirectional: + bendList.append((idx2+atom_counter, idx1+atom_counter, idx0+atom_counter)) + angleList.append(rdMolTransforms.GetAngleRad(conf, idx2, idx1, idx0)) + atom_counter += m.GetNumAtoms() + return bendList, angleList + + +def get_torsions(mol_list, bidirectional=True): + atom_counter=0 + torsionList = [] + dihedralList = [] + for m in mol_list: + torsionSmarts = '[!$(*#*)&!D1]~[!$(*#*)&!D1]' + torsionQuery = Chem.MolFromSmarts(torsionSmarts) + matches = m.GetSubstructMatches(torsionQuery) + conf = m.GetConformer() + for match in matches: + idx2 = match[0] + idx3 = match[1] + bond = m.GetBondBetweenAtoms(idx2, idx3) + jAtom = m.GetAtomWithIdx(idx2) + kAtom = m.GetAtomWithIdx(idx3) + if (((jAtom.GetHybridization() != Chem.HybridizationType.SP2) + and (jAtom.GetHybridization() != Chem.HybridizationType.SP3)) + or ((kAtom.GetHybridization() != Chem.HybridizationType.SP2) + and (kAtom.GetHybridization() != Chem.HybridizationType.SP3))): + continue + for b1 in jAtom.GetBonds(): + if (b1.GetIdx() == bond.GetIdx()): + continue + idx1 = b1.GetOtherAtomIdx(idx2) + for b2 in kAtom.GetBonds(): + if ((b2.GetIdx() == bond.GetIdx()) + or (b2.GetIdx() == b1.GetIdx())): + continue + idx4 = b2.GetOtherAtomIdx(idx3) + # skip 3-membered rings + if (idx4 == idx1): + continue + torsionList.append((idx1+atom_counter, idx2+atom_counter, idx3+atom_counter, idx4+atom_counter)) + dihedralList.append(rdMolTransforms.GetDihedralRad(conf, idx1, idx2, idx3, idx4)) + if bidirectional: + torsionList.append((idx4+atom_counter, idx3+atom_counter, idx2+atom_counter, idx1+atom_counter)) + dihedralList.append(rdMolTransforms.GetDihedralRad(conf, idx4, idx3, idx2, idx1)) + atom_counter += m.GetNumAtoms() + return torsionList, dihedralList + + +def mol_with_atom_index( mol ): + atoms = mol.GetNumAtoms() + for idx in range( atoms ): + mol.GetAtomWithIdx( idx ).SetProp( 'molAtomMapNumber', str( mol.GetAtomWithIdx( idx ).GetIdx() ) ) + return mol + +def atomenvironments(mol, radius=3): + envs = [] + for a in mol.GetAtoms(): + idx = a.GetIdx() + env = Chem.FindAtomEnvironmentOfRadiusN(mol, radius, idx) + amap = {} + submol=Chem.PathToSubmol(mol, env, atomMap=amap) + if amap.get(idx) is not None: + envs.append(Chem.MolToSmarts(submol)) + return envs diff --git a/model/comp_surface/prepare_target/save_ply.py b/model/comp_surface/prepare_target/save_ply.py new file mode 100644 index 0000000000000000000000000000000000000000..ab479b8e7dfc5981c5e1cdfe4c798e76c6d65dd7 --- /dev/null +++ b/model/comp_surface/prepare_target/save_ply.py @@ -0,0 +1,68 @@ +import pymesh +import numpy +""" +Modified from: +save_ply.py - MaSIF +Pablo Gainza - LPDI STI EPFL 2019 +""" + +""" +read_ply.py: Save a ply file to disk using pymesh and load the attributes used by MaSIF. +Pablo Gainza - LPDI STI EPFL 2019 +Released under an Apache License 2.0 +""" + + +def save_ply( + filename, + vertices, + faces=[], + normals=None, + charges=None, + vertex_cb=None, + hbond=None, + hphob=None, + iface=None, + si=None, + normalize_charges=False, +): + """ Save vertices, mesh in ply format. + vertices: coordinates of vertices + faces: mesh + """ + mesh = pymesh.form_mesh(vertices, faces) + if normals is not None: + n1 = normals[:, 0] + n2 = normals[:, 1] + n3 = normals[:, 2] + mesh.add_attribute("vertex_nx") + mesh.set_attribute("vertex_nx", n1) + mesh.add_attribute("vertex_ny") + mesh.set_attribute("vertex_ny", n2) + mesh.add_attribute("vertex_nz") + mesh.set_attribute("vertex_nz", n3) + if charges is not None: + mesh.add_attribute("charge") + if normalize_charges: + charges = charges / 10 + mesh.set_attribute("charge", charges) + if hbond is not None: + mesh.add_attribute("hbond") + mesh.set_attribute("hbond", hbond) + if vertex_cb is not None: + mesh.add_attribute("vertex_cb") + mesh.set_attribute("vertex_cb", vertex_cb) + if hphob is not None: + mesh.add_attribute("vertex_hphob") + mesh.set_attribute("vertex_hphob", hphob) + if iface is not None: + mesh.add_attribute("vertex_iface") + mesh.set_attribute("vertex_iface", iface) + if si is not None: + mesh.add_attribute("vertex_si") + mesh.set_attribute("vertex_si", si) + + pymesh.save_mesh( + filename, mesh, *mesh.get_attribute_names(), use_float=True, ascii=True + ) + diff --git a/model/comp_surface/prepare_target/triangulation/README.md b/model/comp_surface/prepare_target/triangulation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c5c9b1a24902e754acdce8d2b9b215ea05225ca5 --- /dev/null +++ b/model/comp_surface/prepare_target/triangulation/README.md @@ -0,0 +1,12 @@ +### source/triangulation +Functions used by MaSIF to triangulate proteins (through MSMS), regularize these meshes, and compute chemical charges. + ++ *computeAPBS.py*: Wrapper function to compute the Poisson Boltzmann electrostatics for a surface using APBS. ++ *computeCharges.py*: Compute the free electrons/protons in the surface. ++ *computeHydrophobicity.py*: Compute the hydrophobicity of each vertex. ++ *computeMSMS.py*: Compute the MSMS surface of a protein. ++ *compute_normal.py*: Compute the normals of the surface. ++ *fixmesh.py*: Regularize an MSMS mesh ++ *xyzrn.py*: Output a PDB in the input format used by MSMS + + diff --git a/model/comp_surface/prepare_target/triangulation/__init__.py b/model/comp_surface/prepare_target/triangulation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/model/comp_surface/prepare_target/triangulation/computeAPBS.py b/model/comp_surface/prepare_target/triangulation/computeAPBS.py new file mode 100644 index 0000000000000000000000000000000000000000..b37c41950eb8e6403949f560df88fada826f2e07 --- /dev/null +++ b/model/comp_surface/prepare_target/triangulation/computeAPBS.py @@ -0,0 +1,68 @@ +import os +import numpy +from subprocess import Popen, PIPE +import pymesh + +from default_config.global_vars import apbs_bin, pdb2pqr_bin, multivalue_bin +import random + +""" +computeAPBS.py: Wrapper function to compute the Poisson Boltzmann electrostatics for a surface using APBS. +Pablo Gainza - LPDI STI EPFL 2019 +This file is part of MaSIF. +Released under an Apache License 2.0 +""" + +def computeAPBS(vertices, pdb_file, tmp_file_base): + """ + Calls APBS, pdb2pqr, and multivalue and returns the charges per vertex + """ + fields = tmp_file_base.split("/")[0:-1] + directory = "/".join(fields) + "/" + filename_base = tmp_file_base.split("/")[-1] + pdbname = pdb_file.split("/")[-1] + args = [ + pdb2pqr_bin, + "--ff=parse", + "--whitespace", + "--noopt", + "--apbs-input", + pdbname, + filename_base, + ] + p2 = Popen(args, stdout=PIPE, stderr=PIPE, cwd=directory) + stdout, stderr = p2.communicate() + + args = [apbs_bin, filename_base + ".in"] + p2 = Popen(args, stdout=PIPE, stderr=PIPE, cwd=directory) + stdout, stderr = p2.communicate() + + vertfile = open(directory + "/" + filename_base + ".csv", "w") + for vert in vertices: + vertfile.write("{},{},{}\n".format(vert[0], vert[1], vert[2])) + vertfile.close() + + args = [ + multivalue_bin, + filename_base + ".csv", + filename_base + ".dx", + filename_base + "_out.csv", + ] + p2 = Popen(args, stdout=PIPE, stderr=PIPE, cwd=directory) + stdout, stderr = p2.communicate() + + # Read the charge file + chargefile = open(tmp_file_base + "_out.csv") + charges = numpy.array([0.0] * len(vertices)) + for ix, line in enumerate(chargefile.readlines()): + charges[ix] = float(line.split(",")[3]) + + remove_fn = os.path.join(directory, filename_base) + os.remove(remove_fn) + os.remove(remove_fn+'.csv') + os.remove(remove_fn+'.dx') + os.remove(remove_fn+'.in') + os.remove(remove_fn+'-input.p') + os.remove(remove_fn+'_out.csv') + + return charges diff --git a/model/comp_surface/prepare_target/triangulation/computeCharges.py b/model/comp_surface/prepare_target/triangulation/computeCharges.py new file mode 100644 index 0000000000000000000000000000000000000000..43dd3cd3af14d6eaf8c1e456924ab720f93a6a2c --- /dev/null +++ b/model/comp_surface/prepare_target/triangulation/computeCharges.py @@ -0,0 +1,215 @@ +from Bio.PDB import * +import numpy as np +from sklearn.neighbors import KDTree + +""" +computeCharges.py: Wrapper function to compute hydrogen bond potential (free electrons/protons) in the surface +Pablo Gainza - LPDI STI EPFL 2019 +This file is part of MaSIF. +Released under an Apache License 2.0 +""" + +from default_config.chemistry import ( + polarHydrogens, + radii, + acceptorAngleAtom, + acceptorPlaneAtom, + hbond_std_dev, + donorAtom, +) + +# Compute vertex charges based on hydrogen bond potential. +# pdb_filename: The filename of the protonated protein. +# vertices: The surface vertices of the protonated protein +# The name of each vertex in the format, example: B_125_x_ASN_ND2_Green +# where B is chain, 125 res id, x the insertion, ASN aatype, ND2 the name of the +# atom, and green is not used anymore. +def computeCharges(pdb_filename, vertices, names): + parser = PDBParser(QUIET=True) + struct = parser.get_structure(pdb_filename, pdb_filename + ".pdb") + residues = {} + for res in struct.get_residues(): + chain_id = res.get_parent().get_id() + if chain_id == "": + chain_id = " " + residues[(chain_id, res.get_id())] = res + + atoms = Selection.unfold_entities(struct, "A") + satisfied_CO, satisfied_HN = computeSatisfied_CO_HN(atoms) + + charge = np.array([0.0] * len(vertices)) + # Go over every vertex + for ix, name in enumerate(names): + fields = name.split("_") + chain_id = fields[0] + if chain_id == "": + chain_id = " " + if fields[2] == "x": + fields[2] = " " + res_id = (" ", int(fields[1]), fields[2]) + aa = fields[3] + atom_name = fields[4] + # Ignore atom if it is BB and it is already satisfied. + if atom_name == "H" and res_id in satisfied_HN: + continue + if atom_name == "O" and res_id in satisfied_CO: + continue + # Compute the charge of the vertex + charge[ix] = computeChargeHelper( + atom_name, residues[(chain_id, res_id)], vertices[ix] + ) + + return charge + + +# Compute the charge of a vertex in a residue. +def computeChargeHelper(atom_name, res, v): + res_type = res.get_resname() + # Check if it is a polar hydrogen. + if isPolarHydrogen(atom_name, res): + donor_atom_name = donorAtom[atom_name] + a = res[donor_atom_name].get_coord() # N/O + b = res[atom_name].get_coord() # H + # Donor-H is always 180.0 degrees, = pi + angle_deviation = computeAngleDeviation(a, b, v, np.pi) + angle_penalty = computeAnglePenalty(angle_deviation) + return 1.0 * angle_penalty + # Check if it is an acceptor oxygen or nitrogen + elif isAcceptorAtom(atom_name, res): + acceptor_atom = res[atom_name] + b = acceptor_atom.get_coord() + try: + a = res[acceptorAngleAtom[atom_name]].get_coord() + except: + return 0.0 + # 120 degress for acceptor + angle_deviation = computeAngleDeviation(a, b, v, 2 * np.pi / 3) + # TODO: This should not be 120 for all atoms, i.e. for HIS it should be + # ~125.0 + angle_penalty = computeAnglePenalty(angle_deviation) + plane_penalty = 1.0 + if atom_name in acceptorPlaneAtom: + try: + d = res[acceptorPlaneAtom[atom_name]].get_coord() + except: + return 0.0 + plane_deviation = computePlaneDeviation(d, a, b, v) + plane_penalty = computeAnglePenalty(plane_deviation) + return -1.0 * angle_penalty * plane_penalty + # Compute the + return 0.0 + + +# Compute the absolute value of the deviation from theta +def computeAngleDeviation(a, b, c, theta): + return abs(calc_angle(Vector(a), Vector(b), Vector(c)) - theta) + + +# Compute the angle deviation from a plane +def computePlaneDeviation(a, b, c, d): + dih = calc_dihedral(Vector(a), Vector(b), Vector(c), Vector(d)) + dev1 = abs(dih) + dev2 = np.pi - abs(dih) + return min(dev1, dev2) + + +# angle_deviation from ideal value. TODO: do a more data-based solution +def computeAnglePenalty(angle_deviation): + # Standard deviation: hbond_std_dev + return max(0.0, 1.0 - (angle_deviation / (hbond_std_dev)) ** 2) + + +def isPolarHydrogen(atom_name, res): + if atom_name in polarHydrogens[res.get_resname()]: + return True + else: + return False + + +def isAcceptorAtom(atom_name, res): + if atom_name.startswith("O"): + return True + else: + if res.get_resname() == "HIS": + if atom_name == "ND1" and "HD1" not in res: + return True + if atom_name == "NE2" and "HE2" not in res: + return True + return False + + +# Compute the list of backbone C=O:H-N that are satisfied. These will be ignored. +def computeSatisfied_CO_HN(atoms): + ns = NeighborSearch(atoms) + satisfied_CO = set() + satisfied_HN = set() + for atom1 in atoms: + res1 = atom1.get_parent() + if atom1.get_id() == "O": + neigh_atoms = ns.search(atom1.get_coord(), 2.5, level="A") + for atom2 in neigh_atoms: + if atom2.get_id() == "H": + res2 = atom2.get_parent() + # Ensure they belong to different residues. + if res2.get_id() != res1.get_id(): + # Compute the angle N-H:O, ideal value is 180 (but in + # helices it is typically 160) 180 +-30 = pi + angle_N_H_O_dev = computeAngleDeviation( + res2["N"].get_coord(), + atom2.get_coord(), + atom1.get_coord(), + np.pi, + ) + # Compute angle H:O=C, ideal value is ~160 +- 20 = 8*pi/9 + angle_H_O_C_dev = computeAngleDeviation( + atom2.get_coord(), + atom1.get_coord(), + res1["C"].get_coord(), + 8 * np.pi / 9, + ) + ## Allowed deviations: 30 degrees (pi/6) and 20 degrees + # (pi/9) + if ( + angle_N_H_O_dev - np.pi / 6 < 0 + and angle_H_O_C_dev - np.pi / 9 < 0.0 + ): + satisfied_CO.add(res1.get_id()) + satisfied_HN.add(res2.get_id()) + return satisfied_CO, satisfied_HN + + +# Compute the charge of a new mesh, based on the charge of an old mesh. +# Use the top vertex in distance, for now (later this should be smoothed over 3 +# or 4 vertices) +def assignChargesToNewMesh(new_vertices, old_vertices, old_charges, seeder_opts): + dataset = old_vertices + testset = new_vertices + new_charges = np.zeros(len(new_vertices)) + if seeder_opts["feature_interpolation"]: + num_inter = 4 # Number of interpolation features + # Assign k old vertices to each new vertex. + kdt = KDTree(dataset) + dists, result = kdt.query(testset, k=num_inter) + # Square the distances (as in the original pyflann) + dists = np.square(dists) + # The size of result is the same as new_vertices + for vi_new in range(len(result)): + vi_old = result[vi_new] + dist_old = dists[vi_new] + # If one vertex is right on top, ignore the rest. + if dist_old[0] == 0.0: + new_charges[vi_new] = old_charges[vi_old[0]] + continue + + total_dist = np.sum(1 / dist_old) + for i in range(num_inter): + new_charges[vi_new] += ( + old_charges[vi_old[i]] * (1 / dist_old[i]) / total_dist + ) + else: + # Assign k old vertices to each new vertex. + kdt = KDTree(dataset) + dists, result = kdt.query(testset) + new_charges = old_charges[result] + return new_charges + diff --git a/model/comp_surface/prepare_target/triangulation/computeHydrophobicity.py b/model/comp_surface/prepare_target/triangulation/computeHydrophobicity.py new file mode 100644 index 0000000000000000000000000000000000000000..c0948096e4ba3d0074fb032d6fd134bf31f26cac --- /dev/null +++ b/model/comp_surface/prepare_target/triangulation/computeHydrophobicity.py @@ -0,0 +1,33 @@ +import numpy as np + +# Kyte Doolittle scale +kd_scale = {} +kd_scale["ILE"] = 4.5 +kd_scale["VAL"] = 4.2 +kd_scale["LEU"] = 3.8 +kd_scale["PHE"] = 2.8 +kd_scale["CYS"] = 2.5 +kd_scale["MET"] = 1.9 +kd_scale["ALA"] = 1.8 +kd_scale["GLY"] = -0.4 +kd_scale["THR"] = -0.7 +kd_scale["SER"] = -0.8 +kd_scale["TRP"] = -0.9 +kd_scale["TYR"] = -1.3 +kd_scale["PRO"] = -1.6 +kd_scale["HIS"] = -3.2 +kd_scale["GLU"] = -3.5 +kd_scale["GLN"] = -3.5 +kd_scale["ASP"] = -3.5 +kd_scale["ASN"] = -3.5 +kd_scale["LYS"] = -3.9 +kd_scale["ARG"] = -4.5 + +# For each vertex in names, compute +def computeHydrophobicity(names): + hp = np.zeros(len(names)) + for ix, name in enumerate(names): + aa = name.split("_")[3] + hp[ix] = kd_scale[aa] + return hp + diff --git a/model/comp_surface/prepare_target/triangulation/computeMSMS.py b/model/comp_surface/prepare_target/triangulation/computeMSMS.py new file mode 100644 index 0000000000000000000000000000000000000000..b7a345e13a99e17ab72ab9780804a2638d07e0d0 --- /dev/null +++ b/model/comp_surface/prepare_target/triangulation/computeMSMS.py @@ -0,0 +1,46 @@ +import os +from subprocess import Popen, PIPE + +from input_output.read_msms import read_msms +from triangulation.xyzrn import output_pdb_as_xyzrn +from default_config.global_vars import msms_bin +from default_config.masif_opts import masif_opts +import random + +# Pablo Gainza LPDI EPFL 2017-2019 +# Calls MSMS and returns the vertices. +# Special atoms are atoms with a reduced radius. +def computeMSMS(pdb_file, protonate=True): + randnum = random.randint(1,10000000) + file_base = masif_opts['tmp_dir']+"/msms_"+str(randnum) + out_xyzrn = file_base+".xyzrn" + + if protonate: + output_pdb_as_xyzrn(pdb_file, out_xyzrn) + else: + print("Error - pdb2xyzrn is deprecated.") + sys.exit(1) + # Now run MSMS on xyzrn file + FNULL = open(os.devnull, 'w') + args = [msms_bin, "-density", "3.0", "-hdensity", "3.0", "-probe",\ + "1.5", "-if",out_xyzrn,"-of",file_base, "-af", file_base] + #print msms_bin+" "+`args` + p2 = Popen(args, stdout=PIPE, stderr=PIPE) + stdout, stderr = p2.communicate() + + vertices, faces, normals, names = read_msms(file_base) + areas = {} + ses_file = open(file_base+".area") + next(ses_file) # ignore header line + for line in ses_file: + fields = line.split() + areas[fields[3]] = fields[1] + + + # Remove temporary files. + os.remove(file_base+'.area') + os.remove(file_base+'.xyzrn') + os.remove(file_base+'.vert') + os.remove(file_base+'.face') + return vertices, faces, normals, names, areas + diff --git a/model/comp_surface/prepare_target/triangulation/compute_normal.py b/model/comp_surface/prepare_target/triangulation/compute_normal.py new file mode 100644 index 0000000000000000000000000000000000000000..a1cd899a52ec67a7cca14a9360b55d6f42a35f16 --- /dev/null +++ b/model/comp_surface/prepare_target/triangulation/compute_normal.py @@ -0,0 +1,72 @@ +import numpy as np +from numpy.matlib import repmat +""" +compute_normal.py: Compute the normals of a closed shape. +Pablo Gainza - LPDI STI EPFL 2019 +This file is part of MaSIF, based on previous matlab code by Gabriel Peyre, converted to Python by Pablo Gainza +""" + +### +from default_config.global_vars import epsilon as eps + + +def compute_normal(vertex, face): + + """ + compute_normal - compute the normal of a triangulation + vertex: 3xn matrix of vertices + face: 3xm matrix of face indices. + + normal,normalf = compute_normal(vertex,face) + + normal(i,:) is the normal at vertex i. + normalf(j,:) is the normal at face j. + + Copyright (c) 2004 Gabriel Peyr + Converted to Python by Pablo Gainza LPDI EPFL 2017 + """ + + vertex = vertex.T + face = face.T + nface = np.size(face, 1) + nvert = np.size(vertex, 1) + normal = np.zeros((3, nvert)) + # unit normals to the faces + normalf = crossp( + vertex[:, face[1, :]] - vertex[:, face[0, :]], + vertex[:, face[2, :]] - vertex[:, face[0, :]], + ) + sum_squares = np.sum(normalf ** 2, 0) + d = np.sqrt(sum_squares) + d[d < eps] = 1 + normalf = normalf / repmat(d, 3, 1) + # unit normal to the vertex + normal = np.zeros((3, nvert)) + for i in np.arange(0, nface): + f = face[:, i] + for j in np.arange(3): + normal[:, f[j]] = normal[:, f[j]] + normalf[:, i] + + # normalize + d = np.sqrt(np.sum(normal ** 2, 0)) + d[d < eps] = 1 + normal = normal / repmat(d, 3, 1) + # enforce that the normal are outward + vertex_means = np.mean(vertex, 0) + v = vertex - repmat(vertex_means, 3, 1) + s = np.sum(np.multiply(v, normal), 1) + if np.sum(s > 0) < np.sum(s < 0): + # flip + normal = -normal + normalf = -normalf + return normal.T + + +def crossp(x, y): + + # x and y are (m,3) dimensional + z = np.zeros((x.shape)) + z[0, :] = np.multiply(x[1, :], y[2, :]) - np.multiply(x[2, :], y[1, :]) + z[1, :] = np.multiply(x[2, :], y[0, :]) - np.multiply(x[0, :], y[2, :]) + z[2, :] = np.multiply(x[0, :], y[1, :]) - np.multiply(x[1, :], y[0, :]) + return z diff --git a/model/comp_surface/prepare_target/triangulation/fixmesh.py b/model/comp_surface/prepare_target/triangulation/fixmesh.py new file mode 100644 index 0000000000000000000000000000000000000000..3d584824a49f7a13e8dbf02c5350c1abc307b09e --- /dev/null +++ b/model/comp_surface/prepare_target/triangulation/fixmesh.py @@ -0,0 +1,53 @@ +import numpy as np +from numpy.linalg import norm +import pymesh + +""" +fixmesh.py: Regularize a protein surface mesh. +- based on code from the PyMESH documentation. +""" + + +def fix_mesh(mesh, resolution, detail="normal"): + bbox_min, bbox_max = mesh.bbox; + diag_len = norm(bbox_max - bbox_min); + if detail == "normal": + target_len = diag_len * 5e-3; + elif detail == "high": + target_len = diag_len * 2.5e-3; + elif detail == "low": + target_len = diag_len * 1e-2; + + target_len = resolution + #print("Target resolution: {} mm".format(target_len)); + # PGC 2017: Remove duplicated vertices first + mesh, _ = pymesh.remove_duplicated_vertices(mesh, 0.001) + + + count = 0; + print("Removing degenerated triangles") + mesh, __ = pymesh.remove_degenerated_triangles(mesh, 100); + mesh, __ = pymesh.split_long_edges(mesh, target_len); + num_vertices = mesh.num_vertices; + while True: + mesh, __ = pymesh.collapse_short_edges(mesh, 1e-6); + mesh, __ = pymesh.collapse_short_edges(mesh, target_len, + preserve_feature=True); + mesh, __ = pymesh.remove_obtuse_triangles(mesh, 150.0, 100); + if mesh.num_vertices == num_vertices: + break; + + num_vertices = mesh.num_vertices; + #print("#v: {}".format(num_vertices)); + count += 1; + if count > 10: break; + + mesh = pymesh.resolve_self_intersection(mesh); + mesh, __ = pymesh.remove_duplicated_faces(mesh); + mesh = pymesh.compute_outer_hull(mesh); + mesh, __ = pymesh.remove_duplicated_faces(mesh); + mesh, __ = pymesh.remove_obtuse_triangles(mesh, 179.0, 5); + mesh, __ = pymesh.remove_isolated_vertices(mesh); + mesh, _ = pymesh.remove_duplicated_vertices(mesh, 0.001) + + return mesh diff --git a/model/comp_surface/prepare_target/triangulation/xyzrn.py b/model/comp_surface/prepare_target/triangulation/xyzrn.py new file mode 100644 index 0000000000000000000000000000000000000000..b6d6660a1b6acecab195f03aa5f6e3606764d9db --- /dev/null +++ b/model/comp_surface/prepare_target/triangulation/xyzrn.py @@ -0,0 +1,51 @@ +from Bio.PDB import * +from default_config.chemistry import radii, polarHydrogens + +""" +xyzrn.py: Read a pdb file and output it is in xyzrn for use in MSMS +Pablo Gainza - LPDI STI EPFL 2019 +This file is part of MaSIF. +Released under an Apache License 2.0 +""" + +def output_pdb_as_xyzrn(pdbfilename, xyzrnfilename): + """ + pdbfilename: input pdb filename + xyzrnfilename: output in xyzrn format. + """ + parser = PDBParser() + struct = parser.get_structure(pdbfilename, pdbfilename) + outfile = open(xyzrnfilename, "w") + for atom in struct.get_atoms(): + name = atom.get_name() + residue = atom.get_parent() + # Ignore hetatms. + if residue.get_id()[0] != " ": + continue + resname = residue.get_resname() + reskey = residue.get_id()[1] + chain = residue.get_parent().get_id() + atomtype = name[0] + + color = "Green" + coords = None + if atomtype in radii and resname in polarHydrogens: + if atomtype == "O": + color = "Red" + if atomtype == "N": + color = "Blue" + if atomtype == "H": + if name in polarHydrogens[resname]: + color = "Blue" # Polar hydrogens + coords = "{:.06f} {:.06f} {:.06f}".format( + atom.get_coord()[0], atom.get_coord()[1], atom.get_coord()[2] + ) + insertion = "x" + if residue.get_id()[2] != " ": + insertion = residue.get_id()[2] + full_id = "{}_{:d}_{}_{}_{}_{}".format( + chain, residue.get_id()[1], insertion, resname, name, color + ) + if coords is not None: + outfile.write(coords + " " + radii[atomtype] + " 1 " + full_id + "\n") + diff --git a/model/comp_surface/protein_process/openbabel_reduce_openbabel.py b/model/comp_surface/protein_process/openbabel_reduce_openbabel.py new file mode 100644 index 0000000000000000000000000000000000000000..c5d9019efd6bf95c2f512414133c9be17f780083 --- /dev/null +++ b/model/comp_surface/protein_process/openbabel_reduce_openbabel.py @@ -0,0 +1,68 @@ +import os +import subprocess +import time +from tqdm import tqdm +from openbabel import openbabel +from joblib import Parallel, delayed + +def process_protein(name, data_path, save_path): + mol = openbabel.OBMol() + conv = openbabel.OBConversion() + conv.SetInAndOutFormats("pdb", "pdb") + + os.makedirs(os.path.join(save_path, name), exist_ok=True) + result_path = os.path.join(save_path, name, f'{name}_protein_processed_obabel_reduce_obabel.pdb') + if os.path.exists(result_path): + return name + + # step 1 openbabel + rec_path = os.path.join(data_path, name, f'{name}_protein_processed.pdb') + conv.ReadFile(mol, rec_path) + + out_path = os.path.join(save_path, name, f'{name}_protein_processed_obabel.pdb') + conv.WriteFile(mol, out_path) + + # step 2 reduce + rec_path = os.path.join(save_path, name, f'{name}_protein_processed_obabel.pdb') + subprocess.run( + f"reduce -Trim {rec_path} > {os.path.join(save_path, name, f'{name}_protein_processed_obabel_tmp.pdb')}", shell=True) + + subprocess.run( + f"reduce -HIS {os.path.join(save_path, name, f'{name}_protein_processed_obabel_tmp.pdb')} > {os.path.join(save_path, name, f'{name}_protein_processed_obabel_reduce.pdb')}", shell=True) + + subprocess.run( + f"rm {os.path.join(save_path, name, f'{name}_protein_processed_obabel_tmp.pdb')}", + shell=True) + + # step 3 openbabel + rec_path = os.path.join(save_path, name, f'{name}_protein_processed_obabel_reduce.pdb') + conv.ReadFile(mol, rec_path) + + out_path = os.path.join(save_path, name, f'{name}_protein_processed_obabel_reduce_obabel.pdb') + conv.WriteFile(mol, out_path) + + return name + +def main(data_path, save_path, n_jobs): + start_time = time.time() + names = sorted(os.listdir(data_path)) + os.makedirs(save_path, exist_ok=True) + + sucessed_names = Parallel(n_jobs=n_jobs)( + delayed(process_protein)(name, data_path, save_path) for name in tqdm(names) + ) + + print("--- %s seconds ---" % (time.time() - start_time)) + print(f"sucessed_names: {list(filter(None, sucessed_names))}") + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument('--data_path', type=str, default='', help='Path to the data directory') + parser.add_argument('--save_path', type=str, default='', help='Path to the save directory') + parser.add_argument('--n_jobs', type=int, default=1, help='Number of parallel jobs (-1 for all CPUs)') + args = parser.parse_args() + + if not os.path.exists(args.data_path): + raise ValueError(f"Data path {args.data_path} does not exist.") + main(args.data_path, args.save_path, args.n_jobs) \ No newline at end of file diff --git a/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/GeometricFlow b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/GeometricFlow new file mode 100644 index 0000000000000000000000000000000000000000..591e7b744107a86aa2a2392a0334d38fcb06e1ac --- /dev/null +++ b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/GeometricFlow @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4aba4866ec410705f81cdb68fe5474c046b0c237757a50c6aeba012ad1fe3fc7 +size 166208 diff --git a/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/GeometricFlowWrap b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/GeometricFlowWrap new file mode 100644 index 0000000000000000000000000000000000000000..a1c8a2b0c9c1246f307ce12373118318635c9b3d Binary files /dev/null and b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/GeometricFlowWrap differ diff --git a/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/NanoShaper b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/NanoShaper new file mode 100644 index 0000000000000000000000000000000000000000..d7083346b835767ed623c2b8e590a5706e874059 --- /dev/null +++ b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/NanoShaper @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6d41b6f0ddd400aa5713d08b3a178884bfff4c7ae826530ab73549aa93584baf +size 3383549 diff --git a/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/apbs b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/apbs new file mode 100644 index 0000000000000000000000000000000000000000..0061ef7ee850a94ab9c5d51a9f0ef310c659a75b --- /dev/null +++ b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/apbs @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6ebdacce26e31aa01cd221a534147218088de9d55ff111a1c8bbea56a60a32bd +size 29850192 diff --git a/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/msms b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/msms new file mode 100644 index 0000000000000000000000000000000000000000..7ca1eb5b2bdc83707c53b81064f48da4a5973559 --- /dev/null +++ b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/msms @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:739b88d8195b89ee5a9c00ef7b986f6bb9d32f7d3b200f457781c98b95958088 +size 943144 diff --git a/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/tabipb b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/tabipb new file mode 100644 index 0000000000000000000000000000000000000000..10bc902b8d5d6056d486c74c3ef42a5ef1b60c46 --- /dev/null +++ b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/bin/tabipb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e3b2ef3016982438401896ad0817fda5095b3042dc23a601e4e9e96406e0a9b +size 149728 diff --git a/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/include/apbs.h b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/include/apbs.h new file mode 100644 index 0000000000000000000000000000000000000000..9ed0836022e37a7c5f2d5ac463b2506356192c29 --- /dev/null +++ b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/include/apbs.h @@ -0,0 +1,100 @@ +/** + * @defgroup Header dependencies + */ + +/** + * @file apbs.h + * @author Nathan Baker + * @brief Header file for header dependencies + * @ingroup Frontend + * @version $Id$ + * @attention + * @verbatim + * + * APBS -- Adaptive Poisson-Boltzmann Solver + * + * Nathan A. Baker (nathan.baker@pnnl.gov) + * Pacific Northwest National Laboratory + * + * Additional contributing authors listed in the code documentation. + * + * Copyright (c) 2010-2020 Battelle Memorial Institute. Developed at the + * Pacific Northwest National Laboratory, operated by Battelle Memorial + * Institute, Pacific Northwest Division for the U.S. Department of Energy. + * + * Portions Copyright (c) 2002-2010, Washington University in St. Louis. + * Portions Copyright (c) 2002-2010, Nathan A. Baker. + * Portions Copyright (c) 1999-2002, The Regents of the University of + * California. + * Portions Copyright (c) 1995, Michael Holst. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of the developer nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * @endverbatim + */ + +#ifndef _APBSHEADERS_H_ +#define _APBSHEADERS_H_ + +#include "apbscfg.h" + +/* MALOC headers */ +#include "maloc/maloc.h" + +/* Generic headers */ +#include "generic/nosh.h" +#include "generic/mgparm.h" +#include "generic/pbeparm.h" +#include "generic/femparm.h" +#include "generic/bemparm.h" +#include "generic/geoflowparm.h" +#include "generic/vacc.h" +#include "generic/valist.h" +#include "generic/vatom.h" +#include "generic/vcap.h" +#include "generic/vhal.h" +#include "generic/vpbe.h" +#include "generic/vstring.h" +#include "generic/vunit.h" +#include "generic/vparam.h" +#include "generic/vgreen.h" + +//#include "geoflow/cpbconcz2.h" + +/* MG headers */ +#include "mg/vgrid.h" +#include "mg/vmgrid.h" +#include "mg/vopot.h" +#include "mg/vpmg.h" +#include "mg/vpmgp.h" + +/* FEM headers */ +#include "fem/vfetk.h" +#include "fem/vpee.h" + +#endif /* _APBSHEADERS_H_ */ diff --git a/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/include/apbscfg.h b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/include/apbscfg.h new file mode 100644 index 0000000000000000000000000000000000000000..4ab2c464132bdb44801eba27fbe52d4fa843c7d3 --- /dev/null +++ b/model/comp_surface/tools/transfer/APBS-3.4.1.Linux/include/apbscfg.h @@ -0,0 +1,132 @@ +// apbs configuration header generated by CMake + +// apbs version string +#define PACKAGE_STRING "APBS 3.4.1" + +// apbs fast mode +/* #undef APBS_FAST */ + +// apbs debugging mode +/* #undef DEBUG */ + +// prints verbose debugging information +#define VERBOSE_DEBUG + +// apbs quiet mode +/* #undef VAPBSQUIET */ + +// time function available +#define HAVE_TIME_FUNC + +// rand function available +#define HAVE_RAND_FUNC + +// srand function available +#define HAVE_SRAND_FUNC + +// readline library is available +/* #undef HAVE_LIBREADLINE */ + +// do not inline functions +#define APBS_NOINLINE + + + +// Is macro embedding availble? +/* #undef HAVE_EMBED */ + +// zlib compression is available +/* #undef HAVE_ZLIB */ + + + +// have FEtk component PUNC +#define HAVE_PUNC + +// have FEtk component MCX +/* #undef HAVE_MCX */ + +// have FEtk component MC +#define HAVE_MC + +// have fetk component GAMER +#define HAVE_GAMER + +/* #undef HAVE_MPI_H */ + +// The floating point epsilon for the current machine +#define FLOAT_EPSILON 2.220446e-16 + +// The double precision epsilon for the current machine +#define DOUBLE_EPSILON 2.220446e-16 + + + + +// Remain for use be determined. + +/* Define to 1 if you have the+ * RESIDUE ATOM CHARGE RADIUS EPSILON + *+ * where RESIDUE is the residue name string, ATOM is the atom name string, + * CHARGE is the charge in e, RADIUS is the van der Waals radius + * (\f$\sigma_i\f$) in Å, and EPSILON is the van der Waals well-depth + * (\f$\epsilon_i\f$) in kJ/mol. See the Vparam structure documentation for + * the precise definitions of \f$\sigma_i\f$ and \f$\epsilon_i\f$. + * + * ASCII-format flat files are provided with the APBS source code: + *