developing back end run methods

mdpow/analysis/dihedral.py

@@ -78,7 +78,7 @@ def check_dihedral_inputs(selections):
         for group in selections:
             for k in group.keys():
                 if len(group[k]) != 4:
-                    msg = ''''Dihedral calculations require AtomGroups with
+                    msg = '''Dihedral calculations require AtomGroups with
                               only 4 atoms, %s selected''' % len(group)
                     logger.error(msg)
                     raise SelectionError(msg)

mdpow/analysis/ensemble.py

@@ -469,14 +469,14 @@ def _single_universe(self):
             Run on each universe in the ensemble during when
             self.run in called.
         """
-        pass  # pragma: no cover
+        raise NotImplementedError
 
     def _single_frame(self):
         """Calculate data from a single frame of trajectory
 
         Called on each frame for universes in the Ensemble.
         """
-        pass  # pragma: no cover
+        raise NotImplementedError
 
     def _prepare_ensemble(self):
         """For establishing data structures used in running
@@ -505,27 +505,34 @@ def _conclude_ensemble(self):
         pass  # pragma: no cover
 
     def run(self, start=None, stop=None, step=None):
-        """Runs _single_universe on each system and _single_frame
+        """Runs _single_universe on each system or _single_frame
         on each frame in the system.
 
         First iterates through keys of ensemble, then runs _setup_system
         which defines the system and trajectory. Then iterates over
         trajectory frames.
+
+        NotImplementedError will detect whether _single_universe or _single_frame
+        should be implemented, based on which is defined in the EnsembleAnalysisClass.
+        Only one of the two aforementioned functions should be defined for the respective
+        analysis class. For verbose functionality, the analysis will currently show two
+        iteration bars, where only one of which will actually be iterated, while the other
+        will load to completion instantaneously, showing the system that is being worked on.
         """
         logger.info("Setting up systems")
         self._prepare_ensemble()
         for self._key in ProgressBar(self._ensemble.keys(), verbose=True):
             self._setup_system(self._key, start=start, stop=stop, step=step)
-            self._prepare_universe()
-            self._single_universe()
-            for i, ts in enumerate(ProgressBar(self._trajectory[self.start:self.stop:self.step], verbose=True,
+            try:
+                self._single_universe()
+            except NotImplementedError:
+                for i, ts in enumerate(ProgressBar(self._trajectory[self.start:self.stop:self.step], verbose=True,
                                                postfix=f'running system {self._key}')):
-                self._frame_index = i
-                self._ts = ts
-                self.frames[i] = ts.frame
-                self.times[i] = ts.time
-                self._single_frame()
-            self._conclude_universe()
+                    self._frame_index = i
+                    self._ts = ts
+                    self.frames[i] = ts.frame
+                    self.times[i] = ts.time
+                    self._single_frame()
             logger.info("Moving to next universe")
         logger.info("Finishing up")
         self._conclude_ensemble()

mdpow/tests/test_dihedral.py

@@ -23,9 +23,9 @@
 
 class TestDihedral(object):
     DG48910_mean = -172.9849512527183
-    DG491011_mean = -3.7300197060478695
-    DG48910_var = 1490.6576365537262
-    DG491011_var = 128.3805265432388
+    DG491011_mean = 177.74725233051953
+    DG48910_var = 0.20311120667628546
+    DG491011_var = 0.006976126708773456
 
     def setup(self):
         self.tmpdir = td.TempDir()
@@ -37,25 +37,25 @@ def teardown(self):
         self.tmpdir.dissolve()
 
     def test_dataframe(self):
-        dh1 = self.Ens.select_atoms('name C4 or name C17 or name S2 or name N3')
+        dh1 = self.Ens.select_atoms('name C4', 'name C17', 'name S2', 'name N3')
         dh_run = DihedralAnalysis([dh1]).run(start=0, stop=4, step=1)
 
         results = dh_run.results
 
-        assert results['selection'][0] == 'S2-N3-C4-C17'
+        assert results['selection'][0] == 'C4-C17-S2-N3'
         for s in results['solvent']:
             assert s == 'water'
         for i in results['interaction'][:12]:
             assert i == 'Coulomb'
 
     def test_selection_error(self):
-        dh1 = self.Ens.select_atoms('name C17 or name S2 or name N3')
+        dh1 = self.Ens.select_atoms('name C17', 'name S2', 'name N3')
         with pytest.raises(SelectionError):
             dh_run = DihedralAnalysis([dh1]).run(start=0, stop=4, step=1)
 
     def test_results_recursive1(self):
-        dh1 = self.Ens.select_atoms('name C11 or name C10 or name C9 or name C4')
-        dh2 = self.Ens.select_atoms('name C11 or name C10 or name C9 or name C4')
+        dh1 = self.Ens.select_atoms('name C11', 'name C10', 'name C9', 'name C4')
+        dh2 = self.Ens.select_atoms('name C11', 'name C10', 'name C9', 'name C4')
 
         dh_run1 = DihedralAnalysis([dh1]).run(start=0, stop=4, step=1)
         dh_run2 = DihedralAnalysis([dh2]).run(start=0, stop=4, step=1)
@@ -64,29 +64,34 @@ def test_results_recursive1(self):
             assert dh_run1.results['dihedral'][i] == dh_run2.results['dihedral'][i]
 
     def test_results_recursive2(self):
-        dh1 = self.Ens.select_atoms('name C11 or name C10 or name C9 or name C4')
-        dh2 = self.Ens.select_atoms('name C8 or name C4 or name C9 or name C10')
+        dh1 = self.Ens.select_atoms('name C11', 'name C10', 'name C9', 'name C4')
+        dh2 = self.Ens.select_atoms('name C8', 'name C4', 'name C9', 'name C10')
 
         dh_run = DihedralAnalysis([dh1, dh2]).run(start=0, stop=4, step=1)
 
-        dh1_result = dh_run.results.loc[dh_run.results['selection'] == 'C4-C9-C10-C11']['dihedral']
-        dh2_result = dh_run.results.loc[dh_run.results['selection'] == 'C4-C8-C9-C10']['dihedral']
+        dh1_result = dh_run.results.loc[dh_run.results['selection'] == 'C11-C10-C9-C4']['dihedral']
+        dh2_result = dh_run.results.loc[dh_run.results['selection'] == 'C8-C4-C9-C10']['dihedral']
 
         dh1_mean = circmean(dh1_result, high=180, low=-180)
         dh2_mean = circmean(dh2_result, high=180, low=-180)
         dh1_var = circvar(dh1_result, high=180, low=-180)
         dh2_var = circvar(dh2_result, high=180, low=-180)
 
-        assert_almost_equal(self.DG48910_mean, dh1_mean, 6)
-        assert_almost_equal(self.DG48910_var, dh1_var, 6)
-        assert_almost_equal(self.DG491011_mean, dh2_mean, 6)
-        assert_almost_equal(self.DG491011_var, dh2_var, 6)
+        assert_almost_equal(dh1_mean, self.DG48910_mean, 6)
+        assert_almost_equal(dh1_var, self.DG48910_var, 6)
+        assert_almost_equal(dh2_mean, self.DG491011_mean, 6)
+        assert_almost_equal(dh2_var, self.DG491011_var, 6)
 
     def test_ValueError_different_ensemble(self):
         other = Ensemble(dirname=self.tmpdir.name, solvents=['water'])
-        dh1 = self.Ens.select_atoms('name C11 or name C10 or name C9 or name C4')
-        dh2 = other.select_atoms('name C8 or name C4 or name C9 or name C10')
+        dh1 = self.Ens.select_atoms('name C11', 'name C10', 'name C9', 'name C4')
+        dh2 = other.select_atoms('name C8', 'name C4', 'name C9', 'name C10')
         with pytest.raises(ValueError,
                            match='Dihedral selections from different Ensembles, '):
             DihedralAnalysis([dh1, dh2])
 
+    def test_single_universe(self):
+        dh = self.Ens.select_atoms('name C4', 'name C17', 'name S2', 'name N3')
+        with pytest.raises(NotImplementedError):
+            DihedralAnalysis([dh])._single_universe()
+