def launch(self) -> int:
"""Execute the :class:`Solvate <gromacs.solvate.Solvate>` object."""
# Setup Biobb
if self.check_restart(): return 0
self.stage_files()
# Unzip topology to topology_out
top_file = fu.unzip_top(zip_file=self.input_top_zip_path, out_log=self.out_log)
top_dir = str(Path(top_file).parent)
if self.container_path:
shutil.copytree(top_dir, str(Path(self.stage_io_dict.get("unique_dir")).joinpath(Path(top_dir).name)))
top_file = str(Path(self.container_volume_path).joinpath(Path(top_dir).name, Path(top_file).name))
self.cmd = [self.gmx_path, 'solvate',
'-cp', self.stage_io_dict["in"]["input_solute_gro_path"],
'-cs', self.stage_io_dict["in"]["input_solvent_gro_path"],
'-o', self.stage_io_dict["out"]["output_gro_path"],
'-p', top_file]
if self.shell:
self.cmd.append("-shell")
self.cmd.append(str(self.shell))
if self.gmx_lib:
self.environment = os.environ.copy()
self.environment['GMXLIB'] = self.gmx_lib
# Check GROMACS version
if not self.container_path:
if self.gmx_version < 512:
raise GromacsVersionError("Gromacs version should be 5.1.2 or newer %d detected" % self.gmx_version)
fu.log("GROMACS %s %d version detected" % (self.__class__.__name__, self.gmx_version), self.out_log)
# Run Biobb block
self.run_biobb()
# Copy files to host
self.copy_to_host()
if self.container_path:
top_file = str(Path(self.stage_io_dict.get("unique_dir")).joinpath(Path(top_dir).name, Path(top_file).name))
# zip topology
fu.log('Compressing topology to: %s' % self.stage_io_dict["out"]["output_top_zip_path"], self.out_log,
self.global_log)
fu.zip_top(zip_file=self.io_dict["out"]["output_top_zip_path"], top_file=top_file, out_log=self.out_log)
# Remove temporal files
self.tmp_files.extend([self.stage_io_dict.get("unique_dir"), top_dir])
self.remove_tmp_files()
return self.return_code
def launch(self) -> int:
"""Execute the :class:`Ndx2resttop <gromacs_extra.ndx2resttop.Ndx2resttop>` object."""
# Setup Biobb
if self.check_restart(): return 0
top_file = fu.unzip_top(
zip_file=self.io_dict['in'].get("input_top_zip_path"),
out_log=self.out_log)
# Create index list of index file :)
index_dic = {}
lines = open(
self.io_dict['in'].get("input_ndx_path")).read().splitlines()
for index, line in enumerate(lines):
if line.startswith('['):
index_dic[line] = index,
label = line
if index > 0:
index_dic[label] = index_dic[label][0], index
index_dic[label] = index_dic[label][0], index
fu.log('Index_dic: ' + str(index_dic), self.out_log, self.global_log)
self.ref_rest_chain_triplet_list = [
tuple(elem.strip(' ()').replace(' ', '').split(','))
for elem in self.ref_rest_chain_triplet_list.split('),')
]
fu.log(
'ref_rest_chain_triplet_list: ' +
str(self.ref_rest_chain_triplet_list), self.out_log,
self.global_log)
for reference_group, restrain_group, chain in self.ref_rest_chain_triplet_list:
fu.log('Reference group: ' + reference_group, self.out_log,
self.global_log)
fu.log('Restrain group: ' + restrain_group, self.out_log,
self.global_log)
fu.log('Chain: ' + chain, self.out_log, self.global_log)
self.io_dict['out']["output_itp_path"] = fu.create_name(
path=str(Path(top_file).parent),
prefix=self.prefix,
step=self.step,
name=restrain_group + '.itp')
# Mapping atoms from absolute enumeration to Chain relative enumeration
fu.log(
'reference_group_index: start_closed:' +
str(index_dic['[ ' + reference_group + ' ]'][0] + 1) +
' stop_open: ' +
str(index_dic['[ ' + reference_group + ' ]'][1]), self.out_log,
self.global_log)
reference_group_list = [
int(elem)
for line in lines[index_dic['[ ' + reference_group + ' ]'][0] +
1:index_dic['[ ' + reference_group +
' ]'][1]]
for elem in line.split()
]
fu.log(
'restrain_group_index: start_closed:' +
str(index_dic['[ ' + restrain_group + ' ]'][0] + 1) +
' stop_open: ' +
str(index_dic['[ ' + restrain_group + ' ]'][1]), self.out_log,
self.global_log)
restrain_group_list = [
int(elem)
for line in lines[index_dic['[ ' + restrain_group + ' ]'][0] +
1:index_dic['[ ' + restrain_group + ' ]'][1]]
for elem in line.split()
]
selected_list = [
reference_group_list.index(atom) + 1
for atom in restrain_group_list
]
# Creating new ITP with restrictions
with open(self.io_dict['out'].get("output_itp_path"), 'w') as f:
fu.log(
'Creating: ' + str(f) +
' and adding the selected atoms force constants',
self.out_log, self.global_log)
f.write('[ position_restraints ]\n')
f.write('; atom type fx fy fz\n')
for atom in selected_list:
f.write(
str(atom) + ' 1 ' + self.force_constants + '\n')
# Including new ITP in the corresponding ITP-chain file
for file_dir in Path(top_file).parent.iterdir():
if not file_dir.name.startswith(
"posre") and not file_dir.name.endswith("_pr.itp"):
if fnmatch.fnmatch(str(file_dir),
"*_chain_" + chain + ".itp"):
with open(str(file_dir), 'a') as f:
fu.log(
'Opening: ' + str(f) +
' and adding the ifdef include statement',
self.out_log, self.global_log)
f.write('\n')
f.write('; Include Position restraint file\n')
f.write('#ifdef CUSTOM_POSRES\n')
f.write('#include "' + str(
Path(self.io_dict['out'].get(
"output_itp_path")).name) + '"\n')
f.write('#endif\n')
# zip topology
fu.zip_top(zip_file=self.io_dict['out'].get("output_top_zip_path"),
top_file=top_file,
out_log=self.out_log)
# Remove temporal files
self.remove_tmp_files()
return 0
def launch(self) -> int:
"""Execute the :class:`Pmxgentop <pmx.pmxgentop.Pmxgentop>` pmx.pmxgentop.Pmxgentop object."""
# Setup Biobb
if self.check_restart(): return 0
self.stage_files()
# Check if executable exists
if not self.container_path:
if not Path(self.pmx_path).is_file():
if not shutil.which(self.pmx_path):
raise FileNotFoundError('Executable %s not found. Check if it is installed in your system and correctly defined in the properties' % self.pmx_path)
# Unzip topology to topology_out
top_file = fu.unzip_top(zip_file=self.input_top_zip_path, out_log=self.out_log)
top_dir = str(Path(top_file).parent)
# Copy extra files to container: topology folder
if self.container_path:
fu.log('Container execution enabled', self.out_log)
fu.log(f"Unique dir: {self.stage_io_dict['unique_dir']}", self.out_log)
fu.log(f"{self.stage_io_dict['unique_dir']} files: {os.listdir(self.stage_io_dict['unique_dir'])}", self.out_log)
fu.log(f"Copy all files of the unzipped original topology to unique dir:", self.out_log)
shutil.copytree(top_dir, str(Path(self.stage_io_dict.get("unique_dir")).joinpath(Path(top_dir).name)))
top_file = str(Path(self.container_volume_path).joinpath(Path(top_dir).name, Path(top_file).name))
output_file_name = fu.create_name(prefix=self.prefix, step=self.step, name=str(Path(top_file).name))
unique_dir_output_file = str(Path(fu.create_unique_dir()).joinpath(output_file_name))
fu.log(f"unique_dir_output_file: {unique_dir_output_file}", self.out_log)
if self.container_path:
fu.log("Change references for container:", self.out_log)
unique_dir_output_file = str(Path(self.container_volume_path).joinpath(Path(output_file_name)))
fu.log(f" unique_dir_output_file: {unique_dir_output_file}", self.out_log)
self.cmd = [self.pmx_path, 'gentop',
'-o', str(Path(unique_dir_output_file)),
'-ff', self.force_field,
'-p', top_file]
if self.split:
self.cmd.append('--split')
if self.scale_mass:
self.cmd.append('--scale_mass')
if self.gmx_lib:
self.environment = os.environ.copy()
self.environment['GMXLIB'] = self.gmx_lib
# Run Biobb block
self.run_biobb()
# Copy files to host
self.copy_to_host()
if self.container_path:
unique_dir_output_file = str(Path(container_io_dict.get("unique_dir")).joinpath(Path(unique_dir_output_file).name))
# Remove paths from top file
with open(Path(unique_dir_output_file)) as top_fh:
top_lines = top_fh.readlines()
with open(Path(unique_dir_output_file), 'w') as top_fh:
for line in top_lines:
top_fh.write(line.replace(str(Path(unique_dir_output_file).parent)+'/', ''))
# Copy the not modified itp files
for orig_itp_file in Path(top_dir).iterdir():
fu.log(f'Check if {str(Path(unique_dir_output_file).parent.joinpath(Path(orig_itp_file).name))} exists', self.out_log, self.global_log)
if not Path(unique_dir_output_file).parent.joinpath(Path(orig_itp_file).name).exists():
shutil.copy(orig_itp_file, Path(unique_dir_output_file).parent)
fu.log(f'Copying {str(orig_itp_file)} to: {str(Path(unique_dir_output_file).parent)}', self.out_log, self.global_log)
# zip topology
fu.log('Compressing topology to: %s' % self.io_dict["out"]["output_top_zip_path"], self.out_log, self.global_log)
fu.zip_top(zip_file=self.io_dict["out"]["output_top_zip_path"], top_file=str(Path(unique_dir_output_file)), out_log=self.out_log)
self.tmp_files.extend([self.stage_io_dict.get("unique_dir"), top_dir])
self.remove_tmp_files()
return self.return_code
def launch(self) -> int:
"""Launches the execution of the GROMACS solvate module."""
tmp_files = []
# Get local loggers from launchlogger decorator
out_log = getattr(self, 'out_log', None)
err_log = getattr(self, 'err_log', None)
# Check GROMACS version
if not self.container_path:
if self.gmx_version < 512:
raise GromacsVersionError(
"Gromacs version should be 5.1.2 or newer %d detected" %
self.gmx_version)
fu.log(
"GROMACS %s %d version detected" %
(self.__class__.__name__, self.gmx_version), out_log)
# Restart if needed
if self.restart:
if fu.check_complete_files(self.io_dict["out"].values()):
fu.log(
'Restart is enabled, this step: %s will the skipped' %
self.step, out_log, self.global_log)
return 0
# Unzip topology to topology_out
top_file = fu.unzip_top(zip_file=self.input_top_zip_path,
out_log=out_log)
top_dir = str(Path(top_file).parent)
tmp_files.append(top_dir)
container_io_dict = fu.copy_to_container(self.container_path,
self.container_volume_path,
self.io_dict)
if self.container_path:
shutil.copytree(
top_dir,
str(
Path(container_io_dict.get("unique_dir")).joinpath(
Path(top_dir).name)))
top_file = str(
Path(self.container_volume_path).joinpath(
Path(top_dir).name,
Path(top_file).name))
cmd = [
self.gmx_path, 'solvate', '-cp',
container_io_dict["in"]["input_solute_gro_path"], '-cs',
self.input_solvent_gro_path, '-o',
container_io_dict["out"]["output_gro_path"], '-p', top_file
]
new_env = None
if self.gmxlib:
new_env = os.environ.copy()
new_env['GMXLIB'] = self.gmxlib
cmd = fu.create_cmd_line(
cmd,
container_path=self.container_path,
host_volume=container_io_dict.get("unique_dir"),
container_volume=self.container_volume_path,
container_working_dir=self.container_working_dir,
container_user_uid=self.container_user_id,
container_shell_path=self.container_shell_path,
container_image=self.container_image,
out_log=out_log,
global_log=self.global_log)
returncode = cmd_wrapper.CmdWrapper(cmd, out_log, err_log,
self.global_log, new_env).launch()
fu.copy_to_host(self.container_path, container_io_dict, self.io_dict)
if self.container_path:
top_file = str(
Path(container_io_dict.get("unique_dir")).joinpath(
Path(top_dir).name,
Path(top_file).name))
# zip topology
fu.log(
'Compressing topology to: %s' %
container_io_dict["out"]["output_top_zip_path"], out_log,
self.global_log)
fu.zip_top(zip_file=self.io_dict["out"]["output_top_zip_path"],
top_file=top_file,
out_log=out_log)
tmp_files.append(container_io_dict.get("unique_dir"))
if self.remove_tmp:
fu.rm_file_list(tmp_files, out_log=out_log)
return returncode
def launch(self) -> int:
"""Launches the execution of the GROMACS pdb2gmx module."""
tmp_files = []
# Get local loggers from launchlogger decorator
out_log = getattr(self, 'out_log', None)
err_log = getattr(self, 'err_log', None)
# Check GROMACS version
if not self.container_path:
if self.gmx_version < 512:
raise GromacsVersionError(
"Gromacs version should be 5.1.2 or newer %d detected" %
self.gmx_version)
fu.log(
"GROMACS %s %d version detected" %
(self.__class__.__name__, self.gmx_version), out_log)
# Restart if needed
if self.restart:
if fu.check_complete_files(self.io_dict["out"].values()):
fu.log(
'Restart is enabled, this step: %s will the skipped' %
self.step, out_log, self.global_log)
return 0
container_io_dict = fu.copy_to_container(self.container_path,
self.container_volume_path,
self.io_dict)
output_top_path = fu.create_name(prefix=self.prefix,
step=self.step,
name=self.output_top_path)
output_itp_path = fu.create_name(prefix=self.prefix,
step=self.step,
name=self.output_itp_path)
cmd = [
self.gmx_path, "pdb2gmx", "-f",
container_io_dict["in"]["input_pdb_path"], "-o",
container_io_dict["out"]["output_gro_path"], "-p", output_top_path,
"-water", self.water_type, "-ff", self.force_field, "-i",
output_itp_path
]
if self.his:
cmd.append("-his")
cmd = ['echo', self.his, '|'] + cmd
if self.ignh:
cmd.append("-ignh")
new_env = None
if self.gmxlib:
new_env = os.environ.copy()
new_env['GMXLIB'] = self.gmxlib
cmd = fu.create_cmd_line(
cmd,
container_path=self.container_path,
host_volume=container_io_dict.get("unique_dir"),
container_volume=self.container_volume_path,
container_working_dir=self.container_working_dir,
container_user_uid=self.container_user_id,
container_shell_path=self.container_shell_path,
container_image=self.container_image,
out_log=out_log,
global_log=self.global_log)
returncode = cmd_wrapper.CmdWrapper(cmd, out_log, err_log,
self.global_log, new_env).launch()
fu.copy_to_host(self.container_path, container_io_dict, self.io_dict)
if self.container_path:
output_top_path = os.path.join(container_io_dict.get("unique_dir"),
output_top_path)
# zip topology
fu.log(
'Compressing topology to: %s' %
container_io_dict["out"]["output_top_zip_path"], out_log,
self.global_log)
fu.zip_top(zip_file=self.io_dict["out"]["output_top_zip_path"],
top_file=output_top_path,
out_log=out_log)
tmp_files.append(self.output_top_path)
tmp_files.append(self.output_itp_path)
tmp_files.append(container_io_dict.get("unique_dir"))
if self.remove_tmp:
fu.rm_file_list(tmp_files, out_log=out_log)
return returncode
def launch(self) -> int:
"""Launches the execution of the GROMACS editconf module."""
tmp_files = []
# Get local loggers from launchlogger decorator
out_log = getattr(self, 'out_log', None)
err_log = getattr(self, 'err_log', None)
# Restart if needed
if self.restart:
output_file_list = [self.io_dict['out'].get("output_top_zip_path")]
if fu.check_complete_files(output_file_list):
fu.log(
'Restart is enabled, this step: %s will the skipped' %
self.step, out_log, self.global_log)
return 0
# Unzip topology
top_file = fu.unzip_top(
zip_file=self.io_dict['in'].get("input_top_zip_path"),
out_log=out_log)
top_dir = str(Path(top_file).parent)
tmp_files.append(top_dir)
itp_name = str(Path(self.io_dict['in'].get("input_itp_path")).name)
with open(top_file) as top_f:
top_lines = top_f.readlines()
top_f.close()
fu.rm(top_file)
forcefield_pattern = r'#include.*forcefield.itp\"'
for index, line in enumerate(top_lines):
if re.search(forcefield_pattern, line):
break
top_lines.insert(index + 1, '\n')
top_lines.insert(index + 2, '; Including ligand ITP\n')
top_lines.insert(index + 3, '#include "' + itp_name + '"\n')
top_lines.insert(index + 4, '\n')
if self.io_dict['in'].get("input_posres_itp_path"):
top_lines.insert(index + 5, '; Ligand position restraints' + '\n')
top_lines.insert(index + 6, '#ifdef ' + self.posres_name + '\n')
top_lines.insert(
index + 7, '#include "' + str(
Path(self.io_dict['in'].get("input_posres_itp_path")).name)
+ '"\n')
top_lines.insert(index + 8, '#endif' + '\n')
top_lines.insert(index + 9, '\n')
inside_moleculetype_section = False
with open(self.io_dict['in'].get("input_itp_path")) as itp_file:
moleculetype_pattern = r'\[ moleculetype \]'
for line in itp_file:
if re.search(moleculetype_pattern, line):
inside_moleculetype_section = True
continue
if inside_moleculetype_section and not line.startswith(';'):
moleculetype = line.strip().split()[0].strip()
break
molecules_pattern = r'\[ molecules \]'
inside_molecules_section = False
index_molecule = None
molecule_string = moleculetype + (20 -
len(moleculetype)) * ' ' + '1' + '\n'
for index, line in enumerate(top_lines):
if re.search(molecules_pattern, line):
inside_molecules_section = True
continue
if inside_molecules_section and not line.startswith(
';') and line.upper().startswith('PROTEIN'):
index_molecule = index
if index_molecule:
top_lines.insert(index_molecule + 1, molecule_string)
else:
top_lines.append(molecule_string)
new_top = fu.create_name(path=top_dir,
prefix=self.prefix,
step=self.step,
name='ligand.top')
with open(new_top, 'w') as new_top_f:
new_top_f.write("".join(top_lines))
shutil.copy2(self.io_dict['in'].get("input_itp_path"), top_dir)
if self.io_dict['in'].get("input_posres_itp_path"):
shutil.copy2(self.io_dict['in'].get("input_posres_itp_path"),
top_dir)
# zip topology
fu.log(
'Compressing topology to: %s' %
self.io_dict['out'].get("output_top_zip_path"), out_log,
self.global_log)
fu.zip_top(zip_file=self.io_dict['out'].get("output_top_zip_path"),
top_file=new_top,
out_log=out_log)
if self.remove_tmp:
fu.rm_file_list(tmp_files, out_log=out_log)
return 0
def launch(self) -> int:
"""Launch the topology generation."""
tmp_files = []
# Get local loggers from launchlogger decorator
out_log = getattr(self, 'out_log', None)
err_log = getattr(self, 'err_log', None)
# Restart if needed
if self.restart:
output_file_list = [self.io_dict['out'].get("output_top_zip_path")]
if fu.check_complete_files(output_file_list):
fu.log('Restart is enabled, this step: %s will the skipped' % self.step, out_log, self.global_log)
return 0
top_file = fu.unzip_top(zip_file=self.io_dict['in'].get("input_top_zip_path"), out_log=out_log)
# Create index list of index file :)
index_dic = {}
lines = open(self.io_dict['in'].get("input_ndx_path")).read().splitlines()
for index, line in enumerate(lines):
if line.startswith('['):
index_dic[line] = index,
label = line
if index > 0:
index_dic[label] = index_dic[label][0], index
index_dic[label] = index_dic[label][0], index
fu.log('Index_dic: '+str(index_dic), out_log, self.global_log)
self.ref_rest_chain_triplet_list = [tuple(elem.strip(' ()').replace(' ', '').split(',')) for elem in self.ref_rest_chain_triplet_list.split('),')]
fu.log('ref_rest_chain_triplet_list: ' + str(self.ref_rest_chain_triplet_list), out_log, self.global_log)
for reference_group, restrain_group, chain in self.ref_rest_chain_triplet_list:
fu.log('Reference group: '+reference_group, out_log, self.global_log)
fu.log('Restrain group: '+restrain_group, out_log, self.global_log)
fu.log('Chain: '+chain, out_log, self.global_log)
self.io_dict['out']["output_itp_path"] = fu.create_name(path=str(Path(top_file).parent), prefix=self.prefix, step=self.step, name=restrain_group+'.itp')
# Mapping atoms from absolute enumeration to Chain relative enumeration
fu.log('reference_group_index: start_closed:'+str(index_dic['[ '+reference_group+' ]'][0]+1)+' stop_open: '+str(index_dic['[ '+reference_group+' ]'][1]), out_log, self.global_log)
reference_group_list = [int(elem) for line in lines[index_dic['[ '+reference_group+' ]'][0]+1: index_dic['[ '+reference_group+' ]'][1]] for elem in line.split()]
fu.log('restrain_group_index: start_closed:'+str(index_dic['[ '+restrain_group+' ]'][0]+1)+' stop_open: '+str(index_dic['[ '+restrain_group+' ]'][1]), out_log, self.global_log)
restrain_group_list = [int(elem) for line in lines[index_dic['[ '+restrain_group+' ]'][0]+1: index_dic['[ '+restrain_group+' ]'][1]] for elem in line.split()]
selected_list = [reference_group_list.index(atom)+1 for atom in restrain_group_list]
# Creating new ITP with restrictions
with open(self.io_dict['out'].get("output_itp_path"), 'w') as f:
fu.log('Creating: '+str(f)+' and adding the selected atoms force constants', out_log, self.global_log)
f.write('[ position_restraints ]\n')
f.write('; atom type fx fy fz\n')
for atom in selected_list:
f.write(str(atom)+' 1 '+self.force_constants+'\n')
# Including new ITP in the corresponding ITP-chain file
for file_dir in Path(top_file).parent.iterdir():
if not file_dir.name.startswith("posre") and not file_dir.name.endswith("_pr.itp"):
if fnmatch.fnmatch(str(file_dir), "*_chain_"+chain+".itp"):
with open(str(file_dir), 'a') as f:
fu.log('Opening: '+str(f)+' and adding the ifdef include statement', out_log, self.global_log)
f.write('\n')
f.write('; Include Position restraint file\n')
f.write('#ifdef CUSTOM_POSRES\n')
f.write('#include "'+str(Path(self.io_dict['out'].get("output_itp_path")).name)+'"\n')
f.write('#endif\n')
# zip topology
fu.zip_top(zip_file=self.io_dict['out'].get("output_top_zip_path"), top_file=top_file, out_log=out_log)
if self.remove_tmp:
fu.rm_file_list(tmp_files, out_log=out_log)
return 0
def via_gromacs(cls,
parmed_obj,
file_name,
file_path="./",
num_steps=5000 * 500,
write_out_freq=5000,
num_threads=1,
minimisation_mdp=None,
equilibration_mdp=None,
production_mdp=None,
tmp_dir=None,
report_equilibration=False,
report_production=False,
debug=False,
stages=["minimisation", "equilibration", "production"],
**kwargs): #TODO infer threads based on system size
"""
Simulation via GROMACS will be added in the future.
based on cell size, make recomendation on number of threads to use
Parameters
------------
parmed_obj : parmed.structure
Parmed object of the fully parameterised simulated system.
file_name : str
No file type postfix is necessary
file_path : str
Default to current directory
platform : str
The computing architecture to do the calculation, default to CUDA, CPU, OpenCL is also possible.
num_steps : int
Number of production simulation to run, default 2,500,000 steps, i.e. 5 ns.
write_out_freq : int
Write out every nth frame of simulated trajectory, default to every 5000 frame write out one, i.e. 10 ps per frame.
Returns
--------
path : str
The absolute path where the trajectory is written to.
"""
from biobb_md.gromacs.make_ndx import make_ndx, MakeNdx
# from biobb_md.gromacs.grompp_mdrun import grompp_mdrun
from biobb_md.gromacs.mdrun import mdrun
from biobb_md.gromacs.grompp import grompp
from biobb_common.tools.file_utils import zip_top
assert tmp_dir is None or os.path.realpath(
file_path) != os.path.realpath(
tmp_dir
), "Simulation results will not be stored in a temporary directory"
if debug:
import shutil
tmp_dir = "{}/.debug/".format(file_path)
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
os.mkdir(tmp_dir)
elif tmp_dir is None:
tmp_dir = tempfile.mkdtemp(
dir=file_path
) #FIXME just change this to debug dir in dubug mode
else:
try:
os.mkdir(tmp_dir)
except:
raise ValueError(
"Cannot create an empty temporary directory for storing intermediate files"
)
parmed_obj.residues[0].name = "LIG"
parmed_obj = parmed.gromacs.gromacstop.GromacsTopologyFile(
).from_structure(parmed_obj)
parmed_obj.defaults.fudgeLJ = 0.5
parmed_obj.defaults.fudgeQQ = 0.83333
parmed_obj.defaults.gen_pairs = "yes"
# Create prop dict and inputs/outputs
xtc_file = '{}/{}.xtc'.format(file_path, file_name)
gro_file = "{}/{}.gro".format(file_path, file_name)
top_file = "{}/{}.top".format(tmp_dir, "topol")
topzip_file = "{}/{}.zip".format(tmp_dir, "topol")
# parmed_obj.save("{}/{}.pdb".format(tmp_dir, stage), overwrite=True)
parmed_obj.save(gro_file, overwrite=True)
parmed_obj.save(top_file, overwrite=True)
index_file = "{}/{}.ndx".format(tmp_dir, "index")
prop = {
# "can_write_console_log" : False,
'selection': "! r LIG"
}
# Create and launch bb
# tmp = MakeNdx(input_structure_path = gro_file,
# output_ndx_path = index_file,
# properties = prop)
# import logging
# tmp.out_log = logging.Logger("x")
# tmp.err_log = logging.Logger("y")
# tmp.launch()
# print(getattr(tmp, "out_log"))
# print(tmp.err_log)
make_ndx(input_structure_path=gro_file,
output_ndx_path=index_file,
properties=prop)
####################################################
zip_top(topzip_file, top_file)
stage = "minimisation"
if stage in stages:
mdp_dict = mdp2dict(get_data_filename("{}.mdp".format(stage)))
if eval("{}_mdp".format(stage)) is not None:
mdp_dict.update(eval("{}_mdp".format(stage)))
next_gro_file = "{}/{}.gro".format(tmp_dir, stage)
# grompp_mdrun(input_gro_path = gro_file,
# input_ndx_path = index_file,
# input_top_zip_path= topzip_file,
# # input_mdp_path = "{}.mdp".format(stage),
# output_trr_path = "{}/{}.trr".format(tmp_dir, stage),
# output_gro_path = next_gro_file,
# output_edr_path = "{}/{}.edr".format(tmp_dir, stage),
# output_log_path = "{}/{}.log".format(tmp_dir, stage),
# output_xtc_path = "{}/{}.xtc".format(tmp_dir, stage),
# num_threads_omp = num_threads,
# properties = {
# "mdp" : mdp_dict
# }
# )
grompp(
input_gro_path=gro_file,
input_ndx_path=index_file,
input_top_zip_path=topzip_file,
output_tpr_path="{}/{}.tpr".format(tmp_dir, stage),
# input_mdp_path = "{}.mdp".format(stage),
properties={"mdp": mdp_dict})
mdrun(
input_tpr_path="{}/{}.tpr".format(tmp_dir, stage),
output_trr_path="{}/{}.trr".format(tmp_dir, stage),
output_gro_path=next_gro_file,
output_edr_path="{}/{}.edr".format(tmp_dir, stage),
output_log_path="{}/{}.log".format(tmp_dir, stage),
output_cpt_path="{}/{}.cpt".format(tmp_dir, stage),
output_xtc_path="{}/{}.xtc".format(tmp_dir, stage),
properties={
"num_threads": num_threads,
"num_threads_omp": num_threads,
"num_threads_omp_pme": num_threads,
}
# num_threads_omp = 1 #XXX seems for minimisation speed is very slow when multiple threads are used, especially on cluster. Maybe need better handle
)
gro_file = next_gro_file
###################################################333
stage = "equilibration"
if stage in stages:
mdp_dict = mdp2dict(get_data_filename("{}.mdp".format(stage)))
if eval("{}_mdp".format(stage)) is not None:
mdp_dict.update(eval("{}_mdp".format(stage)))
next_gro_file = "{}/{}.gro".format(tmp_dir, stage)
grompp(
input_gro_path=gro_file,
input_ndx_path=index_file,
input_top_zip_path=topzip_file,
output_tpr_path="{}/{}.tpr".format(tmp_dir, stage),
# input_mdp_path = "{}.mdp".format(stage),
properties={"mdp": mdp_dict})
mdrun(input_tpr_path="{}/{}.tpr".format(tmp_dir, stage),
output_trr_path="{}/{}.trr".format(tmp_dir, stage),
output_gro_path=next_gro_file,
output_edr_path="{}/{}.edr".format(tmp_dir, stage),
output_log_path="{}/{}.log".format(tmp_dir, stage),
output_cpt_path="{}/{}.cpt".format(tmp_dir, stage),
output_xtc_path="{}/{}.xtc".format(tmp_dir, stage),
properties={
"num_threads": num_threads,
"num_threads_omp": num_threads,
"num_threads_omp_pme": num_threads,
})
gro_file = next_gro_file
######################################################3
stage = "production"
if stage in stages:
mdp_dict = mdp2dict(get_data_filename("{}.mdp".format(stage)))
if eval("{}_mdp".format(stage)) is not None:
mdp_dict.update(eval("{}_mdp".format(stage)))
next_gro_file = "{}/{}.gro".format(tmp_dir, stage)
grompp(
input_gro_path=gro_file,
input_ndx_path=index_file,
input_top_zip_path=topzip_file,
output_tpr_path="{}/{}.tpr".format(tmp_dir, stage),
# input_mdp_path = "{}.mdp".format(stage),
properties={"mdp": mdp_dict})
mdrun(input_tpr_path="{}/{}.tpr".format(tmp_dir, stage),
output_trr_path="{}/{}.trr".format(tmp_dir, stage),
output_gro_path=next_gro_file,
output_edr_path="{}/{}.edr".format(tmp_dir, stage),
output_log_path="{}/{}.log".format(tmp_dir, stage),
output_cpt_path="{}/{}.cpt".format(tmp_dir, stage),
output_xtc_path=xtc_file,
properties={
"num_threads": num_threads,
"num_threads_omp": num_threads,
"num_threads_omp_pme": num_threads,
})
# gro_file = next_gro_file
######################################################3
if debug is not True and tmp_dir is not None:
import shutil
shutil.rmtree(tmp_dir)
return os.path.abspath(xtc_file)
def launch(self) -> int:
"""Execute the :class:`AppendLigand <gromacs_extra.append_ligand.AppendLigand>` object."""
# Setup Biobb
if self.check_restart(): return 0
# Unzip topology
top_file = fu.unzip_top(
zip_file=self.io_dict['in'].get("input_top_zip_path"),
out_log=self.out_log)
top_dir = str(Path(top_file).parent)
itp_name = str(Path(self.io_dict['in'].get("input_itp_path")).name)
with open(top_file) as top_f:
top_lines = top_f.readlines()
top_f.close()
fu.rm(top_file)
forcefield_pattern = r'#include.*forcefield.itp\"'
if top_lines:
for index, line in enumerate(top_lines):
if re.search(forcefield_pattern, line):
break
else:
fu.log(
f'FATAL: Input topfile {top_file} from input_top_zip_path {self.io_dict["in"].get("input_top_zip_path")} is empty.',
self.out_log, self.global_log)
return 1
top_lines.insert(index + 1, '\n')
top_lines.insert(index + 2, '; Including ligand ITP\n')
top_lines.insert(index + 3, '#include "' + itp_name + '"\n')
top_lines.insert(index + 4, '\n')
if self.io_dict['in'].get("input_posres_itp_path"):
top_lines.insert(index + 5, '; Ligand position restraints' + '\n')
top_lines.insert(index + 6, '#ifdef ' + self.posres_name + '\n')
top_lines.insert(
index + 7, '#include "' + str(
Path(self.io_dict['in'].get("input_posres_itp_path")).name)
+ '"\n')
top_lines.insert(index + 8, '#endif' + '\n')
top_lines.insert(index + 9, '\n')
inside_moleculetype_section = False
with open(self.io_dict['in'].get("input_itp_path")) as itp_file:
moleculetype_pattern = r'\[ moleculetype \]'
for line in itp_file:
if re.search(moleculetype_pattern, line):
inside_moleculetype_section = True
continue
if inside_moleculetype_section and not line.startswith(';'):
moleculetype = line.strip().split()[0].strip()
break
molecules_pattern = r'\[ molecules \]'
inside_molecules_section = False
index_molecule = None
molecule_string = moleculetype + (20 -
len(moleculetype)) * ' ' + '1' + '\n'
for index, line in enumerate(top_lines):
if re.search(molecules_pattern, line):
inside_molecules_section = True
continue
if inside_molecules_section and not line.startswith(
';') and line.upper().startswith('PROTEIN'):
index_molecule = index
if index_molecule:
top_lines.insert(index_molecule + 1, molecule_string)
else:
top_lines.append(molecule_string)
new_top = fu.create_name(path=top_dir,
prefix=self.prefix,
step=self.step,
name='ligand.top')
with open(new_top, 'w') as new_top_f:
new_top_f.write("".join(top_lines))
shutil.copy2(self.io_dict['in'].get("input_itp_path"), top_dir)
if self.io_dict['in'].get("input_posres_itp_path"):
shutil.copy2(self.io_dict['in'].get("input_posres_itp_path"),
top_dir)
# zip topology
fu.log(
'Compressing topology to: %s' %
self.io_dict['out'].get("output_top_zip_path"), self.out_log,
self.global_log)
fu.zip_top(zip_file=self.io_dict['out'].get("output_top_zip_path"),
top_file=new_top,
out_log=self.out_log)
# Remove temporal files
self.tmp_files.append(top_dir)
self.remove_tmp_files()
return 0
def launch(self) -> int:
"""Execute the :class:`Pdb2gmx <gromacs.pdb2gmx.Pdb2gmx>` object."""
# Setup Biobb
if self.check_restart(): return 0
self.stage_files()
internal_top_name = fu.create_name(prefix=self.prefix,
step=self.step,
name=self.internal_top_name)
internal_itp_name = fu.create_name(prefix=self.prefix,
step=self.step,
name=self.internal_itp_name)
# Create command line
self.cmd = [
self.gmx_path, "pdb2gmx", "-f",
self.stage_io_dict["in"]["input_pdb_path"], "-o",
self.stage_io_dict["out"]["output_gro_path"], "-p",
internal_top_name, "-water", self.water_type, "-ff",
self.force_field, "-i", internal_itp_name
]
if self.his:
self.cmd.append("-his")
self.cmd = ['echo', self.his, '|'] + self.cmd
if self.ignh:
self.cmd.append("-ignh")
if self.merge:
self.cmd.append("-merge")
self.cmd.append("all")
if self.gmx_lib:
self.environment = os.environ.copy()
self.environment['GMXLIB'] = self.gmx_lib
# Check GROMACS version
if not self.container_path:
if self.gmx_version < 512:
raise GromacsVersionError(
"Gromacs version should be 5.1.2 or newer %d detected" %
self.gmx_version)
fu.log(
"GROMACS %s %d version detected" %
(self.__class__.__name__, self.gmx_version), self.out_log)
# Run Biobb block
self.run_biobb()
# Copy files to host
self.copy_to_host()
if self.container_path:
internal_top_name = os.path.join(
self.stage_io_dict.get("unique_dir"), internal_top_name)
# zip topology
fu.log(
'Compressing topology to: %s' %
self.io_dict["out"]["output_top_zip_path"], self.out_log,
self.global_log)
fu.zip_top(zip_file=self.io_dict["out"]["output_top_zip_path"],
top_file=internal_top_name,
out_log=self.out_log)
# Remove temporal files
self.tmp_files.extend([
self.internal_top_name, self.internal_itp_name,
self.stage_io_dict.get("unique_dir")
])
self.remove_tmp_files()
return self.return_code
def launch(self) -> int:
"""Execute the :class:`Genion <gromacs.genion.Genion>` object."""
# Setup Biobb
if self.check_restart(): return 0
self.stage_files()
# Unzip topology to topology_out
top_file = fu.unzip_top(zip_file=self.input_top_zip_path,
out_log=self.out_log)
top_dir = str(Path(top_file).parent)
if self.container_path:
shutil.copytree(
top_dir,
Path(self.stage_io_dict.get("unique_dir")).joinpath(
Path(top_dir).name))
top_file = str(
Path(self.container_volume_path).joinpath(
Path(top_dir).name,
Path(top_file).name))
self.cmd = [
'echo', '\"' + self.replaced_group + '\"', '|', self.gmx_path,
'genion', '-s', self.stage_io_dict["in"]["input_tpr_path"], '-o',
self.stage_io_dict["out"]["output_gro_path"], '-p', top_file
]
if self.stage_io_dict["in"].get("input_ndx_path") and Path(
self.stage_io_dict["in"].get("input_ndx_path")).exists():
self.cmd.append('-n')
self.cmd.append(self.stage_io_dict["in"].get("input_ndx_path"))
if self.neutral:
self.cmd.append('-neutral')
if self.concentration:
self.cmd.append('-conc')
self.cmd.append(str(self.concentration))
fu.log(
'To reach up %g mol/litre concentration' % self.concentration,
self.out_log, self.global_log)
if self.seed is not None:
self.cmd.append('-seed')
self.cmd.append(str(self.seed))
if self.gmx_lib:
self.environment = os.environ.copy()
self.environment['GMXLIB'] = self.gmx_lib
# Check GROMACS version
if not self.container_path:
if self.gmx_version < 512:
raise GromacsVersionError(
"Gromacs version should be 5.1.2 or newer %d detected" %
self.gmx_version)
fu.log(
"GROMACS %s %d version detected" %
(self.__class__.__name__, self.gmx_version), self.out_log)
# Run Biobb block
self.run_biobb()
# Copy files to host
self.copy_to_host()
if self.container_path:
top_file = str(
Path(self.stage_io_dict.get("unique_dir")).joinpath(
Path(top_dir).name,
Path(top_file).name))
# zip topology
fu.log(
'Compressing topology to: %s' %
self.stage_io_dict["out"]["output_top_zip_path"], self.out_log,
self.global_log)
fu.zip_top(zip_file=self.io_dict["out"]["output_top_zip_path"],
top_file=top_file,
out_log=self.out_log)
# Remove temporal files
self.tmp_files.extend([self.stage_io_dict.get("unique_dir"), top_dir])
self.remove_tmp_files()
return self.return_code