Clean up the iloc in the tests

CHANGES

@@ -18,6 +18,7 @@ The rules for this file:
   * 1.0.1
 
 Fixes
+  - Remove most of the iloc in the tests (issue #202, PR #254).
   - AMBER parser now raises ValueError when the initial simulation time
     is not found (issue #272, PR #273).
   - The regex in the AMBER parser now reads also 'field=value' pairs where

src/alchemlyb/tests/parsing/test_gmx.py

@@ -124,7 +124,7 @@ def test_u_nk_with_total_energy():
 
     # Check one specific value in the dataframe
     assert_almost_equal(
-        extract_u_nk(dataset['data']['AllStates'][0], T=300).iloc[0][0],
+        extract_u_nk(dataset['data']['AllStates'][0], T=300).loc[0][(0.0,0.0)].values[0],
         -11211.577658852531,
         decimal=6
     )
@@ -142,7 +142,7 @@ def test_u_nk_with_potential_energy():
 
     # Check one specific value in the dataframe
     assert_almost_equal(
-        extract_u_nk(dataset['data']['AllStates'][0], T=300).iloc[0][0],
+        extract_u_nk(dataset['data']['AllStates'][0], T=300).loc[0][(0.0,0.0)].values[0],
         -15656.557252200757,
         decimal=6
     )
@@ -161,7 +161,7 @@ def test_u_nk_without_energy():
 
     # Check one specific value in the dataframe
     assert_almost_equal(
-        extract_u_nk(dataset['data']['AllStates'][0], T=300).iloc[0][0],
+        extract_u_nk(dataset['data']['AllStates'][0], T=300).loc[0][(0.0,0.0)].values[0],
         0.0,
         decimal=6
     )
@@ -180,8 +180,9 @@ def _diag_sum(dataset):
             u_nk = extract_u_nk(filename, T=300)
 
             # Calculate the sum of diagonal elements:
-            for i in range(len(dataset['data'][leg])):
-                ds += u_nk.iloc[i][i]
+            for i, lambda_ in enumerate(u_nk.columns):
+                #18.6 is the time step
+                ds += u_nk.loc[i*186/10][lambda_].values[0]
 
     return ds
 

src/alchemlyb/tests/test_convergence.py

@@ -18,37 +18,21 @@ def test_convergence_ti(gmx_benzene):
     dHdl, u_nk = gmx_benzene
     convergence = forward_backward_convergence(dHdl, 'TI')
     assert convergence.shape == (10, 5)
-    assert convergence.iloc[0, 0] == pytest.approx(3.07, 0.01)
-    assert convergence.iloc[0, 2] == pytest.approx(3.11, 0.01)
-    assert convergence.iloc[-1, 0] == pytest.approx(3.09, 0.01)
-    assert convergence.iloc[-1, 2] == pytest.approx(3.09, 0.01)
 
-def test_convergence_mbar(gmx_benzene):
-    dHdl, u_nk = gmx_benzene
-    convergence = forward_backward_convergence(u_nk, 'MBAR')
-    assert convergence.shape == (10, 5)
-    assert convergence.iloc[0, 0] == pytest.approx(3.02, 0.01)
-    assert convergence.iloc[0, 2] == pytest.approx(3.06, 0.01)
-    assert convergence.iloc[-1, 0] == pytest.approx(3.05, 0.01)
-    assert convergence.iloc[-1, 2] == pytest.approx(3.04, 0.01)
-
-def test_convergence_autombar(gmx_benzene):
-    dHdl, u_nk = gmx_benzene
-    convergence = forward_backward_convergence(u_nk, 'MBAR')
-    assert convergence.shape == (10, 5)
-    assert convergence.iloc[0, 0] == pytest.approx(3.02, 0.01)
-    assert convergence.iloc[0, 2] == pytest.approx(3.06, 0.01)
-    assert convergence.iloc[-1, 0] == pytest.approx(3.05, 0.01)
-    assert convergence.iloc[-1, 2] == pytest.approx(3.04, 0.01)
+    assert convergence.loc[0, 'Forward'] == pytest.approx(3.07, 0.01)
+    assert convergence.loc[0, 'Backward'] == pytest.approx(3.11, 0.01)
+    assert convergence.loc[9, 'Forward'] == pytest.approx(3.09, 0.01)
+    assert convergence.loc[9, 'Backward'] == pytest.approx(3.09, 0.01)
 
-def test_convergence_bar(gmx_benzene):
+@pytest.mark.parametrize('estimator', ['MBAR', 'BAR'])
+def test_convergence_fep(gmx_benzene, estimator):
     dHdl, u_nk = gmx_benzene
-    convergence = forward_backward_convergence(u_nk, 'BAR')
+    convergence = forward_backward_convergence(u_nk, estimator)
     assert convergence.shape == (10, 5)
-    assert convergence.iloc[0, 0] == pytest.approx(3.02, 0.01)
-    assert convergence.iloc[0, 2] == pytest.approx(3.06, 0.01)
-    assert convergence.iloc[-1, 0] == pytest.approx(3.05, 0.01)
-    assert convergence.iloc[-1, 2] == pytest.approx(3.04, 0.01)
+    assert convergence.loc[0, 'Forward'] == pytest.approx(3.02, 0.01)
+    assert convergence.loc[0, 'Backward'] == pytest.approx(3.06, 0.01)
+    assert convergence.loc[9, 'Forward'] == pytest.approx(3.05, 0.01)
+    assert convergence.loc[9, 'Backward'] == pytest.approx(3.04, 0.01)
 
 def test_convergence_wrong_estimator(gmx_benzene):
     dHdl, u_nk = gmx_benzene

src/alchemlyb/tests/test_fep_estimators.py

@@ -139,6 +139,8 @@ def compare_delta_f(self, X_delta_f):
         assert X_delta_f[2] == pytest.approx(d_delta_f, rel=1e-3)
 
     def get_delta_f(self, est):
+        # Use .iloc[0, -1] as we want to cater for both
+        # delta_f_.loc[0.0, 1.0] and delta_f_.loc[(0.0, 0.0), (0.0, 1.0)]
         return est.delta_f_.iloc[0, -1], est.d_delta_f_.iloc[0, -1]
 
 
@@ -181,7 +183,7 @@ def test_failback_adaptive(self, n_uk_list):
         # The hybr will fail on this while adaptive will work
         mbar = AutoMBAR().fit(alchemlyb.concat([n_uk[:2] for n_uk in
                                                 n_uk_list]))
-        assert np.isclose(mbar.d_delta_f_.iloc[0, -1], 1.76832, 0.1)
+        assert np.isclose(mbar.d_delta_f_[(0.0, 0.0, 0.0)][(1.0, 1.0, 1.0)], 1.76832, 0.1)
 
 def test_AutoMBAR_BGFS():
     # A case where only BFGS would work
@@ -227,6 +229,8 @@ def get_delta_f(self, est):
 
         for i in range(len(est.d_delta_f_) - 1):
             ee += est.d_delta_f_.values[i][i+1]**2
+        # Use .iloc[0, -1] as we want to cater for both
+        # delta_f_.loc[0.0, 1.0] and delta_f_.loc[(0.0, 0.0), (0.0, 1.0)]
         return est.delta_f_.iloc[0, -1], ee**0.5
 
 class Test_Units():

src/alchemlyb/tests/test_preprocessing.py

@@ -150,10 +150,10 @@ def test_disordered_exception(self, data):
         """Test that a shuffled DataFrame yields a KeyError.
 
         """
-        indices = np.arange(len(data))
+        indices = data.index.values
         np.random.shuffle(indices)
 
-        df = data.iloc[indices]
+        df = data.loc[indices]
 
         with pytest.raises(KeyError):
             self.slicer(df, lower=200)
@@ -246,7 +246,7 @@ def test_subsampling(self, data, size):
         """Basic test for execution; resulting size of dataset sensitive to
         machine and depends on algorithm.
         """
-        assert len(self.slicer(data, series=data.iloc[:, 0])) <= size
+        assert len(self.slicer(data, series=data.loc[:, data.columns[0]])) <= size
 
     @pytest.mark.parametrize('data', [gmx_benzene_dHdl(),
                                       gmx_benzene_u_nk()])
@@ -273,7 +273,7 @@ def slicer(self, *args, **kwargs):
                                  (False, gmx_benzene_u_nk(), 3571),
                              ])
     def test_conservative(self, data, size, conservative):
-        sliced = self.slicer(data, series=data.iloc[:, 0], conservative=conservative)
+        sliced = self.slicer(data, series=data.loc[:, data.columns[0]], conservative=conservative)
         # results can vary slightly with different machines
         # so possibly do
         # delta = 10

src/alchemlyb/tests/test_ti_estimators.py

@@ -109,6 +109,8 @@ class TIestimatorMixin:
     def test_get_delta_f(self, X_delta_f):
         dHdl, E, dE = X_delta_f
         est = self.cls().fit(dHdl)
+        # Use .iloc[0, -1] as we want to cater for both
+        # delta_f_.loc[0.0, 1.0] and delta_f_.loc[(0.0, 0.0), (0.0, 1.0)]
         delta_f = est.delta_f_.iloc[0, -1]
         d_delta_f = est.d_delta_f_.iloc[0, -1]
 

src/alchemlyb/tests/test_units.py

@@ -60,7 +60,7 @@ def dhdl():
 
     def test_kt2kt_number(self, dhdl):
         new_dhdl = to_kT(dhdl)
-        assert 12.9 == pytest.approx(new_dhdl.iloc[0, 0], 0.1)
+        assert 12.9 == pytest.approx(new_dhdl.loc[(0.0,0.0)], 0.1)
 
     def test_kt2kt_unit(self, dhdl):
         new_dhdl = to_kT(dhdl)
@@ -74,7 +74,7 @@ def test_kj2kt_unit(self, dhdl):
     def test_kj2kt_number(self, dhdl):
         dhdl.attrs['energy_unit'] = 'kJ/mol'
         new_dhdl = to_kT(dhdl)
-        assert 5.0 == pytest.approx(new_dhdl.iloc[0, 0], 0.1)
+        assert 5.0 == pytest.approx(new_dhdl.loc[(0.0,0.0)], 0.1)
 
     def test_kcal2kt_unit(self, dhdl):
         dhdl.attrs['energy_unit'] = 'kcal/mol'
@@ -84,7 +84,7 @@ def test_kcal2kt_unit(self, dhdl):
     def test_kcal2kt_number(self, dhdl):
         dhdl.attrs['energy_unit'] = 'kcal/mol'
         new_dhdl = to_kT(dhdl)
-        assert 21.0 == pytest.approx(new_dhdl.iloc[0, 0], 0.1)
+        assert 21.0 == pytest.approx(new_dhdl.loc[(0.0,0.0)], 0.1)
 
     def test_unknown2kt(self, dhdl):
         dhdl.attrs['energy_unit'] = 'ddd'

src/alchemlyb/tests/test_visualisation.py

@@ -158,13 +158,13 @@ def test_plot_convergence():
         slice = int(len(data_list[0])/num_points*i)
         u_nk_coul = alchemlyb.concat([data[:slice] for data in data_list])
         estimate = MBAR().fit(u_nk_coul)
-        forward.append(estimate.delta_f_.iloc[0,-1])
-        forward_error.append(estimate.d_delta_f_.iloc[0,-1])
+        forward.append(estimate.delta_f_.loc[0.0,1.0])
+        forward_error.append(estimate.d_delta_f_.loc[0.0,1.0])
         # Do the backward
         u_nk_coul = alchemlyb.concat([data[-slice:] for data in data_list])
         estimate = MBAR().fit(u_nk_coul)
-        backward.append(estimate.delta_f_.iloc[0,-1])
-        backward_error.append(estimate.d_delta_f_.iloc[0,-1])
+        backward.append(estimate.delta_f_.loc[0.0,1.0])
+        backward_error.append(estimate.d_delta_f_.loc[0.0,1.0])
 
     df = pd.DataFrame(data={'Forward': forward,
                             'Forward_Error': forward_error,