def _create_view(self, system=None, view=None, gui=True):
"""Helper function to create the NGLview object.
Parameters
----------
system : Sire.System.System
A Sire molecular system.
view : int
The index of an existing view.
gui : bool
Whether to display the gui.
"""
if system is None and view is None:
raise ValueError("Both 'system' and 'view' cannot be 'None'.")
elif system is not None and view is not None:
raise ValueError("One of 'system' or 'view' must be 'None'.")
# Make sure gui flag is valid.
if gui not in [True, False]:
gui = True
# Default to the most recent view.
if view is None:
index = self._num_views
else:
index = view
# Create the file name.
filename = "%s/view_%04d.pdb" % (self._work_dir, index)
# Increment the number of views.
if view is None:
self._num_views += 1
# Create a PDB object and write to file.
if system is not None:
try:
pdb = _SireIO.PDB2(system)
pdb.writeToFile(filename)
except Exception as e:
msg = "Failed to write system to 'PDB' format."
if _isVerbose():
print(msg)
raise IOError(e) from None
else:
raise IOError(msg) from None
# Import NGLView when it is used for the first time.
import nglview as _nglview
# Create the NGLview object.
view = _nglview.show_file(filename)
# Return the view and display it.
return view.display(gui=gui)
def translate(self, vector, property_map={}):
"""Translate the object.
Parameters
----------
vector : [:class:`Length <BioSimSpace.Types.Length>`]
The translation vector in Angstroms.
property_map : dict
A dictionary that maps system "properties" to their user defined
values. This allows the user to refer to properties with their
own naming scheme, e.g. { "charge" : "my-charge" }
"""
# Convert tuple to a list.
if type(vector) is tuple:
vector = list(vector)
# Validate input.
if type(vector) is list:
vec = []
for x in vector:
if type(x) is int:
vec.append(float(x))
elif type(x) is float:
vec.append(x)
elif type(x) is _Length:
vec.append(x.angstroms().magnitude())
else:
raise TypeError("'vector' must contain 'int', 'float', or "
"'BioSimSpace.Types.Length' types only!")
else:
raise TypeError("'vector' must be of type 'list' or 'tuple'")
if type(property_map) is not dict:
raise TypeError("'property_map' must be of type 'dict'")
try:
# Make a local copy of the property map.
_property_map = property_map.copy()
if "coordinates" not in property_map and self._is_merged:
_property_map["coordinates"] = "coordinates0"
# Perform the translation.
self._sire_object = self._sire_object \
.move() \
.translate(_SireMaths.Vector(vec), _property_map) \
.commit()
except UserWarning as e:
msg = "Cannot compute axis-aligned bounding box " + \
"since the object has no 'coordinates' property."
if _isVerbose():
raise _IncompatibleError(msg) from e
else:
raise _IncompatibleError(msg) from None
def rmsd(self, frame=None, atoms=None):
"""Compute the root mean squared displacement.
Parameters
----------
frame : int
The index of the reference frame.
atoms : [int]
A list of reference atom indices.
Returns
-------
rmsd : [float]
A list containing the RMSD value at each time point.
"""
# Default to the first frame.
if frame is None:
frame = 0
else:
if type(frame) is not int:
raise TypeError("'frame' must be of type 'int'")
else:
# Store the number of frames.
n_frames = self._trajectory.n_frames
# Make sure the frame index is within range.
if frame > 0 and frame >= n_frames:
raise ValueError(
"Frame index (%d) of of range (0 to %d)." %
s(frame, n_frames - 1))
elif frame < -n_frames:
raise ValueError(
"Frame index (%d) of of range (-1 to -%d)." %
s(frame, n_frames))
if atoms is not None:
# Check that all of the atom indices are integers.
if not all(isinstance(x, int) for x in atoms):
raise TypeError("'atom' indices must be of type 'int'")
# Use MDTraj to compute the RMSD.
try:
rmsd = _mdtraj.rmsd(self._trajectory, self._trajectory, frame,
atoms)
except Exception as e:
msg = "Atom indices not found in the system."
if _isVerbose():
raise ValueError(msg) from e
else:
raise ValueError(msg) from None
# Convert to a list and return.
return list(rmsd)
def _getAABox(self, property_map={}):
"""Get the axis-aligned bounding box for the object.
Parameters
----------
property_map : dict
A dictionary that maps system "properties" to their user defined
values. This allows the user to refer to properties with their
own naming scheme, e.g. { "charge" : "my-charge" }
Returns
-------
aabox : Sire.Vol.AABox
The axis-aligned bounding box for the object.
"""
# Initialise the coordinates vector.
coord = []
prop = property_map.get("coordinates", "coordinates")
# Handle merged molecules.
if self._is_merged:
prop = "coordinates0"
# Residues need to be converted to molecules to have a
# coordinates property.
try:
c = self._sire_object.property(prop)
except:
try:
c = self.toMolecule()._sire_object.property(prop)
except Exception as e:
msg = "Cannot compute axis-aligned bounding box " + \
"since the object has no 'coordinates' property."
if _isVerbose():
print(msg)
raise _IncompatibleError(msg) from e
else:
raise _IncompatibleError(msg) from None
# We have a vector of coordinates. (Multiple atoms)
if self._is_multi_atom:
coord.extend(c.toVector())
# Convert to a list.
else:
coord = [c]
# Return the AABox for the coordinates.
return _SireVol.AABox(coord)
def search(self, query):
"""Search the molecules for atoms and residues. Search results will be
reduced to their minimal representation, i.e. a residue containing
a single atom will be returned as a atom.
Parameters
----------
query : str
The search query.
Returns
-------
results : [:class:`Atom <BioSimSpace._SireWrappers.Atom>`, \
:class:`Residue <BioSimSpace._SireWrappers.Residue>`, ...]
A list of objects matching the search query.
Examples
--------
Search for all residues named ALA.
>>> result = molecules.search("resname ALA")
Search for all oxygen or hydrogen atoms.
>>> result = molecules.search("element oxygen or element hydrogen")
Search for atom index 23.
>>> result = molecule.search("atomidx 23")
"""
if type(query) is not str:
raise TypeError("'query' must be of type 'str'")
# Intialise a list to hold the search results.
results = []
try:
# Query the Sire system.
search_result = self._sire_object.search(query)
except Exception as e:
msg = "'Invalid search query: %r" % query
if _isVerbose():
raise ValueError(msg) from e
else:
raise ValueError(msg) from None
return _SearchResult(search_result)
def _getAABox(self, property_map={}):
"""Get the axis-aligned bounding box for the molecular system.
Parameters
----------
property_map : dict
A dictionary that maps system "properties" to their user defined
values. This allows the user to refer to properties with their
own naming scheme, e.g. { "charge" : "my-charge" }
Returns
-------
aabox : Sire.Vol.AABox
The axis-aligned bounding box for the molecule.
"""
# Initialise the coordinates vector.
coord = []
# Get all of the molecules in the system.
mols = self.getMolecules()
# Loop over all of the molecules.
for idx, mol in enumerate(mols):
# Extract the atomic coordinates and append them to the vector.
try:
if "coordinates" in property_map:
prop = property_map["coordinates"]
else:
if mol.isMerged():
prop = "coordinates0"
else:
prop = "coordinates"
coord.extend(mol._sire_object.property(prop).toVector())
except UserWarning as e:
msg = "Unable to compute the axis-aligned bounding " + \
"box since a molecule has no 'coordinates' property."
if _isVerbose():
raise _IncompatibleError(msg) from e
else:
raise _IncompatibleError(msg) from None
# Return the AABox for the coordinates.
return _SireVol.AABox(coord)
def search(self, query):
"""Search the residue for atoms and residues.
Parameters
----------
query : str
The search query.
Returns
-------
results : [:class:`Atom <BioSimSpace._SireWrappers.Atom>`]
A list of objects matching the search query.
Examples
--------
Search for all oxygen or hydrogen atoms.
>>> result = residue.search("element oxygen or element hydrogen")
Search for atom index 23.
>>> result = residue.search("atomidx 23")
"""
if type(query) is not str:
raise TypeError("'query' must be of type 'str'")
# Intialise a list to hold the search results.
results = []
try:
# Query the Sire system.
search_result = self._sire_object.search(query)
except Exception as e:
msg = "'Invalid search query: %r" % query
if _isVerbose():
raise ValueError(msg) from e
else:
raise ValueError(msg) from None
return _SearchResult(search_result)
def readMolecules(files, property_map={}):
"""Read a molecular system from file.
Parameters
----------
files : str, [str]
A file name, or a list of file names.
property_map : dict
A dictionary that maps system "properties" to their user defined
values. This allows the user to refer to properties with their
own naming scheme, e.g. { "charge" : "my-charge" }
Returns
-------
system : :class:`System <BioSimSpace._SireWrappers.System>`
A molecular system.
Examples
--------
Load a molecular system from AMBER coordinate and topology files.
>>> import BioSimSpace as BSS
>>> system = BSS.IO.readMolecules(["ala.rst7", "ala.prm7"])
Load the same system, but map the "charge" property to the key "my-charge".
>>> import BioSimSpace as BSS
>>> system = BSS.IO.readMolecules(["ala.rst7", "ala.prm7"], property_map={"charge" : "my-charge"})
>>> import BioSimSpace as BSS
>>> system = BSS.IO.readMolecules(["ala.rst7", "ala.prm7"])
Load a molecular system from all of the files contained within a directory.
>>> import BioSimSpace as BSS
>>> system = BSS.IO.readMolecules(BSS.IO.glob("dir/*"))
Load a molecular system from GROMACS coordinate and topology files using
a custom GROMACS topology directory.
>>> import BioSimSpace as BSS
>>> system = BSS.IO.readMolecules(["mol.gro87", "mol.grotop"], property_map={"GROMACS_PATH" : "/path/to/gromacs/topology"})
"""
global _has_gmx_warned
if _gromacs_path is None and not _has_gmx_warned:
_warn(
"BioSimSpace.IO: Please install GROMACS (http://www.gromacs.org) "
"for GROMACS topology file support.")
_has_gmx_warned = True
# Convert to a list.
if type(files) is str:
files = [files]
# Check that all arguments are of type 'str'.
if type(files) is list:
if not all(isinstance(x, str) for x in files):
raise TypeError("'files' must be a list of 'str' types.")
if len(files) == 0:
raise ValueError("The list of input files is empty!")
else:
raise TypeError(
"'files' must be of type 'str', or a list of 'str' types.")
# Validate the map.
if type(property_map) is not dict:
raise TypeError("'property_map' must be of type 'dict'")
# Add the GROMACS topology file path.
if _gromacs_path is not None and ("GROMACS_PATH" not in property_map):
property_map["GROMACS_PATH"] = _gromacs_path
# Check that the files exist.
for file in files:
if not _os.path.isfile(file):
raise IOError("Missing input file: '%s'" % file)
# Try to read the files and return a molecular system.
try:
system = _SireIO.MoleculeParser.read(files, property_map)
except Exception as e:
if "There are no lead parsers!" in str(e):
msg = (
"Failed to read molecules from %s. "
"It looks like you failed to include a topology file.") % files
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
else:
if "Incompatibility" in str(e):
msg = "Incompatibility between molecular information in files: %s" % files
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
else:
msg = "Failed to read molecules from: %s" % files
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
return _System(system)
def _score_sire_mappings(molecule0, molecule1, sire_mappings, prematch,
scoring_function, property_map0, property_map1):
"""Internal function to score atom mappings based on the root mean squared
displacement (RMSD) between mapped atoms in two molecules. Optionally,
molecule0 can first be aligned to molecule1 based on the mapping prior
to computing the RMSD. The function returns the mappings sorted based
on their score from best to worst, along with a list containing the
scores for each mapping.
Parameters
----------
molecule0 : Sire.Molecule.Molecule
The first molecule (Sire representation).
molecule0 : Sire.Molecule.Molecule
The second molecule (Sire representation).
sire_mappings : [{}]
The list of mappings generated by Sire.
prematch : dict
A dictionary of atom mappings that must be included in the match.
scoring_function : str
The RMSD scoring function.
property_map0 : dict
A dictionary that maps "properties" in molecule0 to their user
defined values. This allows the user to refer to properties
with their own naming scheme, e.g. { "charge" : "my-charge" }
property_map1 : dict
A dictionary that maps "properties" in molecule1 to their user
defined values.
Returns
-------
mapping, scores : ([dict], list)
The ranked mappings and corresponding scores.
"""
# Make sure to re-map the coordinates property in both molecules, otherwise
# the move and align functions from Sire will not work.
prop0 = property_map0.get("coordinates", "coordinates")
prop1 = property_map1.get("coordinates", "coordinates")
if prop0 != "coordinates":
molecule0 = molecule0.edit().setProperty(
"coordinates", molecule0.property(prop0)).commit()
if prop1 != "coordinates":
molecule1 = molecule1.edit().setProperty(
"coordinates", molecule1.property(prop1)).commit()
# Initialise a list to hold the mappings.
mappings = []
# Initialise a list of to hold the score for each mapping.
scores = []
# Loop over all of the mappings.
for mapping in sire_mappings:
# Check that the mapping contains the pre-match.
is_valid = True
for idx0, idx1 in prematch.items():
# Pre-match isn't found, return to top of loop.
if _SireMol.AtomIdx(idx0) not in mapping or mapping[
_SireMol.AtomIdx(idx0)] != _SireMol.AtomIdx(idx1):
is_valid = False
break
if is_valid:
# Rigidly align molecule0 to molecule1 based on the mapping.
if scoring_function == "RMSDALIGN":
try:
molecule0 = molecule0.move().align(
molecule1,
_SireMol.AtomResultMatcher(mapping)).molecule()
except Exception as e:
msg = "Failed to align molecules when scoring based on mapping: %r" % mapping
if _isVerbose():
raise _AlignmentError(msg) from e
else:
raise _AlignmentError(msg) from None
# Flexibly align molecule0 to molecule1 based on the mapping.
elif scoring_function == "RMSDFLEXALIGN":
molecule0 = flexAlign(_Molecule(molecule0),
_Molecule(molecule1),
_from_sire_mapping(mapping),
property_map0=property_map0,
property_map1=property_map1)._sire_object
# Append the mapping to the list.
mappings.append(_from_sire_mapping(mapping))
# We now compute the RMSD between the coordinates of the matched atoms
# in molecule0 and molecule1.
# Initialise lists to hold the coordinates.
c0 = []
c1 = []
# Loop over each atom index in the map.
for idx0, idx1 in mapping.items():
# Append the coordinates of the matched atom in molecule0.
c0.append(molecule0.atom(idx0).property("coordinates"))
# Append the coordinates of atom in molecule1 to which it maps.
c1.append(molecule1.atom(idx1).property("coordinates"))
# Compute the RMSD between the two sets of coordinates.
scores.append(_SireMaths.getRMSD(c0, c1))
# No mappings were found.
if len(mappings) == 0:
if len(prematch) == 0:
return ([{}], [])
else:
return ([prematch], [])
# Sort the scores and return the sorted keys. (Smaller RMSD is best)
keys = sorted(range(len(scores)), key=lambda k: scores[k])
# Sort the mappings.
mappings = [mappings[x] for x in keys]
# Sort the scores and convert to Angstroms.
scores = [scores[x] * _Units.Length.angstrom for x in keys]
# Return the sorted mappings and their scores.
return (mappings, scores)
def _run_pdb2gmx(self, molecule, work_dir):
"""Run using pdb2gmx.
Parameters
----------
molecule : BioSimSpace._SireWrappers.Molecule
The molecule to apply the parameterisation protocol to.
work_dir : str
The working directory.
"""
# A list of supported force fields, mapping to their GROMACS ID string.
# GROMACS supports a sub-set of the AMBER force fields.
supported_ff = {
"ff99": "amber99",
"ff99SB": "amber99sb",
"ff03": "amber03"
}
if self._forcefield not in supported_ff:
raise _IncompatibleError(
"'pdb2gmx' does not support the '%s' force field." %
self._forcefield)
# Create a new system and molecule group.
s = _SireSystem.System("BioSimSpace System")
m = _SireMol.MoleculeGroup("all")
# Add the molecule.
m.add(molecule._getSireObject())
s.add(m)
# Create the file prefix.
prefix = work_dir + "/"
# Write the system to a PDB file.
try:
pdb = _SireIO.PDB2(s, self._property_map)
pdb.writeToFile(prefix + "input.pdb")
except Exception as e:
msg = "Failed to write system to 'PDB' format."
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Generate the pdb2gmx command.
command = "%s pdb2gmx -f input.pdb -o output.gro -p output.top -ignh -ff %s -water none" \
% (_gmx_exe, supported_ff[self._forcefield])
with open(prefix + "README.txt", "w") as file:
# Write the command to file.
file.write("# pdb2gmx was run with the following command:\n")
file.write("%s\n" % command)
# Create files for stdout/stderr.
stdout = open(prefix + "pdb2gmx.out", "w")
stderr = open(prefix + "pdb2gmx.err", "w")
# Run pdb2gmx as a subprocess.
proc = _subprocess.run(command,
cwd=work_dir,
shell=True,
stdout=stdout,
stderr=stderr)
stdout.close()
stderr.close()
# Check for the expected output.
if _os.path.isfile(prefix +
"output.gro") and _os.path.isfile(prefix +
"output.top"):
return ["output.gro", "output.top"]
else:
raise _ParameterisationError("pdb2gmx failed!")
def rmsdAlign(molecule0,
molecule1,
mapping=None,
property_map0={},
property_map1={}):
"""Align atoms in molecule0 to those in molecule1 using the mapping
between matched atom indices. The molecule is aligned using rigid-body
translation and rotations, with a root mean squared displacement (RMSD)
fit to find the optimal translation vector (as opposed to merely taking
the difference of centroids).
Parameters
----------
molecule0 : :class:`Molecule <BioSimSpace._SireWrappers.Molecule>`
The molecule to align.
molecule1 : :class:`Molecule <BioSimSpace._SireWrappers.Molecule>`
The reference molecule.
mapping : dict
A dictionary mapping atoms in molecule0 to those in molecule1.
property_map0 : dict
A dictionary that maps "properties" in molecule0 to their user
defined values. This allows the user to refer to properties
with their own naming scheme, e.g. { "charge" : "my-charge" }
property_map1 : dict
A dictionary that maps "properties" in molecule1 to their user
defined values.
Returns
-------
molecule : :class:`Molecule <BioSimSpace._SireWrappers.Molecule>`
The aligned molecule.
Examples
--------
Align molecule0 to molecule1 based on a precomputed mapping.
>>> import BioSimSpace as BSS
>>> molecule0 = BSS.Align.rmsdAlign(molecule0, molecule1, mapping)
Align molecule0 to molecule1. Since no mapping is passed one will be
autogenerated using :class:`matchAtoms <BioSimSpace.Align.matchAtoms>`
with default options.
>>> import BioSimSpace as BSS
>>> molecule0 = BSS.Align.rmsdAlign(molecule0, molecule1)
"""
if type(molecule0) is not _Molecule:
raise TypeError(
"'molecule0' must be of type 'BioSimSpace._SireWrappers.Molecule'")
if type(molecule1) is not _Molecule:
raise TypeError(
"'molecule1' must be of type 'BioSimSpace._SireWrappers.Molecule'")
if type(property_map0) is not dict:
raise TypeError("'property_map0' must be of type 'dict'")
if type(property_map1) is not dict:
raise TypeError("'property_map1' must be of type 'dict'")
# The user has passed an atom mapping.
if mapping is not None:
if type(mapping) is not dict:
raise TypeError("'mapping' must be of type 'dict'.")
else:
_validate_mapping(molecule0, molecule1, mapping, "mapping")
# Get the best match atom mapping.
else:
mapping = matchAtoms(molecule0,
molecule1,
property_map0=property_map0,
property_map1=property_map1)
# Extract the Sire molecule from each BioSimSpace molecule.
mol0 = molecule0._getSireObject()
mol1 = molecule1._getSireObject()
# Convert the mapping to AtomIdx key:value pairs.
sire_mapping = _to_sire_mapping(mapping)
# Perform the alignment, mol0 to mol1.
try:
mol0 = mol0.move().align(
mol1, _SireMol.AtomResultMatcher(sire_mapping)).molecule()
except Exception as e:
msg = "Failed to align molecules based on mapping: %r" % mapping
if _isVerbose():
raise _AlignmentError(msg) from e
else:
raise _AlignmentError(msg) from None
# Return the aligned molecule.
return _Molecule(mol0)
def _score_rdkit_mappings(molecule0, molecule1, rdkit_molecule0,
rdkit_molecule1, mcs_smarts, prematch,
scoring_function, property_map0, property_map1):
"""Internal function to score atom mappings based on the root mean squared
displacement (RMSD) between mapped atoms in two molecules. Optionally,
molecule0 can first be aligned to molecule1 based on the mapping prior
to computing the RMSD. The function returns the mappings sorted based
on their score from best to worst, along with a list containing the
scores for each mapping.
Parameters
----------
molecule0 : Sire.Molecule.Molecule
The first molecule (Sire representation).
molecule0 : Sire.Molecule.Molecule
The second molecule (Sire representation).
rdkit_mol0 : RDKit.Chem.Mol
The first molecule (RDKit representation).
rdkit_mol1 : RDKit.Chem.Mol
The second molecule (RDKit representation).
mcs_smarts : RDKit.Chem.MolFromSmarts
The smarts string representing the maximum common substructure of
the two molecules.
prematch : dict
A dictionary of atom mappings that must be included in the match.
scoring_function : str
The RMSD scoring function.
property_map0 : dict
A dictionary that maps "properties" in molecule0 to their user
defined values. This allows the user to refer to properties
with their own naming scheme, e.g. { "charge" : "my-charge" }
property_map1 : dict
A dictionary that maps "properties" in molecule1 to their user
defined values.
Returns
-------
mapping, scores : ([dict], list)
The ranked mappings and corresponding scores.
"""
# Adapted from FESetup: https://github.com/CCPBioSim/fesetup
# Make sure to re-map the coordinates property in both molecules, otherwise
# the move and align functions from Sire will not work.
prop0 = property_map0.get("coordinates", "coordinates")
prop1 = property_map1.get("coordinates", "coordinates")
if prop0 != "coordinates":
molecule0 = molecule0.edit().setProperty(
"coordinates", molecule0.property(prop0)).commit()
if prop1 != "coordinates":
molecule1 = molecule1.edit().setProperty(
"coordinates", molecule1.property(prop1)).commit()
# Get the set of matching substructures in each molecule. For some reason
# setting uniquify to True removes valid matches, in some cases even the
# best match! As such, we set uniquify to False and account ignore duplicate
# mappings in the code below.
matches0 = rdkit_molecule0.GetSubstructMatches(mcs_smarts,
uniquify=False,
maxMatches=1000,
useChirality=False)
matches1 = rdkit_molecule1.GetSubstructMatches(mcs_smarts,
uniquify=False,
maxMatches=1000,
useChirality=False)
# Swap the order of the matches.
if len(matches0) < len(matches1):
matches0, matches1 = matches1, matches0
is_swapped = True
else:
is_swapped = False
# Initialise a list to hold the mappings.
mappings = []
# Initialise a list of to hold the score for each mapping.
scores = []
# Loop over all matches from mol0.
for x in range(len(matches0)):
match0 = matches0[x]
# Loop over all matches from mol1.
for y in range(len(matches1)):
match1 = matches1[y]
# Initialise the mapping for this match.
mapping = {}
sire_mapping = {}
# Loop over all atoms in the match.
for i, idx0 in enumerate(match0):
idx1 = match1[i]
# Add to the mapping.
if is_swapped:
mapping[idx1] = idx0
sire_mapping[_SireMol.AtomIdx(idx1)] = _SireMol.AtomIdx(
idx0)
else:
mapping[idx0] = idx1
sire_mapping[_SireMol.AtomIdx(idx0)] = _SireMol.AtomIdx(
idx1)
# This is a new mapping:
if not mapping in mappings:
# Check that the mapping contains the pre-match.
is_valid = True
for idx0, idx1 in prematch.items():
# Pre-match isn't found, return to top of loop.
if idx0 not in mapping or mapping[idx0] != idx1:
is_valid = False
break
if is_valid:
# Rigidly align molecule0 to molecule1 based on the mapping.
if scoring_function == "RMSDALIGN":
try:
molecule0 = molecule0.move().align(
molecule1,
_SireMol.AtomResultMatcher(
sire_mapping)).molecule()
except Exception as e:
msg = "Failed to align molecules when scoring based on mapping: %r" % mapping
if _isVerbose():
raise _AlignmentError(msg) from e
else:
raise _AlignmentError(msg) from None
# Flexibly align molecule0 to molecule1 based on the mapping.
elif scoring_function == "RMSDFLEXALIGN":
molecule0 = flexAlign(
_Molecule(molecule0),
_Molecule(molecule1),
mapping,
property_map0=property_map0,
property_map1=property_map1)._sire_object
# Append the mapping to the list.
mappings.append(mapping)
# We now compute the RMSD between the coordinates of the matched atoms
# in molecule0 and molecule1.
# Initialise lists to hold the coordinates.
c0 = []
c1 = []
# Loop over each atom index in the map.
for idx0, idx1 in sire_mapping.items():
# Append the coordinates of the matched atom in molecule0.
c0.append(molecule0.atom(idx0).property("coordinates"))
# Append the coordinates of atom in molecule1 to which it maps.
c1.append(molecule1.atom(idx1).property("coordinates"))
# Compute the RMSD between the two sets of coordinates.
scores.append(_SireMaths.getRMSD(c0, c1))
# No mappings were found.
if len(mappings) == 0:
if len(prematch) == 0:
return ([{}], [])
else:
return ([prematch], [])
# Sort the scores and return the sorted keys. (Smaller RMSD is best)
keys = sorted(range(len(scores)), key=lambda k: scores[k])
# Sort the mappings.
mappings = [mappings[x] for x in keys]
# Sort the scores and convert to Angstroms.
scores = [scores[x] * _Units.Length.angstrom for x in keys]
# Return the sorted mappings and their scores.
return (mappings, scores)
def getFrames(self, indices=None):
"""Get trajectory frames as a list of System objects.
Parameters
----------
indices : [int], [:class:`Time <BioSimSpace.Types.Time>`]
A list of trajectory frame indices, or time stamps (in ns).
Returns
-------
frames : [:class:`System <BioSimSpace._SireWrappers.System>`]
The list of System objects.
"""
# The process is running. Grab the latest trajectory.
if self._process is not None and self._process.isRunning():
self._trajectory = self.getTrajectory()
# There is no trajectory.
if self._trajectory is None:
return None
# Store the number of frames.
n_frames = self._trajectory.n_frames
# Work out the frame spacing in nanoseconds.
# TODO:
# How can we do this in a robust way if the trajectory is loaded from file?
# Some formats do not store time information as part of the trajectory.
if n_frames > 1:
if self._process is not None:
time_interval = self._process._protocol.getRunTime(
) / self._process._protocol.getFrames()
else:
time_interval = self._trajectory.timestep / 1000
# Create the indices array.
# Default to all frames.
if indices is None:
indices = [x for x in range(0, self._trajectory.n_frames)]
# A single frame index.
elif type(indices) is int:
indices = [indices]
# A single time stamp.
elif type(indices) is _Time:
if n_frames > 1:
# Round time stamp to nearest frame index.
indices = [
round(indices.nanoseconds().magnitude() / time_interval) -
1
]
else:
raise _IncompatibleError(
"Cannot determine time stamps for a trajectory "
"with only one frame!")
# A list of frame indices.
elif all(isinstance(x, int) for x in indices):
pass
# A list of time stamps.
elif all(isinstance(x, _Time) for x in indices):
if n_frames <= 1:
raise _IncompatibleError(
"Cannot determine time stamps for a trajectory "
"with only one frame!")
# Round time stamps to nearest frame indices.
indices = [
round(x.nanoseconds().magnitude() / time_interval) - 1
for x in indices
]
# Unsupported argument.
else:
raise ValueError(
"Unsupported argument. Indices or time stamps "
"must be an 'int' or 'BioSimSpace.Types.Time', or list of 'int' or "
"'BioSimSpace.Types.Time' types.")
# Intialise the list of frames.
frames = []
# Loop over all indices.
for x in indices:
# Make sure the frame index is within range.
if x > 0 and x >= n_frames:
raise ValueError("Frame index (%d) of of range (0 to %d)." %
(x, n_frames - 1))
elif x < -n_frames:
raise ValueError("Frame index (%d) of of range (-1 to -%d)." %
(x, n_frames))
# The name of the frame coordinate file.
frame_file = ".frame.nc"
# Write the current frame as a NetCDF file.
self._trajectory[x].save(frame_file)
# Load the frame and create a System object.
try:
system = _System(
_SireIO.MoleculeParser.read([self._top_file, frame_file]))
except Exception as e:
_os.remove(frame_file)
msg = "Failed to read trajectory frame: '%s'" % frame_file
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Append the system to the list of frames.
frames.append(system)
# Remove the temporary frame coordinate file.
_os.remove(frame_file)
# Return the frames.
return frames
def getFrame(trajectory, topology, index):
"""Extract a single frame from a trajectory file.
Parameters
----------
trajectory : str
A trajectory file.
topology : str
A topology file.
index : int
The index of the frame.
Returns
-------
frame : :class:`System <BioSimSpace._SireWrappers.System>`
The System object of the corresponding frame.
"""
if type(trajectory) is not str:
raise TypeError("'trajectory' must be of type 'str'")
if type(topology) is not str:
raise TypeError("'topology' must be of type 'str'")
if type(index) is not int:
raise TypeError("'index' must be of type 'int'")
# Try to load the frame.
try:
frame = _mdtraj.load_frame(trajectory, index, top=topology)
except:
# Get the file format of the topology file.
try:
# Load the topology file to determine the file format.
file_format = _IO.readMolecules(topology).fileFormat()
# Set the extension.
extension = _extensions.get(file_format, file_format.lower())
# Set the path to the temporary topology file.
top_file = _os.getcwd() + "/.topology." + extension
# Copy the topology to a file with the correct extension.
_shutil.copyfile(topology, top_file)
frame = _mdtraj.load_frame(trajectory, index, top=top_file)
except:
_os.remove(top_file)
raise IOError(
"MDTraj failed to read frame %d from: traj=%s, top=%s" %
(index, trajectory, topology))
# Remove the temporary topology file.
_os.remove(top_file)
# The name of the frame coordinate file.
frame_file = ".frame.nc"
# Save the coordinates to file.
frame.save(frame_file)
# Load the frame into a System object.
try:
system = _System(_SireIO.MoleculeParser.read([topology, frame_file]))
except Exception as e:
_os.remove(frame_file)
msg = "Failed to read trajectory frame: '%s'" % frame_file
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Remove the temporary frame coordinate file.
_os.remove(frame_file)
# Return the system.
return system
def _run_tleap(self, molecule, work_dir):
"""Run using tLEaP.
Parameters
----------
molecule : BioSimSpace._SireWrappers.Molecule
The molecule to apply the parameterisation protocol to.
work_dir : str
The working directory.
"""
# Create a new system and molecule group.
s = _SireSystem.System("BioSimSpace System")
m = _SireMol.MoleculeGroup("all")
# Add the molecule.
m.add(molecule._getSireObject())
s.add(m)
# Create the file prefix.
prefix = work_dir + "/"
# Write the system to a PDB file.
try:
pdb = _SireIO.PDB2(s, self._property_map)
pdb.writeToFile(prefix + "leap.pdb")
except Exception as e:
msg = "Failed to write system to 'PDB' format."
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Try to find a force field file.
ff = _find_force_field(self._forcefield)
# Write the LEaP input file.
with open(prefix + "leap.txt", "w") as file:
file.write("source %s\n" % ff)
file.write("mol = loadPdb leap.pdb\n")
file.write("saveAmberParm mol leap.top leap.crd\n")
file.write("quit")
# Generate the tLEaP command.
command = "%s -f leap.txt" % _tleap_exe
with open(prefix + "README.txt", "w") as file:
# Write the command to file.
file.write("# tLEaP was run with the following command:\n")
file.write("%s\n" % command)
# Create files for stdout/stderr.
stdout = open(prefix + "tleap.out", "w")
stderr = open(prefix + "tleap.err", "w")
# Run tLEaP as a subprocess.
proc = _subprocess.run(command,
cwd=work_dir,
shell=True,
stdout=stdout,
stderr=stderr)
stdout.close()
stderr.close()
# tLEaP doesn't return sensible error codes, so we need to check that
# the expected output was generated.
if _os.path.isfile(prefix +
"leap.top") and _os.path.isfile(prefix +
"leap.crd"):
return ["leap.top", "leap.crd"]
else:
raise _ParameterisationError("tLEaP failed!")
def saveMolecules(filebase, system, fileformat, property_map={}):
"""Save a molecular system to file.
Parameters
----------
filebase : str
The base name of the output file.
system : :class:`System <BioSimSpace._SireWrappers.System>`, \
:class:`Molecule< BioSimSpace._SireWrappers.Molecule>` \
:class:`Molecule< BioSimSpace._SireWrappers.Molecules>`
The molecular system.
fileformat : str, [str]
The file format (or formats) to save to.
property_map : dict
A dictionary that maps system "properties" to their user
defined values. This allows the user to refer to properties
with their own naming scheme, e.g. { "charge" : "my-charge" }
Returns
-------
files : [str]
The list of files that were generated.
Examples
--------
Load a molecular system from AMBER coordinate and topology files then
try to save it to all supported file formats.
>>> import BioSimSpace as BSS
>>> system = BSS.IO.readMolecules(["ala.rst7", "ala.prm7"])
>>> for format in BSS.IO.fileFormats():
... try:
... BSS.IO.saveMolecules("test", system, format)
... except:
... print("Could not convert to format: '%s'" % format)
Load a molecular system from AMBER coordinate and topology files then
try to save it to GROMACS format, mapping and un-mapping the charge
property along the way.
>>> import BioSimSpace as BSS
>>> system = BSS.IO.readMolecules(["ala.rst7", "ala.prm7"], property_map={"charge" : "my-charge"})
>>> BSS.IO.saveMolecules("test", system, ["gro87", "grotop"], property_map={"charge" : "my-charge"})
"""
global _has_gmx_warned
if _gromacs_path is None and not _has_gmx_warned:
_warn(
"BioSimSpace.IO: Please install GROMACS (http://www.gromacs.org) "
"for GROMACS topology file support.")
_has_gmx_warned = True
# Check that the filebase is a string.
if type(filebase) is not str:
raise TypeError("'filebase' must be of type 'str'")
# Check that that the system is of the correct type.
# A System object.
if type(system) is _System:
pass
# A Molecule object.
elif type(system) is _Molecule:
system = _System(system)
elif type(system) is _Molecules:
system = system.toSystem()
# A list of Molecule objects.
elif type(system) is list and all(
isinstance(x, _Molecule) for x in system):
system = _System(system)
# Invalid type.
else:
raise TypeError(
"'system' must be of type 'BioSimSpace.SireWrappers.System', "
"'BioSimSpace._SireWrappers.Molecule, 'BioSimSpace._SireWrappers.Molecules' "
"or a list of 'BiSimSpace._SireWrappers.Molecule' types.")
# Check that fileformat argument is of the correct type.
# Convert to a list if a single string is passed.
# We split on ',' since the user might pass system.fileFormats() as the argument.
if type(fileformat) is str:
fileformat = fileformat.split(",")
# Lists and tuples are okay!
elif type(fileformat) is list:
pass
elif type(fileformat) is tuple:
pass
# Invalid.
else:
raise TypeError(
"'fileformat' must be a 'str' or a 'list' of 'str' types.")
# Make sure all items in list or tuple are strings.
if not all(isinstance(x, str) for x in fileformat):
raise TypeError(
"'fileformat' must be a 'str' or a 'list' of 'str' types.")
# Make a list of the matched file formats.
formats = []
# Make sure that all of the formats are valid.
for format in fileformat:
try:
f = _formats_dict[format.replace(" ", "").upper()][0]
formats.append(f)
except KeyError:
raise ValueError("Unsupported file format '%s'. Supported formats "
"are: %s." % (format, str(_formats)))
# Validate the map.
if type(property_map) is not dict:
raise TypeError("'property_map' must be of type 'dict'")
# Copy the map.
_property_map = property_map.copy()
# Add the GROMACS topology file path.
if _gromacs_path is not None and ("GROMACS_PATH" not in _property_map):
_property_map["GROMACS_PATH"] = _gromacs_path
# Get the directory name.
dirname = _os.path.dirname(filebase)
# If the user has passed a directory, make sure that is exists.
if _os.path.basename(filebase) != filebase:
# Create the directory if it doesn't already exist.
if not _os.path.isdir(dirname):
_os.makedirs(dirname, exist_ok=True)
# Store the current working directory.
dir = _os.getcwd()
# Change to the working directory for the process.
# This avoid problems with relative paths.
if dirname != "":
_os.chdir(dirname)
# A list of the files that have been written.
files = []
# Save the system using each file format.
for format in formats:
# Add the file format to the property map.
_property_map["fileformat"] = _SireBase.wrap(format)
# Write the file.
try:
file = _SireIO.MoleculeParser.save(system._getSireObject(),
filebase, _property_map)
files += file
except Exception as e:
if dirname != "":
_os.chdir(dir)
msg = "Failed to save system to format: '%s'" % format
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Change back to the original directory.
if dirname != "":
_os.chdir(dir)
# Return the list of files.
return files
def _setup(self):
"""Setup the input files and working directory ready for simulation."""
# Create the input files...
# First create a copy of the system.
system = self._system.copy()
# If the we are performing a free energy simulation, then check that
# the system contains a single perturbable molecule. If so, then create
# and write a perturbation file to the work directory.
if type(self._protocol) is _Protocol.FreeEnergy:
if system.nPerturbableMolecules() == 1:
# Extract the perturbable molecule.
pert_mol = system.getPerturbableMolecules()[0]
# Write the perturbation file and get the molecule corresponding
# to the lambda = 0 state.
pert_mol = pert_mol._toPertFile(
self._pert_file, property_map=self._property_map)
self._input_files.append(self._pert_file)
# Remove the perturbable molecule.
system._sire_object.remove(pert_mol.number())
# Recreate the system, putting the perturbable molecule with
# renamed properties first.
updated_system = _System(pert_mol) + _System(system)
# Copy across all of the properties from the orginal system.
for prop in system._sire_object.propertyKeys():
updated_system._sire_object.setProperty(
prop, system._sire_object.property(prop))
# Copy the updated system object across.
system = updated_system
else:
raise ValueError("'BioSimSpace.Protocol.FreeEnergy' requires a single "
"perturbable molecule. The system has %d" \
% system.nPerturbableMolecules())
# If this is a different protocol and the system still contains a
# perturbable molecule, then we'll warn the user and simulate the
# lambda = 0 state.
else:
if system.nPerturbableMolecules() > 0:
if not "is_lambda1" in self._property_map:
is_lambda1 = False
_warnings.warn(
"The system contains a perturbable molecule but "
"this isn't a 'FreeEnergy' protocol. We will assume "
"that you intend to simulate the lambda = 0 state. "
"If you want to simulate the lambda = 1 state, then "
"pass {'is_lambda1' : True} in the 'property_map' "
"argument.")
else:
is_lambda1 = self._property_map["is_lambda1"]
self._property_map.pop("is_lambda1")
# Loop over all perturbable molecules in the system and replace them
# with a regular molecule and the chosen end state.
for mol in system.getPerturbableMolecules():
system.updateMolecules(
mol._toRegularMolecule(property_map=self._property_map,
is_lambda1=is_lambda1))
# Copy across the properties from the original system.
for prop in self._system._sire_object.propertyKeys():
system._sire_object.setProperty(
prop, self._system._sire_object.property(prop))
# RST file (coordinates).
try:
rst = _SireIO.AmberRst7(system._sire_object, self._property_map)
rst.writeToFile(self._rst_file)
except Exception as e:
msg = "Failed to write system to 'RST7' format."
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# PRM file (topology).
try:
prm = _SireIO.AmberPrm(system._sire_object, self._property_map)
prm.writeToFile(self._top_file)
except Exception as e:
msg = "Failed to write system to 'PRM7' format."
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Generate the SOMD configuration file.
# Skip if the user has passed a custom config.
if type(self._protocol) is _Protocol.Custom:
self.setConfig(self._protocol.getConfig())
else:
self._generate_config()
self.writeConfig(self._config_file)
# Generate the dictionary of command-line arguments.
self._generate_args()
# Return the list of input files.
return self._input_files
def run(self, molecule, work_dir=None, queue=None):
"""Run the parameterisation protocol.
Parameters
----------
molecule : BioSimSpace._SireWrappers.Molecule
The molecule to apply the parameterisation protocol to.
work_dir : str
The working directory.
queue : queue.Queue
The thread queue is which this method has been run.
Returns
-------
molecule : BioSimSpace._SireWrappers.Molecule
The parameterised molecule.
"""
if type(molecule) is not _Molecule:
raise TypeError(
"'molecule' must be of type 'BioSimSpace._SireWrappers.Molecule'"
)
if type(work_dir) is not None and type(work_dir) is not str:
raise TypeError("'work_dir' must be of type 'str'")
if type(queue) is not None and type(queue) is not _queue.Queue:
raise TypeError("'queue' must be of type 'queue.Queue'")
# Set work_dir to the current directory.
if work_dir is None:
work_dir = _os.getcwd()
# Create the file prefix.
prefix = work_dir + "/"
# Create a copy of the molecule.
new_mol = molecule.copy()
# Use the net molecular charge passed as an option.
if self._net_charge is not None:
charge = self._net_charge
else:
# The user will likely have passed a bare PDB or Mol2 file.
# Antechamber expects the molecule to be uncharged, or integer
# charged (where the charge, or number of electrons, is passed with
# the -nc flag).
# Get the total charge on the molecule.
if "charge" in self._property_map:
_property_map = {"charge": self._property_map["charge"]}
prop = self._property_map["charge"]
else:
_property_map = {"charge": "charge"}
prop = "charge"
# The molecule has a charge property.
if new_mol._getSireObject().hasProperty(prop):
charge = new_mol.charge(property_map=_property_map).magnitude()
# Charge is non-integer, try to fix it.
if abs(round(charge) - charge) > 0:
new_mol._fixCharge(property_map=_property_map)
charge = round(charge)
else:
charge = None
# Only try "formal_charge" when "charge" is missing. Unlikely to have
# both if this is a bare molecule, but the user could be re-parameterising
# an existing molecule.
if charge is None:
# Get the total formal charge on the molecule.
if "formal_charge" in self._property_map:
_property_map = {
"charge": self._property_map["formal_charge"]
}
prop = self._property_map["charge"]
else:
_property_map = {"charge": "formal_charge"}
prop = "formal_charge"
if new_mol._getSireObject().hasProperty(prop):
charge = new_mol.charge(
property_map=_property_map).magnitude()
# Compute the formal charge ourselves to check that it is consistent.
formal_charge = _formalCharge(molecule).magnitude()
if charge != formal_charge:
_warnings.warn(
"The formal charge on the molecule is %d "
"but we estimate it to be %d" %
(charge, formal_charge))
else:
msg = (
"The molecule has no 'charge' or 'formal_charge' information, and "
"no 'net_charge' option has been passed. You can use the "
"'BioSimSpace.Parameters.formalCharge' function to compute the "
"formal charge")
raise _ParameterisationError(msg)
# Create a new system and molecule group.
s = _SireSystem.System("BioSimSpace System")
m = _SireMol.MoleculeGroup("all")
# Add the molecule.
m.add(new_mol._getSireObject())
s.add(m)
# Write the system to a PDB file.
try:
pdb = _SireIO.PDB2(s)
pdb.writeToFile(prefix + "antechamber.pdb")
except Exception as e:
msg = "Failed to write system to 'PDB' format."
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Generate the Antechamber command.
command = ("%s -at %d -i antechamber.pdb -fi pdb " +
"-o antechamber.mol2 -fo mol2 -c %s -s 2 -nc %d") % (
_protocol._antechamber_exe, self._version,
self._charge_method.lower(), charge)
with open(prefix + "README.txt", "w") as file:
# Write the command to file.
file.write("# Antechamber was run with the following command:\n")
file.write("%s\n" % command)
# Create files for stdout/stderr.
stdout = open(prefix + "antechamber.out", "w")
stderr = open(prefix + "antechamber.err", "w")
# Run Antechamber as a subprocess.
proc = _subprocess.run(command,
cwd=work_dir,
shell=True,
stdout=stdout,
stderr=stderr)
stdout.close()
stderr.close()
# Antechamber doesn't return sensible error codes, so we need to check that
# the expected output was generated.
if _os.path.isfile(prefix + "antechamber.mol2"):
# Run parmchk to check for missing parameters.
command = ("%s -s %d -i antechamber.mol2 -f mol2 " +
"-o antechamber.frcmod") % (_protocol._parmchk_exe,
self._version)
with open(prefix + "README.txt", "a") as file:
# Write the command to file.
file.write("\n# ParmChk was run with the following command:\n")
file.write("%s\n" % command)
# Create files for stdout/stderr.
stdout = open(prefix + "parmchk.out", "w")
stderr = open(prefix + "parmchk.err", "w")
# Run parmchk as a subprocess.
proc = _subprocess.run(command,
cwd=work_dir,
shell=True,
stdout=stdout,
stderr=stderr)
stdout.close()
stderr.close()
# The frcmod file was created.
if _os.path.isfile(prefix + "antechamber.frcmod"):
# Now call tLEaP using the partially parameterised molecule and the frcmod file.
# tLEap will run in the same working directory, using the Mol2 file generated by
# Antechamber.
# Try to find a force field file.
if self._version == 1:
ff = _protocol._find_force_field("gaff")
else:
ff = _protocol._find_force_field("gaff2")
# Write the LEaP input file.
with open(prefix + "leap.txt", "w") as file:
file.write("source %s\n" % ff)
file.write("mol = loadMol2 antechamber.mol2\n")
file.write("loadAmberParams antechamber.frcmod\n")
file.write("saveAmberParm mol leap.top leap.crd\n")
file.write("quit")
# Generate the tLEaP command.
command = "%s -f leap.txt" % _protocol._tleap_exe
with open(prefix + "README.txt", "a") as file:
# Write the command to file.
file.write(
"\n# tLEaP was run with the following command:\n")
file.write("%s\n" % command)
# Create files for stdout/stderr.
stdout = open(prefix + "tleap.out", "w")
stderr = open(prefix + "tleap.err", "w")
# Run tLEaP as a subprocess.
proc = _subprocess.run(command,
cwd=work_dir,
shell=True,
stdout=stdout,
stderr=stderr)
stdout.close()
stderr.close()
# tLEaP doesn't return sensible error codes, so we need to check that
# the expected output was generated.
if _os.path.isfile(prefix +
"leap.top") and _os.path.isfile(prefix +
"leap.crd"):
# Load the parameterised molecule.
try:
par_mol = _Molecule(
_IO.readMolecules([
prefix + "leap.top", prefix + "leap.crd"
])._getSireObject()[_SireMol.MolIdx(0)])
except Exception as e:
msg = "Failed to read molecule from: 'leap.top', 'leap.crd'"
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Make the molecule 'mol' compatible with 'par_mol'. This will create
# a mapping between atom indices in the two molecules and add all of
# the new properties from 'par_mol' to 'mol'.
new_mol._makeCompatibleWith(
par_mol,
property_map=self._property_map,
overwrite=True,
verbose=False)
# Record the forcefield used to parameterise the molecule.
new_mol._forcefield = ff
else:
raise _ParameterisationError("tLEaP failed!")
else:
raise _ParameterisationError("Parmchk failed!")
else:
raise _ParameterisationError("Antechamber failed!")
if queue is not None:
queue.put(new_mol)
return new_mol
def run(self, molecule, work_dir=None, queue=None):
"""Run the parameterisation protocol.
Parameters
----------
molecule : BioSimSpace._SireWrappers.Molecule
The molecule to apply the parameterisation protocol to.
work_dir : str
The working directory.
queue : queue.Queue
The thread queue is which this method has been run.
Returns
-------
molecule : BioSimSpace._SireWrappers.Molecule
The parameterised molecule.
"""
if type(molecule) is not _Molecule:
raise TypeError(
"'molecule' must be of type 'BioSimSpace._SireWrappers.Molecule'"
)
if type(work_dir) is not None and type(work_dir) is not str:
raise TypeError("'work_dir' must be of type 'str'")
if type(queue) is not None and type(queue) is not _queue.Queue:
raise TypeError("'queue' must be of type 'queue.Queue'")
# Set work_dir to the current directory.
if work_dir is None:
work_dir = _os.getcwd()
# Create the file prefix.
prefix = work_dir + "/"
# Create a copy of the molecule.
new_mol = molecule.copy()
# Choose the program to run with depending on the force field compatibility.
# If tLEaP and pdb2gmx are supported, default to tLEaP, then use pdb2gmx if
# tLEaP fails to produce output.
# First, try parameterise using tLEaP.
if self._tleap:
if _tleap_exe is not None:
output = self._run_tleap(molecule, work_dir)
# Otherwise, try using pdb2gmx.
elif self._pdb2gmx:
if _gmx_exe is not None:
output = self._run_pdb2gmx(molecule, work_dir)
else:
raise _MissingSoftwareError(
"Cannot parameterise. Missing AmberTools and GROMACS.")
# Parameterise using pdb2gmx.
elif self._pdb2gmx:
if _gmx_exe is not None:
output = self._run_pdb2gmx(molecule, work_dir)
else:
raise _MissingSoftwareError(
"Cannot use pdb2gmx since GROMACS is not installed!")
# Prepend the working directory to the output file names.
output = [prefix + output[0], prefix + output[1]]
try:
# Load the parameterised molecule.
par_mol = _Molecule(
_IO.readMolecules(output)._getSireObject()[_SireMol.MolIdx(0)])
except Exception as e:
msg = "Failed to read molecule from: '%s', '%s'" % (output[0],
output[1])
if _isVerbose():
raise IOError(msg) from e
else:
raise IOError(msg) from None
# Make the molecule 'mol' compatible with 'par_mol'. This will create
# a mapping between atom indices in the two molecules and add all of
# the new properties from 'par_mol' to 'mol'.
new_mol._makeCompatibleWith(par_mol,
property_map=self._property_map,
overwrite=True,
verbose=False)
# Record the forcefield used to parameterise the molecule.
new_mol._forcefield = self._forcefield
if queue is not None:
queue.put(new_mol)
return new_mol
