Beispiel #1
0
    def test_distarray(self):
        from MDAnalysis.lib.distances import distance_array
        from MDAnalysis.lib.distances import transform_StoR, transform_RtoS

        R_mol1 = transform_StoR(self.S_mol1, self.box, backend=self.backend)
        R_mol2 = transform_StoR(self.S_mol2, self.box, backend=self.backend)

        # Try with box
        dists = distance_array(R_mol1, R_mol2, box=self.box, backend=self.backend)
        # Manually calculate distance_array
        manual = np.zeros((len(R_mol1), len(R_mol2)))
        for i, Ri in enumerate(R_mol1):
            for j, Rj in enumerate(R_mol2):
                Rij = Rj - Ri
                Rij -= round(Rij[2] / self.box[2][2]) * self.box[2]
                Rij -= round(Rij[1] / self.box[1][1]) * self.box[1]
                Rij -= round(Rij[0] / self.box[0][0]) * self.box[0]
                Rij = np.linalg.norm(Rij)  # find norm of Rij vector
                manual[i][j] = Rij

        assert_almost_equal(dists, manual, self.prec,
                            err_msg="distance_array failed with box")

        # Now check using boxV
        dists = distance_array(R_mol1, R_mol2, box=self.boxV, backend=self.backend)
        assert_almost_equal(dists, manual, self.prec,
                            err_msg="distance_array failed with boxV")
Beispiel #2
0
    def process(self):

        if self.writer is not None:
            # Make liposome whole
            residues = self.lipids.residues
            for res2 in residues :
                dr = residues[0].center_of_geometry()-res2.center_of_geometry()
                dr = pbc.unwrap_vector(dr, self.processor.currbox)
                res2.set_positions(res2.get_positions()+dr)

            # Center liposome
            xyz = self.processor.currsnap._pos
            com1 = np.median(self.lipids.get_positions(),axis=0)
            for residue in self.residue_atoms :
                com2 = xyz[residue.first:residue.last+1].mean(axis=0)
                dr = pbc.unwrap_vector(com1 - com2, self.processor.currbox)
                xyz[residue.first:residue.last+1] = xyz[residue.first:residue.last+1] + dr
            delta = com1 - self.processor.currbox/2.0
            self.processor.currsnap._pos = xyz - delta

            self.writer.write(self.processor.currsnap)

        innercom = self.inner.center_of_geometry()
        outercom = self.outer.center_of_geometry()
        lipcom = np.asarray([0.5*(innercom+outercom)])
        rinner = mddist.distance_array(lipcom,self.inner.positions,None).mean()*0.1
        router = mddist.distance_array(lipcom,self.outer.positions,None).mean()*0.1
        eigval, asphericity = geo.sphericity(self.inner.positions)
        axdevinner = np.sqrt(eigval.max()/eigval.mean())*100
        eigval, asphericity = geo.sphericity(self.outer.positions)
        axdevout = np.sqrt(eigval.max()/eigval.mean())*100
        self.records.append(mdactions.MDRecord(self.processor.currtime,
            [rinner,router,rinner**2*self.innerfac,router**2*self.outerfac, axdevinner, axdevout]))
Beispiel #3
0
    def test_distarray(self):
        from MDAnalysis.lib.distances import distance_array
        from MDAnalysis.lib.distances import transform_StoR, transform_RtoS

        R_mol1 = transform_StoR(self.S_mol1, self.box)
        R_mol2 = transform_StoR(self.S_mol2, self.box)

        # Try with box
        dists = distance_array(R_mol1, R_mol2, box=self.box)
        # Manually calculate distance_array
        manual = np.zeros((len(R_mol1), len(R_mol2)))
        for i, Ri in enumerate(R_mol1):
            for j, Rj in enumerate(R_mol2):
                Rij = Rj - Ri
                Rij -= round(Rij[2] / self.box[2][2]) * self.box[2]
                Rij -= round(Rij[1] / self.box[1][1]) * self.box[1]
                Rij -= round(Rij[0] / self.box[0][0]) * self.box[0]
                Rij = np.linalg.norm(Rij)  # find norm of Rij vector
                manual[i][j] = Rij

        assert_almost_equal(dists,
                            manual,
                            self.prec,
                            err_msg="distance_array failed with box")

        # Now check using boxV
        dists = distance_array(R_mol1, R_mol2, box=self.boxV)
        assert_almost_equal(dists,
                            manual,
                            self.prec,
                            err_msg="distance_array failed with boxV")
Beispiel #4
0
    def _singleframe(self):
        distance_array(self.g1.positions, self.g2.positions, box=self.u.dimensions, result=self._result)
        # Maybe exclude same molecule distances
        if not self._exclusion_mask is None:
            self._exclusion_mask[:] = self._maxrange

        count = np.histogram(self._result, **self.rdf_settings)[0]
        self.count += count

        self.volume += self._ts.volume
def getCurvature(particledata, dimensions, cutoff=13):
    # np.set_printoptions(threshold=np.nan, linewidth=np.nan, precision=4)
    # b = np.array([1,0,0])
    # a = np.array([-0.2,1,0])
    # a1 = np.dot(a, b) / np.linalg.norm(b)
    # print(a1)
    coms = particledata.filter(['shiftx', 'shifty', 'shiftz'])
    orientations = particledata.filter(['ux', 'uy', 'uz'])
    distances_array = distance_array(coms.values, coms.values, box=dimensions)
    pairs = getPairs(distances_array, cutoff)
    origin_orientations = orientations.values[pairs[:, 0]]
    origin_connections = np.subtract(coms.values[pairs[:, 1]],
                                     coms.values[pairs[:, 0]])
    # origin_connections = np.divide(origin_connections, 10)
    projections = np.einsum(
        'ij,ij->i', origin_connections, origin_orientations
    )  # same as (origin_connections * origin_orientations).sum(axis=1) BUT FASTER
    projections_array = np.zeros_like(distances_array)
    pairs_t = pairs.T
    projections_array[tuple(pairs_t)] = projections
    projections_array[tuple([pairs_t[1], pairs_t[0]])] = projections
    sums = np.sum(projections_array, axis=1)
    nums = np.count_nonzero(projections_array, axis=1)
    averages = np.zeros_like(sums)
    averages[np.where(
        nums > 0)] = sums[np.where(nums > 0)] / nums[np.where(nums > 0)]

    coms = particledata.filter(['x', 'y', 'z'])
    distances_array = distance_array(coms.values, coms.values, box=None)
    pairs = getPairs(distances_array, cutoff)
    if len(pairs) == 0:
        return np.full((len(particledata.index), 1), np.nan, dtype=np.float32)
    origin_orientations = orientations.values[pairs[:, 0]]
    origin_connections = np.subtract(coms.values[pairs[:, 1]],
                                     coms.values[pairs[:, 0]])
    # origin_connections = np.divide(origin_connections, 10)
    projections = np.einsum(
        'ij,ij->i', origin_connections, origin_orientations
    )  # same as (origin_connections * origin_orientations).sum(axis=1) BUT FASTER
    projections_array = np.zeros_like(distances_array)
    pairs_t = pairs.T
    projections_array[tuple(pairs_t)] = projections
    projections_array[tuple([pairs_t[1], pairs_t[0]])] = projections
    _sums = np.sum(projections_array, axis=1)
    _nums = np.count_nonzero(projections_array, axis=1)
    _averages = np.zeros_like(_sums)
    _averages[np.where(
        _nums > 0)] = _sums[np.where(_nums > 0)] / nums[np.where(_nums > 0)]

    # nonan = np.where(~np.isnan(averages))
    # condition = np.where(np.logical_or(averages[nonan]<-1, averages[nonan]>1))
    condition = np.where(np.logical_or(averages < -1, averages > 1))

    averages[condition] = _averages[condition]
    return np.nan_to_num(averages)
Beispiel #6
0
    def _singleframe(self):
        distance_array(self.g1.positions,
                       self.g2.positions,
                       box=self.u.dimensions,
                       result=self._result)
        # Maybe exclude same molecule distances
        if not self._exclusion_mask is None:
            self._exclusion_mask[:] = self._maxrange

        count = np.histogram(self._result, **self.rdf_settings)[0]
        self.count += count

        self.volume += self._ts.volume
Beispiel #7
0
    def __init__(self,
                 mobiles,
                 refs,
                 method="hard_cut",
                 radius=4.5,
                 kwargs=None):
        """
        Parameters
        ----------
        mobiles : tuple(AtomGroup, AtomGroup)
            two contacting groups that change over time
        refs : tuple(AtomGroup, AtomGroup)
            two contacting atomgroups in their reference conformation. This
            can also be a list of tuples containing different atom groups
        radius : float, optional (4.5 Angstroms)
            radius within which contacts exist in refgroup
        method : string | callable (optional)
            Can either be one of ``['hard_cut' , 'soft_cut']`` or a callable
            with call signature ``func(r, r0, **kwargs)`` (the "Contacts API").
        kwargs : dict, optional
            dictionary of additional kwargs passed to `method`. Check
            respective functions for reasonable values.
        """
        universe = mobiles[0].universe
        super(Contacts, self).__init__(universe, mobiles)

        if method == 'hard_cut':
            self.fraction_contacts = hard_cut_q
        elif method == 'soft_cut':
            self.fraction_contacts = soft_cut_q
        else:
            if not callable(method):
                raise ValueError("method has to be callable")
            self.fraction_contacts = method

        # contacts formed in reference
        self.r0 = []
        self.initial_contacts = []

        if isinstance(refs[0], mda.core.groups.AtomGroup):
            refA, refB = refs
            self.r0.append(distance_array(refA.positions, refB.positions))
            self.initial_contacts.append(contact_matrix(self.r0[-1], radius))
        else:
            for refA, refB in refs:
                self.r0.append(distance_array(refA.positions, refB.positions))
                self.initial_contacts.append(
                    contact_matrix(self.r0[-1], radius))

        self.fraction_kwargs = kwargs if kwargs is not None else {}
Beispiel #8
0
def contact_matrix(coord, cutoff=15.0, returntype="numpy", box=None):
    '''Calculates a matrix of contacts within a numpy array of type float32.

    There is a fast, high-memory-usage version for small systems
    (*returntype* = 'numpy'), and a slower, low-memory-usage version for
    larger systems (*returntype* = 'sparse').

    If *box* dimensions are passed (``box = [Lx, Ly, Lz]``), then
    periodic boundary conditions are applied.  Only orthorhombic boxes
    are currently supported.

    .. versionchanged:: 0.11.0
       Keyword *suppress_progmet* and *progress_meter_freq* were removed.
    '''
    if returntype == "numpy":
        adj = (distance_array(coord, coord, box=box) < cutoff)
        return adj
    elif returntype == "sparse":
        # Initialize square List of Lists matrix of dimensions equal to number of coordinates passed
        sparse_contacts = sparse.lil_matrix((len(coord), len(coord)), dtype='bool')
        if box is not None:
            # if PBC
            contact_matrix_pbc(coord, sparse_contacts, box, cutoff)
        else:
            # if no PBC
            contact_matrix_no_pbc(coord, sparse_contacts, cutoff)
        return sparse_contacts
def isParticleInStructureEnvironment(df, attributes, dimensions, fga_mode):
    xyz = np.array(dimensions[:3])
    if fga_mode == "plane":
        plane = np.array([
            xyz / 2 - attributes["system.plane_edge"] / 2,
            xyz / 2 + attributes["system.plane_edge"] / 2
        ])
        plane[0, 2] = xyz[2] / 2 - attributes["system.ljsigma"] * 3
        plane[1, 2] = xyz[2] / 2 + attributes["system.ljsigma"] * 3
        xcond = np.logical_and(df["x"] >= plane[0, 0], df["x"] <= plane[1, 0])
        ycond = np.logical_and(df["y"] >= plane[0, 1], df["y"] <= plane[1, 1])
        zcond = np.logical_and(df["z"] >= plane[0, 2], df["z"] <= plane[1, 2])
        return np.logical_and.reduce((xcond, ycond, zcond))
    elif fga_mode == "sphere":
        center = np.array([xyz / 2])
        radius = float(
            attributes["system.ljsigma"])**(1.0 / 6) / (2.0 * np.sin(
                attributes["system.gamma"])) + attributes["system.ljsigma"] * 3
        return (distance_array(center,
                               df.filter(["x", "y", "z"]).values,
                               box=dimensions) <= radius).ravel()
    elif fga_mode == "pair":
        plane = np.array([
            xyz / 2 - attributes["system.plane_edge"] / 2,
            xyz / 2 + attributes["system.plane_edge"] / 2
        ])
        plane[0, 1] = xyz[1] / 2 - attributes["system.ljsigma"] * 3
        plane[1, 1] = xyz[1] / 2 + attributes["system.ljsigma"] * 3
        plane[0, 2] = xyz[2] / 2 - attributes["system.ljsigma"] * 3
        plane[1, 2] = xyz[2] / 2 + attributes["system.ljsigma"] * 3
        xcond = np.logical_and(df["x"] >= plane[0, 0], df["x"] <= plane[1, 0])
        ycond = np.logical_and(df["y"] >= plane[0, 1], df["y"] <= plane[1, 1])
        zcond = np.logical_and(df["z"] >= plane[0, 2], df["z"] <= plane[1, 2])
        return np.logical_and.reduce((xcond, ycond, zcond))
Beispiel #10
0
def contact_matrix(coord, cutoff=15.0, returntype="numpy", box=None):
    '''Calculates a matrix of contacts within a numpy array of type float32.

    There is a fast, high-memory-usage version for small systems
    (*returntype* = 'numpy'), and a slower, low-memory-usage version for
    larger systems (*returntype* = 'sparse').

    If *box* dimensions are passed (``box = [Lx, Ly, Lz]``), then
    periodic boundary conditions are applied.  Only orthorhombic boxes
    are currently supported.

    .. versionchanged:: 0.11.0
       Keyword *suppress_progmet* and *progress_meter_freq* were removed.
    '''
    if returntype == "numpy":
        adj = (distance_array(coord, coord, box=box) < cutoff)
        return adj
    elif returntype == "sparse":
        # Initialize square List of Lists matrix of dimensions equal to number of coordinates passed
        sparse_contacts = sparse.lil_matrix((len(coord), len(coord)),
                                            dtype='bool')
        if box is not None:
            # if PBC
            contact_matrix_pbc(coord, sparse_contacts, box, cutoff)
        else:
            # if no PBC
            contact_matrix_no_pbc(coord, sparse_contacts, cutoff)
        return sparse_contacts
Beispiel #11
0
def make_correspondance_by_position2(clusters_prev, clusters_curr, to_group):
    if not clusters_prev:
        return clusters_curr[:ARGS.to_keep]

    kept_clusters = []

    com_prev = np.array(
        [cluster_center_of_mass(c, to_group) for c in clusters_prev])
    com_curr = np.array(
        [cluster_center_of_mass(c, to_group) for c in clusters_curr])

    dist_matrix = distances.distance_array(com_prev, com_curr)

    for i, dist in enumerate(dist_matrix):
        closest_cluster = np.where(dist == min(dist))[0]

        if len(closest_cluster) > 1:
            logging.warn(
                f"More than one same center of mass distance for cluster {i} correspondance. Assign the first."
            )

        if len(clusters_curr[closest_cluster[0]].residues) < 150:
            print("OOOO")
        kept_clusters.append(clusters_curr[closest_cluster[0]])

    return kept_clusters
Beispiel #12
0
    def test_pbc_dist(self):
        from MDAnalysis.lib.distances import distance_array

        results = np.array([[37.629944]])

        dists = distance_array(self.S_mol1, self.S_mol2, box=self.boxV)

        assert_almost_equal(dists, results, self.prec, err_msg="distance_array failed to retrieve PBC distance")
Beispiel #13
0
 def get_contact_sum(self, i, l):
     """A method for checking if selection exists"""
     Ci = -1 
     selection = self.get_contacts(i, l)
     if selection:
         r_ij = distance_array(self.reference.coordinates(), self.close_contacts.coordinates())
         Ci = numpy.sum(numpy.exp(-1 * (r_ij / self.r_eff))) 
     return Ci
Beispiel #14
0
def distance():
    segA = u.segments[0]
    r50 = segA.atoms.select_atoms('resid 50')
    r60 = segA.atoms.select_atoms('resid 60')

    da = distance_array(r50.positions, r60.positions)

    return da.min()
Beispiel #15
0
def contact_matrix(coord, cutoff=15.0, returntype="numpy", box=None):
    '''Calculates a matrix of contacts.

    There is a fast, high-memory-usage version for small systems
    (*returntype* = 'numpy'), and a slower, low-memory-usage version for
    larger systems (*returntype* = 'sparse').

    If *box* dimensions are passed then periodic boundary conditions
    are applied.

    Parameters
    ---------
    coord : array
       Array of coordinates of shape ``(N, 3)`` and dtype float32.
    cutoff : float, optional, default 15
       Particles within `cutoff` are considered to form a contact.
    returntype : string, optional, default "numpy"
       Select how the contact matrix is returned.
       * ``"numpy"``: return as an ``(N. N)`` :class:`numpy.ndarray`
       * ``"sparse"``: return as a :class:`scipy.sparse.lil_matrix`
    box : array-like or ``None``, optional, default ``None``
       Simulation cell dimensions in the form of
       :attr:`MDAnalysis.trajectory.base.Timestep.dimensions` when
       periodic boundary conditions should be taken into account for
       the calculation of contacts.

    Returns
    -------
    array or sparse matrix
       The contact matrix is returned in a format determined by the `returntype`
       keyword.

    See Also
    --------
    :mod:`MDAnalysis.analysis.contacts` for native contact analysis


    .. versionchanged:: 0.11.0
       Keyword *suppress_progmet* and *progress_meter_freq* were removed.
    '''

    if returntype == "numpy":
        adj = (distance_array(coord, coord, box=box) < cutoff)
        return adj
    elif returntype == "sparse":
        # Initialize square List of Lists matrix of dimensions equal to number
        # of coordinates passed
        sparse_contacts = scipy.sparse.lil_matrix((len(coord), len(coord)),
                                                  dtype='bool')
        if box is not None:
            # with PBC
            contact_matrix_pbc(coord, sparse_contacts, box, cutoff)
        else:
            # without PBC
            contact_matrix_no_pbc(coord, sparse_contacts, cutoff)
        return sparse_contacts
Beispiel #16
0
    def test_point(self):
        ag = self.universe.select_atoms('point 5.0 5.0 5.0 3.5')

        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           self.universe.atoms.positions,
                           box=self.universe.dimensions)

        idx = np.where(d < 3.5)[1]

        assert_equal(set(ag.indices), set(idx))
    def test_point(self):
        ag = self.universe.select_atoms('point 5.0 5.0 5.0 3.5')

        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           self.universe.atoms.positions,
                           box=self.universe.dimensions)

        idx = np.where(d < 3.5)[1]

        assert_equal(set(ag.indices), set(idx))
Beispiel #18
0
def dist_measure(sel1, sel2):
    """
        This function outputs the minimum measured distance between the two input selections.
    """
    from numpy import min as npmin

    return npmin(
        mdadist.distance_array(sel1.positions,
                               sel2.positions,
                               backend='OpenMP'))
    def test_sphlayer(self, u):
        r1 = u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        ag = u.select_atoms('sphlayer 2.4 6.0 resid 1')

        d = distance_array(u.atoms.positions, cog, box=u.dimensions)
        idx = set(np.where((d > 2.4) & (d < 6.0))[0])

        assert idx == set(ag.indices)
    def test_sphzone(self):
        r1 = self.u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        ag = self.u.select_atoms('sphzone 5.0 resid 1')

        d = distance_array(self.u.atoms.positions, cog, box=self.box)
        idx = set(np.where(d < 5.0)[0])

        assert_(idx == set(ag.indices))
Beispiel #21
0
    def test_pbc_dist(self):
        from MDAnalysis.lib.distances import distance_array

        results = np.array([[37.629944]])

        dists = distance_array(self.S_mol1, self.S_mol2, box=self.boxV,
                               backend=self.backend)

        assert_almost_equal(dists, results, self.prec,
                            err_msg="distance_array failed to retrieve PBC distance")
Beispiel #22
0
    def test_sphlayer(self, u):
        r1 = u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        ag = u.select_atoms('sphlayer 2.4 6.0 resid 1')

        d = distance_array(u.atoms.positions, cog, box=u.dimensions)
        idx = set(np.where((d > 2.4) & (d < 6.0))[0])

        assert idx == set(ag.indices)
Beispiel #23
0
    def test_sphzone(self):
        r1 = self.u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        ag = self.u.select_atoms('sphzone 5.0 resid 1')

        d = distance_array(self.u.atoms.positions, cog, box=self.box)
        idx = set(np.where(d < 5.0)[0])

        assert_(idx == set(ag.indices))
Beispiel #24
0
def contact_matrix(coord, cutoff=15.0, returntype="numpy", box=None):
    '''Calculates a matrix of contacts.

    There is a fast, high-memory-usage version for small systems
    (*returntype* = 'numpy'), and a slower, low-memory-usage version for
    larger systems (*returntype* = 'sparse').

    If *box* dimensions are passed then periodic boundary conditions
    are applied.

    Parameters
    ---------
    coord : array
       Array of coordinates of shape ``(N, 3)`` and dtype float32.
    cutoff : float, optional, default 15
       Particles within `cutoff` are considered to form a contact.
    returntype : string, optional, default "numpy"
       Select how the contact matrix is returned.
       * ``"numpy"``: return as an ``(N. N)`` :class:`numpy.ndarray`
       * ``"sparse"``: return as a :class:`scipy.sparse.lil_matrix`
    box : array-like or ``None``, optional, default ``None``
       Simulation cell dimensions in the form of
       :attr:`MDAnalysis.trajectory.base.Timestep.dimensions` when
       periodic boundary conditions should be taken into account for
       the calculation of contacts.

    Returns
    -------
    array or sparse matrix
       The contact matrix is returned in a format determined by the `returntype`
       keyword.

    See Also
    --------
    :mod:`MDAnalysis.analysis.contacts` for native contact analysis


    .. versionchanged:: 0.11.0
       Keyword *suppress_progmet* and *progress_meter_freq* were removed.
    '''

    if returntype == "numpy":
        adj = (distance_array(coord, coord, box=box) < cutoff)
        return adj
    elif returntype == "sparse":
        # Initialize square List of Lists matrix of dimensions equal to number
        # of coordinates passed
        sparse_contacts = scipy.sparse.lil_matrix((len(coord), len(coord)), dtype='bool')
        if box is not None:
            # with PBC
            contact_matrix_pbc(coord, sparse_contacts, box, cutoff)
        else:
            # without PBC
            contact_matrix_no_pbc(coord, sparse_contacts, cutoff)
        return sparse_contacts
Beispiel #25
0
    def sample(self, g1=None, g2=None, kargs1=None, kargs2=None):
        kargs1 = kargs1 or {}
        kargs2 = kargs2 or {}
        self.n_frames += 1
        self.g2 = g2
        if g1 is not None:
            self.g1 = g1
        if g2 is None:
            self.g2 = self.g1  # all atoms by default (see __init__)
        ka1 = self.kargs1.copy()
        ka1.update(kargs1)
        ka2 = self.kargs2.copy()
        ka2.update(kargs2)
        if self.observable is not None:
            # determine weights, otherwise assumes number of atoms (default)
            fg1, fg2, error = self._compute_observable(ka1, ka2)

            if error is True:
                raise Exception(
                    "Error, the observable passed to RDF should output "
                    "an array (of scalar or vectors) the same size of "
                    "the group")

            # numpy.histogram accepts negative weights
            self.rdf_settings['weights'] = self._determine_weights(fg1, fg2)

        # This still uses MDA's distance_array. Pro: works also in triclinic
        # boxes. Con: could be faster (?)
        _distances = np.zeros((len(self.g1), len(self.g2)), dtype=np.float64)
        distances.distance_array(
            self.g1.positions,
            self.g2.positions,
            box=self.universe.dimensions,
            result=_distances)

        count = np.histogram(_distances, **self.rdf_settings)[0]
        self.count += count

        box = self.universe.dimensions
        self.volume += np.product(box[:3])
        self.nsamples += 1
        self.n_squared += len(self.g1) * len(self.g2)
    def test_around(self):
        r1 = self.u.select_atoms('resid 1')

        ag = self.u.select_atoms('around 5.0 resid 1')

        d = distance_array(self.u.atoms.positions, r1.positions, box=self.box)
        idx = set(np.where(d < 5.0)[0])

        # Around doesn't include atoms from the reference group
        idx.difference_update(set(r1.indices))
        assert_(idx == set(ag.indices))
    def test_point_1(self):
        # The example selection
        ag = self.u.select_atoms('point 5.0 5.0 5.0 3.5')

        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           self.u.atoms.positions,
                           box=self.box)

        idx = np.where(d < 3.5)[1]

        assert_equal(set(ag.indices), set(idx))
Beispiel #28
0
    def test_point_1(self):
        # The example selection
        ag = self.u.select_atoms('point 5.0 5.0 5.0 3.5')

        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           self.u.atoms.positions,
                           box=self.box)

        idx = np.where(d < 3.5)[1]

        assert_equal(set(ag.indices), set(idx))
Beispiel #29
0
    def test_around(self):
        r1 = self.u.select_atoms('resid 1')

        ag = self.u.select_atoms('around 5.0 resid 1')

        d = distance_array(self.u.atoms.positions, r1.positions, box=self.box)
        idx = set(np.where(d < 5.0)[0])

        # Around doesn't include atoms from the reference group
        idx.difference_update(set(r1.indices))
        assert_(idx == set(ag.indices))
    def test_spherical_zone(self, u, meth, periodic):
        sel = Parser.parse('sphzone 5.0 resid 1', u.atoms)
        sel = self.choosemeth(sel, meth, periodic)
        result = sel.apply(u.atoms)

        r1 = u.select_atoms('resid 1')
        box = u.dimensions if periodic else None
        cog = r1.center_of_geometry(pbc=periodic).reshape(1, 3)
        d = distance_array(u.atoms.positions, cog, box=box)
        ref = set(np.where(d < 5.0)[0])

        assert ref == set(result.indices)
Beispiel #31
0
 def _add_bonds(self):
     positions = fmutils.AverageStructure(self.atu.atoms).run().result
     distmat = distance_array(positions, positions, backend="OpenMP")
     if self._rmin > 0.:
         a0, a1 = np.where((distmat >= self._rmin)
                           & (distmat <= self._rmax))
     else:
         a0, a1 = np.where((distmat > self._rmin) & (distmat <= self._rmax))
     bonds = topologyattrs.Bonds(
         set([(x, y) for x, y in zip(a0, a1) if y > x]))
     self._topology.add_TopologyAttr(bonds)
     self._generate_from_topology()
    def _check_point(self, meth, periodic):
        sel = Parser.parse('point 5.0 5.0 5.0  3.0', self.u.atoms)
        sel = self.choosemeth(sel, meth, periodic)
        result = sel.apply(self.u.atoms)

        box = self.u.dimensions if periodic else None
        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           self.u.atoms.positions,
                           box=box)
        ref = set(np.where(d < 3.0)[1])

        assert_(ref == set(result.indices))
Beispiel #33
0
    def _check_point(self, meth, periodic):
        sel = Parser.parse('point 5.0 5.0 5.0  3.0', self.u.atoms)
        sel = self.choosemeth(sel, meth, periodic)
        result = sel.apply(self.u.atoms)

        box = self.u.dimensions if periodic else None
        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           self.u.atoms.positions,
                           box=box)
        ref = set(np.where(d < 3.0)[1])

        assert_(ref == set(result.indices))
Beispiel #34
0
    def test_point_2(self):
        ag1 = self.u.atoms[:10000]

        ag2 = ag1.select_atoms('point 5.0 5.0 5.0 3.5')

        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           ag1.positions,
                           box=self.box)

        idx = np.where(d < 3.5)[1]

        assert_equal(set(ag2.indices), set(idx))
    def test_point_2(self):
        ag1 = self.u.atoms[:10000]

        ag2 = ag1.select_atoms('point 5.0 5.0 5.0 3.5')

        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           ag1.positions,
                           box=self.box)

        idx = np.where(d < 3.5)[1]

        assert_equal(set(ag2.indices), set(idx))
Beispiel #36
0
    def _check_spherical_layer(self, meth, periodic):
        sel = Parser.parse('sphlayer 2.4 6.0 resid 1', self.u.atoms)
        sel = self.choosemeth(sel, meth, periodic)
        result = sel.apply(self.u.atoms)

        r1 = self.u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        box = self.u.dimensions if periodic else None
        d = distance_array(self.u.atoms.positions, cog, box=box)
        ref = set(np.where((d > 2.4) & (d < 6.0))[0])

        assert_(ref == set(result.indices))
    def _check_spherical_zone(self, meth, periodic):
        sel = Parser.parse('sphzone 5.0 resid 1', self.u.atoms)
        sel = self.choosemeth(sel, meth, periodic)
        result = sel.apply(self.u.atoms)

        r1 = self.u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        box = self.u.dimensions if periodic else None
        d = distance_array(self.u.atoms.positions, cog, box=box)
        ref = set(np.where(d < 5.0)[0])

        assert_(ref == set(result.indices))
Beispiel #38
0
 def test_pbc_wrong_wassenaar_distance(self, backend):
     from MDAnalysis.lib.distances import distance_array
     box = MDAnalysis.lib.mdamath.triclinic_vectors([2, 2, 2, 60, 60, 60])
     a, b, c = box
     point_a = a + b
     point_b = .5 * point_a
     dist = distance_array(point_a[np.newaxis, :],
                           point_b[np.newaxis, :],
                           box=box,
                           backend=backend)
     assert_almost_equal(dist[0, 0], 1)
     # check that our distance is different then the wassenaar distance as
     # expected.
     assert np.linalg.norm(point_a - point_b) != dist[0, 0]
Beispiel #39
0
def static_SAS(system, dict):
    """Uses system without trajectory to return SAS. No CHICOs input."""

    # Location check
    print "Pre-initialising relevant variables and arrays...\n"
    print "Warning: SAS is a score based on NACHOs. Please make sure you understand the concept before using " \
          "any potential results.\n"

    # Create variable SAS
    global SAS
    SAS = 0

    global minDistDict
    minDistDict = {}

    for key in dict:

        # Assign row values to variables and convert to strings
        resid1 = str("resid %s and not name H*") % dict[key][0]
        resid2 = str("resid %s and not name H*") % dict[key][1]

        # Debug statement
        # Check if code is assigning strings correctly
        # print resid1, resid2

        # Grab coordinates from resid variables. WARNING: get_positions() will change in MDAnalysis 16.0!
        coords1 = system.select_atoms(resid1).get_positions()
        coords2 = system.select_atoms(resid2).get_positions()

        # Pass coords variables to cdists.distance_array function
        ContactsMatrix = cdists.distance_array(coords1, coords2)

        # Append minimum to minDistArray
        minDistDict[key] = np.amin(ContactsMatrix)

        # Restore ContactsMatrix to 0, or it will get confused.
        ContactsMatrix = 0

    # Take output from minDistArray
    if minDistDict is not None:
        for key in minDistDict:
            # Enter the arbitrary score: SAS (System Activation Score)
            if key < 8:
                if minDistDict[key] < args.cutoff:
                    SAS -= 1
            elif key > 7:
                if minDistDict[key] < args.cutoff:
                    SAS += 1

    return minDistDict, SAS
    def test_point(self, u, periodic):
        sel = Parser.parse('point 5.0 5.0 5.0  3.0', u.atoms)
        if periodic:
            sel.periodic = True
        else:
            sel.periodic = False
        result = sel.apply(u.atoms)

        box = u.dimensions if periodic else None
        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           u.atoms.positions,
                           box=box)
        ref = set(np.where(d < 3.0)[1])

        assert ref == set(result.indices)
Beispiel #41
0
    def test_point(self, u, periodic):
        sel = Parser.parse('point 5.0 5.0 5.0  3.0', u.atoms)
        if periodic:
            sel.periodic = True
        else:
            sel.periodic = False
        result = sel.apply(u.atoms)

        box = u.dimensions if periodic else None
        d = distance_array(np.array([[5.0, 5.0, 5.0]], dtype=np.float32),
                           u.atoms.positions,
                           box=box)
        ref = set(np.where(d < 3.0)[1])

        assert ref == set(result.indices)
Beispiel #42
0
    def _check_around(self, meth, periodic):
        sel = Parser.parse('around 5.0 resid 1', self.u.atoms)
        sel = self.choosemeth(sel, meth, periodic)
        result = sel.apply(self.u.atoms)

        r1 = self.u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        box = self.u.dimensions if periodic else None
        d = distance_array(self.u.atoms.positions, r1.positions, box=box)
        ref = set(np.where(d < 5.0)[0])

        # Around doesn't include atoms from the reference group
        ref.difference_update(set(r1.indices))
        assert_(ref == set(result.indices))
Beispiel #43
0
    def compute(self, inp, *args, **kwarg):
        # TODO generalise to set of points?
        """Compute the observable.

        :param AtomGroup inp:  the input atom group
        :returns: atomic positions

        """
        inp = self._to_atomgroup(inp)
        inp2 = self._to_atomgroup(args[0])
        mask = np.asarray([0., 0., 0])
        mask[self.dirmask] = 1.0
        return distances.distance_array(
            inp.positions * mask,
            inp2.positions * mask,
            box=inp.universe.dimensions).ravel()
Beispiel #44
0
    def test_spherical_layer(self, u, periodic):
        sel = Parser.parse('sphlayer 2.4 6.0 resid 1', u.atoms)
        if periodic:
            sel.periodic = True
        else:
            sel.periodic = False

        result = sel.apply(u.atoms)

        r1 = u.select_atoms('resid 1')
        box = u.dimensions if periodic else None
        cog = r1.center_of_geometry().reshape(1, 3)
        d = distance_array(u.atoms.positions, cog, box=box)
        ref = set(np.where((d > 2.4) & (d < 6.0))[0])

        assert ref == set(result.indices)
    def test_spherical_zone(self, u, periodic):
        sel = Parser.parse('sphzone 5.0 resid 1', u.atoms)
        if periodic:
            sel.periodic = True
        else:
            sel.periodic = False

        result = sel.apply(u.atoms)

        r1 = u.select_atoms('resid 1')
        box = u.dimensions if periodic else None
        cog = r1.center_of_geometry().reshape(1, 3)
        d = distance_array(u.atoms.positions, cog, box=box)
        ref = set(np.where(d < 5.0)[0])

        assert ref == set(result.indices)
    def _check_around(self, meth, periodic):
        sel = Parser.parse('around 5.0 resid 1', self.u.atoms)
        sel = self.choosemeth(sel, meth, periodic)
        result = sel.apply(self.u.atoms)

        r1 = self.u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        box = self.u.dimensions if periodic else None
        d = distance_array(self.u.atoms.positions, r1.positions,
                           box=box)
        ref = set(np.where(d < 5.0)[0])

        # Around doesn't include atoms from the reference group
        ref.difference_update(set(r1.indices))
        assert_(ref == set(result.indices))
Beispiel #47
0
def generate_contacts(
        universe,
        selection,
        upper_cutoff=6.0,
        lower_cutoff=0.0,
        resid_separation=3
    ):

    gr = universe.select_atoms(selection)
    distances = cdists.distance_array(gr.positions, gr.positions)

    triu = np.triu(distances)
    mask = np.argwhere((triu < upper_cutoff) & (triu > lower_cutoff))

    contacts = [(atom1, atom2) for atom1, atom2 in mask \
        if not abs(gr.atoms[atom1].resid - gr.atoms[atom2].resid) <= resid_separation]
    return gr, triu, set([ frozenset(pair) for pair in contacts ])
Beispiel #48
0
 def _add_bonds(self):
     print(self.atu.bonds)
     positions = fmutils.AverageStructure(self.atu.atoms).run().result
     distmat = distance_array(positions, positions, backend="OpenMP")
     if self._rmin > 0.:
         a0, a1 = np.where((distmat >= self._rmin)
                           & (distmat <= self._rmax))
     else:
         print(self._rmax)
         a0, a1 = np.where((distmat > self._rmin) & (distmat <= self._rmax))
     skeleton_bonds = set([(skeleton[0].ix, skeleton[1].ix)
                           for skeleton in self.atu.bonds])
     rmax_bonds = set([(x, y) for x, y in zip(a0, a1) if y > x])
     all_bonds = skeleton_bonds.union(rmax_bonds)
     bonds = topologyattrs.Bonds(all_bonds)
     self._topology.add_TopologyAttr(bonds)
     self._generate_from_topology()
    def test_around(self, u, periodic):
        sel = Parser.parse('around 5.0 resid 1', u.atoms)
        if periodic:
            sel.periodic = True
        else:
            sel.periodic = False

        result = sel.apply(u.atoms)

        r1 = u.select_atoms('resid 1')
        cog = r1.center_of_geometry().reshape(1, 3)

        box = u.dimensions if periodic else None
        d = distance_array(u.atoms.positions, r1.positions,
                           box=box)
        ref = set(np.where(d < 5.0)[0])

        # Around doesn't include atoms from the reference group
        ref.difference_update(set(r1.indices))
        assert ref == set(result.indices)
Beispiel #50
0
    def _single_run(self, start, stop):
        """Perform a single pass of the trajectory"""
        self.u.trajectory[start]

        # Calculate partners at t=0
        box = self.u.dimensions if self.pbc else None

        # 2d array of all distances
        d = distance_array(self.h.positions, self.a.positions, box=box)
        if self.exclusions:
            # set to above dist crit to exclude
            d[self.exclusions] = self.d_crit + 1.0

        # find which partners satisfy distance criteria
        hidx, aidx = numpy.where(d < self.d_crit)

        a = calc_angles(self.d.positions[hidx], self.h.positions[hidx],
                        self.a.positions[aidx], box=box)
        # from amongst those, who also satisfiess angle crit
        idx2 = numpy.where(a > self.a_crit)
        hidx = hidx[idx2]
        aidx = aidx[idx2]

        nbonds = len(hidx)  # number of hbonds at t=0
        results = numpy.zeros_like(numpy.arange(start, stop, self._skip),
                                   dtype=numpy.float32)

        if self.time_cut:
            # counter for time criteria
            count = numpy.zeros(nbonds, dtype=numpy.float64)

        for i, ts in enumerate(self.u.trajectory[start:stop:self._skip]):
            box = self.u.dimensions if self.pbc else None

            d = calc_bonds(self.h.positions[hidx], self.a.positions[aidx],
                           box=box)
            a = calc_angles(self.d.positions[hidx], self.h.positions[hidx],
                            self.a.positions[aidx], box=box)

            winners = (d < self.d_crit) & (a > self.a_crit)
            results[i] = winners.sum()

            if self.bond_type is 'continuous':
                # Remove losers for continuous definition
                hidx = hidx[numpy.where(winners)]
                aidx = aidx[numpy.where(winners)]
            elif self.bond_type is 'intermittent':
                if self.time_cut:
                    # Add to counter of where losers are
                    count[~ winners] += self._skip * self.u.trajectory.dt
                    count[winners] = 0  # Reset timer for winners

                    # Remove if you've lost too many times
                    # New arrays contain everything but removals
                    hidx = hidx[count < self.time_cut]
                    aidx = aidx[count < self.time_cut]
                    count = count[count < self.time_cut]
                else:
                    pass

            if len(hidx) == 0:  # Once everyone has lost, the fun stops
                break

        results /= nbonds

        return results
Beispiel #51
0
def distance():
    segA = u.segments[0]
    r50 = segA.atoms.select_atoms("resid 50")
    r60 = segA.atoms.select_atoms("resid 60")
    da = distance_array(r50.positions, r60.positions)
    return da.min()
Beispiel #52
0
def main():
    ap = argparse.ArgumentParser(description='Calculate Vina score for a static conformation')
    ap.add_argument('receptor', help='PDBQT file for receptor')
    ap.add_argument('ligand', help='PDBQT file for ligand, positioned where you want it relative to receptor')
    args = ap.parse_args()

    # Load receptor and ligand
    # This will take damn near forever due to guessing bonds
    ligand_u = mda.Universe(args.ligand, guess_bonds=True, vdwradii=autodock_vdw_radii)
    receptor_u = mda.Universe(args.receptor, guess_bonds=True, vdwradii=autodock_vdw_radii)

    # Vina score is described in: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3041641
    # We are only calculating the c_inter component

    # Calculate distance matrix
    dists = mdadist.distance_array(receptor_u.atoms.positions, ligand_u.atoms.positions)

    # Calculate d_ij, which is just the distance minus the vdW radii of the two atoms
    # I'm sure this is incredibly slow and there is some fast numpy array way to do this.
    # Probably by pre-assembling arrays of vdW radii and doing array subtractions.
    dij = dists.copy()
    hydrophobic_mask = np.zeros_like(dists)
    hbond_mask = np.zeros_like(dists)
    for r_i in range(len(receptor_u.atoms)):
        for l_i in range(len(ligand_u.atoms)):
            r_atom = receptor_u.atoms[r_i]
            l_atom = ligand_u.atoms[l_i]
            r_vdw = atom_kind_data[r_atom.type][RADIUS]
            l_vdw = atom_kind_data[l_atom.type][RADIUS]
            dij[r_i, l_i] -= r_vdw
            dij[r_i, l_i] -= l_vdw
            # If both atoms are hydrophobic, we care about their hydrophobic interaction score
            if r_atom.type in hydrophobic_atom_types and l_atom.type in hydrophobic_atom_types:
                hydrophobic_mask[r_i, l_i] = 1
            # Determine which atoms are involved in H-bonds
            if could_hbond(r_atom, l_atom):
                hbond_mask[r_i, l_i] = 1

    print('There are {} atom pairs in total'.format(len(receptor_u.atoms)*len(ligand_u.atoms)))
    print('{} atom pairs have hydrophobic interactions'.format(int(np.sum(hydrophobic_mask))))
    print('{} atom pairs can H-bond'.format(int(np.sum(hbond_mask))))

    # Calculate gauss1 component of score. Weight = -0.0356
    #   gauss1(d) = exp(-(d/0.5)^2)
    gauss1 = np.exp(-np.square(dij/0.5))

    # Calculate gauss2 component of score. Weight = -0.00516
    #   gauss2(d) = exp(-((d-3)/2)^2)
    gauss2 = np.exp(-np.square((dij-3.0)/2))

    # Calculate repulsion component of score. Weight = 0.840
    #   repulsion(d) = d^2 if d < 0, or 0 otherwise
    repulsion = np.square(np.clip(dij, a_min=None, a_max=0.0))

    # Calculate hydrophobic component of score. Weight = -0.0351
    # Both atoms must be hydrophobic or score is zero.
    #    hydrophobic(d) = 1 when d < 0.5
    #                   = 0 when d > 1.5
    #                   = linearly interpolated between these values otherwise
    hydrophobic = np.clip(1.5-dij, a_min=0.0, a_max=1.0)
    hydrophobic *= hydrophobic_mask

    # Calculate H-bonding component of score. Weight = -0.587
    #    hbond(d) = 1 when d < -0.7
    #             = 0 when d > 0
    #             = linearly interpolated between these values otherwise
    hbond = np.clip(-10*dij/7, a_min=0.0, a_max=1.0)
    hbond *= hbond_mask

    # Distance cutoff is 8A in Vina
    dist_cutoff_mask = np.zeros_like(dists)
    dist_cutoff_mask[dists <= 8] = 1

    gauss1 *= dist_cutoff_mask
    gauss2 *= dist_cutoff_mask
    repulsion *= dist_cutoff_mask
    hydrophobic *= dist_cutoff_mask
    hbond *= dist_cutoff_mask

    print('Gauss1: {}'.format(GAUSS1_WEIGHT*np.sum(gauss1)))
    print('Gauss2: {}'.format(GAUSS2_WEIGHT*np.sum(gauss2)))
    print('Repuls: {}'.format(REPULSION_WEIGHT*np.sum(repulsion)))
    print('Hphobc: {}'.format(HYDROPHOBIC_WEIGHT*np.sum(hydrophobic)))
    print('H-bond: {}'.format(HBOND_WEIGHT*np.sum(hbond)))

    c_inter = GAUSS1_WEIGHT*np.sum(gauss1) + \
        GAUSS2_WEIGHT*np.sum(gauss2) + \
        REPULSION_WEIGHT*np.sum(repulsion) + \
        HYDROPHOBIC_WEIGHT*np.sum(hydrophobic) + \
        HBOND_WEIGHT*np.sum(hbond)

    print(c_inter)
def contact_matrix(coord, cutoff=15.0, returntype="numpy", box=None):
    '''Calculates a matrix of contacts.

    There is a fast, high-memory-usage version for small systems
    (*returntype* = 'numpy'), and a slower, low-memory-usage version for
    larger systems (*returntype* = 'sparse').

    If *box* dimensions are passed then periodic boundary conditions
    are applied.

    Parameters
    ---------
    coord : array
       Array of coordinates of shape ``(N, 3)`` and dtype float32.
    cutoff : float, optional, default 15
       Particles within `cutoff` are considered to form a contact.
    returntype : string, optional, default "numpy"
       Select how the contact matrix is returned.
       * ``"numpy"``: return as an ``(N. N)`` :class:`numpy.ndarray`
       * ``"sparse"``: return as a :class:`scipy.sparse.lil_matrix`
    box : array-like or ``None``, optional, default ``None``
       Simulation cell dimensions in the form of
       :attr:`MDAnalysis.trajectory.base.Timestep.dimensions` when
       periodic boundary conditions should be taken into account for
       the calculation of contacts.

    Returns
    -------
    array or sparse matrix
       The contact matrix is returned in a format determined by the `returntype`
       keyword.


    Note
    ----
    :module:`scipy.sparse` is require for using *sparse* matrices; if it cannot
    be imported then an `ImportError` is raised.

    .. versionchanged:: 0.11.0
       Keyword *suppress_progmet* and *progress_meter_freq* were removed.

    '''

    if returntype == "numpy":
        adj = (distance_array(coord, coord, box=box) < cutoff)
        return adj
    elif returntype == "sparse":
        if sparse is None:
            # hack: if we are running with minimal dependencies then scipy was
            #       not imported and we have to bail here (see scipy import at top)
            raise ImportError("For sparse matrix functionality you need to "
                              "import scipy.")
        # Initialize square List of Lists matrix of dimensions equal to number
        # of coordinates passed
        sparse_contacts = sparse.lil_matrix((len(coord), len(coord)), dtype='bool')
        if box is not None:
            # with PBC
            contact_matrix_pbc(coord, sparse_contacts, box, cutoff)
        else:
            # without PBC
            contact_matrix_no_pbc(coord, sparse_contacts, cutoff)
        return sparse_contacts
Beispiel #54
0
def anal_jointdist(prot,rfirst,mols,cutoff,midz,box,mat,matburr,buried=None) :
  """
  Calculates the joint probability of residue interactions

  Parameters
  ----------
  prot : AtomSelection
    the protein atoms
  rfirst : NumpyArray
    the first atom of each residue in the protein
  mols : NumpyArray
    the centroid of the molecule of interest
  cutoff : float
    the contact cut-off
  midz : float
    the middle of the bilayer
  box : NumpyArray
    the box sides
  mat : NumpyArray
    the joint probability for non-buried molecules
  matburr : NumpyArray
    the joint probability for buried molecules
  buried : NumpyArray of boolean, optional
    flag to indicate buried molecule
  """
  imat = np.zeros(mat.shape)
  imatburr = np.zeros(matburr.shape)

  # Calculate all distances at once
  if box is not None :
    dist_all = distances.distance_array(np.array(mols), prot.get_positions(), box)
  else :
    kdtree = KDTree(dim=3, bucket_size=10)
    kdtree.set_coords(prot.get_positions())

  # Loop over all molecules
  for mi,mol in enumerate(mols) :
    if box is not None :
      dist = dist_all[mi,:]
    else :
      dist = np.ones(prot.get_positions().shape[0])+cutoff
      kdtree.search(np.array([mol]), cutoff)
      for i in kdtree.get_indices() : dist[i] = 0.0

    # Check if this molecule is on
    if dist.min() >= cutoff : continue

    # Check contacts for reach residue
    for i in range(len(rfirst)-1) :
      if dist[rfirst[i]:rfirst[i+1]].min() >= cutoff : continue
      if (buried is not None and buried[mi]) :
        imatburr[i,i] = 1
      else :
        imat[i,i] = 1

      for j in range(i+1,len(rfirst)-1) :
        if dist[rfirst[j]:rfirst[j+1]].min() >= cutoff : continue

        if (buried is not None and buried[mi]) :
          imatburr[i,j] = 1
          imatburr[j,i] = 1
        else :
          imat[i,j] = 1
          imat[j,i] = 1

  return (mat+imat,matburr+imatburr)
Beispiel #55
0
def anal_contacts(prot,rfirst,mols,cutoff,midz,box,molfile,resfile,
                    burresfile=None,buried=None,reslist=None,reslistfile=None) :
  """
  Calculates a range of contacts and write out contact vectors to files

  Parameters
  ----------
  prot : AtomSelection
    the protein atoms
  rfirst : NumpyArray
    the first atom of each residue in the protein
  mols : NumpyArray
    the centroid of the molecule of interest
  cutoff : float
    the contact cut-off
  midz : float
    the middle of the bilayer
  box : NumpyArray
    the box sides
  molfile : fileobject
    the file to write molecular contacts to
  resfile : fileobject
    the file to write residue contacts to
  burresfile : fileobject, optional
    the file to write buried residue contacts to
  buried : NumpyArray of boolean, optional
    flag to indicate buried molecule
  reslist : list
    a list of residues to write out individual mol contacts
  reslistfile : fileobject
    the file to write out individual mol contacts to
  """
  molon = np.zeros(len(mols),dtype=bool)
  reson = np.zeros(len(rfirst)-1,dtype=bool)
  if buried is not None :
    burreson = np.zeros(len(rfirst)-1,dtype=bool)
  if reslist is not None :
    resonlist = np.zeros([len(reslist),len(mols)],dtype=bool)

  # Calculate all distances at once
  if box is not None :
    dist_all = distances.distance_array(np.array(mols), prot.get_positions(), box)
  else :
    kdtree = KDTree(dim=3, bucket_size=10)
    kdtree.set_coords(prot.get_positions())

  # Loop over all molecules
  for mi,mol in enumerate(mols) :
    if box is not None :
      dist = dist_all[mi,:]
    else :
      dist = np.ones(prot.get_positions().shape[0])+cutoff
      kdtree.search(np.array([mol]), cutoff)
      for i in kdtree.get_indices() : dist[i] = 0.0

    # Check if this molecule is on
    molon[mi] = dist.min() < cutoff
    if  molon[mi] :
      # Check contacts for reach residue
      for i in range(len(rfirst)-1) :
        if dist[rfirst[i]:rfirst[i+1]].min() < cutoff :
          if (burresfile is not None and buried[mi]) :
            burreson[i] = True
          else :
            reson[i] = True
          if reslist is not None and i in reslist:
            resonlist[reslist.index(i),mi] = True

  # Write state information to file
  write_booleans(molfile,molon)
  write_booleans(resfile,reson)
  if buried is not None :
    write_booleans(burresfile,burreson)
  if reslist is not None:
    write_booleans(reslistfile,resonlist.reshape(len(reslist)*len(mols)))
Beispiel #56
0
# Author: Samuel Genheden [email protected]

"""
Script to find the space where to insert the solutes
"""

import sys

import MDAnalysis
import MDAnalysis.lib.distances as mddist
import numpy as np

u = MDAnalysis.Universe(sys.argv[1])
lipids = u.select_atoms("name PO4 and resid 9108:10688")
com = np.asarray([lipids.center_of_geometry()])
radius = mddist.distance_array(com,lipids.positions,None).mean()

print "outside sphere %.3f %.3f %.3f %.3f"%(com[0,0], com[0,1], com[0,2], radius+10)
print "inside box 0.0 0.0 0.0 %.3f %.3f %.3f"%tuple(u.dimensions[:3])
	def get_heavy_atom_distances(self):
		self.heavy_atoms = self.u.select_atoms("not type 102 103 104 109 111 112") 
		dismat = distance_array(self.heavy_atoms.coordinates(), self.heavy_atoms.coordinates())