Add ASV benchmarks for MDAnalysis.lib core kernels

benchmarks/benchmarks/analysis/contacts.py

@@ -0,0 +1,27 @@
+import MDAnalysis as mda
+from MDAnalysis.analysis import contacts
+from MDAnalysisTests.datafiles import PSF, DCD
+
+
+class ContactsBench:
+
+    params = [4.5, 6.0]
+    param_names = ["radius"]
+
+    def setup(self, radius):
+        self.u = mda.Universe(PSF, DCD)
+        self.sel1 = "protein"
+        self.sel2 = "name CA"
+
+        g1 = self.u.select_atoms(self.sel1)
+        g2 = self.u.select_atoms(self.sel2)
+
+        self.analysis = contacts.Contacts(
+            self.u,
+            select=(self.sel1, self.sel2),
+            refgroup=(g1, g2),
+            radius=radius,
+        )
+
+    def time_contacts_run(self, radius):
+        self.analysis.run()

benchmarks/benchmarks/lib/dihedrals.py

@@ -0,0 +1,19 @@
+import numpy as np
+from MDAnalysis.lib.distances import calc_dihedrals
+
+
+class DihedralBench:
+
+    params = [100, 500, 1000, 10000]
+    param_names = ["n_dihedrals"]
+
+    def setup(self, n_dihedrals):
+        self.coords = np.random.random((n_dihedrals, 4, 3))
+
+    def time_calc_dihedrals(self, n_dihedrals):
+        calc_dihedrals(
+            self.coords[:,0],
+            self.coords[:,1],
+            self.coords[:,2],
+            self.coords[:,3]
+        )

benchmarks/benchmarks/lib/distances.py

@@ -0,0 +1,26 @@
+import numpy as np
+from MDAnalysis.lib.distances import distance_array, self_distance_array
+
+
+class DistanceArrayBench:
+
+    params = [100, 500, 1000, 10000]
+    param_names = ["n_atoms"]
+
+    def setup(self, n_atoms):
+        self.coords1 = np.random.random((n_atoms, 3))
+        self.coords2 = np.random.random((n_atoms, 3))
+
+    def time_distance_array(self, n_atoms):
+        distance_array(self.coords1, self.coords2)
+
+class SelfDistanceArrayBench:
+
+    params = [100, 500, 1000, 10000]
+    param_names = ["n_atoms"]
+
+    def setup(self, n_atoms):
+        self.coords = np.random.random((n_atoms, 3))
+
+    def time_self_distance_array(self, n_atoms):
+        self_distance_array(self.coords)

benchmarks/benchmarks/lib/fastns.py

@@ -0,0 +1,16 @@
+import numpy as np
+from MDAnalysis.lib.nsgrid import FastNS
+
+
+class FastNSBench:
+
+    params = [100, 500, 1000, 10000]
+    param_names = ["n_atoms"]
+
+    def setup(self, n_atoms):
+        self.coords = np.random.random((n_atoms, 3)).astype(np.float32)
+        self.box = np.array([10, 10, 10, 90, 90, 90], dtype=np.float32)
+
+    def time_fastns(self, n_atoms):
+        ns = FastNS(5.0, self.coords, self.box)
+        ns.self_search()

benchmarks/benchmarks/lib/neighborsearch.py

@@ -0,0 +1,15 @@
+import numpy as np
+from MDAnalysis.lib.NeighborSearch import AtomNeighborSearch
+import MDAnalysis as mda
+from MDAnalysisTests.datafiles import PSF, DCD
+
+
+class NeighborSearchBench:
+
+    def setup(self):
+        self.u = mda.Universe(PSF, DCD)
+        self.atoms = self.u.select_atoms("protein")
+        self.ns = AtomNeighborSearch(self.atoms)
+
+    def time_neighbor_search(self):
+        self.ns.search(self.atoms, 5.0)