def get_covalent_chains(molecular_system,
chain=None,
selection='all',
syntaxis='MolSysMT',
check=True):
if check:
from molsysmt.tools.molecular_system import is_molecular_system
if not is_molecular_system(molecular_system):
raise MolecularSystemNeededError()
from molsysmt.topology.get_bondgraph import get_bondgraph
if selection is 'all':
mask = None
else:
mask = select(molecular_system,
selection=selection,
syntaxis=syntaxis,
check=False)
chain_atom_indices = []
for sel_in_chain in chain:
atom_indices = select(molecular_system,
selection=sel_in_chain,
mask=mask)
chain_atom_indices.append(atom_indices)
atom_indices = np.sort(np.unique(np.concatenate(chain_atom_indices)))
graph = get_bondgraph(molecular_system,
selection=atom_indices,
nodes_name='atom_index',
check=False)
n_slaves = len(chain_atom_indices)
output = [[ii] for ii in chain_atom_indices[0]]
for slave_index in range(n_slaves):
chain_atom_indices[slave_index] = set(chain_atom_indices[slave_index])
for slave_index in range(1, n_slaves):
slave_preindex = slave_index - 1
tmp_output = output.copy()
output = []
for chain in tmp_output:
for ii in graph.neighbors(chain[slave_preindex]):
if ii in chain_atom_indices[slave_index]:
new_chain = chain.copy()
new_chain.append(ii)
output.append(new_chain)
del (graph)
return np.array(output, dtype=int)
def remove_solvent(molecular_system,
water=True,
ions=True,
cosolutes=True,
include_selection=None,
exclude_selection=None,
syntaxis='MolSysMT'):
from molsysmt.basic import select, remove
molecular_system = digest_molecular_system(molecular_system)
syntaxis = digest_syntaxis(syntaxis)
atom_indices_to_be_removed = []
atom_indices_water = []
atom_indices_ions = []
atom_indices_cosolutes = []
atom_indices_included = []
atom_indices_excluded = []
if water:
atom_indices_water = select(molecular_system, 'group_type=="water"')
if ions:
atom_indices_ions = select(molecular_system, 'group_type=="ion"')
if cosolutes:
atom_indices_cosolutes = select(molecular_system,
'group_type=="cosolute"')
atom_indices_to_be_removed = list(
(set(atom_indices_water) | set(atom_indices_ions)
| set(atom_indices_cosolutes)))
if include_selection is not None:
atom_indices_included = select(molecular_system,
selection=include_selection,
syntaxis=syntaxis)
atom_indices_to_be_removed = list(
(set(atom_indices_to_be_removed) | set(atom_indices_included)))
if exclude_selection is not None:
atom_indices_excluded = select(molecular_system,
selection=exclude_selection,
syntaxis=syntaxis)
atom_indices_to_be_removed = list(
(set(atom_indices_to_be_removed) - set(atom_indices_excluded)))
return remove(molecular_system, atom_indices_to_be_removed)
def show_colored_cartoon_by_scalar_residue_values(view,
values,
selection='all',
cmap=None,
vmin=None,
vmax=None):
from nglview.color import _ColorScheme
from molsysmt.basic import select
groups_selection = select(view,
target='group',
selection=selection,
to_syntaxis='NGLview')
if vmin is None:
vmin = min(values)
if vmax is None:
vmax = max(values)
norm = Normalize(vmin=vmin, vmax=vmax)
scheme = _ColorScheme(
[[to_hex(cmap(norm(ii))), jj]
for ii, jj in zip(values, groups_selection.split(' '))],
label='user')
view.add_cartoon(selection='protein', color=scheme)
# It can also be done as:
# nv.color.ColormakerRegistry.add_scheme('buried_factors',[['#'+ii[2:],str(jj)] for ii,jj in zip(colors, range(706))])
# view.add_cartoon(selection='protein', color='buried_factors')
pass
def show_colored_surface_by_scalar_residue_values(view,
values,
selection='all',
cmap=None,
vmin=None,
vmax=None):
from nglview.color import _ColorScheme
from molsysmt.basic import select
from matplotlib.colors import Normalize, to_hex
groups_selection = select(view,
target='group',
selection=selection,
to_syntaxis='NGLview')
if vmin is None:
vmin = min(values)
if vmax is None:
vmax = max(values)
norm = Normalize(vmin=vmin, vmax=vmax)
scheme = _ColorScheme(
[[to_hex(cmap(norm(ii))), jj]
for ii, jj in zip(values, groups_selection.split(' '))],
label='user')
view.add_surface(selection='protein', color=scheme)
pass
def remove_ions (molecular_system, selection="all", include_selection=None, exclude_selection=None, syntaxis="MolSysMT"):
from molsysmt.basic import select, remove
molecular_system = digest_molecular_system(molecular_system)
syntaxis = digest_syntaxis(syntaxis)
atom_indices_to_be_removed = select(molecular_system, 'molecule_type=="ion"')
if include_selection is not None:
atom_indices_included = select(molecular_system, selection=include_selection, syntaxis=syntaxis)
atom_indices_to_be_removed = list((set(atom_indices_to_be_removed) | set(atom_indices_included)))
if exclude_selection is not None:
atom_indices_excluded = select(molecular_system, selection=exclude_selection, syntaxis=syntaxis)
atom_indices_to_be_removed = list((set(atom_indices_to_be_removed) - set(atom_indices_excluded)))
return remove(molecular_system, atom_indices_to_be_removed)
def remove_waters(molecular_system,
selection="all",
include_selection=None,
exclude_selection=None,
syntaxis="MolSysMT",
check=True):
from molsysmt.basic import select, remove, is_molecular_system
if check:
if not is_molecular_system(molecular_system):
raise NeedsSingleMolecularSystemError()
try:
syntaxis = digest_syntaxis(syntaxis)
except:
raise WrongSyntaxisError()
atom_indices_to_be_removed = select(molecular_system,
'molecule_type=="water"',
check=False)
if include_selection is not None:
atom_indices_included = select(molecular_system,
selection=include_selection,
syntaxis=syntaxis,
check=False)
atom_indices_to_be_removed = list(
(set(atom_indices_to_be_removed) | set(atom_indices_included)))
if exclude_selection is not None:
atom_indices_excluded = select(molecular_system,
selection=exclude_selection,
syntaxis=syntaxis,
check=False)
atom_indices_to_be_removed = list(
(set(atom_indices_to_be_removed) - set(atom_indices_excluded)))
return remove(molecular_system, atom_indices_to_be_removed)
def get_center(molecular_system,
selection='all',
groups_of_atoms=None,
weights=None,
structure_indices='all',
syntaxis='MolSysMT',
engine='MolSysMT',
parallel=False):
molecular_system = digest_molecular_system(molecular_system)
engine = digest_engine(engine)
if engine == 'MolSysMT':
if groups_of_atoms is None:
atom_indices = select(molecular_system,
selection=selection,
syntaxis=syntaxis)
groups_of_atoms = [atom_indices]
groups_serialized = serialized_lists(groups_of_atoms, dtype='int64')
if weights is None:
weights = np.ones((groups_serialized.n_values))
elif weights is 'masses':
raise NotImplementedError
coordinates = get(molecular_system,
target='system',
structure_indices=structure_indices,
coordinates=True)
length_units = puw.get_unit(coordinates)
coordinates = np.asfortranarray(puw.get_value(coordinates),
dtype='float64')
n_atoms = coordinates.shape[1]
n_structures = coordinates.shape[0]
com = libcom.center_of_mass(coordinates, groups_serialized.indices,
groups_serialized.values,
groups_serialized.starts, weights,
n_structures, n_atoms,
groups_serialized.n_indices,
groups_serialized.n_values)
del (coordinates, groups_serialized)
return com * length_units
else:
raise NotImplementedError(NotImplementedMessage)
def get_missing_heavy_atoms(molecular_system,
selection='all',
engine='PDBFixer',
syntaxis='MolSysMT'):
engine = digest_engine(engine)
output = {}
if engine == "PDBFixer":
from molsysmt.basic import convert, get_form, select
correction_group_indices = False
if selection is not 'all':
group_indices_in_selection = select(molecular_system,
target='group',
selection=selection)
correction_group_indices = True
tmp_item = convert(molecular_system,
selection=selection,
to_form="pdbfixer.PDBFixer",
syntaxis=syntaxis)
tmp_item.findMissingResidues()
tmp_item.findMissingAtoms()
missingAtoms = tmp_item.missingAtoms
for group, atoms in missingAtoms.items():
if correction_group_indices:
group_index = group_indices_in_selection[group.index]
else:
group_index = group.index
output[group_index] = []
for atom in atoms:
output[group_index].append(atom.name)
else:
raise NotImplementedError
return output
def get_sasa (molecular_system, target='atom', selection='all', structure_indices='all', syntaxis='MolSysMT',
engine='MDTraj'):
engine = digest_engine(engine)
target = digest_target(target)
if engine == 'MDTraj':
from mdtraj import shrake_rupley
tmp_item = convert(molecular_system, structure_indices=structure_indices, to_form='mdtraj.Trajectory')
sasa_array = shrake_rupley(tmp_item, mode='atom') # tiene probe_radius y n_sphere_points
if target=='atom':
if selection is not 'all':
atom_indices = select(molecular_system, selection=selection, syntaxis=syntaxis)
sasa_array = sasa_array[:,atom_indices]
else:
sets_atoms = get(molecular_system, target=target, selection=selection, syntaxis=syntaxis, atom_index=True)
n_sets = len(sets_atoms)
n_structures = sasa_array.shape[0]
new_sasa_array = np.empty([n_structures, n_sets], dtype='float')
for ii in range(n_sets):
new_sasa_array[:,ii] = sasa_array[:,sets_atoms[ii].astype(int)].sum(axis=1)
sasa_array = new_sasa_array
sasa_array = puw.quantity(sasa_array, 'nm**2')
sasa_array = puw.standardize(sasa_array)
else:
raise NotImplementedError("Engine not implemented yet")
return sasa_array
def one_system(molecular_system=None,
selection=None,
structure_indices=None,
form=None,
syntaxis='MolSysMT'):
from molsysmt.basic import convert, select
atom_indices = None
if form is not None:
tmp_molecular_system = convert(molecular_system, form)
else:
tmp_molecular_system = item
if selection is not None:
atom_indices = select(molecular_system, selection, syntaxis=syntaxis)
structure_indices = frameslist(tmp_molecular_system, structure_indices)
return tmp_molecular_system, atom_indices, structure_indices
def align(molecular_system,
selection='backbone',
structure_indices='all',
reference_molecular_system=None,
reference_selection='backbone',
reference_frame_index=0,
syntaxis='MolSysMT',
parallel=True,
method='sequence alignment and least rmsd fit',
engine_sequence_alignment='biopython',
engine_least_rmsd_fit='MolSysMT'):
output = None
if method == 'sequence alignment and least rmsd fit':
from molsysmt.basic import select
if engine_sequence_alignment == 'biopython':
from molsysmt.topology import get_sequence_identity
identity, identical_groups, reference_identical_groups = get_sequence_identity(
molecular_system,
selection=selection,
reference_molecular_system=reference_molecular_system,
reference_selection=reference_selection,
engine='biopython')
else:
raise NotImplementedError
aux_atoms_list = select(molecular_system,
target='atom',
selection='group_index==@identical_groups')
selection_to_be_fitted = select(molecular_system,
target='atom',
selection=selection,
mask=aux_atoms_list)
aux_atoms_list = select(
reference_molecular_system,
target='atom',
selection='group_index==@reference_identical_groups')
reference_selection_to_be_fitted = select(
reference_molecular_system,
target='atom',
selection=reference_selection,
mask=aux_atoms_list)
if engine_least_rmsd_fit == 'MolSysMT':
from molsysmt.structure import fit
output = fit(molecular_system=molecular_system,
selection=selection_to_be_fitted,
structure_indices=structure_indices,
reference_molecular_system=reference_molecular_system,
reference_selection=reference_selection_to_be_fitted,
reference_frame_index=reference_frame_index,
engine='MolSysMT',
parallel=parallel,
syntaxis=syntaxis)
else:
raise NotImplementedError
return output
def wrap_to_pbc(molecular_system,
selection='all',
structure_indices='all',
center='[0,0,0] nanometers',
center_of_selection=None,
weights_for_center=None,
recenter=True,
keep_covalent_bonds=False,
syntaxis='MolSysMT',
engine='MolSysMT',
in_place=False):
engine = digest_engine(engine)
structure_indices = digest_structure_indices(structure_indices)
if engine == 'MolSysMT':
from molsysmt.basic import select, get, set, extract, copy
atom_indices = select(molecular_system,
selection=selection,
syntaxis=syntaxis)
coordinates = get(molecular_system,
target='atom',
indices=atom_indices,
coordinates=True)
length_units = puw.get_unit(coordinates)
n_structures = coordinates.shape[0]
n_atoms = coordinates.shape[1]
box, box_shape = get(molecular_system,
target='system',
structure_indices=structure_indices,
box=True,
box_shape=True)
box = puw.convert(box, to_unit=length_units)
orthogonal = 0
if box_shape is None:
raise ValueError(
"The system has no PBC box. The input argument 'pbc' can not be True."
)
elif box_shape == 'cubic':
orthogonal = 1
if center_of_selection is not None:
from molsysmt.structure import get_center
center = get_center(molecular_system,
selection=center_of_selection,
weights=weights_for_center,
structure_indices=structure_indices,
syntaxis=syntaxis,
engine='MolSysMT')
center = puw.convert(center, to_unit=length_units)
center = puw.get_value(center)
else:
center = puw.quantity(center)
center = puw.convert(center, to_unit=length_units)
center = puw.get_value(center)
center_shape = np.shape(center)
if len(center_shape) == 1 and center_shape[-1] == 3:
center = np.tile(center, [n_structures, 1, 1])
elif len(center_shape) == 2 and center_shape[
-1] == 3 and center_shape[0] == n_structures:
center = np.expand_dims(center, axis=1)
elif len(center_shape
) == 2 and center_shape[-1] == 3 and center_shape[0] == 1:
center = np.tile(center[0], [n_structures, 1, 1])
elif len(center_shape
) == 3 and center_shape[-1] == 3 and center_shape[
0] == n_structures and center_shape[1] == 1:
center = np.array(center)
else:
raise ValueError('center needs the right shape')
box = np.asfortranarray(puw.get_value(box), dtype='float64')
coordinates = np.asfortranarray(puw.get_value(coordinates),
dtype='float64')
center = np.asfortranarray(center, dtype='float64')
libbox.wrap_pbc(coordinates, center, box, orthogonal, n_atoms,
n_structures)
if recenter:
translation = np.tile(-center, (n_atoms, 1))
coordinates += translation
coordinates = np.ascontiguousarray(coordinates) * length_units
else:
raise NotImpementedEngineError()
if in_place:
set(molecular_system,
target='atom',
indices=atom_indices,
structure_indices=structure_indices,
syntaxis=syntaxis,
coordinates=coordinates)
pass
else:
tmp_molecular_system = copy(molecular_system)
set(tmp_molecular_system,
target='atom',
indices=atom_indices,
structure_indices=structure_indices,
syntaxis=syntaxis,
coordinates=coordinates)
return tmp_molecular_system
def get_rmsd(molecular_system,
selection='backbone',
structure_indices='all',
reference_molecular_system=None,
reference_selection=None,
reference_frame_index=0,
reference_coordinates=None,
parallel=True,
syntaxis='MolSysMT',
engine='MolSysMT'):
from molsysmt.basic import is_a_molecular_system
if not is_a_molecular_system(molecular_system):
raise SingleMolecularSystemNeededError()
engine = digest_engine(engine)
if engine == 'MolSysMT':
from molsysmt.basic import select, get
from molsysmt._private._digestion import digest_structure_indices
n_atoms, n_structures = get(molecular_system,
n_atoms=True,
n_structures=True)
atom_indices = select(molecular_system,
selection=selection,
syntaxis=syntaxis)
n_atom_indices = atom_indices.shape[0]
structure_indices = digest_structure_indices(structure_indices)
if structure_indices is 'all':
structure_indices = np.arange(n_structures)
n_structure_indices = structure_indices.shape[0]
if reference_coordinates is None:
if reference_molecular_system is None:
reference_molecular_system = molecular_system
if reference_selection is None:
reference_selection = selection
reference_atom_indices = select(reference_molecular_system,
selection=reference_selection,
syntaxis=syntaxis)
reference_coordinates = get(
reference_molecular_system,
target='atom',
indices=reference_atom_indices,
structure_indices=reference_frame_index,
coordinates=True)
coordinates = get(molecular_system,
coordinates=True,
structure_indices='all')
units = puw.get_unit(coordinates)
coordinates = np.asfortranarray(puw.get_value(coordinates),
dtype='float64')
reference_coordinates = np.asfortranarray(puw.get_value(
reference_coordinates, to_unit=units),
dtype='float64')
if reference_coordinates.shape[1] != n_atom_indices:
raise ValueError(
"reference selection and selection needs to have the same number of atoms"
)
rmsd_val = librmsd.rmsd(coordinates, atom_indices,
reference_coordinates, structure_indices,
n_atoms, n_structures, n_atom_indices,
n_structure_indices)
rmsd_val = rmsd_val * units
rmsd_val = puw.standardize(rmsd_val)
del (coordinates, units)
return rmsd_val
elif engine == 'MDTraj':
#from mdtraj import rmsd as mdtraj_rmsd
#from molsysmt.basic import convert
#tmp_molecular_system = convert(molecular_system, to_form='mdtraj.Trajectory')
#rmsd_val = mdtraj_rmsd(tmp_molecular_system, ref_item, frame=ref_structure_indices,
# ref_atom_indices=ref_atom_indices, atom_indices=atom_indices,
# parallel=parallel, precentered=precentered)
#rmsd_val = puw.standardize(rmsd_val)
#return rmsd_val
raise NotImplementedError
else:
raise NotImplementedError
def buch(molecular_system,
selection='all',
selection_2=None,
structure_indices='all',
threshold='2.3 angstroms',
acceptors=None,
donors=None,
pbc=False,
optimize=False,
output_form='dict',
engine='MolSysMT',
syntaxis='MolSysMT'):
from molsysmt.hbonds.donors_and_acceptors import get_acceptor_atoms, get_donor_atoms
from molsysmt.structure import get_neighbors
molecular_system = digest_molecular_system(molecular_system)
engine = digest_engine(engine)
structure_indices = digest_structure_indices(structure_indices)
output = None
if selection_2 is None:
if acceptors is None:
acceptors_1 = get_acceptor_atoms(molecular_system,
selection=selection,
engine=engine,
syntaxis=syntaxis)
else:
acceptors_1 = select(molecular_system,
selection=selection,
mask=acceptors,
syntaxis=syntaxis)
if donors is None:
donors_1 = get_donor_atoms(molecular_system,
selection=selection,
engine=engine,
syntaxis=syntaxis)
else:
donors_1 = select(molecular_system,
selection=selection,
mask=donors,
syntaxis=syntaxis)
neighs, _ = get_neighbors(molecular_system,
selection=acceptors_1,
selection_2=donors_1[0],
structure_indices=structure_indices,
threshold=threshold,
pbc=pbc,
engine=engine,
syntaxis=syntaxis)
if output_form == 'dict':
output = {}
n_acceptors = len(acceptors_1)
for frame_index in range(neighs.shape[0]):
for ii in range(n_acceptors):
for donor_index in neighs[frame_index][ii]:
hbond_id = tuple(donors_1[donor_index].tolist() +
[acceptors_1[ii]])
try:
output[hbond_id].append(frame_index)
except:
output[hbond_id] = [frame_index]
else:
raise NotImplementedError
else:
if acceptors is None:
acceptors_1 = get_acceptor_atoms(molecular_system,
selection=selection,
engine=engine,
syntaxis=syntaxis)
acceptors_2 = get_acceptor_atoms(molecular_system,
selection=selection_2,
engine=engine,
syntaxis=syntaxis)
else:
acceptors_1 = select(molecular_system,
selection=selection,
mask=acceptors,
syntaxis=syntaxis)
acceptors_2 = select(molecular_system,
selection=selection_2,
mask=acceptors,
syntaxis=syntaxis)
if donors is None:
donors_1 = get_donor_atoms(molecular_system,
selection=selection,
engine=engine,
syntaxis=syntaxis)
donors_2 = get_donor_atoms(molecular_system,
selection=selection_2,
engine=engine,
syntaxis=syntaxis)
else:
donors_1 = select(molecular_system,
selection=selection,
mask=donors,
syntaxis=syntaxis)
donors_2 = select(molecular_system,
selection=selection_2,
mask=donors,
syntaxis=syntaxis)
neighs, _ = get_neighbors(molecular_system,
selection=acceptors_1,
selection_2=donors_2[0],
structure_indices=structure_indices,
threshold=threshold,
pbc=pbc,
engine=engine,
syntaxis=syntaxis)
neighs_2, _ = get_neighbors(molecular_system,
selection=acceptors_2,
selection_2=donors_1[0],
structure_indices=structure_indices,
threshold=threshold,
pbc=pbc,
engine=engine,
syntaxis=syntaxis)
if output_form == 'dict':
output = {}
n_acceptors = len(acceptors_1)
for frame_index in range(neighs.shape[0]):
for ii in range(n_acceptors):
for donor_index in neighs[frame_index][ii]:
hbond_id = tuple(donors_2[donor_index].tolist() +
[acceptors_1[ii]])
try:
output[hbond_id].append(frame_index)
except:
output[hbond_id] = [frame_index]
n_acceptors = len(acceptors_2)
for frame_index in range(neighs_2.shape[0]):
for ii in range(n_acceptors):
for donor_index in neighs_2[frame_index][ii]:
hbond_id = tuple(donors_1[donor_index].tolist() +
[acceptors_2[ii]])
try:
output[hbond_id].append(frame_index)
except:
output[hbond_id] = [frame_index]
else:
raise NotImplementedError()
return output
def fit(molecular_system=None,
selection='backbone',
structure_indices='all',
reference_molecular_system=None,
reference_selection=None,
reference_frame_index=0,
to_form=None,
parallel=True,
syntaxis='MolSysMT',
method='least rmsd',
engine='MolSysMT',
check=True):
from molsysmt.basic import select, get, set, convert, copy, is_molecular_system
if check:
if not is_molecular_system(molecular_system):
raise MolecularSystemNeededError()
engine = digest_engine(engine)
if engine == 'MolSysMT':
n_atoms, n_structures = get(molecular_system,
n_atoms=True,
n_structures=True,
check=False)
atom_indices = select(molecular_system,
selection=selection,
syntaxis=syntaxis,
check=False)
n_atom_indices = atom_indices.shape[0]
structure_indices = digest_structure_indices(structure_indices)
if structure_indices is 'all':
structure_indices = np.arange(n_structures)
n_structure_indices = structure_indices.shape[0]
if reference_molecular_system is None:
reference_molecular_system = molecular_system
if reference_selection is None:
reference_selection = selection
reference_atom_indices = select(reference_molecular_system,
selection=reference_selection,
syntaxis=syntaxis,
check=False)
reference_coordinates = get(reference_molecular_system,
target='atom',
indices=reference_atom_indices,
structure_indices=reference_frame_index,
coordinates=True,
check=False)
coordinates = get(molecular_system,
coordinates=True,
structure_indices='all',
check=False)
units = puw.get_unit(coordinates)
coordinates = np.asfortranarray(puw.get_value(coordinates),
dtype='float64')
reference_coordinates = np.asfortranarray(puw.get_value(
reference_coordinates, to_unit=units),
dtype='float64')
if reference_coordinates.shape[1] != n_atom_indices:
raise ValueError(
"reference selection and selection needs to have the same number of atoms"
)
librmsd.least_rmsd_fit(coordinates, atom_indices,
reference_coordinates, structure_indices,
n_atoms, n_structures, n_atom_indices,
n_structure_indices)
coordinates = np.ascontiguousarray(coordinates) * units
coordinates = puw.standardize(coordinates)
if to_form is None:
tmp_molecular_system = copy(molecular_system, check=False)
else:
tmp_molecular_system = convert(molecular_system,
to_form=to_form,
check=False)
set(tmp_molecular_system,
target='system',
coordinates=coordinates,
check=False)
del (coordinates, units)
return tmp_molecular_system
elif engine == 'MDTraj':
#tmp_item.superpose(tmp_ref_item,frame=ref_structure_indices,atom_indices=atom_indices,ref_atom_indices=ref_atom_indices,parallel=parallel)
#if in_form==x_form:
# item=tmp_item
#elif in_form=='molsysmt.Trajectory':
# item._import_mdtraj_data(tmp_item)
#elif in_form=='molsysmt.MolSys':
# item.trajectory._import_mdtraj_data(tmp_item)
#else:
# item=_convert(tmp_item, to_form=in_form)
raise NotImplementedMethodError()
else:
raise NotImplementedMethodError()
def standardize_view(view, atom_indices='all', structure_indices='all'):
from molsysmt.basic import select, get, convert
from molsysmt.build import is_solvated
if atom_indices is not 'all':
string_atom_indices = '@' + ','.join(map(str, atom_indices))
else:
string_atom_indices = 'all'
tmp_topology = convert(view, to_form='molsysmt.Topology')
sel_cartoon = select(
tmp_topology,
selection='molecule_type in ["protein", "dna", "rna"]',
mask=atom_indices,
to_syntaxis='NGLview')
sel_balls = select(tmp_topology,
selection='molecule_type in ["ion"]',
mask=atom_indices,
to_syntaxis='NGLview')
sel_licorice = select(
tmp_topology,
selection='molecule_type in ["lipid", "small molecule"]',
mask=atom_indices,
to_syntaxis='NGLview')
peptide_indices = select(tmp_topology,
selection='molecule_type=="peptide"',
target='molecule')
peptides_to_cartoon = []
peptides_to_licorice = []
for peptide_index in peptide_indices:
n_aminoacids = get(tmp_topology,
target='molecule',
indices=peptide_index,
n_groups=True)[0]
if n_aminoacids > 4:
peptides_to_cartoon.append(peptide_index)
else:
peptides_to_licorice.append(peptide_index)
sel_peptides_cartoon = select(
tmp_topology,
selection='molecule_index in @peptides_to_cartoon',
mask=atom_indices,
to_syntaxis='NGLview')
sel_peptides_licorice = select(
tmp_topology,
selection='molecule_index in @peptides_to_licorice',
mask=atom_indices,
to_syntaxis='NGLview')
view.clear()
view.add_cartoon(selection=sel_cartoon)
view.add_cartoon(selection=sel_peptides_cartoon)
view.add_licorice(selection=sel_licorice, radius=0.4)
view.add_licorice(selection=sel_peptides_licorice, radius=0.4)
view.add_ball_and_stick(selection=sel_balls)
n_waters = get(view, target="system", n_waters=True)
n_selected_waters = get(view, target="system", n_waters=True)
solvated = is_solvated(view)
if (not solvated) or (n_selected_waters < n_waters):
sel_water = select(tmp_topology,
selection='molecule_type in ["water"]',
mask=atom_indices,
to_syntaxis='NGLview')
view.add_licorice(selection=sel_water)
view.center(selection=string_atom_indices)
pass
def get_least_rmsd(molecular_system=None,
selection='backbone',
structure_indices='all',
reference_molecular_system=None,
reference_selection=None,
reference_frame_index=0,
reference_coordinates=None,
parallel=True,
syntaxis='MolSysMT',
engine='MolSysMT',
check=True):
if check:
from molsysmt.tools.molecular_system import is_molecular_system
if not is_a_molecular_system(molecular_system):
raise SingleMolecularSystemNeededError()
engine = digest_engine(engine)
if engine == 'MolSysMT':
n_atoms, n_structures = get(molecular_system,
n_atoms=True,
n_structures=True,
check=False)
atom_indices = select(molecular_system,
selection=selection,
syntaxis=syntaxis,
check=False)
n_atom_indices = atom_indices.shape[0]
structure_indices = digest_structure_indices(structure_indices)
if structure_indices is 'all':
structure_indices = np.arange(n_structures)
n_structure_indices = structure_indices.shape[0]
if reference_coordinates is None:
if reference_molecular_system is None:
reference_molecular_system = molecular_system
if reference_selection is None:
reference_selection = selection
reference_atom_indices = select(reference_molecular_system,
selection=reference_selection,
syntaxis=syntaxis,
check=False)
reference_coordinates = get(
reference_molecular_system,
target='atom',
indices=reference_atom_indices,
structure_indices=reference_frame_index,
coordinates=True,
check=False)
coordinates = get(molecular_system,
coordinates=True,
structure_indices='all',
check=False)
units = puw.get_unit(coordinates)
coordinates = np.asfortranarray(puw.get_value(coordinates),
dtype='float64')
reference_coordinates = np.asfortranarray(puw.get_value(
reference_coordinates, to_unit=units),
dtype='float64')
if reference_coordinates.shape[1] != n_atom_indices:
raise ValueError(
"reference selection and selection needs to have the same number of atoms"
)
rmsd_val = librmsd.least_rmsd(coordinates, atom_indices,
reference_coordinates, structure_indices,
n_atoms, n_structures, n_atom_indices,
n_structure_indices)
rmsd_val = rmsd_val * units
rmsd_val = puw.standardize(rmsd_val)
del (coordinates, units)
return rmsd_val
elif engine == 'MDTraj':
raise NotImplementedError
else:
raise NotImplementedError
def comparison_two_systems(molecular_system_1=None,
selection_1=None,
structure_indices_1=None,
molecular_system_2=None,
selection_2=None,
structure_indices_2=None,
form=None,
syntaxis='MolSysMT'):
from molsysmt.basic import convert, select
single_molecular_system = False
diff_selection = True
atom_indices_1 = None
atom_indices_2 = None
if molecular_system1 is None and molecular_system_2 is None:
raise BadCallError(BadCallMessage)
if molecular_system_1 is None or molecular_system_2 is None:
single_molecular_system = True
if molecular_system_1 is None:
molecular_system_1 = molecular_system_2
else:
molecular_system_2 = molecular_system_1
if form is not None:
tmp_molecular_system_1 = convert(molecular_system_1, form)
tmp_molecular_system_2 = convert(molecular_system_2, form)
else:
tmp_molecular_system_1 = molecular_system_1
tmp_molecular_system_2 = molecular_system_2
if selection_1 is not None:
atom_indices_1 = select(tmp_molecular_system_1,
selection_1,
syntaxis=syntaxis)
if selection_2 is not None:
atom_indices_2 = select(tmp_molecular_system_2,
selection_2,
syntaxis=syntaxis)
if selection_1 is None and selection_2 is None:
atom_indices_1 = None
atom_indices_2 = None
elif selection_1 is None or selection_2 is None:
if single_molecular_system is True:
diff_selection = False
if selection_1 is None:
atom_indices_1 = atom_indices_2
else:
atom_indices_2 = atom_indices_1
else:
if selection_1 is None:
atom_indices_1 = select(tmp_molecular_system_1,
selection_2,
syntaxis=syntaxis)
else:
atom_indices_2 = select(tmp_molecular_system_2,
selection_1,
syntaxis=syntaxis)
structure_indices_1 = frameslist(tmp_molecular_system_1,
structure_indices_1)
structure_indices_2 = frameslist(tmp_molecular_system_2,
structure_indices_2)
return tmp_molecular_system_1, atom_indices_1, structure_indices_1, \
tmp_molecular_system_2, atom_indices_2, structure_indices_2, \
single_molecular_system, diff_selection
def add_terminal_cappings(molecular_system,
N_terminal=None,
C_terminal=None,
selection='all',
syntaxis='MolSysMT',
engine='PDBFixer'):
from molsysmt.basic import get_form, convert, get, select
form_in = get_form(molecular_system)
if engine is 'PDBFixer':
from pdbfixer.pdbfixer import Sequence
tmp_molecular_system = convert(molecular_system,
to_form='pdbfixer.PDBFixer')
atom_indices_in_selection = select(tmp_molecular_system,
selection=selection,
syntaxis=syntaxis)
atom_indices_in_components = get(
tmp_molecular_system,
target='component',
selection='component_type in ["peptide", "protein"] \
and atom_index in @atom_indices_in_selection',
atom_index=True)
for atom_indices_in_component in atom_indices_in_components:
chain_id = get(
tmp_molecular_system,
target='chain',
selection='atom_index in @atom_indices_in_component',
chain_id=True)
groups_sequence = get(
tmp_molecular_system,
target='group',
selection='atom_index in @atom_indices_in_component',
group_name=True)
groups_sequence = list(groups_sequence)
if N_terminal is not None:
groups_sequence = [N_terminal] + groups_sequence
if C_terminal is not None:
groups_sequence = groups_sequence + [C_terminal]
tmp_molecular_system.sequences.append(
Sequence(chain_id, groups_sequence))
tmp_molecular_system.findMissingResidues()
tmp_molecular_system.findMissingAtoms()
tmp_molecular_system.addMissingAtoms()
n_hs = get(tmp_molecular_system,
target='atom',
selection='atom_type=="H"',
n_atoms=True)
if n_hs > 0:
tmp_molecular_system.addMissingHydrogens(pH=7.4)
tmp_molecular_system = convert(tmp_molecular_system, to_form=form_in)
else:
raise NotImplementedError
return tmp_molecular_system
def get_sequence_identity(molecular_system,
selection='all',
reference_molecular_system=None,
reference_selection='all',
syntaxis='MolSysMT',
engine='biopython'):
from molsysmt.topology.get_sequence_alignment import get_sequence_alignment
from molsysmt.basic import select
if engine == 'biopython':
# This is code from ensembler.modeling.calculate_seq_identity
# This should be implemented here importing the function but there is a conflict installing
# ensembler: ensembler is only available for python 2.7
# (https://github.com/choderalab/ensembler/blob/master/ensembler/modeling.py)
group_indices = select(molecular_system,
target='group',
selection=selection)
reference_group_indices = select(reference_molecular_system,
target='group',
selection=reference_selection)
seq, seq_ref = get_sequence_alignment(
molecular_system,
selection=selection,
reference_molecular_system=reference_molecular_system,
reference_selection=reference_selection,
syntaxis=syntaxis,
engine=engine)
intersect = []
intersect_ref = []
ii = 0
ii_ref = 0
for res, res_ref in zip(seq, seq_ref):
if res != '-' and res_ref == '-':
ii += 1
elif res == '-' and res_ref != '-':
ii_ref += 1
elif res == res_ref:
if res != '-' and res_ref != '-':
intersect.append(group_indices[ii])
intersect_ref.append(reference_group_indices[ii_ref])
ii += 1
ii_ref += 1
else:
ii += 1
ii_ref += 1
else:
raise NotImplementedError
identity = 100.0 * (len(intersect) / len(group_indices))
return identity, intersect, intersect_ref
def solvate(molecular_system,
box_geometry="truncated octahedral",
clearance='14.0 angstroms',
anion='Cl-',
num_anions="neutralize",
cation='Na+',
num_cations="neutralize",
ionic_strength='0.0 molar',
engine="LEaP",
to_form=None,
logfile=False,
verbose=False):
"""solvate(item, geometry=None, water=None, engine=None)
Methods and wrappers to create and solvate boxes
Parameters
----------
anion: 'Cl-', 'Br-', 'F-', and 'I-'
num_anions: number of cations to add. integer or "neutralize"
cation: "NA" 'Cs+', 'K+', 'Li+', 'Na+', and 'Rb+'
num_cations: number of cations to add. integer or "neutralize"
box_geometry: "cubic", "truncated_octahedral" or "rhombic_dodecahedron" (Default: "truncated_octahedral")
Returns
-------
item : bla bla
bla bla
Examples
--------
See Also
--------
Notes
-----
"""
from molsysmt.basic import get_form, convert
engine = digest_engine(engine)
to_form = digest_to_form(to_form)
if to_form is None:
to_form = get_form(molecular_system)
if engine == "OpenMM":
from openmm import Vec3
clearance = puw.convert(clearance, to_form='openmm.unit')
ionic_strength = puw.convert(ionic_strength, to_form='openmm.unit')
modeller = convert(molecular_system, to_form='openmm.Modeller')
molecular_mechanics = convert(molecular_system,
to_form='molsysmt.MolecularMechanics')
parameters = molecular_mechanics.get_openmm_System_parameters()
forcefield = molecular_mechanics.to_openmm_ForceField()
solvent_model = None
if molecular_mechanics.water_model == 'SPC':
solvent_model = 'tip3p'
elif molecular_mechanics.water_model in [
'TIP3P', 'TIP3PFB', 'SPCE', 'TIP4PEW', 'TIP4PFB', 'TIP5P'
]:
solvent_model = molecular_mechanics.water_model.lower()
else:
raise NotImplementedError()
if box_geometry == "truncated octahedral":
max_size = max(
max((pos[i] for pos in modeller.positions)) -
min((pos[i] for pos in modeller.positions)) for i in range(3))
vectors = Vec3(1.0, 0,
0), Vec3(1.0 / 3.0, 2.0 * np.sqrt(2.0) / 3.0,
0.0), Vec3(-1.0 / 3.0,
np.sqrt(2.0) / 3.0,
np.sqrt(6.0) / 3.0)
box_vectors = [(max_size + clearance) * v for v in vectors]
modeller.addSolvent(forcefield,
model=solvent_model,
boxVectors=box_vectors,
ionicStrength=ionic_strength,
positiveIon=cation,
negativeIon=anion)
elif box_geometry == "rhombic dodecahedral":
max_size = max(
max((pos[i] for pos in modeller.positions)) -
min((pos[i] for pos in modeller.positions)) for i in range(3))
vectors = Vec3(1.0, 0.0,
0.0), Vec3(0.0, 1.0,
0.0), Vec3(0.5, 0.5,
np.sqrt(2) / 2)
box_vectors = [(max_size + clearance) * v for v in vectors]
modeller.addSolvent(forcefield,
model=solvent_model,
boxVectors=box_vectors,
ionicStrength=ionic_strength,
positiveIon=cation,
negativeIon=anion)
else:
modeller.addSolvent(forcefield,
model=solvent_model,
padding=clearance,
ionicStrength=ionic_strength,
positiveIon=cation,
negativeIon=anion)
tmp_item = convert(modeller, to_form=to_form)
del (modeller)
return tmp_item
elif engine == "PDBFixer":
from openmm import Vec3
clearance = puw.convert(clearance, to_form='openmm.unit')
ionic_strength = puw.convert(ionic_strength, to_form='openmm.unit')
pdbfixer = convert(molecular_system, to_form='pdbfixer.PDBFixer')
max_size = max(
max((pos[i] for pos in pdbfixer.positions)) -
min((pos[i] for pos in pdbfixer.positions)) for i in range(3))
box_size = None
box_vectors = None
if box_geometry == "truncated octahedral":
vectors = Vec3(1.0, 0,
0), Vec3(1.0 / 3.0, 2.0 * np.sqrt(2.0) / 3.0,
0.0), Vec3(-1.0 / 3.0,
np.sqrt(2.0) / 3.0,
np.sqrt(6.0) / 3.0)
elif box_geometry == "rhombic dodecahedral":
vectors = Vec3(1.0, 0.0,
0.0), Vec3(0.0, 1.0,
0.0), Vec3(0.5, 0.5,
np.sqrt(2) / 2)
elif box_geometry == "cubic":
vectors = Vec3(1.0, 0.0, 0.0), Vec3(0.0, 1.0,
0.0), Vec3(0.0, 0.0, 1.0)
box_vectors = [(max_size + clearance) * v for v in vectors]
pdbfixer.addSolvent(boxVectors=box_vectors,
ionicStrength=ionic_strength,
positiveIon=cation,
negativeIon=anion)
tmp_item = convert(pdbfixer, to_form=to_form)
del (pdbfixer)
return tmp_item
elif engine == "LEaP":
from molsysmt.thirds.tleap import TLeap
from molsysmt._private.files_and_directories import temp_directory, temp_filename
from molsysmt.tools.file_pdb import replace_HETATM_by_ATOM_in_terminal_cappings
from shutil import rmtree, copyfile
from os import getcwd, chdir
from molsysmt.basic import set as _set, select
from molsysmt.build import has_hydrogens, remove_hydrogens
if has_hydrogens(molecular_system):
raise ValueError(
"A molecular system without hydrogen atoms is needed.")
#molecular_system = remove_hydrogens(molecular_system)
#if verbose:
# print("All Hydrogen atoms were removed to be added by LEaP\n\n")
indices_NME_C = select(
molecular_system,
target='atom',
selection='group_name=="NME" and atom_name=="C"')
with_NME_C = (len(indices_NME_C) > 0)
if with_NME_C:
_set(molecular_system,
target='atom',
selection='group_name=="NME" and atom_name=="C"',
atom_name='CH3')
current_directory = getcwd()
working_directory = temp_directory()
pdbfile_in = temp_filename(dir=working_directory, extension='pdb')
_ = convert(molecular_system, to_form=pdbfile_in)
#replace_HETATM_from_capping_atoms(pdbfile_in)
tmp_prmtop = temp_filename(dir=working_directory, extension='prmtop')
tmp_inpcrd = tmp_prmtop.replace('prmtop', 'inpcrd')
tmp_logfile = tmp_prmtop.replace('prmtop', 'leap.log')
molecular_mechanics = convert(molecular_system,
to_form='molsysmt.MolecularMechanics')
parameters = molecular_mechanics.get_leap_parameters()
forcefield = parameters['forcefield']
water = parameters['water_model']
solvent_model = None
if water == 'SPC':
solvent_model = 'SPCBOX'
elif water == 'TIP3P':
solvent_model = 'TIP3PBOX'
elif water == 'TIP4P':
solvent_model = 'TIP4PBOX'
if verbose:
print('Working directory:', working_directory)
tleap = TLeap()
tleap.load_parameters(*forcefield)
tleap.load_unit('MolecularSystem', pdbfile_in)
tleap.check_unit('MolecularSystem')
tleap.get_total_charge('MolecularSystem')
tleap.solvate('MolecularSystem',
solvent_model,
clearance,
box_geometry=box_geometry)
if num_anions != 0:
if num_anions == 'neutralize':
num_anions = 0
tleap.add_ions('MolecularSystem',
anion,
num_ions=num_anions,
replace_solvent=True)
if num_cations != 0:
if num_cations == 'neutralize':
num_cations = 0
tleap.add_ions('MolecularSystem',
cation,
num_ions=num_cations,
replace_solvent=True)
tleap.save_unit('MolecularSystem', tmp_prmtop)
errors = tleap.run(working_directory=working_directory,
verbose=verbose)
del (tleap)
if logfile:
copyfile(tmp_logfile, current_directory + '/build_peptide.log')
tmp_item = convert([tmp_prmtop, tmp_inpcrd], to_form=to_form)
if with_NME_C:
_set(tmp_item,
target='atom',
selection='group_name=="NME" and atom_name=="CH3"',
atom_name='C')
rmtree(working_directory)
return tmp_item
else:
raise NotImplementedError
def translate(molecular_system,
translation=None,
selection='all',
structure_indices='all',
syntaxis='MolSysMT',
in_place=False,
check=True):
from molsysmt.basic import get, set, select, copy, is_molecular_system
if check:
if not is_molecular_system(molecular_system):
raise MolecularSystemNeededError()
atom_indices = select(molecular_system,
selection=selection,
syntaxis=syntaxis)
coordinates = get(molecular_system,
target='atom',
indices=atom_indices,
structure_indices=structure_indices,
coordinates=True)
length_units = puw.get_unit(coordinates)
coordinates = puw.get_value(coordinates)
translation = puw.get_value(translation, to_unit=length_units)
n_atoms = coordinates.shape[1]
if type(translation) in [list, tuple]:
translation = np.array(translation)
if type(translation) == np.ndarray:
if len(translation.shape) == 1:
if translation.shape[0] == 3:
translation = np.tile(translation, (n_atoms, 1))
else:
raise ValueError('Wrong shape of translation vector')
elif len(translation.shape) == 2:
if translation.shape[1] != 3:
raise ValueError('Wrong shape of translation vector')
elif len(translation.shape) == 3:
if translation.shape[2] != 3:
raise ValueError('Wrong shape of translation vector')
if translation.shape[1] == 1:
translation = np.tile(translation, (n_atoms, 1))
coordinates += translation
coordinates = coordinates * length_units
if in_place:
return set(molecular_system,
target='atom',
indices=atom_indices,
structure_indices=structure_indices,
coordinates=coordinates)
else:
tmp_molecular_system = copy(molecular_system)
set(tmp_molecular_system,
target='atom',
indices=atom_indices,
structure_indices=structure_indices,
coordinates=coordinates)
return tmp_molecular_system
def get_distances(molecular_system,
selection="all",
groups_of_atoms=None,
group_behavior=None,
structure_indices="all",
molecular_system_2=None,
selection_2=None,
groups_of_atoms_2=None,
group_behavior_2=None,
structure_indices_2=None,
pairs=False,
crossed_frames=False,
pbc=False,
parallel=False,
output_form='tensor',
output_atom_indices=False,
output_structure_indices=False,
engine='MolSysMT',
syntaxis='MolSysMT'):
from molsysmt.structure.get_center_of_mass import get_center_of_mass
from molsysmt.structure.get_geometric_center import get_geometric_center
# group_behavior in
# ['center_of_mass','geometric_center','minimum_distance','maximum_distance']
# output_form in ['tensor','dict']
# crossed_frames es para cuando queremos calcular lista de frames1 contra lista de frames 2
# (todos con todos), si crossed_frames=False entonces es sólo el primer frame de lista 1 contra
# el primer frame de lista 2, el segundo contra el segundo, etc.
# selection groups está por si quiero distancias entre centros de masas, necesita
# hacer un lista de listas frente a otra lista de listas.
molecular_system = digest_molecular_system(molecular_system)
if molecular_system_2 is None:
same_system = True
molecular_system_2 = molecular_system
else:
same_system = False
molecular_system_2 = digest_molecular_system(molecular_system_2)
engine = digest_engine(engine)
structure_indices = digest_structure_indices(structure_indices)
structure_indices_2 = digest_structure_indices(structure_indices_2)
if group_behavior == 'minimum_distance' or group_behavior_2 == 'minimum_distance':
if group_behavior == 'minimum_distance' and group_behavior_2 == 'minimum_distance':
raise NotImplementedError(NotImplementedMessage)
#num_groups_1=len(groups_of_atoms)
#num_groups_2=len(groups_of_atoms_2)
#structure_indices = _digest_structure_indices(item, structure_indices)
#num_frames=len(structure_indices)
#dists = np.zeros((num_frames, num_groups_1, num_groups_2),dtype=float)
#for ii in range(num_groups_1):
# group1 = groups_of_atoms_2[ii]
# for jj in range(num_groups_2):
# group2 = groups_of_atoms_2[jj]
# _, min_dist = min_distances(molecular_system=molecular_system, selection=group1,
# structure_indices=structure_indices,
# selection_2=group2,
# pbc=pbc, parallel=parallel, engine=engine)
# dists[:,ii,jj]=min_dist
#del(num_groups1,num_groups2,structure_indices,num_frames,group1,group2)
#return dists
else:
raise NotImplementedError(NotImplementedMessage)
if engine == 'MolSysMT':
same_selection = False
same_groups = False
same_frames = False
if groups_of_atoms is not None:
selection = None
if (selection is not None) and (selection_2 is None):
if (groups_of_atoms_2 is None):
selection_2 = selection
same_selection = True
if groups_of_atoms is not None:
if (selection_2 is None) and (groups_of_atoms_2 is None):
groups_of_atoms_2 = groups_of_atoms
same_groups = True
if structure_indices_2 is None:
structure_indices_2 = structure_indices
same_frames = True
if selection is not None:
if group_behavior == 'center_of_mass':
coordinates_1 = get_center_of_mass(
molecular_system,
selection=selection,
structure_indices=structure_indices)
atom_indices_1 = [0]
elif group_behavior == 'geometric_center':
coordinates_1 = get_geometric_center(
molecular_system,
selection=selection,
structure_indices=structure_indices)
atom_indices_1 = [0]
else:
atom_indices_1 = select(molecular_system,
selection=selection,
syntaxis=syntaxis)
coordinates_1 = get(molecular_system,
target='atom',
indices=atom_indices_1,
structure_indices=structure_indices,
coordinates=True)
else:
if group_behavior == 'center_of_mass':
coordinates_1 = get_center_of_mass(
molecular_system,
groups_of_atoms=groups_of_atoms,
structure_indices=structure_indices)
atom_indices_1 = np.range(coordinates_1.shape[1])
elif group_behavior == 'geometric_center':
coordinates_1 = get_geometric_center(
molecular_system,
groups_of_atoms=groups_of_atoms,
structure_indices=structure_indices)
atom_indices_1 = np.arange(coordinates_1.shape[1])
else:
raise ValueError(
"Value of argument group_behavior not recognized.")
if selection_2 is not None:
if same_system and same_selection and same_frames:
atom_indices_2 = atom_indices_1
coordinates_2 = coordinates_1
else:
if group_behavior_2 == 'center_of_mass':
coordinates_2 = get_center_of_mass(
molecular_system_2,
selection=selection_2,
structure_indices=structure_indices_2)
atom_indices_2 = [0]
elif group_behavior_2 == 'geometric_center':
coordinates_2 = get_geometric_center(
molecular_system_2,
selection=selection_2,
structure_indices=structure_indices_2)
atom_indices_2 = [0]
else:
atom_indices_2 = select(molecular_system_2,
selection=selection_2,
syntaxis=syntaxis)
coordinates_2 = get(molecular_system_2,
target='atom',
indices=atom_indices_2,
structure_indices=structure_indices_2,
coordinates=True)
else:
if same_system and same_groups and same_frames:
atom_indices_2 = atom_indices_1
coordinates_2 = coordinates_1
else:
if group_behavior_2 == 'center_of_mass':
coordinates_2 = get_center_of_mass(
molecular_system_2,
groups_of_atoms=groups_of_atoms_2,
structure_indices=structure_indices_2)
atom_indices_2 = np.arange(coordinates_2.shape[1])
elif group_behavior_2 == 'geometric_center':
coordinates_2 = get_geometric_center(
molecular_system_2,
groups_of_atoms=groups_of_atoms_2,
structure_indices=structure_indices_2)
atom_indices_2 = np.arange(coordinates_2.shape[1])
else:
raise ValueError(
"Value of argument group_behavior_2 not recognized.")
diff_set = not ((same_system and same_selection and same_frames) or
(same_system and same_groups and same_frames))
length_units = puw.get_unit(coordinates_1)
coordinates_1 = np.asfortranarray(puw.get_value(coordinates_1),
dtype='float64')
coordinates_2 = np.asfortranarray(puw.get_value(coordinates_2),
dtype='float64')
nframes_1 = coordinates_1.shape[0]
nframes_2 = coordinates_2.shape[0]
nelements1 = coordinates_1.shape[1]
nelements2 = coordinates_2.shape[1]
if pbc:
box, box_shape = get(molecular_system,
target='system',
box=True,
box_shape=True,
structure_indices=structure_indices)
orthogonal = 0
if box_shape is None:
raise ValueError(
"The system has no PBC box. The input argument 'pbc' can not be True."
)
elif box_shape == 'cubic':
orthogonal = 1
else:
box = np.zeros([nframes_1, 3, 3]) * length_units
orthogonal = 1
box = np.asfortranarray(puw.get_value(box), dtype='float64')
if crossed_frames is False:
if nframes_1 != nframes_2:
raise ValueError(
"Both structure_indices and structure_indices_2 need the same number of frames."
)
else:
if pairs is False:
dists = libgeometry.distance(int(diff_set), coordinates_1,
coordinates_2, box,
orthogonal, int(pbc),
nelements1, nelements2,
nframes_1)
else:
if nframes_1 != nframes_2:
raise ValueError(
"Both selection and selection_2 need the same number of atoms."
)
else:
dists = libgeometry.distance_pairs(
coordinates_1, coordinates_2, box, orthogonal,
int(pbc), nelements1, nelements2, nframes_1)
else:
raise NotImplementedError(NotImplementedMessage)
del (coordinates_1, coordinates_2, box)
dists = dists * length_units
if output_form == 'tensor':
if output_structure_indices:
if structure_indices is 'all':
structure_indices = np.arange(nframes_1)
if structure_indices_2 is 'all':
structure_indices_2 = np.arange(nframes_2)
if output_atom_indices:
return atom_indices_1, structure_indices, atom_indices_2, structure_indices_2, dists
else:
return structure_indices, structure_indices_2, dists
elif output_atom_indices:
return atom_indices_1, atom_indices_2, dists
else:
return dists
elif output_form == 'dict':
if structure_indices is 'all':
structure_indices = np.arange(nframes_1)
if structure_indices_2 is 'all':
structure_indices_2 = np.arange(nframes_2)
if pairs is False:
if crossed_frames is False:
tmp_dict = {}
for ii in range(len(atom_indices_1)):
atom1 = atom_indices_1[ii]
tmp_dict[atom1] = {}
for jj in range(len(atom_indices_2)):
atom2 = atom_indices_2[jj]
tmp_dict[atom1][atom2] = {}
for kk in range(len(structure_indices)):
frame_index_1 = structure_indices[kk]
tmp_dict[atom1][atom2][frame_index_1] = dists[
kk, ii, jj]
return tmp_dict
else:
raise NotImplementedError(NotImplementedMessage)
else:
if crossed_frames is False:
tmp_dict = {}
for ii in range(len(atom_indices_1)):
atom1 = atom_indices_1[ii]
atom2 = atom_indices_2[ii]
if atom1 not in tmp_dict:
tmp_dict[atom1] = {}
if atom2 not in tmp_dict[atom1]:
tmp_dict[atom1][atom2] = {}
for kk in range(len(structure_indices)):
frame_index_1 = structure_indices[kk]
tmp_dict[atom1][atom2][frame_index_1] = dists[kk,
ii]
return tmp_dict
else:
raise NotImplementedError(NotImplementedMessage)
else:
raise NotImplementedError(NotImplementedMessage)
elif engine == 'MDTraj':
#tmp_item1, atom_indices1, structure_indices1, tmp_item2, atom_indices2, structure_indices2,\
#single_item, single_selection = _digest_comparison_two_systems(item, selection, frame,\
# item2, selection2, frame2,\
# form='mdtraj.Trajectory')
#if (group_behavior is None) and (group_behavior2 is None):
# if item2 is None:
# from mdtraj import compute_distances as _mdtraj_compute_distances
# tensor1_to_grid, tensor2_to_grid = np.meshgrid(atom_indices1,atom_indices2)
# pairs_list =np.vstack([tensor1_to_grid.ravel(), tensor2_to_grid.ravel()]).T
# dists = _mdtraj_compute_distances(tmp_item1,pairs_list,pbc)
# if output_form=='matrix':
# nframes=dists.shape[0]
# del(_mdtraj_compute_distances,pairs_list)
# return dists.reshape(len(atom_indices2),len(atom_indices1),nframes).T
# elif output_form=='dict':
# tmp_dict={}
# for kk in range(dists.shape[1]):
# ii=pairs_list[kk,0]
# jj=pairs_list[kk,1]
# try:
# tmp_dict[ii][jj]=dists[:,kk]
# except:
# tmp_dict[ii]={}
# tmp_dict[ii][jj]=dists[:,kk]
# del(_mdtraj_compute_distances,pairs_list)
# return tmp_dict
# else:
# raise NotImplementedError(NotImplementedMessage)
# else:
# raise NotImplementedError(NotImplementedMessage)
#else:
# raise NotImplementedError(NotImplementedMessage)
raise NotImplementedError(NotImplementedMessage)
else:
raise NotImplementedError(NotImplementedMessage)
