AC-2D-22¶

Amorphous, 2D graphene structures generated using a Monte Carlo bond-switching algorithm, as described in Figure 3 of the paper: Exploring the Configurational Space of Amorphous Graphene with Machine-Learned Atomic Energies. Files are downloaded from Zenodo.

>>> from load_atoms import load_dataset
>>> load_dataset("AC-2D-22")
AC-2D-22:
    structures: '150'
    atoms: 30,000
    species:
        C: 100.00%
    properties:
        per atom: (forces, local_energy, nn_local_energy)
        per structure: (beta, config, criterion)

License¶

This dataset is licensed under the CC BY-NC-SA 4.0 license.

Citation¶

If you use this dataset in your work, please cite the following:

@article{El-Machachi-22-10,
  title = {
    Exploring the Configurational Space of Amorphous
    Graphene with Machine-Learned Atomic Energies
  },
  author = {
    {El-Machachi}, Zakariya and Wilson, Mark and Deringer, Volker L.
  },
  year = {2022},
  journal = {Chemical Science},
  doi = {10.1039/D2SC04326B}
}

Properties¶

Per-atom:

Property	Units	Type	Description
`forces`	eV/Å	`ndarray(N, 3)`	force vectors (C-GAP-17)
`local_energy`	eV	`ndarray(N,)`	local energy of each atom (C-GAP-17)
`nn_local_energy`	eV	`ndarray(N,)`	average nearest neighbour local energy (C-GAP-17)

Per-structure:

Property	Units	Type	Description
`beta`	1/eV	`float`	β used for MC bond-switching
`criterion`		`str`	energy term used in MC criterion
`config`		`str`	type of the structure (paracrystalline \| CRN)

Miscellaneous information¶

AC-2D-22 is imported as an InMemoryAtomsDataset:

Importer script for AC-2D-22

from __future__ import annotations

from pathlib import Path
from typing import Iterator

from ase import Atoms
from ase.io import read
from load_atoms.database.backend import BaseImporter, rename, unzip_file
from load_atoms.database.internet import FileDownload
from load_atoms.progress import Progress


class Importer(BaseImporter):
    @classmethod
    def files_to_download(cls) -> list[FileDownload]:
        return [
            FileDownload(
                url="https://zenodo.org/record/7221166/files/data.tar.gz",
                expected_hash="023de5805f15",
            )
        ]

    @classmethod
    def get_structures(
        cls, tmp_dir: Path, progress: Progress
    ) -> Iterator[Atoms]:
        # untar the file
        contents_path = unzip_file(tmp_dir / "data.tar.gz", progress)
        root = contents_path / "data/fig_3"

        table = [
            (
                "loc_run_fig_3a/Final_structures",
                {
                    "config": "continuous random network",
                    "beta": 2.0,
                    "criterion": "local energy",
                },
            ),
            (
                "NN_run_fig_3b/Final_structures_pristine",
                {
                    "config": "paracrystalline",
                    "beta": 2.0,
                    "criterion": "nearest-neighbour energy",
                },
            ),
            (
                "NN_run_fig_3b/Final_structures_thermal",
                {
                    "config": "paracrystalline",
                    "beta": 2.0,
                    "criterion": "nearest-neighbour energy",
                },
            ),
            (
                "loc_run_fig_3c/beta_50/Final_structures",
                {
                    "config": "paracrystalline",
                    "beta": 50.0,
                    "criterion": "local energy",
                },
            ),
            (
                "loc_run_fig_3c/beta_60/Final_structures",
                {
                    "config": "paracrystalline",
                    "beta": 60.0,
                    "criterion": "local energy",
                },
            ),
            (
                "fig_3d/total_beta_0.8/Final_structures",
                {
                    "config": "paracrystalline",
                    "beta": 0.8,
                    "criterion": "total energy",
                },
            ),
        ]

        for path, info in table:
            structures = cls.read_structures(root / path, progress)
            for structure in structures:
                structure.info.update(info)
                yield cls.process_structure(structure)

    @staticmethod
    def read_structures(archive_dir: Path, progress: Progress) -> list[Atoms]:
        extracted = unzip_file(archive_dir / "fin_run.tar.gz", progress)
        return [read(file) for file in sorted(extracted.glob("**/*.xyz"))]  # type: ignore

    @staticmethod
    def process_structure(structure: Atoms) -> Atoms:
        # Remove unwanted arrays
        if "c_1" in structure.arrays:
            del structure.arrays["c_1"]

        # Rotate 90 degrees around the x-axis
        structure.rotate(90, "x", center="COU", rotate_cell=True)

        return rename(
            structure,
            {
                "Forces": "forces",
                "Energy_per_atom": "local_energy",
                "NN_Energy_per_atom": "nn_local_energy",
            },
        )