def run(in_parms):
"""
Run a GROMACS simulations using the PDBREMIX parms dictionary.
"""
parms = copy.deepcopy(in_parms)
basename = parms['output_basename']
# Copies across topology and related *.itp files, with appropriate
# filename renaming in #includes
top = basename + '.top'
in_top = parms['topology']
shutil.copy(in_top, top)
in_name = os.path.basename(in_top).replace('.top', '')
in_dir = os.path.dirname(in_top)
file_tag = "%s/%s_*itp" % (in_dir, in_name)
new_files = [top]
for f in glob.glob(file_tag):
new_f = os.path.basename(f)
new_f = new_f.replace(in_name, basename)
shutil.copy(f, new_f)
new_files.append(new_f)
for f in new_files:
replace_include_file(f, in_name + "_", basename + "_")
# Copy over input coordinates/velocities
in_gro = basename + '.in.gro'
shutil.copy(parms['input_crds'], in_gro)
# Generates a postiional-restraint topology file
if parms['restraint_pdb']:
# 1kcal*mol*A**-2 = 4.184 kJ*mol*(0.1 nm)**-2
kcalmolang2_to_kJmolnm2 = 400.184
open(basename + '_posre.itp', 'w').write(
make_restraint_itp(
parms['restraint_pdb'],
parms['restraint_force'] * kcalmolang2_to_kJmolnm2))
# Generate .mdp file based on parms
in_mdp = basename + '.grompp.mdp'
open(in_mdp, 'w').write(make_mdp(parms))
# Now run .grompp to generate this .tpr file
tpr = basename + '.tpr'
# .mdp to save complete set of parameters
mdp = basename + '.mdrun.mdp'
data.binary(
'grompp',
'-f %s -po %s -c %s -p %s -o %s' \
% (in_mdp, mdp, in_gro, top, tpr),
basename + '.grompp')
util.check_files(tpr)
# Run simulation with the .tpr file
data.binary('mdrun', '-v -deffnm %s' % (basename), basename + '.mdrun')
top, crds, vels = get_restart_files(basename)
util.check_output(top)
util.check_output(crds)
# Cleanup
delete_backup_files(basename)
def run_pymol_script(pml, width=500, height=500):
is_quit = 'quit' in util.words_in_file(pml)
if is_quit:
pymol_batch = data.binary("pymol_batch")
cmd = pymol_batch + ' -c '
else:
pymol = data.binary("pymol")
cmd = pymol + " -q " # no splash screen
cmd += " -W %d -H %d " % (width, height)
cmd += pml
util.run_with_output(cmd)
def check_dcd_byte_order(dcd):
"""
Uses flipdcd to DCD trajectories have matching OS endianess.
"""
if sys.byteorder in 'big':
option = '-B'
elif sys.byteorder in 'little':
option = '-L'
else:
raise Exception("Couldn't figure out system byte order %s" % sys.byteorder)
data.binary('flipdcd', '%s %s' % (option, dcd), dcd+'.flipdcd')
def neutralize_system_with_salt(
in_top, in_gro, basename, force_field):
"""
Takes a .top file and adds counterions to neutralize the overall
charge of system, and saves to `basename.gro`.
"""
# Calculate overall charege in the .top file
qtot = sum([q for mass, q, chain in read_top(in_top)])
counter_ion_charge = -int(round(qtot))
if counter_ion_charge == 0:
shutil.copy(in_gro, basename + '.gro')
return
# Create a .tpr paramater file for genion to find low-energy sites
in_mdp = basename + '.salt.grompp.mdp'
open(in_mdp, 'w').write(ions_mdp + force_field_mdp)
top = basename + '.top'
if in_top != top:
shutil.copy(in_top, top)
tpr = basename + '.salt.tpr'
out_mdp = basename + '.mdp'
data.binary(
'grompp',
'-f %s -po %s -c %s -p %s -o %s' \
% (in_mdp, out_mdp, in_gro, top, tpr),
basename + '.salt.grompp')
util.check_files(tpr)
# Use genion to generate a gro of system with counterions
gro = basename + '.gro'
# Genion requires user input "SOL" to choose solvent for replacement
input_fname = basename + '.salt.genion.in'
open(input_fname, 'w').write('SOL')
# Different versions of Gromacs use different counterions
charge_str = ""
if 'GROMACS4.5' in force_field:
charge_str = " -pname NA -nname CL "
elif 'GROMACS4.0' in force_field:
charge_str = " -pname NA+ -nname CL- "
else:
raise ValueError, "Cannot recognize force_field " + force_field
if counter_ion_charge > 0:
charge_str += " -np %d " % counter_ion_charge
else:
charge_str += " -nn %d " % abs(counter_ion_charge)
log = basename + '.salt.genion.log'
data.binary(
'genion',
'-g %s -s %s -o %s -p %s -neutral %s' % \
(log, tpr, gro, top, charge_str),
basename + '.salt.genion',
input_fname)
util.check_files(gro)
def neutralize_system_with_salt(in_top, in_gro, basename, force_field):
"""
Takes a .top file and adds counterions to neutralize the overall
charge of system, and saves to `basename.gro`.
"""
# Calculate overall charege in the .top file
qtot = sum([q for mass, q, chain in read_top(in_top)])
counter_ion_charge = -int(round(qtot))
if counter_ion_charge == 0:
shutil.copy(in_gro, basename + '.gro')
return
# Create a .tpr paramater file for genion to find low-energy sites
in_mdp = basename + '.salt.grompp.mdp'
open(in_mdp, 'w').write(ions_mdp + force_field_mdp)
top = basename + '.top'
if in_top != top:
shutil.copy(in_top, top)
tpr = basename + '.salt.tpr'
out_mdp = basename + '.mdp'
data.binary(
'grompp',
'-f %s -po %s -c %s -p %s -o %s' \
% (in_mdp, out_mdp, in_gro, top, tpr),
basename + '.salt.grompp')
util.check_files(tpr)
# Use genion to generate a gro of system with counterions
gro = basename + '.gro'
# Genion requires user input "SOL" to choose solvent for replacement
input_fname = basename + '.salt.genion.in'
open(input_fname, 'w').write('SOL')
# Different versions of Gromacs use different counterions
charge_str = ""
if 'GROMACS4.5' in force_field:
charge_str = " -pname NA -nname CL "
elif 'GROMACS4.0' in force_field:
charge_str = " -pname NA+ -nname CL- "
else:
raise ValueError, "Cannot recognize force_field " + force_field
if counter_ion_charge > 0:
charge_str += " -np %d " % counter_ion_charge
else:
charge_str += " -nn %d " % abs(counter_ion_charge)
log = basename + '.salt.genion.log'
data.binary(
'genion',
'-g %s -s %s -o %s -p %s -neutral %s' % \
(log, tpr, gro, top, charge_str),
basename + '.salt.genion',
input_fname)
util.check_files(gro)
def pdb_to_top_and_crds(force_field, pdb, basename, solvent_buffer=10.0):
"""
Creates CHARMM .coor and .psf file for NAMD simulation.
"""
solv_dir = basename + '.solvate'
save_dir = os.getcwd()
pdb = os.path.abspath(pdb)
util.goto_dir(solv_dir)
# Remove all but protein heavy atoms in a single clean conformation
stripped_pdb = basename + '.clean.pdb'
pdbtext.clean_pdb(pdb, stripped_pdb)
# Make input script for psfgen
psfgen_psf = basename+'.psfgen.psf'
psfgen_pdb = basename+'.psfgen.pdb'
script = module_load_script
script += make_chain_loading_script(stripped_pdb, basename)
script += make_disulfide_script(stripped_pdb)
script += write_script
script = script % {
# load the included CHARMM2 atom topologies
'topology': os.path.join(data.data_dir, 'charmm22.topology'),
'out_pdb': psfgen_pdb,
'out_psf': psfgen_psf
}
psfgen_in = basename+".psfgen.in"
open(psfgen_in, "w").write(script)
data.binary('psfgen', psfgen_in, basename+'.psfgen')
util.check_output(psfgen_psf)
util.check_output(psfgen_pdb)
solvate_psf(psfgen_psf, psfgen_pdb, basename, solvent_buffer)
psf = basename+'.psf'
coor = basename+'.coor'
pdb = basename+'.pdb'
os.rename(pdb, coor)
convert_restart_to_pdb(basename, pdb)
shutil.copy(psf, save_dir)
shutil.copy(coor, save_dir)
shutil.copy(pdb, save_dir)
os.chdir(save_dir)
return psf, coor
def solvate_psf(in_psf, in_pdb, basename, solvent_buffer=10.0):
"""
Uses VMD to add explicit waters to a .psf topology file
"""
parms = {
'in_psf': in_psf,
'in_pdb': in_pdb,
'name': basename,
'solvent_buffer': solvent_buffer,
}
tcl = basename + '.vmd.tcl'
open(tcl, 'w').write(solvate_vmd_script % parms)
data.binary('vmd', '-dispdev text -eofexit', basename+'.vmd', tcl)
util.check_output(basename+'.vmd.pdb')
util.check_output(basename+'.pdb')
def run(in_parms):
"""
Runs a NAMD simulation using the PDBREMIX in_parms dictionary.
"""
parms = copy.deepcopy(in_parms)
name = parms['output_basename']
# load the included CHARMM2 energy parameters
parms['parameter'] = os.path.join(data.data_dir, 'charmm22.parameter')
parms['psf_type'] = 'paraTypeCharmm on'
# copy over input xsc and topology files (same basename)
xsc = parms['topology'].replace('.psf', '.xsc')
if os.path.isfile(xsc):
shutil.copy(xsc, name + '.in.xsc')
parms['xsc'] = name + '.in.xsc'
else:
parms['xsc'] = ''
shutil.copy(parms['topology'], name + '.psf')
parms['topology'] = name + '.psf'
# copy over coordinates
shutil.copy(parms['input_crds'], name + '.in.coor')
parms['input_crds'] = name + '.in.coor'
# copy over velocities
if 'input_vels' in parms and parms['input_vels']:
shutil.copy(parms['input_vels'], name + '.in.vel')
parms['input_vels'] = name + '.in.vel'
else:
parms['input_vels'] = ''
# copy over restraint coordinates
if 'restraint_pdb' in parms and parms['restraint_pdb']:
shutil.copy(parms['restraint_pdb'], name + '.restraint.coor')
parms['restraint_pdb'] = name + '.restraint.coor'
else:
parms['restraint_pdb'] = ''
namd_in = name + ".namd2.in"
open(namd_in, "w").write(make_namd_input_file(parms))
data.binary('namd2', namd_in, name + '.namd2')
top, crds, vels = get_restart_files(name)
util.check_output(top)
util.check_output(crds)
def run(in_parms):
"""
Run a AMBER simulations using the PDBREMIX in_parms dictionary.
"""
parms = copy.deepcopy(in_parms)
basename = parms['output_basename']
# Copies across topology file
input_top = parms['topology']
util.check_files(input_top)
new_top = basename + '.top'
shutil.copy(input_top, new_top)
# Copies over coordinate/velocity files
input_crd = parms['input_crds']
util.check_files(input_crd)
if input_crd.endswith('.crd'):
new_crd = basename + '.in.crd'
else:
new_crd = basename + '.in.rst'
shutil.copy(input_crd, new_crd)
# Decide on type of output coordinate/velocity file
if 'n_step_minimization' in parms:
rst = basename + ".crd"
else:
rst = basename + ".rst"
# Construct the long list of arguments for sander
trj = basename + ".trj"
vel_trj = basename + ".vel.trj"
ene = basename + ".ene"
inf = basename + ".inf"
sander_out = basename + ".sander.out"
sander_in = basename + ".sander.in"
args = "-O -i %s -o %s -p %s -c %s -r %s -x %s -v %s -e %s -inf %s" \
% (sander_in, sander_out, new_top, new_crd, rst, trj, vel_trj, ene, inf)
# Make the input script
script = make_sander_input_file(parms)
# If positional restraints
if parms['restraint_pdb']:
# Generate the AMBER .crd file that stores the constrained coordinates
pdb = parms['restraint_pdb']
soup = pdbatoms.Soup(pdb)
ref_crd = basename + '.restraint.crd'
write_soup_to_rst(soup, ref_crd)
util.check_output(ref_crd)
# Add the restraints .crd to the SANDER arguments
args += " -ref %s" % ref_crd
# Add the restraint forces and atom indices to the SANDER input file
script += make_restraint_script(pdb, parms['restraint_force'])
open(sander_in, "w").write(script)
# Run the simulation
data.binary('sander', args, basename)
# Check if output is okay
util.check_output(sander_out, ['FATAL'])
top, crds, vels = get_restart_files(basename)
util.check_output(top)
util.check_output(crds)
def run_tleap(force_field, pdb, name, solvent_buffer=0.0, excess_charge=0):
"""
Generates AMBER topology and coordinate files from PDB.
Depending on whether excess_charge is non-zero, will also generate
counterions. If solvent_buffer is non-zero, will generate explicit
waters, otherwise, no waters generated. No waters is used for
implicit solvent simulations.
"""
util.check_output(pdb)
# Remove all but protein heavy atoms in a single clean conformation
tleap_pdb = name + '.clean.pdb'
pdbtext.clean_pdb(pdb, tleap_pdb)
# The restart files to be generated
top = name + '.top'
crd = name + '.crd'
# Dictionary to substitute into tleap scripts
params = {
'top': top,
'crd': crd,
'pdb': tleap_pdb,
'data_dir': data.data_dir,
'solvent_buffer': solvent_buffer,
}
# use best force-field for the 2 versions of AMBER author has tested
if 'AMBER11' in force_field:
params['amber_ff'] = "leaprc.ff99SB"
elif 'AMBER8' in force_field:
params['amber_ff'] = "leaprc.ff96"
else:
raise Exception("Don't know which version of AMBER(8|11) to use.")
# make the tleap input script
script = force_field_script
# check for a few non-standard residue that have been included
residues = [r.type for r in pdbatoms.Soup(tleap_pdb).residues()]
if 'PHD' in residues:
leaprc = open("%s/phd.leaprc" % data.data_dir).read()
script += leaprc
if 'ZNB' in residues:
leaprc = open("%s/znb.leaprc" % data.data_dir).read()
script += leaprc
script += "pdb = loadpdb %(pdb)s\n"
script += disulfide_script_and_rename_cysteines(tleap_pdb, tleap_pdb)
if 'GBSA' not in force_field:
# Add explicit waters as not GBSA implicit solvent
if excess_charge != 0:
# Add script to add counterions, must specify + or -
if excess_charge > 0:
script += "addions pdb Cl- 0\n"
else:
script += "addions pdb Na+ 0\n"
solvent_buffer = 10
params['solvent_buffer'] = solvent_buffer
script += explicit_water_box_script
script += save_and_quit_script
script = script % params
# Now write script to input file
tleap_in = name + ".tleap.in"
open(tleap_in, "w").write(script)
# Now run tleap with tleap_in
data.binary('tleap', "-f " + tleap_in, name + '.tleap')
# Check output is okay
if os.path.isfile('leap.log'):
os.rename('leap.log', name + '.tleap.log')
util.check_output(name + '.tleap.log', ['FATAL'])
util.check_output(top)
util.check_output(crd)
return top, crd
def pdb_to_top_and_crds(force_field, pdb, basename, solvent_buffer=10):
"""
Converts a PDB file into GROMACS topology and coordinate files,
and fully converted PDB file. These constitute the restart files
of a GROMACS simulation.
"""
util.check_files(pdb)
full_pdb = os.path.abspath(pdb)
save_dir = os.getcwd()
# All intermediate files placed into a subdirectory
util.goto_dir(basename + '.solvate')
# Remove all but protein heavy atoms in a single clean conformation
pdb = basename + '.clean.pdb'
pdbtext.clean_pdb(full_pdb, pdb)
# Generate protein topology in pdb2gmx_gro using pdb2gmx
pdb2gmx_gro = basename + '.pdb2gmx.gro'
top = basename + '.top'
itp = basename + '_posre.itp'
# Choose force field based on GROMACS version
if 'GROMACS4.5' in force_field:
ff = 'amber99'
elif 'GROMACS4.0' in force_field:
ff = 'G43a1'
else:
raise ValueError, "Couldn't work out pdb2gmx for " + force_field
args = '-ignh -ff %s -water spc -missing -f %s -o %s -p %s -i %s -chainsep id_or_ter -merge all' \
% (ff, pdb, pdb2gmx_gro, top, itp)
data.binary('pdb2gmx', args, basename + '.pdb2gmx')
util.check_files(pdb2gmx_gro)
# Now add a box with editconf
box_gro = basename + '.box.gro'
solvent_buffer_in_nm = solvent_buffer / 10.0
data.binary(
'editconf',
'-f %s -o %s -c -d %f -bt cubic' \
% (pdb2gmx_gro, box_gro, solvent_buffer_in_nm),
basename+'.box')
util.check_files(box_gro)
# Given box dimensions, can now populate with explict waters
solvated_gro = basename + '.solvated.gro'
data.binary(
'genbox',
'-cp %s -cs spc216.gro -o %s -p %s' \
% (box_gro, solvated_gro, top),
'%s.solvated' % basename)
util.check_files(solvated_gro)
# Neutralize with counterions using genion to place ions
# based on energy parameters processed by grompp
gro = basename + '.gro'
neutralize_system_with_salt(top, solvated_gro, basename, force_field)
util.check_files(gro)
# Make a reference PDB file from restart files for viewing and restraints
convert_restart_to_pdb(basename, basename + '.pdb')
# Copy finished restart files back into original directory
fnames = util.re_glob(
'*',
os.path.basename(basename) + r'[^\.]*\.(pdb|itp|gro|mdp|top)$')
for fname in fnames:
shutil.copy(fname, save_dir)
# Cleanup
delete_backup_files(basename)
os.chdir(save_dir)
return top, gro
def run(in_parms):
"""
Run a AMBER simulations using the PDBREMIX in_parms dictionary.
"""
parms = copy.deepcopy(in_parms)
basename = parms['output_basename']
# Copies across topology file
input_top = parms['topology']
util.check_files(input_top)
new_top = basename + '.top'
shutil.copy(input_top, new_top)
# Copies over coordinate/velocity files
input_crd = parms['input_crds']
util.check_files(input_crd)
if input_crd.endswith('.crd'):
new_crd = basename + '.in.crd'
else:
new_crd = basename + '.in.rst'
shutil.copy(input_crd, new_crd)
# Decide on type of output coordinate/velocity file
if 'n_step_minimization' in parms:
rst = basename + ".crd"
else:
rst = basename + ".rst"
# Construct the long list of arguments for sander
trj = basename + ".trj"
vel_trj = basename + ".vel.trj"
ene = basename + ".ene"
inf = basename + ".inf"
sander_out = basename + ".sander.out"
sander_in = basename + ".sander.in"
args = "-O -i %s -o %s -p %s -c %s -r %s -x %s -v %s -e %s -inf %s" \
% (sander_in, sander_out, new_top, new_crd, rst, trj, vel_trj, ene, inf)
# Make the input script
script = make_sander_input_file(parms)
# If positional restraints
if parms['restraint_pdb']:
# Generate the AMBER .crd file that stores the constrained coordinates
pdb = parms['restraint_pdb']
soup = pdbatoms.Soup(pdb)
ref_crd = basename + '.restraint.crd'
write_soup_to_rst(soup, ref_crd)
util.check_output(ref_crd)
# Add the restraints .crd to the SANDER arguments
args += " -ref %s" % ref_crd
# Add the restraint forces and atom indices to the SANDER input file
script += make_restraint_script(pdb, parms['restraint_force'])
open(sander_in, "w").write(script)
# Run the simulation
data.binary('sander', args, basename)
# Check if output is okay
util.check_output(sander_out, ['FATAL'])
top, crds, vels = get_restart_files(basename)
util.check_output(top)
util.check_output(crds)
def run_tleap(
force_field, pdb, name, solvent_buffer=0.0, excess_charge=0):
"""
Generates AMBER topology and coordinate files from PDB.
Depending on whether excess_charge is non-zero, will also generate
counterions. If solvent_buffer is non-zero, will generate explicit
waters, otherwise, no waters generated. No waters is used for
implicit solvent simulations.
"""
util.check_output(pdb)
# Remove all but protein heavy atoms in a single clean conformation
tleap_pdb = name + '.clean.pdb'
pdbtext.clean_pdb(pdb, tleap_pdb)
# The restart files to be generated
top = name + '.top'
crd = name + '.crd'
# Dictionary to substitute into tleap scripts
params = {
'top': top,
'crd': crd,
'pdb': tleap_pdb,
'data_dir':data.data_dir,
'solvent_buffer': solvent_buffer,
}
# use best force-field for the 2 versions of AMBER author has tested
if 'AMBER11' in force_field:
params['amber_ff'] = "leaprc.ff99SB"
elif 'AMBER14' in force_field:
params['amber_ff'] = "leaprc.ff14SB"
elif 'AMBER8' in force_field:
params['amber_ff'] = "leaprc.ff96"
else:
raise Exception("Don't know which version of AMBER(8|11|14) to use.")
# make the tleap input script
script = force_field_script
# check for a few non-standard residue that have been included
residues = [r.type for r in pdbatoms.Soup(tleap_pdb).residues()]
if 'PHD' in residues:
leaprc = open("%s/phd.leaprc" % data.data_dir).read()
script += leaprc
if 'ZNB' in residues:
leaprc = open("%s/znb.leaprc" % data.data_dir).read()
script += leaprc
script += "pdb = loadpdb %(pdb)s\n"
script += disulfide_script_and_rename_cysteines(tleap_pdb, tleap_pdb)
if 'GBSA' not in force_field:
# Add explicit waters as not GBSA implicit solvent
if excess_charge != 0:
# Add script to add counterions, must specify + or -
if excess_charge > 0:
script += "addions pdb Cl- 0\n"
else:
script += "addions pdb Na+ 0\n"
solvent_buffer = 10
params['solvent_buffer'] = solvent_buffer
script += explicit_water_box_script
script += save_and_quit_script
script = script % params
# Now write script to input file
tleap_in = name + ".tleap.in"
open(tleap_in, "w").write(script)
# Now run tleap with tleap_in
data.binary('tleap', "-f "+tleap_in, name+'.tleap')
# Check output is okay
if os.path.isfile('leap.log'):
os.rename('leap.log', name + '.tleap.log')
util.check_output(name+'.tleap.log', ['FATAL'])
util.check_output(top)
util.check_output(crd)
return top, crd
def run(in_parms):
"""
Run a GROMACS simulations using the PDBREMIX parms dictionary.
"""
parms = copy.deepcopy(in_parms)
basename = parms['output_basename']
# Copies across topology and related *.itp files, with appropriate
# filename renaming in #includes
top = basename + '.top'
in_top = parms['topology']
shutil.copy(in_top, top)
in_name = os.path.basename(in_top).replace('.top', '')
in_dir = os.path.dirname(in_top)
file_tag = "%s/%s_*itp" % (in_dir, in_name)
new_files = [top]
for f in glob.glob(file_tag):
new_f = os.path.basename(f)
new_f = new_f.replace(in_name, basename)
shutil.copy(f, new_f)
new_files.append(new_f)
for f in new_files:
replace_include_file(f, in_name + "_", basename + "_")
# Copy over input coordinates/velocities
in_gro = basename + '.in.gro'
shutil.copy(parms['input_crds'], in_gro)
# Generates a postiional-restraint topology file
if parms['restraint_pdb']:
# 1kcal*mol*A**-2 = 4.184 kJ*mol*(0.1 nm)**-2
kcalmolang2_to_kJmolnm2 = 400.184
open(basename + '_posre.itp', 'w').write(
make_restraint_itp(
parms['restraint_pdb'],
parms['restraint_force'] * kcalmolang2_to_kJmolnm2))
# Generate .mdp file based on parms
in_mdp = basename + '.grompp.mdp'
open(in_mdp, 'w').write(make_mdp(parms))
# Now run .grompp to generate this .tpr file
tpr = basename + '.tpr'
# .mdp to save complete set of parameters
mdp = basename + '.mdrun.mdp'
data.binary(
'grompp',
'-f %s -po %s -c %s -p %s -o %s' \
% (in_mdp, mdp, in_gro, top, tpr),
basename + '.grompp')
util.check_files(tpr)
# Run simulation with the .tpr file
data.binary(
'mdrun',
'-v -deffnm %s' % (basename),
basename + '.mdrun')
top, crds, vels = get_restart_files(basename)
util.check_output(top)
util.check_output(crds)
# Cleanup
delete_backup_files(basename)
def pdb_to_top_and_crds(force_field, pdb, basename, solvent_buffer=10):
"""
Converts a PDB file into GROMACS topology and coordinate files,
and fully converted PDB file. These constitute the restart files
of a GROMACS simulation.
"""
util.check_files(pdb)
full_pdb = os.path.abspath(pdb)
save_dir = os.getcwd()
# All intermediate files placed into a subdirectory
util.goto_dir(basename + '.solvate')
# Remove all but protein heavy atoms in a single clean conformation
pdb = basename + '.clean.pdb'
pdbtext.clean_pdb(full_pdb, pdb)
# Generate protein topology in pdb2gmx_gro using pdb2gmx
pdb2gmx_gro = basename + '.pdb2gmx.gro'
top = basename + '.top'
itp = basename + '_posre.itp'
# Choose force field based on GROMACS version
if 'GROMACS4.5' in force_field:
ff = 'amber99'
elif 'GROMACS4.0' in force_field:
ff = 'G43a1'
else:
raise ValueError, "Couldn't work out pdb2gmx for " + force_field
args = '-ignh -ff %s -water spc -missing -f %s -o %s -p %s -i %s -chainsep id_or_ter -merge all' \
% (ff, pdb, pdb2gmx_gro, top, itp)
data.binary('pdb2gmx', args, basename+'.pdb2gmx')
util.check_files(pdb2gmx_gro)
# Now add a box with editconf
box_gro = basename + '.box.gro'
solvent_buffer_in_nm = solvent_buffer/10.0
data.binary(
'editconf',
'-f %s -o %s -c -d %f -bt cubic' \
% (pdb2gmx_gro, box_gro, solvent_buffer_in_nm),
basename+'.box')
util.check_files(box_gro)
# Given box dimensions, can now populate with explict waters
solvated_gro = basename + '.solvated.gro'
data.binary(
'genbox',
'-cp %s -cs spc216.gro -o %s -p %s' \
% (box_gro, solvated_gro, top),
'%s.solvated' % basename)
util.check_files(solvated_gro)
# Neutralize with counterions using genion to place ions
# based on energy parameters processed by grompp
gro = basename + '.gro'
neutralize_system_with_salt(top, solvated_gro, basename, force_field)
util.check_files(gro)
# Make a reference PDB file from restart files for viewing and restraints
convert_restart_to_pdb(basename, basename+'.pdb')
# Copy finished restart files back into original directory
fnames = util.re_glob(
'*', os.path.basename(basename) + r'[^\.]*\.(pdb|itp|gro|mdp|top)$')
for fname in fnames:
shutil.copy(fname, save_dir)
# Cleanup
delete_backup_files(basename)
os.chdir(save_dir)
return top, gro
