Merge branch 'MDAnalysis:develop' into devel-relprop

Author: ChiahsinChu

.pep8speaks.yml

@@ -0,0 +1,40 @@
+scanner:
+    diff_only: True
+    linter: pycodestyle
+
+pycodestyle:  # Valid if scanner.linter is pycodestyle
+    max-line-length: 79
+    ignore: ["E203", "E701"]
+    exclude: []
+    count: False
+    first: False
+    show-pep8: False
+    show-source: False
+    statistics: False
+    hang-closing: False
+    filename: []
+    select: []
+
+flake8:  # Valid if scanner.linter is flake8
+    max-line-length: 79
+    ignore: ["E203", "E501", "E701"]
+    exclude: []
+    count: False
+    show-source: False
+    statistics: False
+    hang-closing: False
+    filename: []
+    select: []
+
+no_blank_comment: True
+descending_issues_order: False
+only_mention_files_with_errors: True
+
+message:
+    opened:
+        header: ""
+        footer: ""
+    updated:
+        header: ""
+        footer: ""
+    no_errors: "There are currently no PEP 8 issues detected in this Pull Request. Cheers! :beers: "

benchmarks/benchmarks/GRO.py

@@ -1,8 +1,9 @@
+import MDAnalysis as mda
 import numpy as np
 from MDAnalysis.coordinates.GRO import GROReader
 from MDAnalysis.topology.GROParser import GROParser
 from MDAnalysisTests.datafiles import GRO
-import MDAnalysis as mda
+
 
 class GROReadBench(object):
     def time_read_GRO_coordinates(self):

benchmarks/benchmarks/ag_methods.py

@@ -2,35 +2,31 @@
 import numpy as np
 
 try:
-    from MDAnalysisTests.datafiles import (GRO, TPR, XTC,
-                                           PSF, DCD,
-                                           TRZ_psf, TRZ)
     from MDAnalysis.exceptions import NoDataError
+    from MDAnalysisTests.datafiles import DCD, GRO, PSF, TPR, TRZ, XTC, TRZ_psf
 except:
     pass
 
+
 class AtomGroupMethodsBench(object):
     """Benchmarks for the various MDAnalysis
     atomgroup methods.
     """
+
     # NOTE: the write() method has been
     # excluded as file writing is considered
     # a separate benchmarking category
 
     params = (10, 100, 1000, 10000)
-    param_names = ['num_atoms']
+    param_names = ["num_atoms"]
 
     def setup(self, num_atoms):
         self.u = MDAnalysis.Universe(GRO)
         self.ag = self.u.atoms[:num_atoms]
         self.weights = np.ones(num_atoms)
-        self.vdwradii = {'H':1.0,
-                         'C':1.0,
-                         'N':1.0,
-                         'O':1.0,
-                         'DUMMY':1.0}
-        self.rot_matrix = np.ones((3,3))
-        self.trans = np.ones((4,4))
+        self.vdwradii = {"H": 1.0, "C": 1.0, "N": 1.0, "O": 1.0, "DUMMY": 1.0}
+        self.rot_matrix = np.ones((3, 3))
+        self.trans = np.ones((4, 4))
 
     def time_bbox_pbc(self, num_atoms):
         """Benchmark bounding box calculation
@@ -60,15 +56,13 @@ def time_center_pbc(self, num_atoms):
         """Benchmark center calculation with
         pbc active.
         """
-        self.ag.center(weights=self.weights,
-                       pbc=True)
+        self.ag.center(weights=self.weights, pbc=True)
 
     def time_center_no_pbc(self, num_atoms):
         """Benchmark center calculation with
         pbc inactive.
         """
-        self.ag.center(weights=self.weights,
-                       pbc=False)
+        self.ag.center(weights=self.weights, pbc=False)
 
     def time_centroid_pbc(self, num_atoms):
         """Benchmark centroid calculation with
@@ -83,8 +77,7 @@ def time_centroid_no_pbc(self, num_atoms):
         self.ag.centroid(pbc=False)
 
     def time_concatenate(self, num_atoms):
-        """Benchmark atomgroup concatenation.
-        """
+        """Benchmark atomgroup concatenation."""
         self.ag.concatenate(self.ag)
 
     def time_difference(self, num_atoms):
@@ -97,7 +90,7 @@ def time_groupby(self, num_atoms):
         """Benchmark atomgroup groupby
         operation.
         """
-        self.ag.groupby('resnames')
+        self.ag.groupby("resnames")
 
     def time_guess_bonds(self, num_atoms):
         """Benchmark atomgroup bond guessing
@@ -106,18 +99,15 @@ def time_guess_bonds(self, num_atoms):
         self.ag.guess_bonds(self.vdwradii)
 
     def time_intersection(self, num_atoms):
-        """Benchmark ag intersection.
-        """
+        """Benchmark ag intersection."""
         self.ag.intersection(self.ag)
 
     def time_is_strict_subset(self, num_atoms):
-        """Benchmark ag strict subset operation.
-        """
+        """Benchmark ag strict subset operation."""
         self.ag.is_strict_subset(self.ag)
 
     def time_is_strict_superset(self, num_atoms):
-        """Benchmark ag strict superset operation.
-        """
+        """Benchmark ag strict superset operation."""
         self.ag.is_strict_superset(self.ag)
 
     def time_isdisjoint(self, num_atoms):
@@ -155,19 +145,17 @@ def time_rotateby(self, num_atoms):
         """Benchmark rotation by an angle
         of the ag coordinates.
         """
-        self.ag.rotateby(angle=45,
-                         axis=[1,0,0])
+        self.ag.rotateby(angle=45, axis=[1, 0, 0])
 
     def time_split(self, num_atoms):
         """Benchmark ag splitting into
         multiple ags based on a simple
         criterion.
         """
-        self.ag.split('residue')
+        self.ag.split("residue")
 
     def time_subtract(self, num_atoms):
-        """Benchmark ag subtraction.
-        """
+        """Benchmark ag subtraction."""
         self.ag.subtract(self.ag)
 
     def time_symmetric_difference(self, num_atoms):
@@ -187,7 +175,7 @@ def time_translate(self, num_atoms):
         translation vector to the ag
         coordinates.
         """
-        self.ag.translate([0,0.5,1])
+        self.ag.translate([0, 0.5, 1])
 
     def time_union(self, num_atoms):
         """Benchmark union operation
@@ -202,14 +190,13 @@ def time_wrap(self, num_atoms):
         self.ag.wrap()
 
 
-
 class AtomGroupAttrsBench(object):
     """Benchmarks for the various MDAnalysis
     atomgroup attributes.
     """
 
     params = (10, 100, 1000, 10000)
-    param_names = ['num_atoms']
+    param_names = ["num_atoms"]
 
     def setup(self, num_atoms):
         self.u = MDAnalysis.Universe(GRO)
@@ -235,7 +222,7 @@ def time_dihedral(self, num_atoms):
         """
         self.ag[:4].dihedral
 
-    #TODO: use universe / ag that
+    # TODO: use universe / ag that
     # is suitable for force calc
     def time_forces(self, num_atoms):
         """Benchmark atomgroup force
@@ -246,7 +233,7 @@ def time_forces(self, num_atoms):
         except NoDataError:
             pass
 
-    #TODO: use universe / ag that
+    # TODO: use universe / ag that
     # is suitable for velocity extraction
     def time_velocity(self, num_atoms):
         """Benchmark atomgroup velocity
@@ -265,8 +252,7 @@ def time_improper(self, num_atoms):
         self.ag[:4].improper
 
     def time_indices(self, num_atoms):
-        """Benchmark atom index calculation.
-        """
+        """Benchmark atom index calculation."""
         self.ag.ix
 
     def time_atomcount(self, num_atoms):
@@ -326,15 +312,17 @@ def time_bond(self, num_atoms):
 
 class CompoundSplitting(object):
     """Test how fast can we split compounds into masks and apply them
-    
+
     The benchmark used in Issue #3000. Parameterizes multiple compound number
     and size combinations.
     """
-    
-    params = [(100, 10000, 1000000),  # n_atoms
-              (1, 10, 100),           # n_compounds
-              (True, False),          # homogeneous
-              (True, False)]          # contiguous
+
+    params = [
+        (100, 10000, 1000000),  # n_atoms
+        (1, 10, 100),  # n_compounds
+        (True, False),  # homogeneous
+        (True, False),
+    ]  # contiguous
 
     def setup(self, n_atoms, n_compounds, homogeneous, contiguous):
         rg = np.random.Generator(np.random.MT19937(3000))
@@ -345,7 +333,7 @@ def setup(self, n_atoms, n_compounds, homogeneous, contiguous):
 
         if n_compounds == 1 and not (homogeneous and contiguous):
             raise NotImplementedError
-            
+
         if n_compounds == n_atoms:
             if not (homogeneous and contiguous):
                 raise NotImplementedError
@@ -354,51 +342,56 @@ def setup(self, n_atoms, n_compounds, homogeneous, contiguous):
             ats_per_compound, remainder = divmod(n_atoms, n_compounds)
             if remainder:
                 raise NotImplementedError
-            compound_indices = np.tile(np.arange(n_compounds),
-                                       (ats_per_compound, 1)).T.ravel()
+            compound_indices = np.tile(
+                np.arange(n_compounds), (ats_per_compound, 1)
+            ).T.ravel()
         else:
-            compound_indices = np.sort(np.floor(rg.random(n_atoms)
-                                                * n_compounds).astype(np.int))
-                
+            compound_indices = np.sort(
+                np.floor(rg.random(n_atoms) * n_compounds).astype(np.int)
+            )
+
         unique_indices = np.unique(compound_indices)
         if len(unique_indices) != n_compounds:
             raise RuntimeError
-        
+
         if not contiguous:
             rg.shuffle(compound_indices)
-        
-        self.u = MDAnalysis.Universe.empty(n_atoms,
-                                           n_residues=n_compounds,
-                                           n_segments=1,
-                                           atom_resindex=compound_indices,
-                                           trajectory=True)
-        self.u.atoms.positions = rg.random((n_atoms, 3),
-                                           dtype=np.float32) * 100
+
+        self.u = MDAnalysis.Universe.empty(
+            n_atoms,
+            n_residues=n_compounds,
+            n_segments=1,
+            atom_resindex=compound_indices,
+            trajectory=True,
+        )
+        self.u.atoms.positions = rg.random((n_atoms, 3), dtype=np.float32) * 100
         self.u.dimensions = [50, 50, 50, 90, 90, 90]
 
     def time_center_compounds(self, *args):
-        self.u.atoms.center(None, compound='residues')
+        self.u.atoms.center(None, compound="residues")
 
 
 class FragmentFinding(object):
     """Test how quickly we find fragments (distinct molecules from bonds)"""
+
     # if we try to parametrize over topology &
     # trajectory formats asv will use all
     # possible combinations, so instead handle
     # this in setup()
-    params = ('large_fragment_small_solvents',
-              'large_fragment',
-              'polymer_chains', # 20ish polymer chains
-              )
-    param_names = ['universe_type']
+    params = (
+        "large_fragment_small_solvents",
+        "large_fragment",
+        "polymer_chains",  # 20ish polymer chains
+    )
+    param_names = ["universe_type"]
 
     def setup(self, universe_type):
-        if universe_type == 'large_fragment_small_solvents':
-            univ = (TPR, XTC) 
-        elif universe_type == 'large_fragment':
+        if universe_type == "large_fragment_small_solvents":
+            univ = (TPR, XTC)
+        elif universe_type == "large_fragment":
             univ = (PSF, DCD)
         else:
-            univ = (TRZ_psf, TRZ) 
+            univ = (TRZ_psf, TRZ)
         self.u = MDAnalysis.Universe(*univ)
 
     def time_find_fragments(self, universe_type):
@@ -407,6 +400,7 @@ def time_find_fragments(self, universe_type):
 
 class FragmentCaching(FragmentFinding):
     """Test how quickly we find cached fragments"""
+
     def setup(self, universe_type):
         super(FragmentCaching, self).setup(universe_type)
         frags = self.u.atoms.fragments  # Priming the cache