simplify: structure.sites -> structure

Author: janosh

docs_rst/conf-normal.py

@@ -348,7 +348,7 @@ def find_source():
         filename = f"pymatgen/core/{rel_path}#L{line_start}-L{line_end}"
     except Exception:
         # no need to be relative to core here as module includes full path.
-        filename = info["module"].replace(".", "/") + ".py"
+        filename = f"{info['module'].replace('.', '/')}.py"
 
     tag = "v" + __version__
     return f"https://github.com/materialsproject/pymatgen/blob/{tag}/{filename}"

pymatgen/analysis/chemenv/coordination_environments/chemenv_strategies.py

@@ -254,57 +254,52 @@ def equivalent_site_index_and_transform(self, psite):
                         isite = isite2
                         break
         # Get the translation between psite and its corresponding site in the unit cell (Translation I)
-        thissite = self.structure_environments.structure[isite]
-        dthissite = psite.frac_coords - thissite.frac_coords
+        this_site = self.structure_environments.structure[isite]
+        dthis_site = psite.frac_coords - this_site.frac_coords
         # Get the translation between the equivalent site for which the neighbors have been computed and the site in
         # the unit cell that corresponds to psite (Translation II)
-        equivsite = self.structure_environments.structure[self.structure_environments.sites_map[isite]].to_unit_cell()
+        equiv_site = self.structure_environments.structure[self.structure_environments.sites_map[isite]].to_unit_cell()
         # equivsite = self.structure_environments.structure[self.structure_environments.sites_map[isite]]
         dequivsite = (
             self.structure_environments.structure[self.structure_environments.sites_map[isite]].frac_coords
-            - equivsite.frac_coords
+            - equiv_site.frac_coords
         )
         found = False
         # Find the symmetry that applies the site in the unit cell to the equivalent site, as well as the translation
         # that gets back the site to the unit cell (Translation III)
         # TODO: check that these tolerances are needed, now that the structures are refined before analyzing envs
         tolerances = [1e-8, 1e-7, 1e-6, 1e-5, 1e-4]
         for tolerance in tolerances:
-            for symop in self.symops:
-                newsite = PeriodicSite(
-                    equivsite._species,
-                    symop.operate(equivsite.frac_coords),
-                    equivsite._lattice,
+            for sym_op in self.symops:
+                new_site = PeriodicSite(
+                    equiv_site._species,
+                    sym_op.operate(equiv_site.frac_coords),
+                    equiv_site._lattice,
                 )
-                if newsite.is_periodic_image(thissite, tolerance=tolerance):
-                    mysym = symop
-                    dthissite2 = thissite.frac_coords - newsite.frac_coords
+                if new_site.is_periodic_image(this_site, tolerance=tolerance):
+                    my_sym = sym_op
+                    dthissite2 = this_site.frac_coords - new_site.frac_coords
                     found = True
                     break
             if not found:
-                symops = [SymmOp.from_rotation_and_translation()]
-                for symop in symops:
-                    newsite = PeriodicSite(
-                        equivsite._species,
-                        symop.operate(equivsite.frac_coords),
-                        equivsite._lattice,
+                sym_ops = [SymmOp.from_rotation_and_translation()]
+                for sym_op in sym_ops:
+                    new_site = PeriodicSite(
+                        equiv_site._species,
+                        sym_op.operate(equiv_site.frac_coords),
+                        equiv_site._lattice,
                     )
                     # if newsite.is_periodic_image(thissite):
-                    if newsite.is_periodic_image(thissite, tolerance=tolerance):
-                        mysym = symop
-                        dthissite2 = thissite.frac_coords - newsite.frac_coords
+                    if new_site.is_periodic_image(this_site, tolerance=tolerance):
+                        my_sym = sym_op
+                        dthissite2 = this_site.frac_coords - new_site.frac_coords
                         found = True
                         break
             if found:
                 break
         if not found:
             raise EquivalentSiteSearchError(psite)
-        return [
-            self.structure_environments.sites_map[isite],
-            dequivsite,
-            dthissite + dthissite2,
-            mysym,
-        ]
+        return [self.structure_environments.sites_map[isite], dequivsite, dthis_site + dthissite2, my_sym]
 
     @abc.abstractmethod
     def get_site_neighbors(self, site):

pymatgen/analysis/interfaces/substrate_analyzer.py

@@ -52,7 +52,7 @@ def from_zsl(
         if elasticity_tensor is not None:
             energy_density = elasticity_tensor.energy_density(strain)
 
-            elastic_energy = film.volume * energy_density / len(film.sites)
+            elastic_energy = film.volume * energy_density / len(film)
         else:
             elastic_energy = 0
 

pymatgen/analysis/magnetism/analyzer.py

@@ -609,11 +609,7 @@ def __init__(
         self,
         structure: Structure,
         default_magmoms: dict[str, float] | None = None,
-        strategies: list[str]
-        | tuple[str, ...] = (
-            "ferromagnetic",
-            "antiferromagnetic",
-        ),
+        strategies: list[str] | tuple[str, ...] = ("ferromagnetic", "antiferromagnetic"),
         automatic: bool = True,
         truncate_by_symmetry: bool = True,
         transformation_kwargs: dict | None = None,
@@ -706,7 +702,11 @@ def __init__(
         # we will first create a set of transformations
         # and then apply them to our input structure
         self.transformations = self._generate_transformations(self.sanitized_structure)
-        self._generate_ordered_structures(self.sanitized_structure, self.transformations)
+        ordered_structures, ordered_structures_origins = self._generate_ordered_structures(
+            self.sanitized_structure, self.transformations
+        )
+        self.ordered_structures = ordered_structures
+        self.ordered_structure_origins = ordered_structures_origins
 
     @staticmethod
     def _sanitize_input_structure(input_structure: Structure) -> Structure:
@@ -934,7 +934,7 @@ def _generate_ordered_structures(
         self,
         sanitized_input_structure: Structure,
         transformations: dict[str, MagOrderingTransformation],
-    ):
+    ) -> tuple[list[Structure], list[str]]:
         """Apply our input structure to our list of transformations and output a list
         of ordered structures that have been pruned for duplicates and for those
         with low symmetry (optional).
@@ -1056,9 +1056,7 @@ def _add_structures(ordered_structures, ordered_structures_origins, structures_t
                 self.logger.info(f"Input structure was found in enumerated structures at index {matches.index(True)}")
                 self.input_index = matches.index(True)
                 self.input_origin = ordered_structures_origins[self.input_index]
-
-        self.ordered_structures = ordered_structures
-        self.ordered_structure_origins = ordered_structures_origins
+        return ordered_structures, ordered_structures_origins
 
 
 MagneticDeformation = namedtuple("MagneticDeformation", "type deformation")

pymatgen/analysis/tests/test_adsorption.py

@@ -105,15 +105,15 @@ def test_generate_adsorption_structures(self):
         # Check translation
         sites = self.asf_211.find_adsorption_sites()
         ads_site_coords = sites["all"][0]
-        c_site = structures[0].sites[-2]
+        c_site = structures[0][-2]
         assert str(c_site.specie) == "C"
         self.assertArrayAlmostEqual(c_site.coords, sites["all"][0])
         # Check no translation
         structures = self.asf_111.generate_adsorption_structures(co, translate=False)
         assert co == Molecule("CO", [[1.0, -0.5, 3], [0.8, 0.46, 3.75]])
         sites = self.asf_111.find_adsorption_sites()
         ads_site_coords = sites["all"][0]
-        c_site = structures[0].sites[-2]
+        c_site = structures[0][-2]
         self.assertArrayAlmostEqual(c_site.coords, ads_site_coords + np.array([1.0, -0.5, 3]))
 
     def test_adsorb_both_surfaces(self):

pymatgen/command_line/enumlib_caller.py

@@ -205,7 +205,7 @@ def get_sg_info(ss):
             finder = SpacegroupAnalyzer(Structure.from_sites(ss), self.symm_prec)
             return finder.get_space_group_number()
 
-        target_sgnum = get_sg_info(symmetrized_structure.sites)
+        target_sgnum = get_sg_info(list(symmetrized_structure))
         curr_sites = list(itertools.chain.from_iterable(disordered_sites))
         sgnum = get_sg_info(curr_sites)
         ordered_sites = sorted(ordered_sites, key=lambda sites: len(sites))
@@ -250,12 +250,12 @@ def get_sg_info(ss):
         output.append(str(self.enum_precision_parameter))
         output.append("full")
 
-        ndisordered = sum(len(s) for s in disordered_sites)
+        n_disordered = sum(len(s) for s in disordered_sites)
         base = int(
-            ndisordered
+            n_disordered
             * lcm(
                 *(
-                    f.limit_denominator(ndisordered * self.max_cell_size).denominator
+                    f.limit_denominator(n_disordered * self.max_cell_size).denominator
                     for f in map(fractions.Fraction, index_amounts)
                 )
             )
@@ -268,7 +268,7 @@ def get_sg_info(ss):
         # enumeration. See Cu7Te5.cif test file.
         base *= 10
 
-        # base = ndisordered #10 ** int(math.ceil(math.log10(ndisordered)))
+        # base = ndisordered # 10 ** int(math.ceil(math.log10(ndisordered)))
         # To get a reasonable number of structures, we fix concentrations to the
         # range expected in the original structure.
         total_amounts = sum(index_amounts)

pymatgen/command_line/tests/test_gulp_caller.py

@@ -306,7 +306,7 @@ def test_get_energy_relax_structure_buckingham(self):
         assert isinstance(energy, float)
         assert isinstance(struct, Structure)
         site_len = len(struct)
-        assert site_len == len(self.mgo_uc.sites)
+        assert site_len == len(self.mgo_uc)
 
 
 @unittest.skipIf(not gulp_present, "gulp not present.")

pymatgen/core/structure.py

@@ -436,7 +436,7 @@ def is_valid(self, tol: float = DISTANCE_TOLERANCE) -> bool:
             (bool) True if SiteCollection does not contain atoms that are too
             close together.
         """
-        if len(self.sites) == 1:
+        if len(self) == 1:
             return True
         all_dists = self.distance_matrix[np.triu_indices(len(self), 1)]
         return bool(np.min(all_dists) > tol)
@@ -480,7 +480,7 @@ def add_site_property(self, property_name: str, values: list):
             values (list): A sequence of values. Must be same length as
                 number of sites.
         """
-        if len(values) != len(self.sites):
+        if len(values) != len(self):
             raise ValueError("Values must be same length as sites.")
         for site, val in zip(self.sites, values):
             site.properties[property_name] = val
@@ -551,8 +551,11 @@ def add_oxidation_state_by_site(self, oxidation_states: list[float]):
             oxidation_states (list): List of oxidation states.
                 E.g., [1, 1, 1, 1, 2, 2, 2, 2, 5, 5, 5, 5, -2, -2, -2, -2]
         """
-        if len(oxidation_states) != len(self.sites):
-            raise ValueError("Oxidation states of all sites must be specified.")
+        if len(oxidation_states) != len(self):
+            raise ValueError(
+                f"Oxidation states of all sites must be specified, expected {len(self)} values, "
+                f"got {len(oxidation_states)}"
+            )
         for site, ox in zip(self.sites, oxidation_states):
             new_sp = {}
             for el, occu in site.species.items():
@@ -613,8 +616,8 @@ def add_spin_by_site(self, spins: list[float]):
             spins (list): List of spins
                 E.g., [+5, -5, 0, 0]
         """
-        if len(spins) != len(self.sites):
-            raise ValueError("Spin of all sites must be specified in the dictionary.")
+        if len(spins) != len(self):
+            raise ValueError(f"Spins for all sites must be specified, expected {len(self)} spins, got {len(spins)}")
 
         for site, spin in zip(self.sites, spins):
             new_sp = {}

pymatgen/core/tests/test_structure.py

@@ -998,14 +998,14 @@ def test_rotate_sites(self):
         self.structure.rotate_sites(
             indices=[1],
             theta=2.0 * np.pi / 3.0,
-            anchor=self.structure.sites[0].coords,
+            anchor=self.structure[0].coords,
             to_unit_cell=False,
         )
         self.assertArrayAlmostEqual(self.structure.frac_coords[1], [-1.25, 1.5, 0.75], decimal=6)
         self.structure.rotate_sites(
             indices=[1],
             theta=2.0 * np.pi / 3.0,
-            anchor=self.structure.sites[0].coords,
+            anchor=self.structure[0].coords,
             to_unit_cell=True,
         )
         self.assertArrayAlmostEqual(self.structure.frac_coords[1], [0.75, 0.5, 0.75], decimal=6)

pymatgen/electronic_structure/boltztrap.py

@@ -1639,14 +1639,15 @@ def get_complete_dos(self, structure: Structure, analyzer_for_second_spin=None):
                 raise BoltztrapError("Dos merging error: spin component are the same")
 
         for s in self._dos_partial:
-            if structure.sites[int(s)] not in pdoss:
-                pdoss[structure.sites[int(s)]] = {}
+            idx = int(s)
+            if structure[idx] not in pdoss:
+                pdoss[structure[idx]] = {}
             for o in self._dos_partial[s]:
-                if Orbital[o] not in pdoss[structure.sites[int(s)]]:
-                    pdoss[structure.sites[int(s)]][Orbital[o]] = {}
-                pdoss[structure.sites[int(s)]][Orbital[o]][spin_1] = self._dos_partial[s][o]
+                if Orbital[o] not in pdoss[structure[idx]]:
+                    pdoss[structure[idx]][Orbital[o]] = {}
+                pdoss[structure[idx]][Orbital[o]][spin_1] = self._dos_partial[s][o]
                 if analyzer_for_second_spin:
-                    pdoss[structure.sites[int(s)]][Orbital[o]][spin_2] = analyzer_for_second_spin._dos_partial[s][o]
+                    pdoss[structure[idx]][Orbital[o]][spin_2] = analyzer_for_second_spin._dos_partial[s][o]
         if analyzer_for_second_spin:
             tdos = Dos(
                 self.dos.efermi,

pymatgen/electronic_structure/cohp.py

@@ -796,7 +796,7 @@ def from_file(cls, fmt, filename=None, structure_file=None, are_coops=False, are
         bond_dict = {
             label: {
                 "length": v["length"],
-                "sites": [structure.sites[site] for site in v["sites"]],
+                "sites": [structure[site] for site in v["sites"]],
             }
             for label, v in cohp_data.items()
         }

pymatgen/io/lammps/data.py

@@ -783,10 +783,10 @@ def from_ff_and_topologies(cls, box, ff, topologies, atom_style="full"):
                     topo_labels[k].extend([tuple(topo.type_by_sites[j] for j in t) for t in v])
             if isinstance(v_collector, list):
                 v_collector.append(topo.velocities)
-            mol_ids.extend([i + 1] * len(topo.sites))
+            mol_ids.extend([i + 1] * len(topo))
             labels.extend(topo.type_by_sites)
             coords.append(topo.sites.cart_coords)
-            q = [0.0] * len(topo.sites) if not topo.charges else topo.charges
+            q = [0.0] * len(topo) if not topo.charges else topo.charges
             charges.extend(q)
 
         atoms = pd.DataFrame(np.concatenate(coords), columns=["x", "y", "z"])

pymatgen/io/lobster/lobsterenv.py

@@ -822,10 +822,10 @@ def _find_environments(self, additional_condition, lowerlimit, upperlimit, only_
         list_icohps = []
         list_lengths = []
         list_keys = []
-        for isite in range(len(self.structure)):
+        for idx in range(len(self.structure)):
             icohps = self._get_icohps(
                 icohpcollection=self.Icohpcollection,
-                isite=isite,
+                isite=idx,
                 lowerlimit=lowerlimit,
                 upperlimit=upperlimit,
                 only_bonds_to=only_bonds_to,
@@ -836,10 +836,10 @@ def _find_environments(self, additional_condition, lowerlimit, upperlimit, only_
                 lengths_from_ICOHPs,
                 neighbors_from_ICOHPs,
                 selected_ICOHPs,
-            ) = self._find_relevant_atoms_additional_condition(isite, icohps, additional_condition)
+            ) = self._find_relevant_atoms_additional_condition(idx, icohps, additional_condition)
 
             if len(neighbors_from_ICOHPs) > 0:
-                centralsite = self.structure.sites[isite]
+                centralsite = self.structure[idx]
 
                 neighbors_by_distance_start = self.structure.get_sites_in_sphere(
                     pt=centralsite.coords,

pymatgen/io/res.py

@@ -290,7 +290,7 @@ def _sfac_from_sites(cls, sites: list[PeriodicSite]) -> ResSFAC:
     @classmethod
     def _res_from_structure(cls, structure: Structure) -> Res:
         """Produce a res file structure from a pymatgen Structure."""
-        return Res(None, [], cls._cell_from_lattice(structure.lattice), cls._sfac_from_sites(list(structure.sites)))
+        return Res(None, [], cls._cell_from_lattice(structure.lattice), cls._sfac_from_sites(list(structure)))
 
     @classmethod
     def _res_from_entry(cls, entry: ComputedStructureEntry) -> Res:
@@ -305,7 +305,7 @@ def _res_from_entry(cls, entry: ComputedStructureEntry) -> Res:
             AirssTITL(seed, pres, entry.structure.volume, entry.energy, isd, iasd, spg, 1),
             rems,
             cls._cell_from_lattice(entry.structure.lattice),
-            cls._sfac_from_sites(list(entry.structure.sites)),
+            cls._sfac_from_sites(list(entry.structure)),
         )
 
     def __init__(self, entry: Structure | ComputedStructureEntry):

pymatgen/io/tests/test_babel.py

@@ -95,7 +95,7 @@ def add_hydrogen(self):
         assert len(pb.Molecule(mol_0d).atoms) == 2
         adaptor = BabelMolAdaptor(mol_0d)
         adaptor.add_hydrogen()
-        assert len(adaptor.pymatgen_mol.sites) == 14
+        assert len(adaptor.pymatgen_mol) == 14
 
     def test_rotor_search_wrs(self):
         mol = copy.deepcopy(self.mol)