emmet-builders 0.84.2rc8__tar.gz → 0.84.2rc9__tar.gz

{emmet-builders-0.84.2rc8 → emmet-builders-0.84.2rc9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emmet-builders
-Version: 0.84.2rc8
+Version: 0.84.2rc9
 Summary: Builders for the Emmet Library
 Home-page: https://github.com/materialsproject/emmet
 Author: The Materials Project

{emmet-builders-0.84.2rc8 → emmet-builders-0.84.2rc9}/emmet/builders/molecules/atomic.py

@@ -41,7 +41,7 @@ class PartialChargesBuilder(Builder):
     energy) will be used.
 
     The process is as follows:
-        1. Gather MoleculeDocs by species hash
+        1. Gather MoleculeDocs by formula
         2. For each molecule, group all tasks by solvent.
         3. For each solvent, sort tasks by level of theory and electronic energy
         4. For each method:
@@ -86,14 +86,12 @@ class PartialChargesBuilder(Builder):
         self.tasks.ensure_index("last_updated")
         self.tasks.ensure_index("state")
         self.tasks.ensure_index("formula_alphabetical")
-        self.tasks.ensure_index("species_hash")
 
         # Search index for molecules
         self.molecules.ensure_index("molecule_id")
         self.molecules.ensure_index("last_updated")
         self.molecules.ensure_index("task_ids")
         self.molecules.ensure_index("formula_alphabetical")
-        self.molecules.ensure_index("species_hash")
 
         # Search index for charges
         self.charges.ensure_index("molecule_id")
@@ -113,23 +111,23 @@ class PartialChargesBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.charges.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
-        N = ceil(len(to_process_hashes) / number_splits)
+        N = ceil(len(to_process_forms) / number_splits)
 
-        for hash_chunk in grouper(to_process_hashes, N):
-            query = dict(temp_query)
-            query["species_hash"] = {"$in": list(hash_chunk)}
-            yield {"query": query}
+        for formula_chunk in grouper(to_process_forms, N):
+            yield {"query": {"formula_alphabetical": {"$in": list(formula_chunk)}}}
 
     def get_items(self) -> Iterator[List[Dict]]:
         """
@@ -154,26 +152,28 @@ class PartialChargesBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.charges.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
         self.logger.info(f"Found {len(to_process_docs)} unprocessed documents")
-        self.logger.info(f"Found {len(to_process_hashes)} unprocessed hashes")
+        self.logger.info(f"Found {len(to_process_forms)} unprocessed formulas")
 
         # Set total for builder bars to have a total
-        self.total = len(to_process_hashes)
+        self.total = len(to_process_forms)
 
-        for shash in to_process_hashes:
+        for formula in to_process_forms:
             mol_query = dict(temp_query)
-            mol_query["species_hash"] = shash
+            mol_query["formula_alphabetical"] = formula
             molecules = list(self.molecules.query(criteria=mol_query))
 
             yield molecules
@@ -190,9 +190,9 @@ class PartialChargesBuilder(Builder):
         """
 
         mols = [MoleculeDoc(**item) for item in items]
-        shash = mols[0].species_hash
+        formula = mols[0].formula_alphabetical
         mol_ids = [m.molecule_id for m in mols]
-        self.logger.debug(f"Processing {shash} : {mol_ids}")
+        self.logger.debug(f"Processing {formula} : {mol_ids}")
 
         charges_docs = list()
 
@@ -237,7 +237,7 @@ class PartialChargesBuilder(Builder):
                     tdoc = self.tasks.query_one(
                         {
                             "task_id": task,
-                            "species_hash": shash,
+                            "formula_alphabetical": formula,
                             "orig": {"$exists": True},
                         }
                     )
@@ -247,7 +247,7 @@ class PartialChargesBuilder(Builder):
                             tdoc = self.tasks.query_one(
                                 {
                                     "task_id": int(task),
-                                    "species_hash": shash,
+                                    "formula_alphabetical": formula,
                                     "orig": {"$exists": True},
                                 }
                             )
@@ -271,7 +271,7 @@ class PartialChargesBuilder(Builder):
 
                     charges_docs.append(doc)
 
-        self.logger.debug(f"Produced {len(charges_docs)} charges docs for {shash}")
+        self.logger.debug(f"Produced {len(charges_docs)} charges docs for {formula}")
 
         return jsanitize([doc.model_dump() for doc in charges_docs], allow_bson=True)
 
@@ -320,7 +320,7 @@ class PartialSpinsBuilder(Builder):
     data available (based on level of theory and electronic energy) will be used.
 
     The process is as follows:
-        1. Gather MoleculeDocs by species_hash
+        1. Gather MoleculeDocs by formula
         2. For each molecule, group all tasks by solvent.
         3. For each solvent, sort tasks by level of theory and electronic energy
         4. For each method:
@@ -365,14 +365,12 @@ class PartialSpinsBuilder(Builder):
         self.tasks.ensure_index("last_updated")
         self.tasks.ensure_index("state")
         self.tasks.ensure_index("formula_alphabetical")
-        self.tasks.ensure_index("species_hash")
 
         # Search index for molecules
         self.molecules.ensure_index("molecule_id")
         self.molecules.ensure_index("last_updated")
         self.molecules.ensure_index("task_ids")
         self.molecules.ensure_index("formula_alphabetical")
-        self.molecules.ensure_index("species_hash")
 
         # Search index for spins
         self.spins.ensure_index("molecule_id")
@@ -392,23 +390,23 @@ class PartialSpinsBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.spins.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
-        N = ceil(len(to_process_hashes) / number_splits)
+        N = ceil(len(to_process_forms) / number_splits)
 
-        for hash_chunk in grouper(to_process_hashes, N):
-            query = dict(temp_query)
-            query["species_hash"] = {"$in": list(hash_chunk)}
-            yield {"query": query}
+        for formula_chunk in grouper(to_process_forms, N):
+            yield {"query": {"formula_alphabetical": {"$in": list(formula_chunk)}}}
 
     def get_items(self) -> Iterator[List[Dict]]:
         """
@@ -433,26 +431,28 @@ class PartialSpinsBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.spins.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
         self.logger.info(f"Found {len(to_process_docs)} unprocessed documents")
-        self.logger.info(f"Found {len(to_process_hashes)} unprocessed hashes")
+        self.logger.info(f"Found {len(to_process_forms)} unprocessed formulas")
 
         # Set total for builder bars to have a total
-        self.total = len(to_process_hashes)
+        self.total = len(to_process_forms)
 
-        for shash in to_process_hashes:
+        for formula in to_process_forms:
             mol_query = dict(temp_query)
-            mol_query["species_hash"] = shash
+            mol_query["formula_alphabetical"] = formula
             molecules = list(self.molecules.query(criteria=mol_query))
 
             yield molecules
@@ -469,9 +469,9 @@ class PartialSpinsBuilder(Builder):
         """
 
         mols = [MoleculeDoc(**item) for item in items]
-        shash = mols[0].species_hash
+        formula = mols[0].formula_alphabetical
         mol_ids = [m.molecule_id for m in mols]
-        self.logger.debug(f"Processing {shash} : {mol_ids}")
+        self.logger.debug(f"Processing {formula} : {mol_ids}")
 
         spins_docs = list()
 
@@ -520,7 +520,7 @@ class PartialSpinsBuilder(Builder):
                     tdoc = self.tasks.query_one(
                         {
                             "task_id": task,
-                            "species_hash": shash,
+                            "formula_alphabetical": formula,
                             "orig": {"$exists": True},
                         }
                     )
@@ -530,7 +530,7 @@ class PartialSpinsBuilder(Builder):
                             tdoc = self.tasks.query_one(
                                 {
                                     "task_id": int(task),
-                                    "species_hash": shash,
+                                    "formula_alphabetical": formula,
                                     "orig": {"$exists": True},
                                 }
                             )
@@ -551,7 +551,9 @@ class PartialSpinsBuilder(Builder):
 
                     spins_docs.append(doc)
 
-        self.logger.debug(f"Produced {len(spins_docs)} partial spins docs for {shash}")
+        self.logger.debug(
+            f"Produced {len(spins_docs)} partial spins docs for {formula}"
+        )
 
         return jsanitize([doc.model_dump() for doc in spins_docs], allow_bson=True)
 

{emmet-builders-0.84.2rc8 → emmet-builders-0.84.2rc9}/emmet/builders/molecules/bonds.py

@@ -40,7 +40,7 @@ class BondingBuilder(Builder):
     data available (based on level of theory and electronic energy) will be used.
 
     The process is as follows:
-        1. Gather MoleculeDocs by species hash
+        1. Gather MoleculeDocs by formula
         2. For each molecule, group all tasks by solvent.
         3. For each solvent, sort tasks by level of theory and electronic energy
         4. For each method:
@@ -85,14 +85,12 @@ class BondingBuilder(Builder):
         self.tasks.ensure_index("last_updated")
         self.tasks.ensure_index("state")
         self.tasks.ensure_index("formula_alphabetical")
-        self.tasks.ensure_index("species_hash")
 
         # Search index for molecules
         self.molecules.ensure_index("molecule_id")
         self.molecules.ensure_index("last_updated")
         self.molecules.ensure_index("task_ids")
         self.molecules.ensure_index("formula_alphabetical")
-        self.molecules.ensure_index("species_hash")
 
         # Search index for bonds
         self.bonds.ensure_index("molecule_id")
@@ -112,23 +110,23 @@ class BondingBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.bonds.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
-        N = ceil(len(to_process_hashes) / number_splits)
+        N = ceil(len(to_process_forms) / number_splits)
 
-        for hash_chunk in grouper(to_process_hashes, N):
-            query = dict(temp_query)
-            query["species_hash"] = {"$in": list(hash_chunk)}
-            yield {"query": query}
+        for formula_chunk in grouper(to_process_forms, N):
+            yield {"query": {"formula_alphabetical": {"$in": list(formula_chunk)}}}
 
     def get_items(self) -> Iterator[List[Dict]]:
         """
@@ -153,26 +151,28 @@ class BondingBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.bonds.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
         self.logger.info(f"Found {len(to_process_docs)} unprocessed documents")
-        self.logger.info(f"Found {len(to_process_hashes)} unprocessed hashes")
+        self.logger.info(f"Found {len(to_process_forms)} unprocessed formulas")
 
         # Set total for builder bars to have a total
-        self.total = len(to_process_hashes)
+        self.total = len(to_process_forms)
 
-        for shash in to_process_hashes:
+        for formula in to_process_forms:
             mol_query = dict(temp_query)
-            mol_query["species_hash"] = shash
+            mol_query["formula_alphabetical"] = formula
             molecules = list(self.molecules.query(criteria=mol_query))
 
             yield molecules
@@ -189,9 +189,9 @@ class BondingBuilder(Builder):
         """
 
         mols = [MoleculeDoc(**item) for item in items]
-        shash = mols[0].species_hash
+        formula = mols[0].formula_alphabetical
         mol_ids = [m.molecule_id for m in mols]
-        self.logger.debug(f"Processing {shash} : {mol_ids}")
+        self.logger.debug(f"Processing {formula} : {mol_ids}")
 
         bonding_docs = list()
 
@@ -255,7 +255,7 @@ class BondingBuilder(Builder):
                     tdoc = self.tasks.query_one(
                         {
                             "task_id": task,
-                            "species_hash": shash,
+                            "formula_alphabetical": formula,
                             "orig": {"$exists": True},
                         }
                     )
@@ -265,7 +265,7 @@ class BondingBuilder(Builder):
                             tdoc = self.tasks.query_one(
                                 {
                                     "task_id": int(task),
-                                    "species_hash": shash,
+                                    "formula_alphabetical": formula,
                                     "orig": {"$exists": True},
                                 }
                             )
@@ -288,13 +288,13 @@ class BondingBuilder(Builder):
                     )
                     bonding_docs.append(doc)
 
-        self.logger.debug(f"Produced {len(bonding_docs)} bonding docs for {shash}")
+        self.logger.debug(f"Produced {len(bonding_docs)} bonding docs for {formula}")
 
         return jsanitize([doc.model_dump() for doc in bonding_docs], allow_bson=True)
 
     def update_targets(self, items: List[List[Dict]]):
         """
-        Inserts the new documents into the bonds collection
+        Inserts the new documents into the charges collection
 
         Args:
             items [[dict]]: A list of documents to update

{emmet-builders-0.84.2rc8 → emmet-builders-0.84.2rc9}/emmet/builders/molecules/metal_binding.py

@@ -44,7 +44,7 @@ class MetalBindingBuilder(Builder):
     will be used.
 
     The process is as follows:
-        1. Gather MoleculeDocs by species hash
+        1. Gather MoleculeDocs by formula
         2. For each molecule, first identify if there are any metals. If not, then no MetalBindingDoc can be made.
             If so, then identify the possible solvents that can be used to generate MetalBindingDocs
         3. For each combination of Molecule ID and solvent, search for additional documents:
@@ -111,7 +111,6 @@ class MetalBindingBuilder(Builder):
         self.molecules.ensure_index("last_updated")
         self.molecules.ensure_index("task_ids")
         self.molecules.ensure_index("formula_alphabetical")
-        self.molecules.ensure_index("species_hash")
 
         # Search index for charges
         self.charges.ensure_index("molecule_id")
@@ -169,23 +168,23 @@ class MetalBindingBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.metal_binding.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
-        N = ceil(len(to_process_hashes) / number_splits)
+        N = ceil(len(to_process_forms) / number_splits)
 
-        for hash_chunk in grouper(to_process_hashes, N):
-            query = dict(temp_query)
-            query["species_hash"] = {"$in": list(hash_chunk)}
-            yield {"query": query}
+        for formula_chunk in grouper(to_process_forms, N):
+            yield {"query": {"formula_alphabetical": {"$in": list(formula_chunk)}}}
 
     def get_items(self) -> Iterator[List[Dict]]:
         """
@@ -208,26 +207,28 @@ class MetalBindingBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.metal_binding.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
         self.logger.info(f"Found {len(to_process_docs)} unprocessed documents")
-        self.logger.info(f"Found {len(to_process_hashes)} unprocessed hashes")
+        self.logger.info(f"Found {len(to_process_forms)} unprocessed formulas")
 
         # Set total for builder bars to have a total
-        self.total = len(to_process_hashes)
+        self.total = len(to_process_forms)
 
-        for shash in to_process_hashes:
+        for formula in to_process_forms:
             mol_query = dict(temp_query)
-            mol_query["species_hash"] = shash
+            mol_query["formula_alphabetical"] = formula
             molecules = list(self.molecules.query(criteria=mol_query))
 
             yield molecules
@@ -244,9 +245,9 @@ class MetalBindingBuilder(Builder):
         """
 
         mols = [MoleculeDoc(**item) for item in items]
-        shash = mols[0].species_hash
+        formula = mols[0].formula_alphabetical
         mol_ids = [m.molecule_id for m in mols]
-        self.logger.debug(f"Processing {shash} : {mol_ids}")
+        self.logger.debug(f"Processing {formula} : {mol_ids}")
 
         binding_docs = list()
 
@@ -486,7 +487,7 @@ class MetalBindingBuilder(Builder):
                         binding_docs.append(doc)
 
         self.logger.debug(
-            f"Produced {len(binding_docs)} metal binding docs for {shash}"
+            f"Produced {len(binding_docs)} metal binding docs for {formula}"
         )
 
         return jsanitize([doc.model_dump() for doc in binding_docs], allow_bson=True)

{emmet-builders-0.84.2rc8 → emmet-builders-0.84.2rc9}/emmet/builders/molecules/orbitals.py

@@ -27,7 +27,7 @@ class OrbitalBuilder(Builder):
     each solvent available).
 
     The process is as follows:
-        1. Gather MoleculeDocs by species hash
+        1. Gather MoleculeDocs by formula
         2. For each doc, sort tasks by solvent
         3. For each solvent, grab the best TaskDoc (including NBO data using
             the highest level of theory with lowest electronic energy for the
@@ -69,14 +69,12 @@ class OrbitalBuilder(Builder):
         self.tasks.ensure_index("last_updated")
         self.tasks.ensure_index("state")
         self.tasks.ensure_index("formula_alphabetical")
-        self.tasks.ensure_index("species_hash")
 
         # Search index for molecules
         self.molecules.ensure_index("molecule_id")
         self.molecules.ensure_index("last_updated")
         self.molecules.ensure_index("task_ids")
         self.molecules.ensure_index("formula_alphabetical")
-        self.molecules.ensure_index("species_hash")
 
         # Search index for orbitals
         self.orbitals.ensure_index("molecule_id")
@@ -95,23 +93,23 @@ class OrbitalBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.orbitals.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
-        N = ceil(len(to_process_hashes) / number_splits)
+        N = ceil(len(to_process_forms) / number_splits)
 
-        for hash_chunk in grouper(to_process_hashes, N):
-            query = dict(temp_query)
-            query["species_hash"] = {"$in": list(hash_chunk)}
-            yield {"query": query}
+        for formula_chunk in grouper(to_process_forms, N):
+            yield {"query": {"formula_alphabetical": {"$in": list(formula_chunk)}}}
 
     def get_items(self) -> Iterator[List[Dict]]:
         """
@@ -136,26 +134,28 @@ class OrbitalBuilder(Builder):
 
         self.logger.info("Finding documents to process")
         all_mols = list(
-            self.molecules.query(temp_query, [self.molecules.key, "species_hash"])
+            self.molecules.query(
+                temp_query, [self.molecules.key, "formula_alphabetical"]
+            )
         )
 
         processed_docs = set([e for e in self.orbitals.distinct("molecule_id")])
         to_process_docs = {d[self.molecules.key] for d in all_mols} - processed_docs
-        to_process_hashes = {
-            d["species_hash"]
+        to_process_forms = {
+            d["formula_alphabetical"]
             for d in all_mols
             if d[self.molecules.key] in to_process_docs
         }
 
         self.logger.info(f"Found {len(to_process_docs)} unprocessed documents")
-        self.logger.info(f"Found {len(to_process_hashes)} unprocessed hashes")
+        self.logger.info(f"Found {len(to_process_forms)} unprocessed formulas")
 
         # Set total for builder bars to have a total
-        self.total = len(to_process_hashes)
+        self.total = len(to_process_forms)
 
-        for shash in to_process_hashes:
+        for formula in to_process_forms:
             mol_query = dict(temp_query)
-            mol_query["species_hash"] = shash
+            mol_query["formula_alphabetical"] = formula
             molecules = list(self.molecules.query(criteria=mol_query))
 
             yield molecules
@@ -172,9 +172,9 @@ class OrbitalBuilder(Builder):
         """
 
         mols = [MoleculeDoc(**item) for item in items]
-        shash = mols[0].species_hash
+        formula = mols[0].formula_alphabetical
         mol_ids = [m.molecule_id for m in mols]
-        self.logger.info(f"Processing {shash} : {mol_ids}")
+        self.logger.info(f"Processing {formula} : {mol_ids}")
 
         orbital_docs = list()
 
@@ -221,7 +221,7 @@ class OrbitalBuilder(Builder):
                         tdoc = self.tasks.query_one(
                             {
                                 "task_id": task,
-                                "species_hash": shash,
+                                "formula_alphabetical": formula,
                                 "orig": {"$exists": True},
                             }
                         )
@@ -231,7 +231,7 @@ class OrbitalBuilder(Builder):
                                 tdoc = self.tasks.query_one(
                                     {
                                         "task_id": int(task),
-                                        "species_hash": shash,
+                                        "formula_alphabetical": formula,
                                         "orig": {"$exists": True},
                                     }
                                 )
@@ -253,7 +253,7 @@ class OrbitalBuilder(Builder):
                         if orbital_doc is not None:
                             orbital_docs.append(orbital_doc)
 
-        self.logger.debug(f"Produced {len(orbital_docs)} orbital docs for {shash}")
+        self.logger.debug(f"Produced {len(orbital_docs)} orbital docs for {formula}")
 
         return jsanitize([doc.model_dump() for doc in orbital_docs], allow_bson=True)