first version of the dump

.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

README.md

@@ -1,3 +1,47 @@
 ---
 license: mit
+tags:
+- chemistry
+pretty_name: Materials Project
+size_categories:
+- 100K<n<1M
 ---
+
+# Dataset
+
+Materials project (2019 dump)
+
+This dataset contains 133420 materials with formation energy per atom.
+
+Processed from [mp.2019.04.01.json](https://figshare.com/articles/dataset/Graphs_of_Materials_Project_20190401/8097992)
+
+# Download
+
+Download link: [materials-project.tar.gz](https://huggingface.co/datasets/materials-toolkits/materials-project/raw/main/materials-project.tar.gz)
+
+MD5 checksum `c132f3781f32cd17f3a92aa6501b9531`
+
+# Content
+
+Bundled in `materials-project.tar.gz`.
+
+## Index (`index.json`)
+
+list of dict:
+* `index` (int) => index of the structure in data file.
+* `id` (str) => id of Materials Project.
+* `formula` (str) => formula.
+* `natoms` (int) => number of atoms.
+* `energy_pa` (float) => formation energy per atom.
+
+## Data (`data.hdf5`)
+
+fields:
+* `structures` => a group containing structure information.
+* `structures/cell` (float32) => lattice of the material.
+* `structures/natoms` (int32) => number of atoms.
+* `structures/energy_pa` (float32) => formation energy per atom.
+* `structures/atoms_ptr` (int64) => position of the first atom of the structures in the `atoms` group.
+* `atoms` => a group containing information about atoms.
+* `atoms/positions` (float32) => the positions of the atoms.
+* `atoms/atomic_number` (uint8) => the atomic number of the atoms.

download-and-process.py

@@ -0,0 +1,219 @@
+#!/usr/bin/python
+
+import os
+import io
+import shutil
+from typing import Optional
+import requests
+import hashlib
+import math
+import multiprocessing as mp
+import json
+import re
+import tarfile
+
+from ase.io import read
+import numpy as np
+import h5py
+
+zip_file = "mp.2019.04.01.json.zip"
+url = "https://figshare.com/ndownloader/articles/8097992/versions/2"
+
+
+def download_raw_mp(path: Optional[str] = "."):
+    filename = os.path.join(path, zip_file)
+
+    sha1 = hashlib.sha1()
+
+    if os.path.exists(filename):
+        with open(filename, "rb") as f:
+            while True:
+                data = f.read(1 << 20)
+                if not data:
+                    break
+                sha1.update(data)
+        return sha1.hexdigest()
+
+    r = requests.get(url, stream=True)
+
+    with open(zip_file, "wb") as f:
+        total_length = int(r.headers.get("content-length"))
+        for i, chunk in enumerate(r.iter_content(chunk_size=1 << 20)):
+            if chunk:
+                sha1.update(chunk)
+                f.write(chunk)
+                f.flush()
+                print(
+                    f"[{i+1}/{int(math.ceil(total_length/(1<<20)))}] downloading {zip_file} ..."
+                )
+
+
+def unzip(path: Optional[str] = "."):
+    temp_dir = os.path.join(path, "unzipped")
+
+    os.makedirs(temp_dir, exist_ok=True)
+
+    if not os.path.exists(os.path.join(temp_dir, "mp.2019.04.01.json.zip")):
+        print("unzip mp.2019.04.01.json.zip")
+        shutil.unpack_archive(zip_file, temp_dir)
+
+    if not os.path.exists(os.path.join(temp_dir, "mp.2019.04.01.json")):
+        print("unzip mp.2019.04.01.json")
+        shutil.unpack_archive(
+            os.path.join(temp_dir, "mp.2019.04.01.json.zip"),
+            temp_dir,
+        )
+
+
+def gen_structure_from_json(filename: str, chunksize: Optional[int] = 1 << 20):
+    stack = None
+    with open(filename, "r") as fp:
+        count = 0
+        fp.seek(0, os.SEEK_END)
+        total = int(math.ceil(fp.tell() / chunksize))
+        fp.seek(0, os.SEEK_SET)
+
+        while True:
+            data = fp.read(chunksize)
+
+            print(f"[{count}/{total}] processing {filename} ...")
+            count += 1
+
+            if len(data) == 0:
+                break
+
+            if stack is None:
+                stack = data[data.find("{") + 1 :]
+            else:
+                stack += data
+
+            splited = re.split(r"}\s*,\s*{", stack)
+            for elem in splited[:-1]:
+                yield "{" + elem + "}"
+
+            stack = splited[-1]
+
+    stack = stack[: stack.rfind("}")]
+    yield "{" + stack + "}"
+
+
+def parse_structure(json_str: str) -> tuple:
+    data = json.loads(json_str)
+    struct = read(io.StringIO(data["structure"]), format="cif")
+
+    cell = struct.cell.array
+    natoms = len(struct)
+    x = struct.get_scaled_positions()
+    formula = struct.get_chemical_formula()
+    z = struct.get_atomic_numbers()
+
+    material_id = data["material_id"]
+    energy_pa = data["formation_energy_per_atom"]
+    return material_id, natoms, formula, cell, x, z, energy_pa
+
+
+def process_job(input_queue, output_queue):
+    while True:
+        job = input_queue.get()
+
+        if job is None:
+            break
+
+        output_queue.put(parse_structure(job))
+
+
+def process(path: Optional[str] = ".", workers: Optional[int] = max(4, os.cpu_count())):
+    if os.path.exists(os.path.join(path, "index.json")) and os.path.exists(
+        os.path.join(path, "data.hdf5")
+    ):
+        return
+
+    input_queue = mp.Queue()
+    output_queue = mp.Queue()
+    results = []
+
+    processes = []
+    for _ in range(workers):
+        p = mp.Process(target=process_job, args=(input_queue, output_queue))
+        p.start()
+        processes.append(p)
+
+    for elem in gen_structure_from_json(
+        os.path.join(path, "unzipped/mp.2019.04.01.json")
+    ):
+        input_queue.put(elem)
+
+        if input_queue.qsize() > 2 * workers:
+            results.append(output_queue.get())
+        while not output_queue.empty():
+            results.append(output_queue.get())
+
+    for _ in range(workers):
+        input_queue.put(None)
+
+    for process in processes:
+        process.join()
+
+    while not output_queue.empty():
+        results.append(output_queue.get())
+
+    material_id = [material_id for material_id, _, _, _, _, _, _ in results]
+    formula = [formula for _, _, formula, _, _, _, _ in results]
+
+    natoms = np.array([natoms for _, natoms, _, _, _, _, _ in results], dtype=np.int64)
+    atoms_ptr = np.pad(natoms.cumsum(0), (1, 0)).astype(np.int64)
+    idx = np.arange(len(results), dtype=np.int64)
+
+    cell = np.stack(
+        [cell for _, _, _, cell, _, _, _ in results], axis=0, dtype=np.float32
+    )
+    x = np.concatenate([x for _, _, _, _, x, _, _ in results], axis=0, dtype=np.float32)
+    z = np.concatenate([z for _, _, _, _, _, z, _ in results], axis=0, dtype=np.int64)
+    energy_pa = np.array(
+        [energy_pa for _, _, _, _, _, _, energy_pa in results], dtype=np.float32
+    )
+
+    index = [
+        {
+            "index": int(i),
+            "id": str(m_id),
+            "formula": str(f),
+            "natoms": int(n),
+            "energy_pa": float(e),
+        }
+        for i, m_id, f, n, e in zip(idx, material_id, formula, natoms, energy_pa)
+    ]
+    with open(os.path.join(path, "index.json"), "w") as fp:
+        json.dump(index, fp)
+
+    f = h5py.File("data.hdf5", "w")
+
+    structures = f.create_group("structures")
+    structures.create_dataset("cell", data=cell, dtype=np.float32)
+    structures.create_dataset("natoms", data=natoms, dtype=np.int32)
+    structures.create_dataset("energy_pa", data=energy_pa, dtype=np.float32)
+    structures.create_dataset("atoms_ptr", data=atoms_ptr, dtype=np.int64)
+
+    atoms = f.create_group("atoms")
+    atoms.create_dataset("positions", data=x, dtype=np.float32)
+    atoms.create_dataset("atomic_number", data=z, dtype=np.uint8)
+
+    f.close()
+
+
+def compress(path: Optional[str] = "."):
+    output_file = os.path.join(path, "materials-project.tar.gz")
+
+    if os.path.exists(output_file):
+        return
+
+    print("compress into materials-project.tar.gz")
+    with tarfile.open(output_file, "w:gz") as tar:
+        tar.add(os.path.join(path, "index.json"))
+        tar.add(os.path.join(path, "data.hdf5"))
+
+
+download_raw_mp()
+unzip()
+process()
+compress()

materials-project.tar.gz

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