simplify: structure.sites -> structure

Author: janosh

pymatgen/analysis/local_env.py

@@ -81,17 +81,16 @@ def radii(self):
         """
         List of ionic radii of elements in the order of sites.
         """
-        el = [site.species_string for site in self._structure.sites]
-        radii_dict = dict(zip(el, self._ionic_radii))
-        # print radii_dict
+        elems = [site.species_string for site in self._structure]
+        radii_dict = dict(zip(elems, self._ionic_radii))
         return radii_dict
 
     @property
     def valences(self):
         """
         List of oxidation states of elements in the order of sites.
         """
-        el = [site.species_string for site in self._structure.sites]
+        el = [site.species_string for site in self._structure]
         valence_dict = dict(zip(el, self._valences))
         return valence_dict
 
@@ -122,7 +121,7 @@ def nearest_key(sorted_vals, skey):
                 return after
             return before
 
-        for i, site in enumerate(self._structure.sites):
+        for i, site in enumerate(self._structure):
             if isinstance(site.specie, Element):
                 radius = site.specie.atomic_radius
                 # Handle elements with no atomic_radius
@@ -186,7 +185,7 @@ def _get_valences(self):
                 valences = bv.get_valences(self._structure)
             except Exception:
                 valences = []
-                for site in self._structure.sites:
+                for site in self._structure:
                     if len(site.specie.common_oxidation_states) > 0:
                         valences.append(site.specie.common_oxidation_states[0])
                     # Handle noble gas species
@@ -199,9 +198,9 @@ def _get_valences(self):
                     self._structure.add_oxidation_state_by_site(valences)
                 # raise
 
-        # el = [site.specie.symbol for site in self._structure.sites]
-        # el = [site.species_string for site in self._structure.sites]
-        # el = [site.specie for site in self._structure.sites]
+        # el = [site.specie.symbol for site in self._structure]
+        # el = [site.species_string for site in self._structure]
+        # el = [site.specie for site in self._structure]
         # valence_dict = dict(zip(el, valences))
         # print valence_dict
         return valences
@@ -2093,7 +2092,7 @@ def site_is_of_motif_type(struct, n, approach="min_dist", delta=0.1, cutoff=10,
     ops = LocalStructOrderParams(["cn", "tet", "oct", "bcc", "q6", "sq_pyr", "tri_bipyr"])
 
     neighs_cent = get_neighbors_of_site_with_index(struct, n, approach=approach, delta=delta, cutoff=cutoff)
-    neighs_cent.append(struct.sites[n])
+    neighs_cent.append(struct[n])
     opvals = ops.get_order_parameters(
         neighs_cent,
         len(neighs_cent) - 1,

pymatgen/analysis/magnetism/analyzer.py

@@ -219,12 +219,12 @@ def __init__(
         # round magmoms on magnetic ions below threshold to zero
         # and on non magnetic ions below threshold_nonmag
         magmoms = [
-            m
-            if abs(m) > threshold and a.species_string in self.default_magmoms
-            else m
-            if abs(m) > threshold_nonmag and a.species_string not in self.default_magmoms
+            magmom
+            if abs(magmom) > threshold and site.species_string in self.default_magmoms
+            else magmom
+            if abs(magmom) > threshold_nonmag and site.species_string not in self.default_magmoms
             else 0
-            for (m, a) in zip(magmoms, structure.sites)
+            for magmom, site in zip(magmoms, structure)
         ]
 
         # overwrite existing magmoms with default_magmoms

pymatgen/analysis/piezo_sensitivity.py

@@ -376,8 +376,8 @@ def get_unstable_FCM(self, max_force=1):
         struct = self.structure
         operations = self.FCM_operations
         # set max force in reciprocal space
-        numsites = len(struct.sites)
-        D = (1 / max_force) * 2 * (np.ones([numsites * 3, numsites * 3]))
+        n_sites = len(struct)
+        D = (1 / max_force) * 2 * (np.ones([n_sites * 3, n_sites * 3]))
         for op in operations:
             same = 0
             transpose = 0
@@ -634,30 +634,30 @@ def get_rand_FCM(self, asum=15, force=10):
         """
         from pymatgen.io.phonopy import get_phonopy_structure
 
-        numsites = len(self.structure.sites)
+        n_sites = len(self.structure)
         structure = get_phonopy_structure(self.structure)
         pnstruc = Phonopy(structure, np.eye(3), np.eye(3))
 
         dyn = self.get_unstable_FCM(force)
         dyn = self.get_stable_FCM(dyn)
 
-        dyn = np.reshape(dyn, (numsites, 3, numsites, 3)).swapaxes(1, 2)
+        dyn = np.reshape(dyn, (n_sites, 3, n_sites, 3)).swapaxes(1, 2)
 
         dynmass = np.zeros([len(self.structure), len(self.structure), 3, 3])
         masses = []
-        for j in range(numsites):
-            masses.append(self.structure.sites[j].specie.atomic_mass)
-        dynmass = np.zeros([numsites, numsites, 3, 3])
-        for m in range(numsites):
-            for n in range(numsites):
+        for idx in range(n_sites):
+            masses.append(self.structure[idx].specie.atomic_mass)
+        dynmass = np.zeros([n_sites, n_sites, 3, 3])
+        for m in range(n_sites):
+            for n in range(n_sites):
                 dynmass[m][n] = dyn[m][n] * np.sqrt(masses[m]) * np.sqrt(masses[n])
 
         supercell = pnstruc.get_supercell()
         primitive = pnstruc.get_primitive()
 
         converter = dyntofc.DynmatToForceConstants(primitive, supercell)
 
-        dyn = np.reshape(np.swapaxes(dynmass, 1, 2), (numsites * 3, numsites * 3))
+        dyn = np.reshape(np.swapaxes(dynmass, 1, 2), (n_sites * 3, n_sites * 3))
 
         converter.set_dynamical_matrices(dynmat=[dyn])
 

pymatgen/analysis/structure_prediction/substitutor.py

@@ -160,7 +160,7 @@ def _is_charge_balanced(struct):
         """
         Checks if the structure object is charge balanced
         """
-        return sum(s.specie.oxi_state for s in struct.sites) == 0.0
+        return sum(site.specie.oxi_state for site in struct) == 0.0
 
     @staticmethod
     def _is_from_chemical_system(chemical_system, struct):

pymatgen/command_line/gulp_caller.py

@@ -299,12 +299,12 @@ def structure_lines(
 
         if frac_flg:
             gin += "frac\n"
-            coord_attr = "frac_coords"
+            coords_key = "frac_coords"
         else:
             gin += "cart\n"
-            coord_attr = "coords"
-        for site in structure.sites:
-            coord = [str(i) for i in getattr(site, coord_attr)]
+            coords_key = "coords"
+        for site in structure:
+            coord = [str(i) for i in getattr(site, coords_key)]
             specie = site.specie
             core_site_desc = specie.symbol + " core " + " ".join(coord) + "\n"
             gin += core_site_desc

pymatgen/command_line/tests/test_gulp_caller.py

@@ -253,7 +253,7 @@ def test_get_relaxed_structure(self):
             out_str = fp.read()
         struct = self.gio.get_relaxed_structure(out_str)
         assert isinstance(struct, Structure)
-        assert len(struct.sites) == 8
+        assert len(struct) == 8
         assert struct.lattice.a == 4.212
         assert struct.lattice.alpha == 90
 
@@ -286,12 +286,12 @@ def setUp(self):
     def test_get_energy_tersoff(self):
         p = Poscar.from_file(os.path.join(PymatgenTest.TEST_FILES_DIR, "POSCAR.Al12O18"), check_for_POTCAR=False)
         structure = p.structure
-        enrgy = get_energy_tersoff(structure)
-        assert isinstance(enrgy, float)
+        energy = get_energy_tersoff(structure)
+        assert isinstance(energy, float)
 
     def test_get_energy_buckingham(self):
-        enrgy = get_energy_buckingham(self.mgo_uc)
-        assert isinstance(enrgy, float)
+        energy = get_energy_buckingham(self.mgo_uc)
+        assert isinstance(energy, float)
         # test with vacancy structure
         del self.mgo_uc[0]
         energy = get_energy_buckingham(
@@ -302,10 +302,10 @@ def test_get_energy_buckingham(self):
         assert isinstance(energy, float)
 
     def test_get_energy_relax_structure_buckingham(self):
-        enrgy, struct = get_energy_relax_structure_buckingham(self.mgo_uc)
-        assert isinstance(enrgy, float)
+        energy, struct = get_energy_relax_structure_buckingham(self.mgo_uc)
+        assert isinstance(energy, float)
         assert isinstance(struct, Structure)
-        site_len = len(struct.sites)
+        site_len = len(struct)
         assert site_len == len(self.mgo_uc.sites)
 
 

pymatgen/core/structure.py

@@ -773,17 +773,17 @@ def from_sites(
         prop_keys: list[str] = []
         props = {}
         lattice = sites[0].lattice
-        for i, site in enumerate(sites):
+        for idx, site in enumerate(sites):
             if site.lattice != lattice:
                 raise ValueError("Sites must belong to the same lattice")
-            for k, v in site.properties.items():
-                if k not in prop_keys:
-                    prop_keys.append(k)
-                    props[k] = [None] * len(sites)
-                props[k][i] = v
-        for k, v in props.items():
-            if any(vv is None for vv in v):
-                warnings.warn(f"Not all sites have property {k}. Missing values are set to None.")
+            for key, val in site.properties.items():
+                if key not in prop_keys:
+                    prop_keys.append(key)
+                    props[key] = [None] * len(sites)
+                props[key][idx] = val
+        for key, val in props.items():
+            if any(vv is None for vv in val):
+                warnings.warn(f"Not all sites have property {key}. Missing values are set to None.")
         return cls(
             lattice,
             [site.species for site in sites],

pymatgen/electronic_structure/boltztrap.py

@@ -382,7 +382,7 @@ def write_proj(self, output_file_proj, output_file_def):
         # This function is useless in std version of BoltzTraP code
         # because x_trans script overwrite BoltzTraP.def
         for oi, o in enumerate(Orbital):
-            for site_nb in range(0, len(self._bs.structure.sites)):
+            for site_nb in range(len(self._bs.structure)):
                 if oi < len(self._bs.projections[Spin.up][0][0]):
                     with open(output_file_proj + "_" + str(site_nb) + "_" + str(o), "w") as f:
                         f.write(self._bs.structure.composition.formula + "\n")
@@ -424,7 +424,7 @@ def write_proj(self, output_file_proj, output_file_def):
             )
             i = 1000
             for oi, o in enumerate(Orbital):
-                for site_nb in range(0, len(self._bs.structure.sites)):
+                for site_nb in range(0, len(self._bs.structure)):
                     if oi < len(self._bs.projections[Spin.up][0][0]):
                         f.write(f"{i},'boltztrap.proj_{site_nb}_{o.name}old', 'formatted',0\n")
                         i += 1

pymatgen/electronic_structure/boltztrap2.py

@@ -623,7 +623,7 @@ def get_partial_doses(self, tdos, eband_ud, spins, enr, npts_mu, T, progress):
             n_iter = np.prod(np.sum([np.array(i.shape)[2:] for i in self.data.proj.values()]))
             t = tqdm(total=n_iter * 2)
         for spin, eb in zip(spins, eband_ud):
-            for isite, site in enumerate(self.data.structure.sites):
+            for idx, site in enumerate(self.data.structure):
                 if site not in pdoss:
                     pdoss[site] = {}
                 for iorb, orb in enumerate(Orbital):
@@ -635,7 +635,7 @@ def get_partial_doses(self, tdos, eband_ud, spins, enr, npts_mu, T, progress):
                     if orb not in pdoss[site]:
                         pdoss[site][orb] = {}
 
-                    self.data.ebands = self.data.proj[spin][:, :, isite, iorb].T
+                    self.data.ebands = self.data.proj[spin][:, :, idx, iorb].T
                     coeffs = fite.fitde3D(self.data, self.equivalences)
                     proj, vvproj, cproj = fite.getBTPbands(self.equivalences, coeffs, self.data.lattvec)
 

pymatgen/io/common.py

@@ -354,7 +354,7 @@ def to_cube(self, filename, comment=None):
                     f"\t {self.dim[idx]} {lattice_matrix[0]:.6f} {lattice_matrix[1]:.6f} {lattice_matrix[2]:.6f}\n"
                 )
 
-            for site in self.structure.sites:
+            for site in self.structure:
                 file.write(
                     f"\t {Element(site.species_string).Z} 0.000000 "
                     f"{ang_to_bohr * site.coords[0]} "

pymatgen/io/cssr.py

@@ -43,8 +43,8 @@ def __str__(self):
             f"{len(self.structure)} 0",
             f"0 {self.structure.formula}",
         ]
-        for i, site in enumerate(self.structure.sites):
-            output.append(f"{i + 1} {site.specie} {site.a:.4f} {site.b:.4f} {site.c:.4f}")
+        for idx, site in enumerate(self.structure):
+            output.append(f"{idx + 1} {site.specie} {site.a:.4f} {site.b:.4f} {site.c:.4f}")
         return "\n".join(output)
 
     def write_file(self, filename):

pymatgen/io/lmto.py

@@ -126,9 +126,9 @@ def as_dict(self):
         sites = []
         classes = []
         num_atoms = {}
-        for s, site in enumerate(self.structure.sites):
+        for idx, site in enumerate(self.structure):
             atom = site.specie
-            label_index = ineq_sites_index.index(eq_atoms[s])
+            label_index = ineq_sites_index.index(eq_atoms[idx])
             if atom.symbol in num_atoms:
                 if label_index + 1 > sum(num_atoms.values()):
                     num_atoms[atom.symbol] += 1

pymatgen/io/tests/test_pwscf.py

@@ -358,7 +358,7 @@ def test_read_str(self):
 
         # generate list of coords
         pw_sites = []
-        for site in pwin.structure.sites:
+        for site in pwin.structure:
             pw_sites.append(list(site.coords))
         pw_sites = np.array(pw_sites)
 

pymatgen/io/tests/test_zeopp.py

@@ -159,7 +159,7 @@ def setUp(self):
         self.structure = p.structure
         bv = BVAnalyzer()
         valences = bv.get_valences(self.structure)
-        el = [site.species_string for site in self.structure.sites]
+        el = [site.species_string for site in self.structure]
         valence_dict = dict(zip(el, valences))
         self.rad_dict = {}
         for k, v in valence_dict.items():
@@ -210,7 +210,7 @@ def setUp(self):
         self.structure = p.structure
         bv = BVAnalyzer()
         valences = bv.get_valences(self.structure)
-        el = [site.species_string for site in self.structure.sites]
+        el = [site.species_string for site in self.structure]
         valence_dict = dict(zip(el, valences))
         self.rad_dict = {}
         for k, v in valence_dict.items():
@@ -240,10 +240,10 @@ def setUp(self):
         valences = bv.get_valences(self.structure)
         radii = []
         for idx, valence in enumerate(valences):
-            el = self.structure.sites[idx].specie.symbol
+            el = self.structure[idx].specie.symbol
             radius = Species(el, valence).ionic_radius
             radii.append(radius)
-        el = [site.species_string for site in self.structure.sites]
+        el = [site.species_string for site in self.structure]
         self.rad_dict = dict(zip(el, radii))
         for el in self.rad_dict:
             print((el, self.rad_dict[el].real))

pymatgen/io/vasp/sets.py

@@ -3037,16 +3037,16 @@ def get_valid_magmom_struct(structure, inplace=True, spin_mode="auto"):
     default_values = {"s": 1.0, "v": [1.0, 1.0, 1.0], "n": None}
     if spin_mode[0].lower() == "a":
         mode = "n"
-        for isite in structure.sites:
-            if "magmom" not in isite.properties or isite.properties["magmom"] is None:
+        for site in structure:
+            if "magmom" not in site.properties or site.properties["magmom"] is None:
                 pass
-            elif isinstance(isite.properties["magmom"], (float, int)):
+            elif isinstance(site.properties["magmom"], (float, int)):
                 if mode == "v":
                     raise TypeError("Magmom type conflict")
                 mode = "s"
-                if isinstance(isite.properties["magmom"], int):
-                    isite.properties["magmom"] = float(isite.properties["magmom"])
-            elif len(isite.properties["magmom"]) == 3:
+                if isinstance(site.properties["magmom"], int):
+                    site.properties["magmom"] = float(site.properties["magmom"])
+            elif len(site.properties["magmom"]) == 3:
                 if mode == "s":
                     raise TypeError("Magmom type conflict")
                 mode = "v"
@@ -3056,12 +3056,12 @@ def get_valid_magmom_struct(structure, inplace=True, spin_mode="auto"):
         mode = spin_mode[0].lower()
 
     new_struct = structure.copy() if not inplace else structure
-    for isite in new_struct.sites:
+    for site in new_struct:
         if mode == "n":
-            if "magmom" in isite.properties:
-                isite.properties.pop("magmom")
-        elif "magmom" not in isite.properties or isite.properties["magmom"] is None:
-            isite.properties["magmom"] = default_values[mode]
+            if "magmom" in site.properties:
+                site.properties.pop("magmom")
+        elif "magmom" not in site.properties or site.properties["magmom"] is None:
+            site.properties["magmom"] = default_values[mode]
 
     if not inplace:
         return new_struct

pymatgen/io/vasp/tests/test_sets.py

@@ -494,16 +494,16 @@ def test_valid_magmom_struct(self):
         # First test the helper function
         struct = self.structure.copy()
         get_valid_magmom_struct(structure=struct, inplace=True, spin_mode="v")
-        props = [isite.properties for isite in struct.sites]
+        props = [site.properties for site in struct]
         assert props == [{"magmom": [1.0, 1.0, 1.0]}] * len(props)
 
         struct = self.structure.copy()
         get_valid_magmom_struct(structure=struct, inplace=True, spin_mode="s")
-        props = [isite.properties for isite in struct.sites]
+        props = [site.properties for site in struct]
         assert props == [{"magmom": 1.0}] * len(props)
         struct.insert(0, "Li", [0, 0, 0])
         get_valid_magmom_struct(structure=struct, inplace=True, spin_mode="a")
-        props = [isite.properties for isite in struct.sites]
+        props = [site.properties for site in struct]
         assert props == [{"magmom": 1.0}] * len(props)
 
         struct = self.structure.copy()

pymatgen/io/xr.py

@@ -52,7 +52,7 @@ def __str__(self):
         ]
         # There are actually 10 more fields per site
         # in a typical xr file from GULP, for example.
-        for idx, site in enumerate(self.structure.sites):
+        for idx, site in enumerate(self.structure):
             output.append(f"{idx + 1} {site.specie} {site.x:.4f} {site.y:.4f} {site.z:.4f}")
         mat = self.structure.lattice.matrix
         for _ in range(2):