@mat3ra/made 2024.4.8-0 → 2024.4.16-0

package/README.md

@@ -5,15 +5,40 @@
 
 Made is a library for **MA**terials **DE**sign in JavaScript/TypeScript and Python. It allows for the creation and manipulation of material structures from atoms up on the web. The library is aimed to be used for the development of web applications, both on the client (web browser) and server (eg. Node.js) side.
 
-The library was originally designed as part of and presently powers materials design capabilities of the [Exabyte.io](https://exabyte.io) platform. For example, [this page](https://platform.exabyte.io/demo/materials/n3HSzCmyoctgJFGGE) representing a crystal of Silicon online uses Made.js.
+## 1. Overview
 
-Exabyte.io believe in a collaborative future of materials design on the web.
+The package provides a software environment for interacting with Materials-related data structures from ESSE Data Convention [[1]](#links) for use on the web.
 
-## Functionality
+## 2. Installation
 
-As below:
+### 2.1. JavaScript/TypeScript
+
+From NPM for use within a software project:
+
+```bash
+npm install @mat3ra/made
+
+```
+
+### 2.2. Python
+
+From PyPI for use within a software project:
+
+```bash
+pip install mat3ra-made
+```
+
+When willing to use the optional `tools` module, install the package with the following command:
+
+```bash
+pip install "mat3ra-made[tools]"
+```
+
+
+## 3. Functionality
+
+As below
 
-- the package provides a software environment for interacting with Materials-related data structures from ESSE Data Convention [[1]](#links) and is written in ECMAScript 2015 for use on the web
 - High-level classes for the representation of the [Material](src/material.js) and the corresponding structural information, ie:
     - [Basis](src/basis/basis.js),
     - [Lattice](src/lattice/lattice.js),
@@ -32,38 +57,18 @@ As below:
     - [combinatorial sets](src/parsers/xyz_combinatorial_basis.js)
     - [interpolated sets for chemical reactions](src/tools/basis.js)
 
-The package is written in a modular way easy to extend. Contributions can be in the form of additional tools or modules you develop, or feature requests and [bug/issue reports](https://help.github.com/articles/creating-an-issue/).
-
-## Installation
-
-From NPM for use within a software project:
-
-```bash
-npm install @mat3ra/made
-
-```
 
-From source to contribute to development:
-
-```bash
-git clone git@github.com:Exabyte-io/made
-```
-
-## Contribution
+## 4. Contribution
 
 This repository is an [open-source](LICENSE.md) work-in-progress and we welcome contributions.
 
-### Why contribute?
-
 We regularly deploy the latest code containing all accepted contributions online as part of the [Mat3ra.com](https://mat3ra.com) platform, so contributors will see their code in action there.
 
-### Adding new functionality
-
 We suggest forking this repository and introducing the adjustments there to be considered for merging into this repository as explained in more details [here](https://gist.github.com/Chaser324/ce0505fbed06b947d962), for example.
 
-### Source code conventions
+### 4.1. Source code conventions
 
-Made.js is written in EcmaScript 6th edition [[2]](#links) with the application of object-oriented design patterns encapsulating key concepts following the conventions below.
+Object-oriented design patterns encapsulate key concepts following the conventions below.
 
 1. Classes follow the Exabyte Data Convention and data structures defined in ESSE [[1]](#links)
 
@@ -71,12 +76,12 @@ Made.js is written in EcmaScript 6th edition [[2]](#links) with the application
 
 3. `tools` directory contains helper functions that act on one or more classes and include an external parameter. Functions that use class data without any external parameters should be implemented inside the class. For example, `basis.clone()` is implemented in `Basis`, but basis repetition is implemented as a tool in the correspondingly named function ([tools/basis.js#repeat](src/tools/basis.js)) because the repetion requires a parameter external to basis - number of repetitions in 3 spatial dimensions.
 
-4. `parsers` directory contains the parsers to- and from- ESSE format mentioned in 1. All functionality related to external data conversion is contained in this directory.
+4. [Deprecated, use mat3ra-parsers or @mat3ra/parsers] `parsers` directory contains the parsers to- and from- ESSE format mentioned in 1. All functionality related to external data conversion is contained in this directory.
 
 
-### TODO list
+### 4.2. TODO list
 
-Desirable features for implementation:
+[Outdated] Desirable features for implementation:
 
 - identify primitive / conventional structures
 - support for molecular geometries
@@ -90,7 +95,11 @@ Desirable features for implementation:
     - a combination of the above
     - arbitrary atomic arrangement
 
-## Tests
+## 5. Development
+
+### 5.1. JavaScript/TypeScript
+
+#### 5.1.1. Tests
 
 Made tests are written based on Mocha [6](#links) testing framework and can be executed as follows.
 
@@ -105,7 +114,7 @@ npm install
 npm test
 ```
 
-### Tests Important Notes
+#### 5.1.2. Important Notes
 
 1. Keep the tests directory structure similar to the main codebase directory structure. Every JS module in the main codebase should have a corresponding module in tests directory which implements the tests for provided functionality.
 
@@ -115,7 +124,7 @@ npm test
 
 4. [Tests setup module](./tests/setup.js) can be used to implement the hooks that are used to prepare the tests environment.
 
-## Using Linter
+#### 5.1.3. Using Linter
 
 Linter setup will prevent committing files that don't adhere to the code standard. It will
 attempt to fix what it can automatically prior to the commit in order to reduce diff noise. This can lead to "unexpected" behavior where a
@@ -149,13 +158,44 @@ npm run lint:fix
 In which case, you may need to then add the linter edits to your staging, which in the example above, puts the
 file back to identical with the base branch, resulting in no staged changes whatsoever.
 
-## Configuring WebStorm for use with Linter
+#### 5.1.4. Configuring WebStorm for use with Linter
 
 In order for the WebStorm IDE to take full advantage of the linting configuration, it can be configured in the project:
 
 - `Preferences -> Languages & Frameworks -> JavaScript -> Code Quality Tools -> ESLint`
 - Check `Automatic ESLint configuration` which should infer all the configurations from the project directory
 
+### 5.2. Python
+
+#### 5.2.1. Tests
+
+Python 3.8+ is required to run the tests. We recommend using PyEnv to manage Python versions. Tests are written based on PyTest and can be executed as follows.
+
+```bash
+virtualenv .venv
+source .venv/bin/activate
+pip install ".[tests]"
+pytest tests/py
+```
+
+#### 5.2.2. Important Notes
+
+Conventions:
+
+- The "tools" module has external dependencies on "pymatgen" and "ase" packages and so is meant as optional. When implementing new functionality, the use of ASE is recommended over pymatgen for compatibility purposes.
+
+### 5.3. Known Issues
+
+#### 5.3.1. JavaScript/TypeScript
+
+To be added.
+
+#### 5.3.2. Python
+
+As below:
+
+- Python 3.8 tests are failing on Apple Silicon due to https://github.com/materialsproject/pymatgen/issues/3521
+
 ## Links
 
 1. [Exabyte Source of Schemas and Examples (ESSE), Github Repository](https://github.com/exabyte-io/exabyte-esse)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/made",
-    "version": "2024.4.8-0",
+    "version": "2024.4.16-0",
     "description": "MAterials DEsign library",
     "scripts": {
         "lint": "eslint --cache src/js tests/js && prettier --write src/js tests/js",

package/pyproject.toml

@@ -17,34 +17,36 @@ classifiers = [
 dependencies = [
     # add requirements here
     "numpy",
-    "pymatgen",
-    "ase",
     "mat3ra-esse",
     "mat3ra-code",
 ]
 
 [project.optional-dependencies]
-tests = [
-    "coverage[toml]>=5.3",
+# tracking separately the deps required to use the tools module
+tools = [
+    "pymatgen",
+    "ase",
+]
+dev = [
     "pre-commit",
     "black",
     "ruff",
     "isort",
     "mypy",
     "pip-tools",
+]
+tests = [
+    "coverage[toml]>=5.3",
     "pytest",
     "pytest-cov",
-    "pydantic",
+    # B/c of https://github.com/binary-husky/gpt_academic/issues/1237
     "gradio",
-]
-# required to use the tools module
-tools = [
-    "pymatgen",
-    "ase",
+    "pydantic",
+    "mat3ra-made[tools]",
 ]
 all = [
     "mat3ra-made[tests]",
-    "mat3ra-made[tools]",
+    "mat3ra-made[dev]",
 ]
 
 # Entrypoint scripts can be defined here, see examples below.

package/src/py/mat3ra/made/tools/analyze.py

@@ -0,0 +1,41 @@
+import numpy as np
+from ase import Atoms
+
+from .convert import convert_material_args_kwargs_to_atoms
+
+
+@convert_material_args_kwargs_to_atoms
+def calculate_average_interlayer_distance(
+    interface_atoms: Atoms, tag_substrate: str, tag_film: str, threshold: float = 0.5
+) -> float:
+    """
+    Calculate the average distance between the top layer of substrate atoms and the bottom layer of film atoms.
+
+    Args:
+        interface_atoms (ase.Atoms): The ASE Atoms object containing both sets of atoms.
+        tag_substrate (int): The tag representing the substrate atoms.
+        tag_film (int): The tag representing the film atoms.
+        threshold (float): The threshold for identifying the top and bottom layers of atoms.
+
+    Returns:
+        float: The average distance between the top layer of substrate and the bottom layer of film.
+    """
+    # Extract z-coordinates of substrate and film atoms
+    z_substrate = interface_atoms.positions[interface_atoms.get_tags() == tag_substrate][:, 2]
+    z_film = interface_atoms.positions[interface_atoms.get_tags() == tag_film][:, 2]
+
+    # Identify the top layer of substrate atoms and bottom layer of film atoms by z-coordinate
+    top_substrate_layer_z = np.max(z_substrate)
+    bottom_film_layer_z = np.min(z_film)
+
+    # Get the average z-coordinate of the top substrate atoms (within a threshold from the top)
+    top_substrate_atoms = z_substrate[z_substrate >= top_substrate_layer_z - threshold]
+    avg_z_top_substrate = np.mean(top_substrate_atoms)
+
+    # Get the average z-coordinate of the bottom film atoms (within a threshold from the bottom)
+    bottom_film_atoms = z_film[z_film <= bottom_film_layer_z + threshold]
+    avg_z_bottom_film = np.mean(bottom_film_atoms)
+
+    # Calculate the average distance between the top layer of substrate and the bottom layer of film
+    average_interlayer_distance = avg_z_bottom_film - avg_z_top_substrate
+    return abs(average_interlayer_distance)

package/src/py/mat3ra/made/tools/calculate.py

@@ -0,0 +1,20 @@
+from ase import Atoms
+from ase.calculators.calculator import Calculator
+
+from .convert import convert_material_args_kwargs_to_atoms
+
+
+@convert_material_args_kwargs_to_atoms
+def calculate_total_energy(atoms: Atoms, calculator: Calculator):
+    """
+    Set calculator for ASE Atoms and calculate the total energy.
+
+    Args:
+        atoms (ase.Atoms): The Atoms object to calculate the energy of.
+        calculator (ase.calculators.calculator.Calculator): The calculator to use for the energy calculation.
+
+    Returns:
+        float: The total energy of the atoms.
+    """
+    atoms.set_calculator(calculator)
+    return atoms.get_total_energy()

package/src/py/mat3ra/made/tools/convert.py

@@ -0,0 +1,186 @@
+import inspect
+from functools import wraps
+from typing import Any, Callable, Dict, Union
+
+from ase import Atoms
+from mat3ra.made.material import Material
+from mat3ra.utils.mixins import RoundNumericValuesMixin
+from pymatgen.core.structure import Lattice, Structure
+from pymatgen.io.ase import AseAtomsAdaptor
+from pymatgen.io.vasp.inputs import Poscar
+
+
+def to_pymatgen(material_or_material_data: Union[Material, Dict[str, Any]]) -> Structure:
+    """
+    Converts material object in ESSE format to a pymatgen Structure object.
+
+    Args:
+        material_or_material_data (dict|class): A dictionary containing the material information in ESSE format.
+
+    Returns:
+        Structure: A pymatgen Structure object.
+    """
+    material_data = material_or_material_data
+
+    if isinstance(material_or_material_data, Material):
+        material_data = material_or_material_data.to_json()
+
+    lattice_params = material_data["lattice"]
+    a = lattice_params["a"]
+    b = lattice_params["b"]
+    c = lattice_params["c"]
+    alpha = lattice_params["alpha"]
+    beta = lattice_params["beta"]
+    gamma = lattice_params["gamma"]
+    lattice = Lattice.from_parameters(a, b, c, alpha, beta, gamma)
+
+    basis = material_data["basis"]
+    elements = [element["value"] for element in basis["elements"]]
+    coordinates = [coord["value"] for coord in basis["coordinates"]]
+    labels = [label["value"] for label in basis.get("labels", [])]
+
+    # Assuming that the basis units are fractional since it's a crystal basis
+    coords_are_cartesian = "units" in basis and basis["units"].lower() == "angstrom"
+
+    if "labels" in inspect.signature(Structure.__init__).parameters:
+        structure = Structure(lattice, elements, coordinates, coords_are_cartesian=coords_are_cartesian, labels=labels)
+    else:
+        # Passing labels does not work for pymatgen `2023.6.23` supporting py3.8
+        print(f"labels: {labels}. Not passing labels to pymatgen.")
+        structure = Structure(lattice, elements, coordinates, coords_are_cartesian=coords_are_cartesian)
+
+    return structure
+
+
+def from_pymatgen(structure: Structure):
+    """
+    Converts a pymatgen Structure object to a material object in ESSE format.
+
+    Args:
+        structure (Structure): A pymatgen Structure object.
+
+    Returns:
+        dict: A dictionary containing the material information in ESSE format.
+    """
+    __round__ = RoundNumericValuesMixin.round_array_or_number
+    basis = {
+        "elements": [{"id": i, "value": str(site.specie)} for i, site in enumerate(structure.sites)],
+        "coordinates": [
+            {"id": i, "value": __round__(list(site.frac_coords))} for i, site in enumerate(structure.sites)
+        ],
+        "units": "crystal",
+        "cell": __round__(structure.lattice.matrix.tolist()),
+        "constraints": [],
+    }
+
+    lattice = {
+        "a": __round__(structure.lattice.a),
+        "b": __round__(structure.lattice.b),
+        "c": __round__(structure.lattice.c),
+        "alpha": __round__(structure.lattice.alpha),
+        "beta": __round__(structure.lattice.beta),
+        "gamma": __round__(structure.lattice.gamma),
+        "units": {"length": "angstrom", "angle": "degree"},
+        "type": "TRI",
+        "vectors": {
+            "a": __round__(structure.lattice.matrix[0].tolist()),
+            "b": __round__(structure.lattice.matrix[1].tolist()),
+            "c": __round__(structure.lattice.matrix[2].tolist()),
+            "alat": 1,
+            "units": "angstrom",
+        },
+    }
+
+    material_data = {
+        "name": structure.formula,
+        "basis": basis,
+        "lattice": lattice,
+        "isNonPeriodic": not structure.is_ordered,
+        "_id": "",
+        "metadata": {"boundaryConditions": {"type": "pbc", "offset": 0}},
+        "isUpdated": True,
+    }
+
+    return material_data
+
+
+def to_poscar(material_or_material_data: Union[Material, Dict[str, Any]]) -> str:
+    """
+    Converts material object in ESSE format to a POSCAR string.
+
+    Args:
+        material_or_material_data (dict|class): A dictionary containing the material information in ESSE format.
+
+    Returns:
+        str: A POSCAR string.
+    """
+    structure = to_pymatgen(material_or_material_data)
+    poscar = Poscar(structure)
+    # For pymatgen `2023.6.23` supporting py3.8 the method name is "get_string"
+    # TODO: cleanup the if statement when dropping support for py3.8
+    if hasattr(poscar, "get_string"):
+        return poscar.get_string()
+    return poscar.get_str()
+
+
+def from_poscar(poscar: str) -> Dict[str, Any]:
+    """
+    Converts a POSCAR string to a material object in ESSE format.
+
+    Args:
+        poscar (str): A POSCAR string.
+
+    Returns:
+        dict: A dictionary containing the material information in ESSE format.
+    """
+    structure = Structure.from_str(poscar, "poscar")
+    return from_pymatgen(structure)
+
+
+def to_ase(material_or_material_data: Union[Material, Dict[str, Any]]) -> Atoms:
+    """
+    Converts material object in ESSE format to an ASE Atoms object.
+
+    Args:
+        material_or_material_data (dict|class): A dictionary containing the material information in ESSE format.
+
+    Returns:
+        Any: An ASE Atoms object.
+    """
+    # TODO: check that atomic labels are properly handled
+    structure = to_pymatgen(material_or_material_data)
+    return AseAtomsAdaptor.get_atoms(structure)
+
+
+def from_ase(ase_atoms: Atoms) -> Dict[str, Any]:
+    """
+    Converts an ASE Atoms object to a material object in ESSE format.
+
+    Args:
+        ase_atoms (Atoms): An ASE Atoms object.
+
+    Returns:
+        dict: A dictionary containing the material information in ESSE format.
+    """
+    # TODO: check that atomic labels/tags are properly handled
+    structure = AseAtomsAdaptor.get_structure(ase_atoms)
+    return from_pymatgen(structure)
+
+
+def convert_material_args_kwargs_to_atoms(func: Callable) -> Callable:
+    """
+    Decorator that converts ESSE Material objects to ASE Atoms objects.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        # Convert args if they are of type ESSE Material
+        new_args = [to_ase(arg) if isinstance(arg, Material) else arg for arg in args]
+
+        # Convert kwargs if they are of type ESSE Material
+        new_kwargs = {k: to_ase(v) if isinstance(v, Material) else v for k, v in kwargs.items()}
+
+        # Call the original function with the converted arguments
+        return func(*new_args, **new_kwargs)
+
+    return wrapper

package/src/py/mat3ra/made/tools/modify.py

@@ -0,0 +1,20 @@
+from typing import Union
+
+from ase import Atoms
+
+from .convert import convert_material_args_kwargs_to_atoms
+
+
+@convert_material_args_kwargs_to_atoms
+def filter_by_label(atoms: Atoms, label: Union[int, str]):
+    """
+    Filter out only atoms corresponding to the label/tag.
+
+    Args:
+        atoms (ase.Atoms): The Atoms object to filter.
+        label (int|str): The tag/label to filter by.
+
+    Returns:
+        ase.Atoms: The filtered Atoms object.
+    """
+    return atoms[atoms.get_tags() == label]

package/tests/py/unit/test_tools_analyze.py

@@ -0,0 +1,12 @@
+import numpy as np
+from ase.build import bulk
+from mat3ra.made.tools.analyze import calculate_average_interlayer_distance
+
+
+def test_calculate_average_interlayer_distance():
+    substrate = bulk("Si", cubic=True)
+    film = bulk("Cu", cubic=True)
+    interface_atoms = substrate + film
+    interface_atoms.set_tags([1] * len(substrate) + [2] * len(film))
+    distance = calculate_average_interlayer_distance(interface_atoms, 1, 2)
+    assert np.isclose(distance, 4.0725)

package/tests/py/unit/test_tools_calculate.py

@@ -0,0 +1,11 @@
+import numpy as np
+from ase.build import bulk
+from ase.calculators import emt
+from mat3ra.made.tools.calculate import calculate_total_energy
+
+
+def test_calculate_total_energy():
+    atoms = bulk("C", cubic=True)
+    calculator = emt.EMT()
+    energy = calculate_total_energy(atoms, calculator)
+    assert np.isclose(energy, 1.3612647524769237)

package/tests/py/unit/test_tools_convert.py

@@ -0,0 +1,71 @@
+import numpy as np
+from ase import Atoms
+from ase.build import bulk
+from mat3ra.made.material import Material
+from mat3ra.made.tools.convert import from_ase, from_poscar, from_pymatgen, to_ase, to_poscar, to_pymatgen
+from pymatgen.core.structure import Element, Lattice, Structure
+
+PYMATGEN_LATTICE = Lattice.from_parameters(a=3.84, b=3.84, c=3.84, alpha=120, beta=90, gamma=60)
+PYMATGEN_STRUCTURE = Structure(PYMATGEN_LATTICE, ["Si", "Si"], [[0, 0, 0], [0.75, 0.5, 0.75]])
+
+POSCAR_CONTENT = """Si2
+1.0
+   3.3489202364344242    0.0000000000000000    1.9335000000000004
+   1.1163067454781415    3.1573922784475164    1.9335000000000004
+   0.0000000000000000    0.0000000000000000    3.8670000000000000
+Si
+2
+direct
+   0.0000000000000000    0.0000000000000000    0.0000000000000000 Si
+   0.2500000000000000    0.2500000000000000    0.2500000000000000 Si
+"""
+
+
+def test_to_pymatgen():
+    material = Material.create(Material.default_config)
+    structure = to_pymatgen(material)
+    assert isinstance(structure, Structure)
+    assert structure.lattice == Lattice.from_parameters(3.867, 3.867, 3.867, 60, 60, 60)
+    assert structure.species == [Element("Si"), Element("Si")]
+    assert (structure.frac_coords == [[0.0, 0.0, 0.0], [0.25, 0.25, 0.25]]).all()
+
+
+def test_from_pymatgen():
+    material_data = from_pymatgen(PYMATGEN_STRUCTURE)
+    assert material_data["lattice"]["a"] == 3.84
+    assert material_data["lattice"]["alpha"] == 120
+
+
+def test_to_poscar():
+    material = Material.create(Material.default_config)
+    poscar = to_poscar(material)
+    assert poscar == POSCAR_CONTENT
+
+
+def test_from_poscar():
+    material_data = from_poscar(POSCAR_CONTENT)
+    assert material_data["lattice"]["a"] == 3.867
+    assert material_data["lattice"]["alpha"] == 60
+
+
+def test_to_ase():
+    material = Material.create(Material.default_config)
+    ase_atoms = to_ase(material)
+    assert isinstance(ase_atoms, Atoms)
+    assert np.allclose(
+        ase_atoms.get_cell().tolist(),
+        [
+            [3.3489202364344242, 0.0, 1.9335000000000004],
+            [1.1163067454781415, 3.1573922784475164, 1.9335000000000004],
+            [0.0, 0.0, 3.8670000000000000],
+        ],
+    )
+    assert ase_atoms.get_chemical_symbols() == ["Si", "Si"]
+    assert np.allclose(ase_atoms.get_scaled_positions().tolist(), [[0.0, 0.0, 0.0], [0.25, 0.25, 0.25]])
+
+
+def test_from_ase():
+    ase_atoms = bulk("Si")
+    material_data = from_ase(ase_atoms)
+    assert material_data["lattice"]["a"] == 3.839589822
+    assert material_data["lattice"]["alpha"] == 60

package/tests/py/unit/test_tools_modify.py

@@ -0,0 +1,11 @@
+from ase.build import bulk
+from mat3ra.made.tools.modify import filter_by_label
+
+
+def test_filter_by_label():
+    substrate = bulk("Si", cubic=True)
+    film = bulk("Cu", cubic=True)
+    interface_atoms = substrate + film
+    interface_atoms.set_tags([1] * len(substrate) + [2] * len(film))
+    film_extracted = filter_by_label(interface_atoms, 2)
+    assert (film.symbols == film_extracted.symbols).all()

package/src/py/mat3ra/made/tools/material.py

@@ -1,44 +0,0 @@
-from typing import Any, Dict, Union
-
-from mat3ra.made.material import Material
-from pymatgen.core.structure import Lattice, Structure
-
-
-def to_pymatgen(material_or_material_data: Union[Material, Dict[str, Any]]) -> Structure:
-    """
-    Converts material object in ESSE format to a pymatgen Structure object.
-
-    Args:
-        material_data (dict): A dictionary containing the material information in ESSE format.
-
-    Returns:
-        Structure: A pymatgen Structure object.
-    """
-    material_data = material_or_material_data
-
-    if isinstance(material_or_material_data, Material):
-        material_data = material_or_material_data.to_json()
-
-    lattice_params = material_data["lattice"]
-    a = lattice_params["a"]
-    b = lattice_params["b"]
-    c = lattice_params["c"]
-    alpha = lattice_params["alpha"]
-    beta = lattice_params["beta"]
-    gamma = lattice_params["gamma"]
-
-    # Create a Lattice from parameters
-    lattice = Lattice.from_parameters(a, b, c, alpha, beta, gamma)
-
-    # Extract the basis information
-    basis = material_data["basis"]
-    elements = [element["value"] for element in basis["elements"]]
-    coordinates = [coord["value"] for coord in basis["coordinates"]]
-
-    # Assuming that the basis units are fractional since it's a crystal basis
-    coords_are_cartesian = "units" in basis and basis["units"].lower() == "angstrom"
-
-    # Create the Structure
-    structure = Structure(lattice, elements, coordinates, coords_are_cartesian=coords_are_cartesian)
-
-    return structure

package/tests/py/unit/test_tools_material.py

@@ -1,12 +0,0 @@
-from mat3ra.made.material import Material
-from mat3ra.made.tools.material import to_pymatgen
-from pymatgen.core.structure import Element, Lattice, Structure
-
-
-def test_to_pymatgen():
-    material = Material.create(Material.default_config)
-    structure = to_pymatgen(material)
-    assert isinstance(structure, Structure)
-    assert structure.lattice == Lattice.from_parameters(3.867, 3.867, 3.867, 60, 60, 60)
-    assert structure.species == [Element("Si"), Element("Si")]
-    assert (structure.frac_coords == [[0.0, 0.0, 0.0], [0.25, 0.25, 0.25]]).all()