delete print debugging statements in tests

delete dead code (commended out)

Author: janosh

pymatgen/analysis/adsorption.py

@@ -110,7 +110,7 @@ def from_bulk_and_miller(
                 are 10% less coordinated than their bulk counterpart
         """
         # TODO: for some reason this works poorly with primitive cells
-        #       may want to switch the coordination algorithm eventually
+        # may want to switch the coordination algorithm eventually
         vnn_bulk = VoronoiNN(tol=0.05)
         bulk_coords = [len(vnn_bulk.get_nn(structure, n)) for n in range(len(structure))]
         struct = structure.copy(site_properties={"bulk_coordinations": bulk_coords})

pymatgen/analysis/local_env.py

@@ -445,8 +445,7 @@ def get_nn_shell_info(self, structure: Structure, site_idx, shell):
         all_nn_info = self.get_all_nn_info(structure)
         sites = self._get_nn_shell_info(structure, all_nn_info, site_idx, shell)
 
-        # Update the site positions
-        #   Did not do this during NN options because that can be slower
+        # Now update the site positions. Did not do this during NN options because that can be slower.
         output = []
         for info in sites:
             orig_site = structure[info["site_index"]]
@@ -495,8 +494,8 @@ def _get_nn_shell_info(
         possible_steps = list(all_nn_info[site_idx])
         for i, step in enumerate(possible_steps):
             # Update the image information
-            #  Note: We do not update the site position yet, as making a
-            #    PeriodicSite for each intermediate step is too costly
+            # Note: We do not update the site position yet, as making a PeriodicSite
+            # for each intermediate step is too costly
             step = dict(step)
             step["image"] = tuple(np.add(step["image"], _cur_image).tolist())
             possible_steps[i] = step
@@ -743,8 +742,7 @@ def get_voronoi_polyhedra(self, structure: Structure, n: int):
                 - volume - Volume of Voronoi cell for this face
                 - n_verts - Number of vertices on the facet
         """
-        # Assemble the list of neighbors used in the tessellation
-        #   Gets all atoms within a certain radius
+        # Assemble the list of neighbors used in the tessellation. Gets all atoms within a certain radius
         targets = structure.elements if self.targets is None else self.targets
         center = structure[n]
 
@@ -814,8 +812,7 @@ def get_all_voronoi_polyhedra(self, structure: Structure):
         sites = [x.to_unit_cell() for x in structure]
         indices = [(i, 0, 0, 0) for i, _ in enumerate(structure)]
 
-        # Get all neighbors within a certain cutoff
-        #   Record both the list of these neighbors, and the site indices
+        # Get all neighbors within a certain cutoff. Record both the list of these neighbors and the site indices.
         all_neighs = structure.get_all_neighbors(self.cutoff, include_index=True, include_image=True)
         for neighs in all_neighs:
             sites.extend([x[0] for x in neighs])
@@ -1548,8 +1545,7 @@ def get_nn_shell_info(self, structure: Structure, site_idx, shell):
         all_nn_info = self.get_all_nn_info(structure)
         sites = self._get_nn_shell_info(structure, all_nn_info, site_idx, shell)
 
-        # Update the site positions
-        #   Did not do this during NN options because that can be slower
+        # Now update the site positions. Did not do this during NN options because that can be slower.
         output = []
         for info in sites:
             orig_site = structure[info["site_index"]]
@@ -1694,8 +1690,7 @@ def get_nn_shell_info(self, structure: Structure, site_idx, shell):
         all_nn_info = self.get_all_nn_info(structure)
         sites = self._get_nn_shell_info(structure, all_nn_info, site_idx, shell)
 
-        # Update the site positions
-        #   Did not do this during NN options because that can be slower
+        # Now update the site positions. Did not do this during NN options because that can be slower.
         output = []
         for info in sites:
             orig_site = structure[info["site_index"]]
@@ -2663,7 +2658,7 @@ def get_q6(self, thetas=None, phis=None):
         real = 0.0
         imag = 0.0
         for idx in nnn_range:
-            real += pre_y_6_6[idx] * self._cos_n_p[6][idx]  # cos(x) =  cos(-x)
+            real += pre_y_6_6[idx] * self._cos_n_p[6][idx]  # cos(x) = cos(-x)
             imag -= pre_y_6_6[idx] * self._sin_n_p[6][idx]  # sin(x) = -sin(-x)
         acc += real * real + imag * imag
 

pymatgen/analysis/phase_diagram.py

@@ -1722,19 +1722,19 @@ def from_dict(cls, dct):
         elements = [Element.from_dict(elem) for elem in dct["elements"]]
         return cls(entries, elements)
 
-    # NOTE the following could be inherited unchanged from PhaseDiagram:
-    #     __repr__,
-    #     as_dict,
-    #     all_entries_hulldata,
-    #     unstable_entries,
-    #     stable_entries,
-    #     get_form_energy(),
-    #     get_form_energy_per_atom(),
-    #     get_hull_energy(),
-    #     get_e_above_hull(),
-    #     get_decomp_and_e_above_hull(),
-    #     get_decomp_and_phase_separation_energy(),
-    #     get_phase_separation_energy()
+    # NOTE following methods are inherited unchanged from PhaseDiagram:
+    # __repr__,
+    # as_dict,
+    # all_entries_hulldata,
+    # unstable_entries,
+    # stable_entries,
+    # get_form_energy(),
+    # get_form_energy_per_atom(),
+    # get_hull_energy(),
+    # get_e_above_hull(),
+    # get_decomp_and_e_above_hull(),
+    # get_decomp_and_phase_separation_energy(),
+    # get_phase_separation_energy()
 
     def get_pd_for_entry(self, entry: Entry | Composition) -> PhaseDiagram:
         """

pymatgen/analysis/piezo_sensitivity.py

@@ -131,14 +131,14 @@ def get_rand_BEC(self, max_charge=1):
                 )
                 BEC[atom] = temp_tensor
             else:
-                tempfcm = np.zeros([3, 3])
+                temp_fcm = np.zeros([3, 3])
                 for op in ops[2]:
-                    tempfcm += op.transform_tensor(BEC[self.BEC_operations[atom][1]])
-                BEC[ops[0]] = tempfcm
+                    temp_fcm += op.transform_tensor(BEC[self.BEC_operations[atom][1]])
+                BEC[ops[0]] = temp_fcm
                 if len(ops[2]) != 0:
                     BEC[ops[0]] = BEC[ops[0]] / len(ops[2])
 
-        #     Enforce Acoustic Sum
+        # Enforce Acoustic Sum
         disp_charge = np.einsum("ijk->jk", BEC) / n_atoms
         add = np.zeros([n_atoms, 3, 3])
 

pymatgen/analysis/pourbaix_diagram.py

@@ -70,7 +70,7 @@
 
 # TODO: Revise to more closely reflect PDEntry, invoke from energy/composition
 # TODO: PourbaixEntries depend implicitly on having entry energies be
-#       formation energies, should be a better way to get from raw energies
+# formation energies, should be a better way to get from raw energies
 # TODO: uncorrected_energy is a bit of a misnomer, but not sure what to rename
 class PourbaixEntry(MSONable, Stringify):
     """
@@ -338,7 +338,7 @@ def from_dict(cls, dct):
 
 
 # TODO: this class isn't particularly useful in its current form, could be
-#       refactored to include information about the reference solid
+# refactored to include information about the reference solid
 class IonEntry(PDEntry):
     """
     Object similar to PDEntry, but contains an Ion object instead of a
@@ -404,12 +404,11 @@ def ion_or_solid_comp_object(formula):
 
 
 # TODO: the solids filter breaks some of the functionality of the
-#       heatmap plotter, because the reference states for decomposition
-#       don't include oxygen/hydrogen in the OER/HER regions
+# heatmap plotter, because the reference states for decomposition
+# don't include oxygen/hydrogen in the OER/HER regions
 
 
-# TODO: create a from_phase_diagram class method for non-formation energy
-#       invocation
+# TODO: create a from_phase_diagram class method for non-formation energy invocation
 # TODO: invocation from a MultiEntry entry list could be a bit more robust
 # TODO: serialization is still a bit rough around the edges
 class PourbaixDiagram(MSONable):

pymatgen/analysis/surface_analysis.py

@@ -1316,24 +1316,6 @@ def set_all_variables(self, delu_dict, delu_default):
 
         return all_delu_dict
 
-        # def surface_phase_diagram(self, y_param, x_param, miller_index):
-        #     return
-        #
-        # def wulff_shape_extrapolated_model(self):
-        #     return
-        #
-        # def surface_pourbaix_diagram(self):
-        #
-        #     return
-        #
-        # def surface_p_vs_t_phase_diagram(self):
-        #
-        #     return
-        #
-        # def broken_bond_vs_gamma(self):
-        #
-        #     return
-
 
 def entry_dict_from_list(all_slab_entries):
     """
@@ -1949,15 +1931,6 @@ def plot_all_stability_map(
 
         return plt
 
-        # class GetChempotRange:
-        #     def __init__(self, entry):
-        #         self.entry = entry
-        #
-        #
-        # class SlabEntryGenerator:
-        #     def __init__(self, entry):
-        #         self.entry = entry
-
 
 def sub_chempots(gamma_dict, chempots):
     """

tests/analysis/test_adsorption.py

@@ -144,34 +144,32 @@ def test_generate_substitution_structures(self):
         # Test this for a low miller index halite structure
         slabs = generate_all_slabs(self.MgO, 1, 10, 10, center_slab=True, max_normal_search=1)
         for slab in slabs:
-            adsgen = AdsorbateSiteFinder(slab)
+            site_finder = AdsorbateSiteFinder(slab)
 
-            ad_slabss = adsgen.generate_substitution_structures("Ni")
+            sub_structs = site_finder.generate_substitution_structures("Ni")
             # There should be 2 configs (sub O and sub
             # Mg) for (110) and (100), 1 for (111)
             if tuple(slab.miller_index) != (1, 1, 1):
-                assert len(ad_slabss) == 2
+                assert len(sub_structs) == 2
             else:
-                assert len(ad_slabss) == 1
+                assert len(sub_structs) == 1
 
             # Test out whether it can correctly dope both
             # sides. Avoid (111) because it is not symmetric
             if tuple(slab.miller_index) != (1, 1, 1):
-                ad_slabss = adsgen.generate_substitution_structures("Ni", sub_both_sides=True, target_species=["Mg"])
+                sub_structs = site_finder.generate_substitution_structures(
+                    "Ni", sub_both_sides=True, target_species=["Mg"]
+                )
                 # Test if default parameters dope the surface site
-                for i, site in enumerate(ad_slabss[0]):
-                    if adsgen.slab[i].surface_properties == "surface" and site.species_string == "Mg":
-                        print(
-                            ad_slabss[0][i].surface_properties,
-                            adsgen.slab[i].surface_properties,
-                        )
-                        assert ad_slabss[0][i].surface_properties == "substitute"
-
-                assert ad_slabss[0].is_symmetric()
+                for i, site in enumerate(sub_structs[0]):
+                    if site_finder.slab[i].surface_properties == "surface" and site.species_string == "Mg":
+                        assert sub_structs[0][i].surface_properties == "substitute"
+
+                assert sub_structs[0].is_symmetric()
                 # Correctly dope the target species
-                assert ad_slabss[0].composition.as_dict()["Mg"] == slab.composition.as_dict()["Mg"] - 2
+                assert sub_structs[0].composition.as_dict()["Mg"] == slab.composition.as_dict()["Mg"] - 2
                 # There should be one config (sub Mg)
-                assert len(ad_slabss) == 1
+                assert len(sub_structs) == 1
 
     def test_functions(self):
         slab = self.slab_dict["111"]

tests/analysis/test_eos.py

@@ -402,38 +402,38 @@ def test_numerical_eoswrapper(self):
         assert_allclose(numerical_eos.eos_params, self.num_eos_fit.eos_params)
 
     def test_numerical_eos_values(self):
-        np.testing.assert_allclose(self.num_eos_fit.e0, -10.84749, atol=1e-3)
-        np.testing.assert_allclose(self.num_eos_fit.v0, 40.857201, atol=1e-1)
-        np.testing.assert_allclose(self.num_eos_fit.b0, 0.55, atol=1e-2)
+        assert_allclose(self.num_eos_fit.e0, -10.84749, atol=1e-3)
+        assert_allclose(self.num_eos_fit.v0, 40.857201, atol=1e-1)
+        assert_allclose(self.num_eos_fit.b0, 0.55, atol=1e-2)
         # TODO: why were these tests commented out?
-        # np.testing.assert_allclose(self.num_eos_fit.b0_GPa, 89.0370727, atol=1e-1)
-        # np.testing.assert_allclose(self.num_eos_fit.b1, 4.344039, atol=1e-2)
+        # assert_allclose(self.num_eos_fit.b0_GPa, 89.0370727, atol=1e-1)
+        # assert_allclose(self.num_eos_fit.b1, 4.344039, atol=1e-2)
 
     def test_eos_func(self):
         # list vs np.array arguments
-        np.testing.assert_allclose(
+        assert_allclose(
             self.num_eos_fit.func([0, 1, 2]),
             self.num_eos_fit.func(np.array([0, 1, 2])),
         )
         # func vs _func
-        np.testing.assert_allclose(
+        assert_allclose(
             self.num_eos_fit.func(0.0),
             self.num_eos_fit._func(0.0, self.num_eos_fit.eos_params),
         )
         # test the eos function: energy = f(volume)
         # numerical eos evaluated at volume=0 == a0 of the fit polynomial
-        np.testing.assert_allclose(self.num_eos_fit.func(0.0), self.num_eos_fit.eos_params[-1])
+        assert_allclose(self.num_eos_fit.func(0.0), self.num_eos_fit.eos_params[-1])
         birch_eos = EOS(eos_name="birch")
         birch_eos_fit = birch_eos.fit(self.volumes, self.energies)
         # birch eos evaluated at v0 == e0
-        np.testing.assert_allclose(birch_eos_fit.func(birch_eos_fit.v0), birch_eos_fit.e0)
+        assert_allclose(birch_eos_fit.func(birch_eos_fit.v0), birch_eos_fit.e0)
 
         fig = birch_eos_fit.plot_ax(ax=None, show=False, fontsize=8, title="birch eos")
         assert hasattr(fig, "savefig")
 
     def test_eos_func_call(self):
         # eos_fit_obj.func(volume) == eos_fit_obj(volume)
-        np.testing.assert_allclose(self.num_eos_fit.func(0.0), self.num_eos_fit(0.0))
+        assert_allclose(self.num_eos_fit.func(0.0), self.num_eos_fit(0.0))
 
     def test_summary_dict(self):
         d = {

tests/analysis/test_interface_reactions.py

@@ -435,8 +435,7 @@ def name_lst(lst):
         def energy_lst(lst):
             return lst[0][1], lst[1][1]
 
-        result_info = [i.get_no_mixing_energy() for i in self.irs if i.grand]
-        print(result_info)
+        result_info = [ir.get_no_mixing_energy() for ir in self.irs if ir.grand]
         for i, j in zip(result_info, answer):
             err_msg = f"get_no_mixing_energy: names get error, {name_lst(j)} expected but gets {name_lst(i)}"
             assert name_lst(i) == name_lst(j), err_msg

tests/analysis/test_quasiharmonic_debye_approx.py

@@ -3,6 +3,7 @@
 import unittest
 
 import numpy as np
+from numpy.testing import assert_allclose
 
 from pymatgen.analysis.eos import EOS
 from pymatgen.analysis.quasiharmonic import QuasiharmonicDebyeApprox
@@ -107,34 +108,33 @@ def setUp(self):
     def test_bulk_modulus(self):
         eos = EOS(self.eos)
         eos_fit = eos.fit(self.volumes, self.energies)
-        print(f"{eos_fit.b0_GPa=!s}")
         bulk_modulus = float(str(eos_fit.b0_GPa).split()[0])
         bulk_modulus_ans = float(str(self.qhda.bulk_modulus).split()[0])
-        np.testing.assert_allclose(bulk_modulus, bulk_modulus_ans, atol=1e-3)
+        assert_allclose(bulk_modulus, bulk_modulus_ans, atol=1e-3)
 
     def test_optimum_volume(self):
         opt_vol = self.qhda.optimum_volumes[0]
-        np.testing.assert_allclose(opt_vol, self.opt_vol, atol=1e-3)
+        assert_allclose(opt_vol, self.opt_vol, atol=1e-3)
 
     def test_debye_temperature(self):
         theta = self.qhda.debye_temperature(self.opt_vol)
-        np.testing.assert_allclose(theta, 2559.675227, atol=1e-3)
+        assert_allclose(theta, 2559.675227, atol=1e-3)
 
     def test_gruneisen_parameter(self):
         gamma = self.qhda.gruneisen_parameter(self.T, self.opt_vol)
-        np.testing.assert_allclose(gamma, 1.670486, atol=1e-3)
+        assert_allclose(gamma, 1.670486, atol=1e-3)
 
     def test_thermal_conductivity(self):
         kappa = self.qhda.thermal_conductivity(self.T, self.opt_vol)
-        np.testing.assert_allclose(kappa, 131.736242, atol=1e-1)
+        assert_allclose(kappa, 131.736242, atol=1e-1)
 
     def test_vibrational_internal_energy(self):
         u = self.qhda.vibrational_internal_energy(self.T, self.opt_vol)
-        np.testing.assert_allclose(u, 0.50102, atol=1e-3)
+        assert_allclose(u, 0.50102, atol=1e-3)
 
     def test_vibrational_free_energy(self):
         A = self.qhda.vibrational_free_energy(self.T, self.opt_vol)
-        np.testing.assert_allclose(A, 0.494687, atol=1e-3)
+        assert_allclose(A, 0.494687, atol=1e-3)
 
 
 class TestAnharmonicQuasiharmociDebyeApprox(unittest.TestCase):
@@ -185,24 +185,24 @@ def setUp(self):
 
     def test_optimum_volume(self):
         opt_vol = self.qhda.optimum_volumes[0]
-        np.testing.assert_allclose(opt_vol, self.opt_vol, atol=1e-3)
+        assert_allclose(opt_vol, self.opt_vol, atol=1e-3)
 
     def test_debye_temperature(self):
         theta = self.qhda.debye_temperature(self.opt_vol)
         np.testing.assert_approx_equal(theta, 601.239096, 4)
 
     def test_gruneisen_parameter(self):
         gamma = self.qhda.gruneisen_parameter(0, self.qhda.ev_eos_fit.v0)
-        np.testing.assert_allclose(gamma, 2.188302, atol=1e-3)
+        assert_allclose(gamma, 2.188302, atol=1e-3)
 
     def test_thermal_conductivity(self):
         kappa = self.qhda.thermal_conductivity(self.T, self.opt_vol)
-        np.testing.assert_allclose(kappa, 21.810997, atol=1e-1)
+        assert_allclose(kappa, 21.810997, atol=1e-1)
 
     def test_vibrational_internal_energy(self):
         u = self.qhda.vibrational_internal_energy(self.T, self.opt_vol)
-        np.testing.assert_allclose(u, 0.13845, atol=1e-3)
+        assert_allclose(u, 0.13845, atol=1e-3)
 
     def test_vibrational_free_energy(self):
         A = self.qhda.vibrational_free_energy(self.T, self.opt_vol)
-        np.testing.assert_allclose(A, -0.014620, atol=1e-3)
+        assert_allclose(A, -0.014620, atol=1e-3)