add first version

.gitattributes

@@ -53,3 +53,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+materials-project.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+unzipped
+*.hdf5
+*.json
+*.zip

dump.py

@@ -0,0 +1,202 @@
+import torch
+import mysql.connector
+import numpy as np
+import tqdm
+from tqdm.contrib.concurrent import process_map
+from ase.data import atomic_numbers
+
+from materials_toolkit.data import HDF5Dataset, StructureData, batching, Batching
+
+import os
+
+
+@batching(
+    entry_id=Batching(dtype=torch.long),
+    structure_id=Batching(dtype=torch.long),
+    calculation_id=Batching(dtype=torch.long),
+    spacegroup=Batching(dtype=torch.long),
+)
+class OQMDData(StructureData):
+    pass
+
+
+class OQMD(HDF5Dataset):
+    data_class = OQMDData
+
+
+def get_all_structures(host, user, password, database="qmdb"):
+
+    with mysql.connector.connect(
+        host=host, user=user, password=password, database=database
+    ) as db:
+        structures = []
+        with db.cursor() as c:
+            # calculate atoms count for all structures
+            c.execute(
+                'select TABLE_NAME from information_schema.tables where table_name="structures_natoms";'
+            )
+            if len(c.fetchall()) == 0:
+                c.execute(
+                    "create table structures_natoms select structure_id,count(*) as natoms from atoms group by structure_id;"
+                )
+
+            # filter valid structures (natoms match between structures table and structures_natoms)
+            c.execute(
+                'select TABLE_NAME from information_schema.tables where table_name="valid_structure";'
+            )
+            if len(c.fetchall()) == 0:
+                c.execute(
+                    """
+                    create table valid_structure 
+                    select structures.id as structure_id,structures.natoms as natoms from structures
+                    inner join structures_natoms
+                    on
+                        structures.id=structures_natoms.structure_id
+                        and structures.natoms=structures_natoms.natoms;
+                    """
+                )
+
+            # get minimal energy of an entry, select lower energy from converged calculations and reject lda setup
+            c.execute(
+                'select TABLE_NAME from information_schema.tables where table_name="entries_minimal_energy";'
+            )
+            if len(c.fetchall()) == 0:  # TODO filtrer standard et static
+                c.execute(
+                    f"""
+                    create table entries_minimal_energy
+                    select calculations.entry_id as entry_id, min(calculations.energy_pa) as energy_pa
+                    from calculations
+                    inner join valid_structure
+                    on
+                        calculations.converged is not null
+                        and calculations.converged=true
+                        and calculations.label NOT LIKE '%lda'
+                        and (calculations.label LIKE 'static%'
+                        or calculations.label LIKE 'standard%')
+                        and valid_structure.structure_id=calculations.output_id
+                    group by calculations.entry_id;
+                    """
+                )
+
+            c.execute(
+                'select TABLE_NAME from information_schema.tables where table_name="entries_with_structure";'
+            )
+            if len(c.fetchall()) == 0:
+                c.execute(
+                    """
+                    create table entries_with_structure
+                    select calculations.entry_id as entry_id, calculations.output_id as structure_id, calculations.id as calculation_id, calculations.label as calculation_label, calculations.energy_pa as energy_pa
+                    from entries_minimal_energy
+                    left join calculations
+                    on
+                        calculations.entry_id=entries_minimal_energy.entry_id
+                        and calculations.energy_pa=entries_minimal_energy.energy_pa
+                    inner join valid_structure
+                    on
+                        valid_structure.structure_id=calculations.output_id
+                    group by calculations.entry_id;
+                    """
+                )
+
+            c.execute("select * from entries_with_structure;")
+            entries_calc = c.fetchall()
+
+            for entry_id, struct_id, calc_id, calc_label, energy_pa in tqdm.tqdm(
+                entries_calc
+            ):
+                c.execute(
+                    f"""
+                    select struct.natoms, spacegroups.hm, struct.x1, struct.x2, struct.x3, struct.y1, struct.y2, struct.y3, struct.z1, struct.z2, struct.z3, struct.volume
+                    from (
+                            select natoms, x1, x2, x3, y1, y2, y3, z1, z2, z3, volume, coalesce(spacegroup_id, 1) as spacegroup_id
+                            from structures 
+                            where structures.id={struct_id}
+                        ) as struct
+                    inner join spacegroups on
+                        struct.spacegroup_id=spacegroups.number;
+                    """
+                )
+                results = c.fetchall()
+                assert len(results) == 1, f"error structure {struct_id}"
+                (
+                    natoms,
+                    space_group,
+                    x1,
+                    x2,
+                    x3,
+                    y1,
+                    y2,
+                    y3,
+                    z1,
+                    z2,
+                    z3,
+                    volume,
+                ) = results[0]
+
+                c.execute(
+                    f"""
+                    select element_id,x,y,z
+                    from atoms
+                    where structure_id={struct_id}
+                    """
+                )
+                atoms = c.fetchall()
+
+                if len(atoms) != natoms:
+                    print(entry_id, struct_id, calc_label, energy_pa)
+                    for element_id, x, y, z in atoms:
+                        print(f"{element_id:>4s} {x:>.3f} {y:>.3f} {z:>.3f}")
+
+                assert len(atoms) == natoms, f"error {len(atoms)} {natoms}"
+
+                z_lst = []
+                coords = []
+                for e_id, x, y, z in atoms:
+                    z_lst.append(atomic_numbers[e_id])
+                    coords.append([x, y, z])
+                coords = np.array(coords)
+                cell = np.array([[x1, x2, x3], [y1, y2, y3], [z1, z2, z3]])
+
+                structures.append(
+                    OQMDData(
+                        z=torch.tensor(z_lst, dtype=torch.long).view(-1),
+                        pos=torch.from_numpy(coords).float().view(-1, 3),
+                        cell=torch.from_numpy(cell).float().view(1, 3, 3),
+                        entry_id=torch.tensor([entry_id]).long().view(1),
+                        structure_id=torch.tensor([struct_id]).long().view(1),
+                        calculation_id=torch.tensor([calc_id]).long().view(1),
+                        spacegroup=torch.tensor([space_group]).long().view(1),
+                        energy_pa=torch.tensor([energy_pa]).float().view(1),
+                    )
+                )
+
+    return structures
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--host", default="localhost", help="mysql host serveur")
+    parser.add_argument("--database", default="qmdb", help="name of the database")
+    parser.add_argument("--user", help="user of the mysql server")
+    parser.add_argument("--password", help="password of the user")
+
+    args = parser.parse_args()
+
+    structures = get_all_structures(
+        host=args.host, user=args.user, password=args.password, database="qmdb"
+    )
+
+    oqmd_dir = os.path.join(".", "open-quantum-materials-database")
+    processed_dir = os.path.join(oqmd_dir, "processed")
+
+    HDF5Dataset.create_dataset(processed_dir, structures)
+
+    dataset = OQMD(oqmd_dir)
+    dataset.compute_convex_hulls()
+
+
+if __name__ == "__main__":
+    main()  # check entry 351317

oqmd.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bafcfd85373fd0c9b6ff297a87a165cb781e4b748c01a547c60bf6747dcb9b2a
+size 65561783