MDAnalysis 2.4.3__tar.gz → 2.5.0__tar.gz

{MDAnalysis-2.4.3 → MDAnalysis-2.5.0}/AUTHORS

@@ -200,7 +200,23 @@ Chronological list of authors
   - Jennifer A Clark
   - Jake Fennick
   - Utsav Khatu
-
+  - Patricio Barletta
+  - Mikhail Glagolev
+2023
+  - Christian Pfaendner
+  - Pratham Chauhan
+  - Meet Brijwani
+  - Vishal Parmar
+  - Moritz Schaeffler
+  - Xu Hong Chen
+  - Domenico Marson
+  - Ahmed Salah Ghoneim
+  - Alexander Schlaich
+  - Josh Vermaas
+  - Xiaoxu Ruan
+  - Egor Marin
+  - Shaivi Malik
+  - Daniel J. Evans
 
 External code
 -------------

{MDAnalysis-2.4.3 → MDAnalysis-2.5.0}/CHANGELOG

@@ -13,6 +13,101 @@ The rules for this file:
   * release numbers follow "Semantic Versioning" http://semver.org
 
 ------------------------------------------------------------------------------
+05/28/23 IAlibay, pgbarletta, mglagolev, hmacdope, manuel.nuno.melo, chrispfae, 
+         ooprathamm, MeetB7, BFedder, v-parmar, MoSchaeffler, jbarnoud, jandom,
+         xhgchen, jaclark5, DrDomenicoMarson, AHMED-salah00, schlaicha,
+         SophiaRuan, g2707, p-j-smith, tylerjereddy, xiki-tempula, richardjgowers,
+         cbouy
+
+ * 2.5.0
+
+Fixes
+  * Fixed ChainReader performing transformations correctly across boundaries in the individual trajectories
+    (Issue #3657 #4008 PR #3906)
+  * Fix the `heavy` distance_type for water bridge analysis where distance
+    is not correctly assigned when more than one hydrogen is bonded to a
+    heavy atom (Issue #4040, PR #4066).
+  * PDB topology parser no longer fails when encountering unknown formal
+    charges and instead simply does not populate attribute (Issue #4027)
+  * Added support for Cython 3.0.0b2 (PR #4129)
+  * Ensure 'HydrogenBondAnalysis' returns the correct distances when using the
+    'between' keyword (PR #4092)
+  * Skip tests artificially checking for readonly or PermissionError cases
+    when running at root user on linux systems (Issue #4112, PR #4120)
+  * Fix chi1_selections() ignored atom names CG1 OG OG1 SG and incorrectly returned
+    None for amino acids CYS, ILE, SER, THR, VAL (Issue #4108)
+  * Fix parsing of box vector in H5MD reader (Issue #4076)
+  * Fix the misleading 'AtomGroup.guess_bonds()' docs and passed missing
+    arguments (PR #4059)
+  * Fix for NetCDF trajectories without `time` variable (Issue #4073)
+  * Allows shape_parameter and asphericity to yield per residue quantities
+    (Issue #3002, PR #3905)
+  * Add tests for "No path data" exception raise in test_psa.py (Issue #4036)
+  * Fix uninitialized `format` variable issue when calling
+    `selections.get_writer` directly (PR #4043)
+  * Fix tests should use results.rmsf to avoid DeprecationWarning (Issue #3695)
+  * Fix EDRReader failing when parsing single-frame EDR files (Issue #3999)
+  * Fix test clobbering in lib/test_util.py (PR #4000)
+  * Fix MSD docs to use the correct error metric in example (Issue #3991)
+  * Add 'PairIJ Coeffs' to the list of sections in LAMMPSParser.py
+    (Issue #3336)
+
+Enhancements
+  * ARM64 (osx and linux) wheels now uploaded on release (Issue #4054)
+  * Add simple atomic distance analysis to `analysis.atomicdistances` with
+    new class `AtomicDistances` (Issue #3654)
+  * Add kwarg `n_frames` to class method `empty()` in
+    `MDAnalysis.core.universe`, enabling creation of a `Universe` with
+    multiple frames from scratch (PR #4140)
+  * PDBReader now populates ts.data['tempfactor'] with the tempfactor for
+    each atom *for each frame*. If an entry is missing for a given atom,
+    this will default to a `1.0` value. Note, this does not affect the
+    topology (i.e. `AtomGroup.tempfactors` is not dynamically updated.
+    (Issue #3825, PR #3988)
+  * Add writing u.trajectory.ts.data['molecule_tag'] as molecule tags to LAMMPS data file (Issue #3548)
+  * Improved speed of chi1_selection (PR #4109)
+  * Add `progressbar_kwargs` parameter to `AnalysisBase.run` method, allowing
+    to modify description, position etc of tqdm progressbars.
+  * Add a nojump transformation, which unwraps trajectories so that particle
+    paths are continuous. (Issue #3703, PR #4031)
+  * Added AtomGroup TopologyAttr to calculate gyration moments (Issue #3904,
+    PR #3905)
+  * Add support for TPR files produced by Gromacs 2023 (Issue #4047)
+  * Add distopia distance calculation library bindings as a selectable backend
+    for `calc_bonds` in `MDA.lib.distances`. (Issue #3783, PR #3914)
+  * AuxReaders are now pickle-able and copy-able (Issue #1785, PR #3887)
+  * Add pickling support for Atom, Residue, Segment, ResidueGroup 
+    and SegmentGroup. (PR #3953)
+
+Changes
+  * As per NEP29 the minimum supported Python version has been raised to 3.9
+    (PR #4115).
+  * einsum method for Einstein summation convention introduced to increase 
+    performance (Issue #2063, PR #4089)
+  * Add progress bars to track the progress of _conclude() functions
+    (_conclude_simple() and _conclude_fft()) in msd.py (Issue #4070, PR #4072)
+  * As per NEP29 the minimum supported NumPy version has been raised to 1.21
+    (note: in practice later versions of NumPy may be used depending on your
+     architecture, operating system, or Python version) (PR #3983)
+  * The deprecated direct indexing and `times` from the `results` attribute of
+    analysis.nucleicacids' NucPairDist and WatsonCrickDist classes has been
+    removed. Please use the `results.pair_distances` and `times` attributes
+    instead (Issue #3744)
+  * RDKitConverter changes (part of Issue #3996):
+    * moved some variables (`MONATOMIC_CATION_CHARGES `and
+      `STANDARDIZATION_REACTIONS`) out of the related functions to allow users
+      fine tuning them if necessary.
+    * changed the sorting of heavy atoms when inferring bond orders and
+      charges: previously only based on the number of unpaired electrons, now
+      based on this and the number of heavy atom neighbors.
+    * use RDKit's `RunReactantInPlace` for the standardization reactions, which
+      should result in a significant speed improvement as we don't need to use
+      bespoke code to transfer atomic properties from the non-standardized mol
+      to the standardized one.
+
+Deprecations
+
+
 03/29/23 richardjgowers, IAlibay
 
  * 2.4.3
@@ -71,6 +166,8 @@ Fixes
     (e.g. bonds, angles) (PR #3779).
 
 Enhancements
+  * Added dipole and quadrupole moment topology methods to AtomGroup
+    (Issue #3841, PR #3842)
   * MDAnalysis now follows PEP621 (PR #3528)
   * Added a reader for GROMACS TNG files based on PyTNG (PR #3765,
     Issue #3237, partially addressing Issue #865) 

MDAnalysis-2.5.0/MDAnalysis/analysis/atomicdistances.py

@@ -0,0 +1,178 @@
+# -*- Mode: python; tab-width: 4; indent-tabs-mode:nil; -*-
+# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
+#
+# MDAnalysis --- https://www.mdanalysis.org
+# Copyright (c) 2006-2017 The MDAnalysis Development Team and contributors
+# (see the file AUTHORS for the full list of names)
+#
+# Released under the GNU Public Licence, v2 or any higher version
+#
+# Please cite your use of MDAnalysis in published work:
+#
+# R. J. Gowers, M. Linke, J. Barnoud, T. J. E. Reddy, M. N. Melo, S. L. Seyler,
+# D. L. Dotson, J. Domanski, S. Buchoux, I. M. Kenney, and O. Beckstein.
+# MDAnalysis: A Python package for the rapid analysis of molecular dynamics
+# simulations. In S. Benthall and S. Rostrup editors, Proceedings of the 15th
+# Python in Science Conference, pages 102-109, Austin, TX, 2016. SciPy.
+# doi: 10.25080/majora-629e541a-00e
+#
+# N. Michaud-Agrawal, E. J. Denning, T. B. Woolf, and O. Beckstein.
+# MDAnalysis: A Toolkit for the Analysis of Molecular Dynamics Simulations.
+# J. Comput. Chem. 32 (2011), 2319--2327, doi:10.1002/jcc.21787
+#
+#
+
+
+r"""
+Simple atomic distance analysis --- :mod:`MDAnalysis.analysis.atomicdistances`
+==============================================================================
+
+:Author: Xu Hong Chen
+:Year: 2023
+:Copyright: GNU Public License v3
+
+This module provides a class to efficiently compute distances between
+two groups of atoms with an equal number of atoms over a trajectory.
+Specifically, for two atom groups ``ag1`` and ``ag2``, it will return
+the distances
+
+.. math::
+    |ag1[i] - ag2[i]|
+
+for all :math:`i` from :math:`0` to `n_atoms` :math:`- 1`, where
+`n_atoms` is the number of atoms in each atom group. By default,
+this computation is done with periodic boundary conditions, but this
+can be easily turned off. These distances are grouped by time step in
+a NumPy array.
+
+For more general functions on computing distances between atoms or
+groups of atoms, please see :class:`MDAnalysis.analysis.distances`.
+
+See Also
+--------
+:mod:`MDAnalysis.analysis.distances`
+:mod:`MDAnalysis.lib.distances`
+
+
+Basic usage
+-----------
+
+This example uses files from the MDAnalysis test suite
+(:data:`~MDAnalysis.tests.datafiles.GRO` and
+:data:`~MDAnalysis.tests.datafiles.XTC`). To get started, execute  ::
+
+   >>> import MDAnalysis as mda
+   >>> from MDAnalysis.tests.datafiles import GRO, XTC
+   >>> import MDAnalysis.analysis.atomicdistances as ad
+
+We will calculate the distances between an atom group of atoms 101-105
+and an atom group of atoms 4001-4005 with periodic boundary conditions.
+To select these atoms:
+
+   >>> u = mda.Universe(GRO, XTC)
+   >>> ag1 = u.atoms[100:105]
+   >>> ag2 = u.atoms[4000:4005]
+
+We can run the calculations using any variable of choice such as
+``my_dists`` and access our results using ``my_dists.results``:
+
+   >>> my_dists = ad.AtomicDistances(ag1, ag2).run()
+   >>> my_dists.results
+   array([[37.80813681, 33.2594864 , 34.93676414, 34.51183299, 34.96340209],
+       [27.11746625, 31.19878079, 31.69439435, 32.63446126, 33.10451345],
+       [23.27210749, 30.38714688, 32.48269361, 31.91444505, 31.84583838],
+       [18.40607922, 39.21993135, 39.33468192, 41.0133789 , 39.46885946],
+       [26.26006981, 37.9966713 , 39.14991106, 38.13423586, 38.95451427],
+       [26.83845081, 34.66255735, 35.59335027, 34.8926705 , 34.27175056],
+       [37.51994763, 38.12161091, 37.56481743, 36.8488121 , 35.75278065],
+       [37.27275501, 37.7831456 , 35.74359073, 34.54893794, 34.76495816],
+       [38.76272761, 41.31816555, 38.81588421, 39.82491432, 38.890219  ],
+       [39.20012515, 40.00563374, 40.83857688, 38.77886735, 41.45775864]])
+
+To do the computation without periodic boundary conditions, we can enter
+the keyword argument ``pbc=False`` after ``ag2``. The result is different
+in this case:
+
+   >>> my_dists_nopbc = ad.AtomicDistances(ag1, ag2, pbc=False).run()
+   >>> my_dists_nopbc.results
+   array([[37.80813681, 33.2594864 , 34.93676414, 34.51183299, 34.96340209],
+       [27.11746625, 31.19878079, 31.69439435, 32.63446126, 33.10451345],
+       [23.27210749, 30.38714688, 32.482695  , 31.91444505, 31.84583838],
+       [18.40607922, 39.21992825, 39.33468192, 41.0133757 , 39.46885946],
+       [26.26006981, 37.99666906, 39.14990985, 38.13423708, 38.95451311],
+       [26.83845081, 34.66255625, 35.59335027, 34.8926705 , 34.27174827],
+       [51.86981409, 48.10347964, 48.39570072, 49.14423513, 50.44804292],
+       [37.27275501, 37.7831456 , 35.74359073, 34.54893794, 34.76495816],
+       [56.39657447, 41.31816555, 38.81588421, 39.82491432, 38.890219  ],
+       [39.20012515, 40.00563374, 40.83857688, 38.77886735, 41.45775864]])
+
+"""
+
+import numpy as np
+
+from MDAnalysis.lib.distances import calc_bonds
+
+
+import warnings
+import logging
+from .base import AnalysisBase
+
+logger = logging.getLogger("MDAnalysis.analysis.atomicdistances")
+
+
+class AtomicDistances(AnalysisBase):
+    r"""Class to calculate atomic distances between two AtomGroups over a
+    trajectory.
+
+    Parameters
+    ----------
+    ag1, ag2 : AtomGroup
+        :class:`~MDAnalysis.core.groups.AtomGroup` with the
+        same number of atoms
+    pbc : bool, optional
+        If ``True``, calculates atomic distances with periodic boundary
+        conditions (PBCs). Setting `pbc` to ``False``, calculates atomic
+        distances without considering PBCs. Defaults to ``True``.
+
+    Attributes
+    ----------
+    results : :class:`numpy.ndarray`
+        The distances :math:`|ag1[i] - ag2[i]|` for all :math:`i`
+        from :math:`0` to `n_atoms` :math:`- 1` for each frame over
+        the trajectory.
+    n_frames : int
+        Number of frames included in the analysis.
+    n_atoms : int
+        Number of atoms in each atom group.
+
+
+    .. versionadded:: 2.5.0
+    """
+
+    def __init__(self, ag1, ag2, pbc=True, **kwargs):
+        # check ag1 and ag2 have the same number of atoms
+        if ag1.atoms.n_atoms != ag2.atoms.n_atoms:
+            raise ValueError("AtomGroups do not "
+                             "have the same number of atoms")
+        # check ag1 and ag2 are from the same trajectory
+        elif ag1.universe.trajectory != ag2.universe.trajectory:
+            raise ValueError("AtomGroups are not "
+                             "from the same trajectory")
+
+        super(AtomicDistances, self).__init__(ag1.universe.trajectory,
+                                              **kwargs)
+
+        self._ag1 = ag1
+        self._ag2 = ag2
+        self._pbc = pbc
+
+    def _prepare(self):
+        # initialize NumPy array of frames x distances for results
+        self.results = np.zeros((self.n_frames, self._ag1.atoms.n_atoms))
+
+    def _single_frame(self):
+        # if PBCs considered, get box size
+        box = self._ag1.dimensions if self._pbc else None
+        self.results[self._frame_index] = calc_bonds(self._ag1.positions,
+                                                     self._ag2.positions,
+                                                     box)

{MDAnalysis-2.4.3 → MDAnalysis-2.5.0}/MDAnalysis/analysis/base.py

@@ -390,7 +390,7 @@ class AnalysisBase(object):
         pass  # pylint: disable=unnecessary-pass
 
     def run(self, start=None, stop=None, step=None, frames=None,
-            verbose=None):
+            verbose=None, *, progressbar_kwargs={}):
         """Perform the calculation
 
         Parameters
@@ -411,12 +411,19 @@ class AnalysisBase(object):
 
         verbose : bool, optional
             Turn on verbosity
+        
+        progressbar_kwargs : dict, optional
+            ProgressBar keywords with custom parameters regarding progress bar position, etc; 
+            see :class:`MDAnalysis.lib.log.ProgressBar` for full list.
 
 
         .. versionchanged:: 2.2.0
             Added ability to analyze arbitrary frames by passing a list of
             frame indices in the `frames` keyword argument.
 
+        .. versionchanged:: 2.5.0
+            Add `progressbar_kwargs` parameter, 
+            allowing to modify description, position etc of tqdm progressbars
         """
         logger.info("Choosing frames to analyze")
         # if verbose unchanged, use class default
@@ -429,9 +436,11 @@ class AnalysisBase(object):
         self._prepare()
         logger.info("Starting analysis loop over %d trajectory frames",
                     self.n_frames)
+
         for i, ts in enumerate(ProgressBar(
                 self._sliced_trajectory,
-                verbose=verbose)):
+                verbose=verbose,
+                **progressbar_kwargs)):
             self._frame_index = i
             self._ts = ts
             self.frames[i] = ts.frame

{MDAnalysis-2.4.3 → MDAnalysis-2.5.0}/MDAnalysis/analysis/bat.py

@@ -372,13 +372,13 @@ class BAT(AnalysisBase):
         v01 = p1 - p0
         v21 = p1 - p2
         # Internal coordinates
-        r01 = np.sqrt(np.sum(v01 *
-                             v01))  # Distance between first two root atoms
-        r12 = np.sqrt(np.sum(v21 *
-                             v21))  # Distance between second two root atoms
+        r01 = np.sqrt(np.einsum('i,i->',v01,v01))  
+        # Distance between first two root atoms
+        r12 = np.sqrt(np.einsum('i,i->',v21,v21))  
+        # Distance between second two root atoms
         # Angle between root atoms
-        a012 = np.arccos(max(-1.,min(1.,np.sum(v01*v21)/\
-                             np.sqrt(np.sum(v01*v01)*np.sum(v21*v21)))))
+        a012 = np.arccos(max(-1.,min(1.,np.einsum('i,i->',v01,v21)/\
+                              np.sqrt(np.einsum('i,i->',v01,v01)*np.einsum('i,i->',v21,v21)))))
         # External coordinates
         e = v01 / r01
         phi = np.arctan2(e[1], e[0])  # Polar angle
@@ -545,12 +545,12 @@ class BAT(AnalysisBase):
             cs_tor = np.cos(torsion)
 
             v21 = p1 - p2
-            v21 /= np.sqrt(np.sum(v21 * v21))
+            v21 /= np.sqrt(np.einsum('i,i->',v21,v21))
             v32 = p2 - p3
-            v32 /= np.sqrt(np.sum(v32 * v32))
+            v32 /= np.sqrt(np.einsum('i,i->',v32,v32))
 
             vp = np.cross(v32, v21)
-            cs = np.sum(v21 * v32)
+            cs = np.einsum('i,i->',v21,v32)
 
             sn = max(np.sqrt(1.0 - cs * cs), 0.0000000001)
             vp = vp / sn