Python ABC MD Setup tutorial using BioExcel Building Blocks (biobb)

public public 1yr ago Version: Version 3 0 bookmarks

AMBER Protein MD Setup tutorials using BioExcel Building Blocks (biobb)

Based on the official GROMACS tutorial .

This tutorial aims to illustrate the process of setting up a simulation system containing a protein , step by step, using the BioExcel Building Blocks library (biobb) wrapping the Ambertools MD package .

Copyright & Licensing

This software has been developed in the MMB group at the BSC & IRB for the European BioExcel , funded by the European Commission (EU H2020 823830 , EU H2020 675728 ).

Licensed under the Apache License 2.0 , see the file LICENSE for details.

Code Snippets

  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
import time
import argparse
from biobb_common.configuration import settings
from biobb_common.tools import file_utils as fu
from biobb_amber.leap.leap_gen_top import leap_gen_top
from biobb_amber.leap.leap_solvate import leap_solvate
from biobb_amber.leap.leap_add_ions import leap_add_ions
from biobb_amber.cpptraj.cpptraj_randomize_ions import cpptraj_randomize_ions
from biobb_amber.parmed.parmed_hmassrepartition import parmed_hmassrepartition
from biobb_amber.sander.sander_mdrun import sander_mdrun
from biobb_amber.process.process_minout import process_minout
from biobb_amber.process.process_mdout import process_mdout
from biobb_analysis.ambertools.cpptraj_rms import cpptraj_rms
from biobb_analysis.ambertools.cpptraj_rgyr import cpptraj_rgyr
from biobb_analysis.ambertools.cpptraj_image import cpptraj_image

def main(config, system=None):
    start_time = time.time()
    conf = settings.ConfReader(config, system)
    global_log, _ = fu.get_logs(path=conf.get_working_dir_path(), light_format=True)
    global_prop = conf.get_prop_dic(global_log=global_log)
    global_paths = conf.get_paths_dic()

    global_log.info("step1_leap_gen_top: Generating Topology")
    leap_gen_top(**global_paths["step1_leap_gen_top"], properties=global_prop["step1_leap_gen_top"])

    global_log.info("step2_leap_solvate: Adding Water Box")
    leap_solvate(**global_paths["step2_leap_solvate"], properties=global_prop["step2_leap_solvate"])

    global_log.info("step3_leap_add_ions: Adding additional ionic concentration")
    leap_add_ions(**global_paths["step3_leap_add_ions"], properties=global_prop["step3_leap_add_ions"])

    global_log.info("step4_cpptraj_randomize_ions: Randomizing ions")
    cpptraj_randomize_ions(**global_paths["step4_cpptraj_randomize_ions"], properties=global_prop["step4_cpptraj_randomize_ions"])

    global_log.info("step5_parmed_hmassrepartition: Generating Topology with Hydrogen Mass Partitioning (4fs)")
    parmed_hmassrepartition(**global_paths["step5_parmed_hmassrepartition"], properties=global_prop["step5_parmed_hmassrepartition"])

    global_log.info("step6_sander_mdrun_eq1: Equilibration Step 1: System energetic minimization")
    sander_mdrun(**global_paths["step6_sander_mdrun_eq1"], properties=global_prop["step6_sander_mdrun_eq1"])

    global_log.info("step7_process_minout_eq1: Checking Equilibration Step 1 results")
    process_minout(**global_paths["step7_process_minout_eq1"], properties=global_prop["step7_process_minout_eq1"])

    global_log.info("step8_sander_mdrun_eq2: Equilibration Step 2: NVT equilibration")
    sander_mdrun(**global_paths["step8_sander_mdrun_eq2"], properties=global_prop["step8_sander_mdrun_eq2"])

    global_log.info("step9_process_mdout_eq2: Checking Equilibration Step 2 results")
    process_mdout(**global_paths["step9_process_mdout_eq2"], properties=global_prop["step9_process_mdout_eq2"])

    global_log.info("step10_sander_mdrun_eq3: Equilibration Step 3: System energetic minimization")
    sander_mdrun(**global_paths["step10_sander_mdrun_eq3"], properties=global_prop["step10_sander_mdrun_eq3"])

    global_log.info("step11_process_minout_eq3: Checking Equilibration Step 3 results")
    process_minout(**global_paths["step11_process_minout_eq3"], properties=global_prop["step11_process_minout_eq3"])

    global_log.info("step12_sander_mdrun_eq4: Equilibration Step 4: System energetic minimization")
    sander_mdrun(**global_paths["step12_sander_mdrun_eq4"], properties=global_prop["step12_sander_mdrun_eq4"])

    global_log.info("step13_process_minout_eq4: Checking Equilibration Step 4 results")
    process_minout(**global_paths["step13_process_minout_eq4"], properties=global_prop["step13_process_minout_eq4"])

    global_log.info("step14_sander_mdrun_eq5: Equilibration Step 5: System energetic minimization")
    sander_mdrun(**global_paths["step14_sander_mdrun_eq5"], properties=global_prop["step14_sander_mdrun_eq5"])

    global_log.info("step15_process_minout_eq5: Checking Equilibration Step 5 results")
    process_minout(**global_paths["step15_process_minout_eq5"], properties=global_prop["step15_process_minout_eq5"])

    global_log.info("step16_sander_mdrun_eq6: Equilibration Step 6: NPT equilibration")
    sander_mdrun(**global_paths["step16_sander_mdrun_eq6"], properties=global_prop["step16_sander_mdrun_eq6"])

    global_log.info("step17_process_mdout_eq6: Checking Equilibration Step 6 results")
    process_mdout(**global_paths["step17_process_mdout_eq6"], properties=global_prop["step17_process_mdout_eq6"])

    global_log.info("step18_sander_mdrun_eq7: Equilibration Step 7: NPT equilibration")
    sander_mdrun(**global_paths["step18_sander_mdrun_eq7"], properties=global_prop["step18_sander_mdrun_eq7"])

    global_log.info("step19_process_mdout_eq7: Checking Equilibration Step 7 results")
    process_mdout(**global_paths["step19_process_mdout_eq7"], properties=global_prop["step19_process_mdout_eq7"])

    global_log.info("step20_sander_mdrun_eq8: Equilibration Step 8: NPT equilibration")
    sander_mdrun(**global_paths["step20_sander_mdrun_eq8"], properties=global_prop["step20_sander_mdrun_eq8"])

    global_log.info("step21_process_mdout_eq8: Checking Equilibration Step 8 results")
    process_mdout(**global_paths["step21_process_mdout_eq8"], properties=global_prop["step21_process_mdout_eq8"])

    global_log.info("step22_sander_mdrun_eq9: Equilibration Step 9: NPT equilibration")
    sander_mdrun(**global_paths["step22_sander_mdrun_eq9"], properties=global_prop["step22_sander_mdrun_eq9"])

    global_log.info("step23_process_mdout_eq9: Checking Equilibration Step 9 results")
    process_mdout(**global_paths["step23_process_mdout_eq9"], properties=global_prop["step23_process_mdout_eq9"])

    global_log.info("step24_sander_mdrun_eq10: Equilibration Step 10: NPT equilibration")
    sander_mdrun(**global_paths["step24_sander_mdrun_eq10"], properties=global_prop["step24_sander_mdrun_eq10"])

    global_log.info("step25_process_mdout_eq10: Checking Equilibration Step 10 results")
    process_mdout(**global_paths["step25_process_mdout_eq10"], properties=global_prop["step25_process_mdout_eq10"])

    global_log.info("step26_sander_mdrun_md: Free Molecular Dynamics Simulation")
    sander_mdrun(**global_paths["step26_sander_mdrun_md"], properties=global_prop["step26_sander_mdrun_md"])

    global_log.info("step27_rmsd_first: Generate RMSd (against 1st snp.) plot for the resulting setup trajectory from the free md step")
    cpptraj_rms(**global_paths["step27_rmsd_first"], properties=global_prop["step27_rmsd_first"])

    global_log.info("step28_rmsd_exp: Generate RMSd (against exp.) plot for the resulting setup trajectory from the free md step")
    cpptraj_rms(**global_paths["step28_rmsd_exp"], properties=global_prop["step28_rmsd_exp"])

    global_log.info("step29_cpptraj_rgyr: Generate Radius of Gyration plot for the resulting setup trajectory from the free md step")
    cpptraj_rgyr(**global_paths["step29_cpptraj_rgyr"], properties=global_prop["step29_cpptraj_rgyr"])

    global_log.info("step30_cpptraj_image: Imaging the resulting trajectory")
    cpptraj_image(**global_paths["step30_cpptraj_image"], properties=global_prop["step30_cpptraj_image"])

    elapsed_time = time.time() - start_time
    global_log.info('')
    global_log.info('')
    global_log.info('Execution successful: ')
    global_log.info('  Workflow_path: %s' % conf.get_working_dir_path())
    global_log.info('  Config File: %s' % config)
    if system:
        global_log.info('  System: %s' % system)
    global_log.info('')
    global_log.info('Elapsed time: %.1f minutes' % (elapsed_time/60))
    global_log.info('')

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="ABC MD Setup pipeline using BioExcel Building Blocks")
    parser.add_argument('--config', required=True)
    parser.add_argument('--system', required=False)
    args = parser.parse_args()
    main(args.config, args.system)

Login to post a comment if you would like to share your experience with this workflow.

Do you know this workflow well? If so, you can request seller status , and start supporting this workflow.

Free

Created: 1yr ago
Updated: 1yr ago
Maitainers: public
URL: https://github.com/bioexcel/biobb_workflows/tree/master/biobb_wf_amber_abc_md_setup/python
Name: python-abc-md-setup-tutorial
Version: Version 3
Badge:
workflow icon

Insert copied code into your website to add a link to this workflow.

Downloaded: 0
Copyright: Public Domain
License: None
  • Future updates

Related Workflows

cellranger-snakemake-gke
snakemake workflow to run cellranger on a given bucket using gke.
A Snakemake workflow for running cellranger on a given bucket using Google Kubernetes Engine. The usage of this workflow ...