@mat3ra/made 2026.7.4-0 → 2026.7.13-0

package/src/js/tools/surface.ts

@@ -1,21 +1,21 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     Coordinate3DSchema,
     MaterialSchema,
     Matrix3X3Schema,
     Vector3DSchema,
 } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import { Cell } from "../cell/cell";
 import { Lattice } from "../lattice/lattice";
 import { Material } from "../material";
 import SupercellTools from "./supercell";
 
-const MULT = math.multiply;
-const ADD = math.add;
-const DOT = math.product;
+const MULT = Utils.math.multiply;
+const ADD = Utils.math.add;
+const DOT = Utils.math.product;
 const getMatrixInLeftHandedRepresentation = (matrix: Matrix3X3Schema) => {
-    return math.det(matrix) < 0 ? MULT(matrix, -1) : matrix;
+    return Utils.math.det(matrix) < 0 ? MULT(matrix, -1) : matrix;
 };
 
 /**
@@ -27,10 +27,10 @@ const getMatrixInLeftHandedRepresentation = (matrix: Matrix3X3Schema) => {
  */
 function extGCD(a: number, b: number): [number, number] {
     if (b === 0) return [1, 0];
-    if (math.mod(a, b) === 0) return [0, 1];
+    if (Utils.math.mod(a, b) === 0) return [0, 1];
 
-    const [x, y] = extGCD(b, math.mod(a, b));
-    return [y, x - y * math.floor(a / b)];
+    const [x, y] = extGCD(b, Utils.math.mod(a, b));
+    return [y, x - y * Utils.math.floor(a / b)];
 }
 
 /**
@@ -46,7 +46,7 @@ function getMillerScalingMatrix(
     millerIndices: Coordinate3DSchema,
     tol = 1e-8,
 ): Matrix3X3Schema {
-    if (!millerIndices.reduce((a, b) => math.abs(a) + math.abs(b)))
+    if (!millerIndices.reduce((a, b) => Utils.math.abs(a) + Utils.math.abs(b)))
         throw new Error("Miller indices are zeros.");
 
     let scalingMatrix;
@@ -94,20 +94,26 @@ function getMillerScalingMatrix(
         // @ts-ignore
         const k2 = DOT(ADD(MULT(l, z1), -MULT(k, z2)), z3);
 
-        if (math.abs(k2) > tol) {
+        // @ts-ignore
+        if (Utils.math.abs(k2) > tol) {
             // For mathjs version 3.20: round(-0.5) = -0
             // For mathjs version 5.10: round(-0.5) = -1
             // Here we specify rounding method to Bankers
             // For Python 3.11: round(-0.5) = 0
+            // @ts-ignore - mathjs v12 dot return type
             const value = k1 / k2;
-            const roundedValue = math.roundCustom(value, 0, math.RoundingMethod.Bankers);
+            const roundedValue = Utils.math.roundCustom(
+                value,
+                0,
+                Utils.math.RoundingMethod.Bankers,
+            );
             const i = -roundedValue;
             [p, q] = [p + i * l, q - i * k];
         }
 
         const [a, b] = extGCD(p * k + q * l, h);
         const c1 = [p * k + q * l, -p * h, -q * h];
-        const c2 = [0, l, -k].map((c) => math.trunc(c / math.gcd(l, k))); // floor division
+        const c2 = [0, l, -k].map((c) => Utils.math.trunc(c / Utils.math.gcd(l, k))); // floor division
         const c3 = [b, a * p, a * q];
 
         scalingMatrix = [c1, c2, c3];

package/src/py/mat3ra/made/basis/__init__.py

@@ -175,9 +175,12 @@ class Basis(BasisSchema, InMemoryEntityPydantic):
             other_basis (Basis): The other basis to add atoms from.
         """
 
-        self.elements.add_items(other_basis.elements.values)
-        self.coordinates.add_items(other_basis.coordinates.values)
-        self.labels.add_items(other_basis.labels.values)
+        for el in other_basis.elements.values:
+            self.elements.add_item(el)
+        for coord in other_basis.coordinates.values:
+            self.coordinates.add_item(coord)
+        for label in other_basis.labels.values:
+            self.labels.add_item(label)
 
     def remove_atom_by_id(self, id: int):
         self.elements.remove_item(id)

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

@@ -0,0 +1,171 @@
+import random
+from typing import List, Optional, Union
+
+import numpy as np
+from mat3ra.made.material import Material
+
+from ..analyze import BaseMaterialAnalyzer
+from ..analyze.utils import minimum_image_distances
+from ..build.defective_structures.three_dimensional.solid_solution.enums import SiteSelectionMethodEnum
+from ..build_components import MaterialWithBuildMetadata
+from ..build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
+
+
+def _most_isotropic_dimensions(total_cells: int) -> List[int]:
+    """
+    Find [a, b, c] repeat factors whose product equals total_cells with minimum aspect ratio.
+
+    Enumerates factor triples with a <= b <= c and returns the triple with the
+    smallest spread (c - a).
+
+    Args:
+        total_cells (int): Target number of unit cells in the supercell.
+
+    Returns:
+        List[int]: Repeat factors [a, b, c] along the three lattice directions.
+    """
+    best_dimensions = [1, 1, total_cells]
+    best_spread = total_cells - 1
+    for a in range(1, total_cells + 1):
+        if total_cells % a:
+            continue
+        for b in range(a, total_cells // a + 1):
+            if (total_cells // a) % b:
+                continue
+            c = total_cells // (a * b)
+            if c < b:
+                continue
+            spread = c - a
+            if spread < best_spread:
+                best_dimensions = [a, b, c]
+                best_spread = spread
+    return best_dimensions
+
+
+def _select_sites_uniform(
+    material: Union[Material, MaterialWithBuildMetadata],
+    source_indices: List[int],
+    number_to_select: int,
+    seed: int = None,
+) -> List[int]:
+    """
+    Select number_to_select sites from source_indices using Farthest Point Sampling.
+
+    Iteratively picks the site whose minimum distance to all already-selected
+    sites is largest, producing a maximally dispersed subset under PBC.
+
+    Args:
+        material (Union[Material, MaterialWithBuildMetadata]): Material with lattice and coordinates.
+        source_indices (List[int]): Indices of candidate sites in the material basis.
+        number_to_select (int): Number of sites to select.
+        seed (int, optional): Random seed for the initial site choice.
+
+    Returns:
+        List[int]: Sorted list of selected site indices.
+    """
+    if number_to_select <= 0:
+        return []
+    if number_to_select >= len(source_indices):
+        return sorted(source_indices)
+
+    material.to_crystal()
+    fractional_coordinates = np.array(material.basis.coordinates.values)
+    lattice_vectors = np.array(material.lattice.vector_arrays)
+    pairwise_distances = minimum_image_distances(fractional_coordinates[source_indices], lattice_vectors)
+
+    random_generator = random.Random(seed)
+    first_pick = random_generator.randrange(len(source_indices))
+    selected = [first_pick]
+    distance_to_selected = pairwise_distances[first_pick].copy()
+    is_candidate = np.ones(len(source_indices), dtype=bool)
+    is_candidate[first_pick] = False
+
+    for _ in range(number_to_select - 1):
+        farthest_distance = np.max(distance_to_selected[is_candidate])
+        tied_candidates = np.where(is_candidate & np.isclose(distance_to_selected, farthest_distance))[0]
+        next_pick = int(random_generator.choice(tied_candidates))
+        selected.append(next_pick)
+        is_candidate[next_pick] = False
+        np.minimum(distance_to_selected, pairwise_distances[next_pick], out=distance_to_selected)
+
+    return sorted(source_indices[i] for i in selected)
+
+
+class SolidSolutionAnalyzer(BaseMaterialAnalyzer):
+    """
+    Analyzes a unit cell to plan supercell dimensions and select substitution sites.
+
+    Given a unit cell material and a desired substitution ratio, finds the
+    most isotropic supercell matching the target concentration within tolerance,
+    then selects specific sites for substitution.
+    """
+
+    source_element: str
+    target_element: str
+    target_concentration: float
+    tolerance: float = 0.01
+    max_supercell_cells: int = 128
+    seed: Optional[int] = None
+    site_selection_method: SiteSelectionMethodEnum = SiteSelectionMethodEnum.UNIFORM
+
+    @property
+    def source_element_count_per_cell(self) -> int:
+        return sum(1 for element in self.material.basis.elements.values if element == self.source_element)
+
+    @property
+    def optimal_supercell_dimensions(self) -> List[int]:
+        source_count_per_cell = self.source_element_count_per_cell
+        if source_count_per_cell == 0:
+            raise ValueError(f"No {self.source_element} atoms found in the unit cell.")
+
+        best_dimensions = None
+        best_shape_spread = self.max_supercell_cells
+        for cell_count in range(1, self.max_supercell_cells + 1):
+            source_atoms = source_count_per_cell * cell_count
+            replacement_atoms = min(max(round(self.target_concentration * source_atoms), 0), source_atoms)
+            achieved_concentration = replacement_atoms / source_atoms
+            if abs(achieved_concentration - self.target_concentration) > self.tolerance:
+                continue
+
+            dimensions = _most_isotropic_dimensions(cell_count)
+            shape_spread = dimensions[2] - dimensions[0]
+            if shape_spread < best_shape_spread:
+                best_dimensions = dimensions
+                best_shape_spread = shape_spread
+            if shape_spread == 0:
+                break
+
+        if best_dimensions is None:
+            raise ValueError(
+                f"Cannot achieve concentration {self.target_concentration} "
+                f"within tolerance {self.tolerance} for up to {self.max_supercell_cells} cells."
+            )
+        return best_dimensions
+
+    @property
+    def actual_concentration(self) -> float:
+        a, b, c = self.optimal_supercell_dimensions
+        source_atoms = self.source_element_count_per_cell * a * b * c
+        replacement_atoms = min(max(round(self.target_concentration * source_atoms), 0), source_atoms)
+        return replacement_atoms / source_atoms
+
+    @property
+    def selected_site_indices(self) -> List[int]:
+        supercell = create_supercell(material=self.material, scaling_factor=self.optimal_supercell_dimensions)
+        supercell_material = MaterialWithBuildMetadata.create(supercell.to_dict())
+        elements = supercell_material.basis.elements.values
+        source_indices = [index for index, element in enumerate(elements) if element == self.source_element]
+        replacement_atoms = min(
+            max(round(self.actual_concentration * len(source_indices)), 0),
+            len(source_indices),
+        )
+
+        if self.site_selection_method == SiteSelectionMethodEnum.UNIFORM:
+            keep_atoms = len(source_indices) - replacement_atoms
+            if keep_atoms < replacement_atoms:
+                kept_indices = _select_sites_uniform(supercell_material, source_indices, keep_atoms, self.seed)
+                return sorted(set(source_indices) - set(kept_indices))
+            return _select_sites_uniform(supercell_material, source_indices, replacement_atoms, self.seed)
+
+        random_generator = random.Random(self.seed)
+        return sorted(random_generator.sample(source_indices, replacement_atoms))

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

@@ -135,3 +135,28 @@ def calculate_von_mises_strain(strain_matrix: np.ndarray) -> float:
     e_von_mises = np.sqrt(exx**2 - exx * eyy + eyy**2 + 3 * exy**2)
 
     return abs(e_von_mises) * 100.0
+
+
+def minimum_image_distances(frac_coords: np.ndarray, lattice_vectors: np.ndarray) -> np.ndarray:
+    """
+    Compute pairwise distances between fractional coordinates under periodic boundary conditions.
+
+    Applies the minimum image convention: for each pair, the shortest distance
+    across all periodic images is returned.
+
+    Args:
+        frac_coords (np.ndarray): Fractional coordinates, shape (N, 3).
+        lattice_vectors (np.ndarray): Lattice vectors, shape (3, 3), rows are vectors.
+
+    Returns:
+        np.ndarray: Symmetric distance matrix, shape (N, N), in the same units as lattice_vectors.
+    """
+    n = len(frac_coords)
+    distances = np.zeros((n, n))
+    for i in range(n):
+        delta = frac_coords[i] - frac_coords[i + 1 :]
+        delta -= np.round(delta)
+        dists = np.linalg.norm(delta @ lattice_vectors, axis=1)
+        distances[i, i + 1 :] = dists
+        distances[i + 1 :, i] = dists
+    return distances

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/__init__.py

@@ -0,0 +1 @@
+

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/__init__.py

@@ -0,0 +1,9 @@
+from .builder import SolidSolutionBuilder
+from .configuration import SolidSolutionConfiguration
+from .enums import SiteSelectionMethodEnum
+
+__all__ = [
+    "SiteSelectionMethodEnum",
+    "SolidSolutionBuilder",
+    "SolidSolutionConfiguration",
+]

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/builder.py

@@ -0,0 +1,37 @@
+from typing import Dict, Type, Union
+
+from mat3ra.made.material import Material
+
+from .....analyze.other import get_chemical_formula_empirical
+from .....build_components import MaterialWithBuildMetadata, TypeConfiguration
+from .....build_components.entities.auxiliary.zero_dimensional.point_defect_site.builder import PointDefectSiteBuilder
+from .....build_components.entities.auxiliary.zero_dimensional.point_defect_site.configuration import (
+    PointDefectSiteConfiguration,
+)
+from .....build_components.operations.core.combinations.merge.builder import MergeBuilder
+from .configuration import SolidSolutionConfiguration
+
+
+class SolidSolutionBuilder(MergeBuilder):
+    """Builds a solid solution by merging substitution sites into a supercell."""
+
+    _ConfigurationType: Type[SolidSolutionConfiguration] = SolidSolutionConfiguration
+
+    @property
+    def merge_component_types_conversion_map(self) -> Dict[Type, Type]:
+        return {
+            PointDefectSiteConfiguration: PointDefectSiteBuilder,
+        }
+
+    def _update_material_name(
+        self, material: Union[Material, MaterialWithBuildMetadata], configuration: TypeConfiguration
+    ) -> MaterialWithBuildMetadata:
+        formula = get_chemical_formula_empirical(material)
+        concentration_percentage = configuration.actual_concentration * 100
+        source_element = configuration.source_element
+        target_element = configuration.target_element
+        material.name = (
+            f"{formula} - Solid Solution ({source_element}\u2192{target_element} "
+            f"{concentration_percentage:.4g}%)"
+        )
+        return material

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/configuration.py

@@ -0,0 +1,30 @@
+from typing import List, Union
+
+from mat3ra.esse.models.materials_category.defective_structures.three_dimensional.solid_solution.configuration import (
+    SolidSolutionConfigurationSchema,
+)
+from mat3ra.esse.models.materials_category_components.operations.core.combinations.merge import MergeMethodsEnum
+from mat3ra.made.material import Material
+
+from .....build_components import MaterialWithBuildMetadata
+from .....build_components.entities.auxiliary.zero_dimensional.point_defect_site.configuration import (
+    PointDefectSiteConfiguration,
+)
+from .....build_components.operations.core.combinations.merge.configuration import MergeConfiguration
+
+
+class SolidSolutionConfiguration(MergeConfiguration, SolidSolutionConfigurationSchema):
+    """Configuration for building a solid solution by merging substitution sites.
+
+    Physical specification: crystal, source_element, target_element, concentrations.
+    The merge_components hold the resolved substitution sites.
+    """
+
+    type: str = "SolidSolutionConfiguration"
+    crystal: Union[Material, MaterialWithBuildMetadata]
+    source_element: str
+    target_element: str
+    target_concentration: float
+    actual_concentration: float
+    merge_components: List[Union[Material, MaterialWithBuildMetadata, PointDefectSiteConfiguration]]
+    merge_method: MergeMethodsEnum = MergeMethodsEnum.REPLACE

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/enums.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class SiteSelectionMethodEnum(str, Enum):
+    # Selects sites purely at random (seeded for reproducibility).
+    RANDOM = "random"
+    # Selects sites using Farthest Point Sampling for maximal dispersion under PBC.
+    UNIFORM = "uniform"

package/src/py/mat3ra/made/tools/build/defective_structures/three_dimensional/solid_solution/helpers.py

@@ -0,0 +1,76 @@
+from typing import Optional, Union
+
+from mat3ra.esse.models.materials_category_components.entities.core.zero_dimensional.atom import AtomSchema
+from mat3ra.esse.models.materials_category_components.operations.core.combinations.merge import MergeMethodsEnum
+from mat3ra.made.material import Material
+
+from .....analyze.solid_solution_analyzer import SolidSolutionAnalyzer
+from .....build_components import MaterialWithBuildMetadata
+from .....build_components.entities.auxiliary.zero_dimensional.point_defect_site.configuration import (
+    PointDefectSiteConfiguration,
+)
+from .....build_components.entities.reusable.three_dimensional.supercell.helpers import create_supercell
+from .builder import SolidSolutionBuilder
+from .configuration import SolidSolutionConfiguration
+from .enums import SiteSelectionMethodEnum
+
+
+def create_solid_solution(
+    material: Union[Material, MaterialWithBuildMetadata],
+    source_element: str,
+    target_element: str,
+    concentration: float,
+    seed: Optional[int] = None,
+    tolerance: float = 0.01,
+    max_supercell_cells: int = 128,
+    site_selection_method: SiteSelectionMethodEnum = SiteSelectionMethodEnum.UNIFORM,
+) -> MaterialWithBuildMetadata:
+    """
+    Create a solid solution by partially substituting one element for another.
+
+    Automatically determines the optimal supercell size to achieve the target
+    concentration, builds the supercell, and performs substitution.
+
+    Args:
+        material (Union[Material, MaterialWithBuildMetadata]): Unit cell crystal.
+        source_element (str): Element to partially replace (e.g. "Hf").
+        target_element (str): Replacement element (e.g. "Zr").
+        concentration (float): Fraction of source_element to replace (0.0-1.0).
+        seed (Optional[int]): Random seed for reproducible site selection.
+        tolerance (float): Acceptable deviation from target concentration.
+        max_supercell_cells (int): Maximum supercell size to search.
+        site_selection_method (SiteSelectionMethodEnum): RANDOM or UNIFORM (Farthest Point Sampling).
+
+    Returns:
+        MaterialWithBuildMetadata: Solid solution with full build metadata.
+    """
+    analyzer = SolidSolutionAnalyzer(
+        material=material,
+        source_element=source_element,
+        target_element=target_element,
+        target_concentration=concentration,
+        tolerance=tolerance,
+        max_supercell_cells=max_supercell_cells,
+        seed=seed,
+        site_selection_method=site_selection_method,
+    )
+    supercell = create_supercell(material, scaling_factor=analyzer.optimal_supercell_dimensions)
+    coordinates = supercell.basis.coordinates.values
+    site_configurations = [
+        PointDefectSiteConfiguration(
+            crystal=supercell,
+            coordinate=coordinates[site_index],
+            element=AtomSchema(chemical_element=target_element),
+        )
+        for site_index in analyzer.selected_site_indices
+    ]
+    configuration = SolidSolutionConfiguration(
+        crystal=material,
+        source_element=source_element,
+        target_element=target_element,
+        target_concentration=concentration,
+        actual_concentration=analyzer.actual_concentration,
+        merge_components=[supercell] + site_configurations,
+        merge_method=MergeMethodsEnum.REPLACE,
+    )
+    return SolidSolutionBuilder().get_material(configuration)

package/src/py/mat3ra/made/tools/build_components/entities/auxiliary/zero_dimensional/crystal_site/crystal_site.py

@@ -6,13 +6,14 @@ from mat3ra.esse.models.materials_category_components.entities.auxiliary.zero_di
     CrystalSiteSchema,
 )
 from mat3ra.made.material import Material
+from pydantic import Field
 
 
 class CrystalSite(CrystalSiteSchema, InMemoryEntityPydantic):
-    crystal: Optional[Material] = None
+    crystal: Optional[Material] = Field(None, exclude=True)
     # element: str
     coordinate: Optional[List[float]] = None
-    nearest_neighbor_vectors: List[np.ndarray] = []
+    nearest_neighbor_vectors: List[np.ndarray] = Field([], exclude=True)
     # coordination_number: int = 0
     # see https://www.cryst.ehu.es/cgi-bin/cryst/programs/nph-wp-list for an example
 

package/src/py/mat3ra/made/tools/build_components/entities/auxiliary/zero_dimensional/point_defect_site/builder.py

@@ -1,3 +1,6 @@
+from mat3ra.code.array_with_ids import ArrayWithIds
+from mat3ra.made.basis import Basis, Coordinates
+
 from ......build_components import MaterialWithBuildMetadata
 from ..... import BaseSingleBuilder
 from .configuration import PointDefectSiteConfiguration
@@ -14,18 +17,16 @@ class PointDefectSiteBuilder(BaseSingleBuilder):
         if configuration.crystal is None:
             raise ValueError("Crystal configuration is required for PointDefectSiteBuilder")
 
-        new_material = MaterialWithBuildMetadata.create(
-            {
-                "name": configuration.crystal.name,
-                "lattice": configuration.crystal.lattice.to_dict(),
-                "basis": configuration.crystal.basis.to_dict(),
-            }
+        crystal = configuration.crystal
+        basis = Basis(
+            elements=ArrayWithIds(values=[], ids=[]),
+            coordinates=Coordinates(values=[], ids=[]),
+            units=crystal.basis.units,
+            cell=crystal.basis.cell,
         )
-        elements = configuration.crystal.basis.elements.values
-        new_material.basis.remove_atoms_by_elements(elements)
-        new_material.basis.add_atom(
+        basis.add_atom(
             element=configuration.element.chemical_element,
             coordinate=configuration.coordinate,
             label=configuration.host_atom_label,
         )
-        return new_material
+        return MaterialWithBuildMetadata(name=crystal.name, lattice=crystal.lattice, basis=basis)

package/src/py/mat3ra/made/tools/build_components/operations/core/combinations/merge/builder.py

@@ -79,6 +79,15 @@ class MergeBuilder(BaseSingleBuilder):
         if len(materials) == 1:
             return materials[0]
 
+        # Optimization: when there are many materials to merge, combine all non-first
+        # materials into one before merging with the base to avoid N sequential merges.
+        if len(materials) > 2:
+            base = materials[0]
+            combined = materials[1]
+            for m in materials[2:]:
+                combined.basis.add_atoms_from_another_basis(m.basis)
+            materials = [base, combined]
+
         parameters = self.build_parameters or self._DefaultBuildParameters
         merge_method = getattr(configuration, "merge_method", None)
         return self._merge_by_method(materials, parameters, merge_method)

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

@@ -42,6 +42,7 @@ from .build.defective_structures.zero_dimensional.point_defect.substitutional.he
 )
 from .build.defective_structures.zero_dimensional.point_defect.types import PointDefectDict
 from .build.defective_structures.zero_dimensional.point_defect.vacancy.helpers import create_defect_point_vacancy
+from .build.defective_structures.three_dimensional.solid_solution.helpers import create_solid_solution
 
 # Pristine Structures
 from .build.pristine_structures.three_dimensional.ideal_crystal.helpers import create_monolayer
@@ -117,6 +118,7 @@ __all__ = [
     "create_defect_point_substitution",
     "create_defect_point_interstitial",
     "create_multiple_defects",
+    "create_solid_solution",
     # Surface Defect Functions
     "create_defect_adatom",
     "create_multiple_adatom_defects",

package/tests/fixtures/hashes.json

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

package/tests/js/cell/cell.ts

@@ -41,7 +41,7 @@ const VECTORS_EQUAL_UP_TO_PRECISION_4: Matrix3X3Schema = [
     [0.0, 0.0, 3.00001],
 ];
 
-const VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME = 6.000110000600002;
+const VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME = 6.000110000600001;
 const VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4 = 6.0001;
 const VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_5 = 6.00011;
 

package/tests/js/fixtures.ts

@@ -1,14 +1,15 @@
 import { AtomicConstraintsSchema, BasisSchema, MaterialSchema } from "@mat3ra/esse/dist/js/types";
+import { MaterialStandata } from "@mat3ra/standata";
 import fs from "fs";
 import path from "path";
 
-// TODO: use @mat3ra/standata
 import AsGeBasis_JSON from "../fixtures/AsGe-basis.json";
 import atomicConstraints_JSON from "../fixtures/atomic-constraints.json";
 import C2H4_JSON from "../fixtures/C2H4.json";
 import C2H4Translated_JSON from "../fixtures/C2H4-translated.json";
 import FeLiSiBasis_JSON from "../fixtures/FeLiSi-basis.json";
 import FeO_JSON from "../fixtures/FeO.json";
+
 import Ge2Basis_JSON from "../fixtures/Ge2-basis.json";
 import Graphene_JSON from "../fixtures/Graphene.json";
 import H2HFinal_JSON from "../fixtures/H2+H-final.json";
@@ -27,6 +28,7 @@ import SiSlab111Gamma120_JSON from "../fixtures/si-slab-111-0.5-vacuum-gamma-120
 import SiSlab111_JSON from "../fixtures/si-slab-111-0.5-vacuum-ratio.json";
 import SiSlab111NoVacuum_JSON from "../fixtures/si-slab-111-0-vacuum.json";
 import Silicon_JSON from "../fixtures/si-standata.json";
+
 import SiSupercell_JSON from "../fixtures/Si-supercell.json";
 import Si2Basis_JSON from "../fixtures/Si2-basis.json";
 import Si2BasisRepeated_JSON from "../fixtures/Si2-basis-repeated.json";
@@ -41,6 +43,9 @@ const SiSlab111 = SiSlab111_JSON as unknown as MaterialSchema;
 const SiSlab111Gamma120 = SiSlab111Gamma120_JSON as unknown as MaterialSchema;
 const SiSlab111NoVacuum = SiSlab111NoVacuum_JSON as unknown as MaterialSchema;
 const FeO = FeO_JSON as unknown as MaterialSchema;
+const FeOStandata = MaterialStandata.getRuntimeDataConfigs().find(
+    (m: any) => m.name?.includes("FeO"),
+) as MaterialSchema;
 const Na4Cl4 = Na4Cl4_JSON as unknown as MaterialSchema;
 const Na4Cl4Cartesian = Na4Cl4Cartesian_JSON as unknown as MaterialSchema;
 const C2H4 = C2H4_JSON as unknown as MaterialSchema;
@@ -79,6 +84,7 @@ export {
     Si2BasisRepeated,
     // Other
     FeO,
+    FeOStandata,
     Na4Cl4,
     Na4Cl4Cartesian,
     C2H4,

package/tests/js/material.test.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 
 import { Material } from "../../src/js/material";
-import { Graphene, Na4Cl4, Silicon } from "./fixtures";
+import { FeOStandata, Graphene, Na4Cl4, Silicon } from "./fixtures";
 
 const newBasisXYZ = `Si     0.000000    0.000000    0.000000
 Ge     0.250000    0.250000    0.250000
@@ -31,5 +31,12 @@ describe("Material", () => {
                 expect(material.scaledHash).to.equal((fixture as any).scaledHash);
             });
         });
+
+        it("should match expected hash for FeO (standata)", () => {
+            const expectedHashes = require("../../fixtures/hashes.json");
+            const material = new Material(FeOStandata);
+            expect(material.calculateHash()).to.equal(expectedHashes.FeO.hash);
+            expect(material.scaledHash).to.equal(expectedHashes.FeO.scaledHash);
+        });
     });
 });

package/tests/py/unit/test_material.py

@@ -140,6 +140,16 @@ def test_calculate_hash(fixture_file):
     assert material.scaled_hash == fixture["scaledHash"]
 
 
+def test_calculate_hash_feo_standata():
+    from mat3ra.standata.materials import Materials
+
+    expected_hashes = load_fixture("hashes.json")["FeO"]
+    data = Materials.get_by_name_first_match("FeO")
+    material = Material.create(data)
+    assert material.hash == expected_hashes["hash"]
+    assert material.scaled_hash == expected_hashes["scaledHash"]
+
+
 def test_model_dump_includes_hashes():
     material = Material.create_default()
     serialized_material = material.model_dump()