@mat3ra/made 2025.4.4-0 → 2025.4.7-1

package/dist/js/basis/basis.d.ts

@@ -58,59 +58,6 @@ export declare class Basis {
     static get unitsOptionsConfig(): typeof ATOMIC_COORD_UNITS;
     static get unitsOptionsDefaultValue(): string;
     static get defaultCell(): [import("@mat3ra/esse/dist/js/types").ArrayOf3NumberElementsSchema, import("@mat3ra/esse/dist/js/types").ArrayOf3NumberElementsSchema, import("@mat3ra/esse/dist/js/types").ArrayOf3NumberElementsSchema];
-    /**
-     * Serialize class instance to JSON.
-     * @param skipRounding - Whether to skip rounding the resulting lattice values, defaults to `false`.
-     * @example As below:
-     {
-            "elements" : [
-                {
-                    "id" : 0,
-                    "value" : "Si"
-                },
-                {
-                    "id" : 1,
-                    "value" : "Si"
-                }
-            ],
-            "coordinates" : [
-                {
-                    "id" : 0,
-                    "value" : [
-                        0,
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "id" : 1,
-                    "value" : [
-                        0.25,
-                        0.25,
-                        0.25
-                    ]
-                }
-            ],
-            "units" : "crystal",
-            "cell" : [
-                [
-                    1,
-                    0,
-                    0
-                ],
-                [
-                    0,
-                    1,
-                    0
-                ],
-                [
-                    0,
-                    0,
-                    1
-                ]
-            ]
-        }
-     */
     toJSON(skipRounding?: boolean): BasisSchema;
     /** Return coordinates rounded to default precision */
     get coordinatesRounded(): {

package/dist/js/basis/basis.js

@@ -43,65 +43,11 @@ class Basis {
     static get defaultCell() {
         return new lattice_1.Lattice().vectorArrays;
     }
-    /**
-     * Serialize class instance to JSON.
-     * @param skipRounding - Whether to skip rounding the resulting lattice values, defaults to `false`.
-     * @example As below:
-     {
-            "elements" : [
-                {
-                    "id" : 0,
-                    "value" : "Si"
-                },
-                {
-                    "id" : 1,
-                    "value" : "Si"
-                }
-            ],
-            "coordinates" : [
-                {
-                    "id" : 0,
-                    "value" : [
-                        0,
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "id" : 1,
-                    "value" : [
-                        0.25,
-                        0.25,
-                        0.25
-                    ]
-                }
-            ],
-            "units" : "crystal",
-            "cell" : [
-                [
-                    1,
-                    0,
-                    0
-                ],
-                [
-                    0,
-                    1,
-                    0
-                ],
-                [
-                    0,
-                    0,
-                    1
-                ]
-            ]
-        }
-     */
     toJSON(skipRounding = false) {
         const json = {
             elements: this.elements,
             coordinates: skipRounding ? this.coordinates : this.coordinatesRounded,
             units: this.units,
-            cell: skipRounding ? this.cell : this.cellRounded,
         };
         if (!underscore_1.default.isEmpty(this.labels)) {
             return JSON.parse(JSON.stringify({
@@ -131,6 +77,7 @@ class Basis {
     clone(extraContext) {
         return new this.constructor({
             ...this.toJSON(),
+            cell: this.cell,
             ...extraContext,
         });
     }

package/package.json

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

package/pyproject.toml

@@ -26,6 +26,7 @@ dependencies = [
 [project.optional-dependencies]
 # tracking separately the deps required to use the tools module
 tools = [
+    "scipy",
     "pymatgen==2024.4.13",
     "ase",
     "pymatgen-analysis-defects==2024.4.23",

package/src/js/basis/basis.ts

@@ -99,65 +99,11 @@ export class Basis {
         return new Lattice().vectorArrays;
     }
 
-    /**
-     * Serialize class instance to JSON.
-     * @param skipRounding - Whether to skip rounding the resulting lattice values, defaults to `false`.
-     * @example As below:
-     {
-            "elements" : [
-                {
-                    "id" : 0,
-                    "value" : "Si"
-                },
-                {
-                    "id" : 1,
-                    "value" : "Si"
-                }
-            ],
-            "coordinates" : [
-                {
-                    "id" : 0,
-                    "value" : [
-                        0,
-                        0,
-                        0
-                    ]
-                },
-                {
-                    "id" : 1,
-                    "value" : [
-                        0.25,
-                        0.25,
-                        0.25
-                    ]
-                }
-            ],
-            "units" : "crystal",
-            "cell" : [
-                [
-                    1,
-                    0,
-                    0
-                ],
-                [
-                    0,
-                    1,
-                    0
-                ],
-                [
-                    0,
-                    0,
-                    1
-                ]
-            ]
-        }
-     */
     toJSON(skipRounding = false): BasisSchema {
         const json = {
             elements: this.elements,
             coordinates: skipRounding ? this.coordinates : this.coordinatesRounded,
             units: this.units,
-            cell: skipRounding ? this.cell : this.cellRounded,
         };
 
         if (!_.isEmpty(this.labels)) {
@@ -194,6 +140,7 @@ export class Basis {
     clone(extraContext?: Partial<BasisProps>): Basis {
         return new (this.constructor as typeof Basis)({
             ...this.toJSON(),
+            cell: this.cell,
             ...extraContext,
         });
     }

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

@@ -26,6 +26,8 @@ class Basis(BasisSchema, InMemoryEntityPydantic):
             kwargs["labels"] = ArrayWithIds.from_list_of_dicts(kwargs["labels"])
         if isinstance(kwargs.get("constraints"), list):
             kwargs["constraints"] = ArrayWithIds.from_list_of_dicts(kwargs["constraints"])
+        if isinstance(kwargs.get("cell"), list):
+            kwargs["cell"] = Cell.from_vectors_array(kwargs["cell"])
         return kwargs
 
     def __init__(self, *args: Any, **kwargs: Any):
@@ -110,6 +112,18 @@ class Basis(BasisSchema, InMemoryEntityPydantic):
         self.elements.add_item(element)
         self.coordinates.add_item(coordinate)
 
+    def add_atoms_from_another_basis(self, other_basis: "Basis"):
+        """
+        Add atoms from another basis to this basis.
+
+        Args:
+            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)
+
     def remove_atom_by_id(self, id: int):
         self.elements.remove_item(id)
         self.coordinates.remove_item(id)

package/src/py/mat3ra/made/cell.py

@@ -1,58 +1,55 @@
-from typing import List, Optional
+from typing import List
 
 import numpy as np
+from mat3ra.code.vector import RoundedVector3D
+from mat3ra.esse.models.properties_directory.structural.lattice.lattice_vectors import LatticeExplicitUnit as CellSchema
 from mat3ra.utils.mixins import RoundNumericValuesMixin
-from pydantic import BaseModel, Field
+from pydantic import Field
 
+DEFAULT_CELL = np.eye(3).tolist()
 
-class Cell(RoundNumericValuesMixin, BaseModel):
-    # TODO: figure out how to use ArrayOf3NumberElementsSchema
-    vector1: List[float] = Field(default_factory=lambda: [1.0, 0.0, 0.0])
-    vector2: List[float] = Field(default_factory=lambda: [0.0, 1.0, 0.0])
-    vector3: List[float] = Field(default_factory=lambda: [0.0, 0.0, 1.0])
-    __round_precision__ = 6
 
-    @classmethod
-    def from_vectors_array(cls, vectors_array: Optional[List[List[float]]] = None) -> "Cell":
-        if vectors_array is None:
-            vectors_array = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]
-
-        # Ensure vectors are properly converted to lists of floats
-        processed_vectors = []
-        for vector in vectors_array:
-            processed_vector = [float(v) for v in vector]
-            processed_vectors.append(processed_vector)
+class Cell(RoundNumericValuesMixin, CellSchema):
+    __rounded_vector3d__ = RoundedVector3D
+    __default_vectors__ = DEFAULT_CELL
 
-        return cls(vector1=processed_vectors[0], vector2=processed_vectors[1], vector3=processed_vectors[2])
+    a: RoundedVector3D = Field(default_factory=lambda: Cell.__rounded_vector3d__(DEFAULT_CELL[0]))
+    b: RoundedVector3D = Field(default_factory=lambda: Cell.__rounded_vector3d__(DEFAULT_CELL[1]))
+    c: RoundedVector3D = Field(default_factory=lambda: Cell.__rounded_vector3d__(DEFAULT_CELL[2]))
 
-    @property
-    def vectors_as_array(self, skip_rounding=False) -> List[List[float]]:
+    @classmethod
+    def from_vectors_array(cls, vectors: List[List[float]] = DEFAULT_CELL) -> "Cell":
+        return cls(
+            a=RoundedVector3D(vectors[0]),
+            b=RoundedVector3D(vectors[1]),
+            c=RoundedVector3D(vectors[2]),
+        )
+
+    def get_vector_arrays(self, skip_rounding=False) -> List[List[float]]:
         if skip_rounding:
-            return [self.vector1, self.vector2, self.vector3]
-        return self.round_array_or_number([self.vector1, self.vector2, self.vector3])
+            return [self.a.value, self.b.value, self.c.value]
+        return [self.a.value_rounded, self.b.value_rounded, self.c.value_rounded]
 
-    def to_list(self, skip_rounding=False) -> List[List[float]]:
-        _ = self.round_array_or_number
-        return [
-            self.vector1 if skip_rounding else _(self.vector1),
-            self.vector2 if skip_rounding else _(self.vector2),
-            self.vector3 if skip_rounding else _(self.vector3),
-        ]
+    @property
+    def vector_arrays(self) -> List[List[float]]:
+        return self.get_vector_arrays(skip_rounding=True)
 
-    def clone(self) -> "Cell":
-        return self.from_vectors_array(self.vectors_as_array)
+    @property
+    def vector_arrays_rounded(self) -> List[List[float]]:
+        return self.get_vector_arrays(skip_rounding=False)
 
     def convert_point_to_cartesian(self, point: List[float]) -> List[float]:
-        np_vector = np.array(self.vectors_as_array)
-        result_list = np.dot(point, np_vector).tolist()
-        return self.round_array_or_number(result_list)
+        np_vector = np.array(self.vector_arrays)
+        return np.dot(point, np_vector).tolist()
 
     def convert_point_to_crystal(self, point: List[float]) -> List[float]:
-        np_vector = np.array(self.vectors_as_array)
-        result_list = np.dot(point, np.linalg.inv(np_vector)).tolist()
-        return self.round_array_or_number(result_list)
+        np_vector = np.array(self.vector_arrays)
+        return np.dot(point, np.linalg.inv(np_vector)).tolist()
 
     @property
     def volume(self) -> float:
-        volume = np.linalg.det(np.array(self.vectors_as_array))
-        return self.round_array_or_number(volume)
+        return np.linalg.det(np.array(self.vector_arrays))
+
+    @property
+    def volume_rounded(self) -> float:
+        return self.round_array_or_number(self.volume)

package/src/py/mat3ra/made/lattice.py

@@ -3,7 +3,6 @@ from typing import List, Optional
 
 import numpy as np
 from mat3ra.code.entity import InMemoryEntityPydantic
-from mat3ra.code.vector import RoundedVector3D
 from mat3ra.esse.models.properties_directory.structural.lattice.lattice_bravais import (
     LatticeImplicitSchema as LatticeBravaisSchema,
 )
@@ -11,35 +10,17 @@ from mat3ra.esse.models.properties_directory.structural.lattice.lattice_bravais
     LatticeTypeEnum,
     LatticeUnitsSchema,
 )
-from mat3ra.esse.models.properties_directory.structural.lattice.lattice_vectors import (
-    LatticeExplicitUnit as LatticeVectorsSchema,
-)
 from mat3ra.utils.mixins import RoundNumericValuesMixin
-from pydantic import Field
 
 from .cell import Cell
 
 COORDINATE_TOLERANCE = 6
 
 
-class LatticeVector(RoundedVector3D):
+class LatticeVectors(Cell):
     pass
 
 
-class LatticeVectors(RoundNumericValuesMixin, LatticeVectorsSchema):
-    """
-    A class to represent the lattice vectors.
-    """
-
-    a: LatticeVector = Field(default_factory=lambda: LatticeVector(root=[1.0, 0.0, 0.0]))
-    b: LatticeVector = Field(default_factory=lambda: LatticeVector(root=[0.0, 1.0, 0.0]))
-    c: LatticeVector = Field(default_factory=lambda: LatticeVector(root=[0.0, 0.0, 1.0]))
-
-    @classmethod
-    def from_vectors_array(cls, vectors: List[List[float]]) -> "LatticeVectors":
-        return cls(a=LatticeVector(root=vectors[0]), b=LatticeVector(root=vectors[1]), c=LatticeVector(root=vectors[2]))
-
-
 class Lattice(RoundNumericValuesMixin, LatticeBravaisSchema, InMemoryEntityPydantic):
     __types__ = LatticeTypeEnum
     __type_default__ = LatticeBravaisSchema.model_fields["type"].default
@@ -111,19 +92,20 @@ class Lattice(RoundNumericValuesMixin, LatticeBravaisSchema, InMemoryEntityPydan
         )
 
     @property
-    def vector_arrays(self, skip_rounding=False) -> List[List[float]]:
-        _ = [self.vectors.a, self.vectors.b, self.vectors.c]
-        if not skip_rounding:
-            return list(map(lambda vector: vector.value_rounded, _))
-        return list(map(lambda vector: vector.root, _))
+    def vector_arrays(self) -> List[List[float]]:
+        return self.vectors.vector_arrays
 
     @property
-    def cell(self) -> Cell:
-        return Cell.from_vectors_array(self.vector_arrays)
+    def vector_arrays_rounded(self) -> List[List[float]]:
+        return self.vectors.vector_arrays_rounded
 
     @property
     def cell_volume(self) -> float:
-        return self.cell.volume
+        return self.vectors.volume
+
+    @property
+    def cell_volume_rounded(self) -> float:
+        return self.vectors.volume_rounded
 
     def get_scaled_by_matrix(self, matrix: List[List[float]]):
         """

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

@@ -61,7 +61,7 @@ class Material(MaterialSchema, HasDescriptionHasMetadataNamedDefaultableInMemory
     def model_post_init(self, __context: Any) -> None:
         if not self.name and self.formula:
             self.name: str = self.formula
-        self.basis.cell = self.lattice.cell
+        self.basis.cell = self.lattice.vectors
 
     @property
     def coordinates_array(self) -> List[List[float]]:
@@ -82,7 +82,7 @@ class Material(MaterialSchema, HasDescriptionHasMetadataNamedDefaultableInMemory
         original_is_in_crystal_units = self.basis.is_in_crystal_units
         self.to_cartesian()
         self.lattice = Lattice.from_vectors_array([lattice_vector1, lattice_vector2, lattice_vector3])
-        self.basis.cell = self.lattice.cell
+        self.basis.cell = self.lattice.vectors
         if original_is_in_crystal_units:
             self.to_crystal()
 

package/src/py/mat3ra/made/tools/build/defect/builders.py

@@ -612,7 +612,7 @@ class TerraceSlabDefectBuilder(SlabDefectBuilder):
             The normalized cut direction vector in Cartesian coordinates.
         """
         np_cut_direction = np.array(cut_direction)
-        direction_vector = np.dot(np.array(material.basis.cell.vectors_as_array), np_cut_direction)
+        direction_vector = np.dot(np.array(material.basis.cell.vector_arrays), np_cut_direction)
         normalized_direction_vector = direction_vector / np.linalg.norm(direction_vector)
         return normalized_direction_vector
 
@@ -648,7 +648,7 @@ class TerraceSlabDefectBuilder(SlabDefectBuilder):
         """
         height_cartesian = self._calculate_height_cartesian(original_material, new_material)
         cut_direction_xy_proj_cart = np.linalg.norm(
-            np.dot(np.array(new_material.basis.cell.vectors_as_array), normalized_direction_vector)
+            np.dot(np.array(new_material.lattice.vector_arrays), normalized_direction_vector)
         )
         # Slope of the terrace along the cut direction
         hypotenuse = np.linalg.norm([height_cartesian, cut_direction_xy_proj_cart])
@@ -679,17 +679,17 @@ class TerraceSlabDefectBuilder(SlabDefectBuilder):
         Returns:
             The material with the increased lattice size.
         """
-        vector_a, vector_b = np.array(material.basis.cell.vector1), np.array(material.basis.cell.vector2)
-        norm_a, norm_b = np.linalg.norm(vector_a), np.linalg.norm(vector_b)
+        vector_a, vector_b = material.lattice.vectors.a, material.lattice.vectors.b
+        norm_a, norm_b = vector_a.norm, vector_b.norm
 
-        delta_a_cart = np.dot(vector_a, np.array(direction_of_increase)) * length_increase / norm_a
-        delta_b_cart = np.dot(vector_b, np.array(direction_of_increase)) * length_increase / norm_b
+        delta_a_cart = np.dot(vector_a.value, np.array(direction_of_increase)) * length_increase / norm_a
+        delta_b_cart = np.dot(vector_b.value, np.array(direction_of_increase)) * length_increase / norm_b
 
         scaling_matrix = np.eye(3)
         scaling_matrix[0, 0] += delta_a_cart / norm_a
         scaling_matrix[1, 1] += delta_b_cart / norm_b
 
-        new_lattice = material.lattice.get_scaled_by_matrix(scaling_matrix)
+        new_lattice = material.lattice.get_scaled_by_matrix(scaling_matrix.tolist())
         material.set_lattice(new_lattice)
         return material
 

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

@@ -42,16 +42,15 @@ def merge_two_bases(basis1: Basis, basis2: Basis, distance_tolerance: float) ->
     merged_elements_values = basis1.elements.values + basis2.elements.values
     merged_coordinates_values = basis1.coordinates.values + basis2.coordinates.values
     merged_labels_values = basis1.labels.values + basis2.labels.values if basis1.labels and basis2.labels else []
+    merged_constraints_values = basis1.constraints.values + basis2.constraints.values
 
-    merged_basis = Basis(
-        elements=ArrayWithIds.from_values(values=merged_elements_values),
-        coordinates=Coordinates.from_values(values=merged_coordinates_values),
-        units=basis1.units,
-        cell=basis1.cell,
-        labels=ArrayWithIds.from_values(values=merged_labels_values),
-        constraints=basis1.constraints,
-    )
-    resolved_basis = resolve_close_coordinates_basis(merged_basis, distance_tolerance)
+    new_basis = basis1.clone()
+    new_basis.elements = ArrayWithIds.from_values(values=merged_elements_values)
+    new_basis.coordinates = Coordinates.from_values(values=merged_coordinates_values)
+    new_basis.labels = ArrayWithIds.from_values(values=merged_labels_values)
+    new_basis.constraints = ArrayWithIds.from_values(values=merged_constraints_values)
+
+    resolved_basis = resolve_close_coordinates_basis(new_basis, distance_tolerance)
 
     return resolved_basis
 
@@ -79,7 +78,7 @@ def merge_two_materials(
 def merge_materials(
     materials: List[Material],
     material_name: Optional[str] = None,
-    distance_tolerance: float = 0.01,
+    distance_tolerance: float = 0.1,
     merge_dangerously=False,
 ) -> Material:
     """

package/tests/fixtures/C2H4-translated.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2b4423a8f4e9d34e2592880517597bcf5ade475de17d8824070438fb24dabe18
-size 1827
+oid sha256:29c040a13aaea2e8317a34dc292abc52004394b746c83f5b7594818e1d736355
+size 1669

package/tests/fixtures/C2H4.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9f0026c208aefc5fa46b5d3261969a617b95d9f7db27c3acda15f6e7d2c920d0
-size 1807
+oid sha256:4ad6e240bbc204fc7ea8e92cd74e27de38a7109f542fbd5deecfca52bd32cee9
+size 1649

package/tests/fixtures/Graphene.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7eb6b302bffb3eb5ba9ca93a5fd11eb4e8b1200a192208ff4cc4efbd69803eca
-size 2106
+oid sha256:3fbf76a64fe44dccbad8e5cbd625e7b3a0fe3f0496c0fd447622632dca0fde62
+size 1733

package/tests/fixtures/H2+H-final.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:614755b60189a75999b7800b1ed47148836bee848cfb61d7f79ed28005716981
-size 1272
+oid sha256:e360cab9de055b791907fd1c63f625756bd90d2e77b7d136032601275b796c06
+size 1114

package/tests/fixtures/H2+H-image.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8739c66fc720bdeec7eeef2a67aa37d2fa54a47281fafcc011593cdebf5e6aee
-size 1274
+oid sha256:84f42fb06dba054dec55a28ecb6c5d976a07daff25ea86b341ceab7cc513afe3
+size 1116

package/tests/fixtures/H2+H-initial.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bb4b3898d48cf7d1f0e8b73f8435f5fbf25eeb297c188a37dbf0446cb85cec3f
-size 1272
+oid sha256:abe820a78f0482aee9418df39b20fdea266117a68e631567634725b02315d883
+size 1114

package/tests/fixtures/Na4Cl4-cartesian.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:503af314a34a074b775ab512994a61a09d0b134ef3048dea3076285f1ef5f44f
-size 2295
+oid sha256:1914573cd9f1bb2e0161d07581125acfeaa9804c6f2285e8c9ef76c83060c867
+size 2137

package/tests/fixtures/Na4Cl4.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f5ecfe71533206ef52419bd1c9843ec668594fd9ea110dda8ac781f25af296d0
-size 2148
+oid sha256:8d4c3c8db449d2dae640888f6474cb04d92f4b98f392c14866d867d1d41517ad
+size 1990

package/tests/fixtures/Ni-hex.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:972098aa21b7f2a8d50bd968245fb69588d3c4f3152a90517c64bf13b2af4683
-size 2242
+oid sha256:0ac714e6f565c9bf4dd30c291a2e13d67da441b07cb5dcf6bb618537596702de
+size 1870

package/tests/fixtures/Si-hex.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a6269540e98507c052a6a6e56328429c7d4cdd858ac4b6c59b838e0782a588fa
-size 2431
+oid sha256:2dc9f03937e4f004274d7dafbb1e06892ef9f425b6f452fa32a43fc191f783cd
+size 2062

package/tests/fixtures/Si-slab.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e6942398bc73bfdecf050070243cbe191a50887ea18b138d458e95c43121df22
-size 1745
+oid sha256:cb8fc82009d8a5c6d437bf17301e7a99760b51f756b4867360d48eaf5b7a7505
+size 1588

package/tests/fixtures/Si2-basis-repeated.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:24211f6b09a3190b7ad69669591cb1e3793eac573892d21bcfa562d128d3c919
-size 792
+oid sha256:025bb26b92bb4b12eb68169e1e888baf847d4b9326538e5494ec8eace7b8cf18
+size 654

package/tests/js/basis/basis.js

@@ -1,6 +1,7 @@
 import { expect } from "chai";
 
 import { Basis } from "../../../src/js/basis/basis";
+import { Material } from "../../../src/js/material";
 import {
     AsGeBasis,
     C2H4,
@@ -21,8 +22,10 @@ describe("Basis", () => {
     });
 
     it("should return true when basis is compared to its clone", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.isEqualTo(basis.clone())).to.be.equal(true);
+        const basis1 = new Material(Na4Cl4).Basis;
+        const basis2 = basis1.clone();
+        expect(basis1.isEqualTo(basis2)).to.be.equal(true);
+        expect(basis1.hasEquivalentCellTo(basis2)).to.be.equal(true);
     });
 
     it("should return jsonified basis", () => {
@@ -31,8 +34,8 @@ describe("Basis", () => {
     });
 
     it("should return true if cells are equal", () => {
-        const basis1 = new Basis(FeLiSiBasis);
-        const basis2 = new Basis(LiFeSiBasis);
+        const basis1 = new Material(Na4Cl4).Basis;
+        const basis2 = new Material(Na4Cl4Cartesian).Basis;
         expect(basis1.hasEquivalentCellTo(basis2)).to.be.equal(true);
     });
 

package/tests/py/unit/fixtures/cuts.py

@@ -0,0 +1,118 @@
+FULL_MATERIAL = {
+    "basis": {
+        "constraints": [],
+        "coordinates": [
+            {"id": 0, "value": [0.0, 0.0, 0.0]},
+            {"id": 1, "value": [0.0, 0.5, 0.5]},
+            {"id": 2, "value": [0.5, 0.0, 0.5]},
+            {"id": 3, "value": [0.5, 0.5, 0.0]},
+        ],
+        "elements": [
+            {"id": 0, "value": "Ni"},
+            {"id": 1, "value": "Ni"},
+            {"id": 2, "value": "Ni"},
+            {"id": 3, "value": "Ni"},
+        ],
+        "labels": [],
+        "units": "crystal",
+    },
+    "consistencyChecks": None,
+    "derivedProperties": None,
+    "description": None,
+    "descriptionObject": None,
+    "external": None,
+    "field_id": None,
+    "formula": None,
+    "icsdId": None,
+    "isDefault": False,
+    "isNonPeriodic": False,
+    "lattice": {
+        "a": 3.52,
+        "alpha": 90.0,
+        "b": 3.52,
+        "beta": 90.0,
+        "c": 3.52,
+        "gamma": 90.0,
+        "type": "TRI",
+        "units": {"angle": "degree", "length": "angstrom"},
+    },
+    "metadata": {"boundaryConditions": {"offset": 0, "type": "pbc"}},
+    "name": "",
+    "scaledHash": None,
+    "schemaVersion": "2022.8.16",
+    "slug": None,
+    "src": None,
+    "systemName": None,
+    "unitCellFormula": None,
+}
+
+CAVITY_MATERIAL_BASIS = {
+    "basis": {
+        "constraints": [],
+        "coordinates": [
+            {"id": 1, "value": [0.0, 0.5, 0.5]},
+            {"id": 2, "value": [0.5, 0.0, 0.5]},
+            {"id": 4, "value": [0.5, 0.5, 0.0]},
+        ],
+        "elements": [{"id": 1, "value": "Ni"}, {"id": 2, "value": "Ni"}, {"id": 4, "value": "Au"}],
+        "labels": [],
+        "units": "crystal",
+    }
+}
+
+
+SECTION_MATERIAL_BASIS = {
+    "basis": {
+        "constraints": [],
+        "coordinates": [{"id": 0, "value": [0.0, 0.0, 0.0]}, {"id": 3, "value": [0.5, 0.5, 0.0]}],
+        "elements": [{"id": 0, "value": "Ni"}, {"id": 3, "value": "Ni"}],
+        "labels": [],
+        "units": "crystal",
+    }
+}
+
+SECTION_MATERIAL_BASIS_EXTRA_ATOM = {
+    "basis": {
+        "constraints": [],
+        "coordinates": [
+            {"id": 0, "value": [0.0, 0.0, 0.0]},
+            {"id": 3, "value": [0.5, 0.5, 0.0]},
+            {"id": 4, "value": [0.51, 0.51, 0.0]},  # Extra atom collides with Au in cavity material
+        ],
+        "elements": [{"id": 0, "value": "Ni"}, {"id": 3, "value": "Ni"}, {"id": 4, "value": "O"}],
+        "labels": [],
+        "units": "crystal",
+    }
+}
+
+MERGED_SECTION_CAVITY_BASIS = {
+    "elements": [
+        {"id": 0, "value": "Ni"},
+        {"id": 1, "value": "Ni"},
+        {"id": 2, "value": "Ni"},
+        {"id": 4, "value": "Au"},
+    ],
+    "coordinates": [
+        {"id": 0, "value": [0.0, 0.0, 0.0]},
+        {"id": 1, "value": [0.0, 0.5, 0.5]},
+        {"id": 2, "value": [0.5, 0.0, 0.5]},
+        {"id": 4, "value": [0.5, 0.5, 0.0]},
+    ],
+    "labels": [],
+}
+
+MERGED_CAVITY_SECTION_BASIS = {
+    "elements": [
+        {"id": 1, "value": "Ni"},
+        {"id": 2, "value": "Ni"},
+        {"id": 0, "value": "Ni"},
+        {"id": 3, "value": "Ni"},
+    ],
+    "coordinates": [
+        {"id": 1, "value": [0.0, 0.5, 0.5]},
+        {"id": 2, "value": [0.5, 0.0, 0.5]},
+        {"id": 0, "value": [0.0, 0.0, 0.0]},
+        {"id": 3, "value": [0.5, 0.5, 0.0]},
+    ],
+    "labels": [],
+}

package/tests/py/unit/test_cell.py

@@ -0,0 +1,104 @@
+from mat3ra.code.vector import RoundedVector3D
+from mat3ra.made.cell import Cell
+
+VECTORS = [
+    [1.0, 0.0, 0.0],
+    [0.0, 2.0, 0.0],
+    [0.0, 0.0, 3.0],
+]
+
+VECTORS_VOLUME = 6.0
+
+VECTORS_EQUAL_UP_TO_PRECISION_4 = [
+    [1.00001, 0.0, 0.0],
+    [0.0, 2.00001, 0.0],
+    [0.0, 0.0, 3.00001],
+]
+
+VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME = 6.000110000600002
+VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4 = 6.0001
+VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_5 = 6.00011
+
+
+def test_cell_creation():
+    cell = Cell(a=RoundedVector3D(VECTORS[0]), b=RoundedVector3D(VECTORS[1]), c=RoundedVector3D(VECTORS[2]))
+    assert cell.a.value == VECTORS[0]
+    assert cell.b.value == VECTORS[1]
+    assert cell.c.value == VECTORS[2]
+    assert cell.volume == 6.0
+    assert cell.vector_arrays == VECTORS
+
+
+def test_cell_creation_default():
+    cell = Cell()
+    assert cell.a.value == Cell.__default_vectors__[0]
+    assert cell.b.value == Cell.__default_vectors__[1]
+    assert cell.c.value == Cell.__default_vectors__[2]
+    assert cell.volume == 1.0
+    assert cell.vector_arrays == Cell.__default_vectors__
+
+
+def test_from_vectors_array():
+    cell = Cell.from_vectors_array(vectors=VECTORS)
+    assert cell.a.value == VECTORS[0]
+    assert cell.b.value == VECTORS[1]
+    assert cell.c.value == VECTORS[2]
+    assert cell.volume == VECTORS_VOLUME
+    assert cell.vector_arrays == VECTORS
+
+
+def test_get_vector_arrays():
+    cell = Cell.from_vectors_array(vectors=VECTORS)
+    assert cell.get_vector_arrays() == VECTORS
+    assert cell.get_vector_arrays(skip_rounding=True) == VECTORS
+    assert cell.get_vector_arrays(skip_rounding=False) == VECTORS
+
+
+def test_vector_arrays_including_rounded():
+    class_reference = Cell
+    class_reference.__rounded_vector3d__ = RoundedVector3D
+
+    class_reference.__rounded_vector3d__.__round_precision__ = 4
+    cell = Cell.from_vectors_array(vectors=VECTORS_EQUAL_UP_TO_PRECISION_4)
+    assert cell.vector_arrays == VECTORS_EQUAL_UP_TO_PRECISION_4
+    assert cell.vector_arrays_rounded == VECTORS
+
+    class_reference.__rounded_vector3d__.__round_precision__ = 5
+    cell = Cell.from_vectors_array(vectors=VECTORS_EQUAL_UP_TO_PRECISION_4)
+    assert cell.vector_arrays == VECTORS_EQUAL_UP_TO_PRECISION_4
+    assert cell.vector_arrays_rounded != VECTORS
+
+
+def test_convert_point_to_cartesian():
+    cell = Cell.from_vectors_array(vectors=VECTORS)
+    coordinate_in_crystal = [0.5, 0.5, 0.5]
+    coordinate_in_cartesian = cell.convert_point_to_cartesian(coordinate_in_crystal)
+    expected_coordinate_in_cartesian = [0.5, 1.0, 1.5]
+    assert coordinate_in_cartesian == expected_coordinate_in_cartesian
+
+
+def test_convert_point_to_crystal():
+    cell = Cell.from_vectors_array(vectors=VECTORS)
+    coordinate_in_cartesian = [0.5, 1.0, 1.5]
+    coordinate_in_crystal = cell.convert_point_to_crystal(coordinate_in_cartesian)
+    expected_coordinate_in_crystal = [0.5, 0.5, 0.5]
+    assert coordinate_in_crystal == expected_coordinate_in_crystal
+
+
+def test_volume():
+    cell = Cell.from_vectors_array(vectors=VECTORS)
+    assert cell.volume == VECTORS_VOLUME
+
+
+def test_volume_rounded():
+    class_reference = Cell
+    class_reference.__round_precision__ = 4
+    cell = class_reference.from_vectors_array(vectors=VECTORS_EQUAL_UP_TO_PRECISION_4)
+    assert cell.volume == VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME
+    assert cell.volume_rounded == VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4
+
+    class_reference.__round_precision__ = 5
+    cell = class_reference.from_vectors_array(vectors=VECTORS_EQUAL_UP_TO_PRECISION_4)
+    assert cell.volume == VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME
+    assert cell.volume_rounded != VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4
+    assert cell.volume_rounded == VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_5

package/tests/py/unit/test_lattice.py

@@ -1,4 +1,5 @@
-from mat3ra.made.lattice import Lattice, LatticeVector
+from mat3ra.code.vector import RoundedVector3D
+from mat3ra.made.lattice import Lattice
 from mat3ra.utils import assertion as assertion_utils
 
 DEFAULT_UNITS = Lattice.__units_default__
@@ -20,16 +21,16 @@ def test_lattice_creation():
 def test_lattice_get_vectors():
     lattice = Lattice(a=2.0, b=3.0, c=4.0)
     expected_vectors = [[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 4.0]]
-    assert expected_vectors == lattice.vector_arrays
+    assert expected_vectors == lattice.vector_arrays_rounded
 
 
 def test_lattice_vectors_access():
     lattice = Lattice(a=2.0, b=3.0, c=4.0)
 
     # Test individual vector access
-    assert isinstance(lattice.vectors.a, LatticeVector)
-    assert isinstance(lattice.vectors.b, LatticeVector)
-    assert isinstance(lattice.vectors.c, LatticeVector)
+    assert isinstance(lattice.vectors.a, RoundedVector3D)
+    assert isinstance(lattice.vectors.b, RoundedVector3D)
+    assert isinstance(lattice.vectors.c, RoundedVector3D)
 
     # Test vector arrays access
     arrays = lattice.vector_arrays
@@ -52,8 +53,10 @@ def test_lattice_from_vectors():
     assert lattice.gamma == 90.0
     assert lattice.units == DEFAULT_UNITS
     assert lattice.type.value == DEFAULT_TYPE
-    assert lattice.cell_volume == 24.0
-    assert lattice.vector_arrays == [[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 4.0]]
+    # Avoid floating point comparison issue
+    assertion_utils.assert_deep_almost_equal(lattice.cell_volume, 24.0)
+    assert lattice.cell_volume_rounded == 24.0
+    assert lattice.vector_arrays_rounded == [[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 4.0]]
 
 
 def test_lattice_get_scaled_by_matrix():
@@ -69,7 +72,6 @@ def test_lattice_get_scaled_by_matrix():
     assert lattice.gamma == 90.0
     assert lattice.units == DEFAULT_UNITS
     assert lattice.type.value == DEFAULT_TYPE
-    assert lattice.cell_volume == 27.0
     assertion_utils.assert_deep_almost_equal(lattice.vector_arrays, expected_vector_values)
 
 

package/tests/py/unit/test_material.py

@@ -23,6 +23,20 @@ def test_create():
     assert_two_entities_deep_almost_equal(material, SI_CONVENTIONAL_CELL)
 
 
+def test_create_with_cell_as_list():
+    # The key cell should be ignored and Basis.Cell created from Lattice by Material
+    cell = [
+        [1.0, 0.0, 0.0],
+        [0.0, 1.0, 0.0],
+        [0.0, 0.0, 1.0],
+    ]
+    config = {**Material.__default_config__, "basis": {**Material.__default_config__["basis"], "cell": cell}}
+
+    material = Material.create(config)
+    assert isinstance(material.basis, Basis)
+    assert material.basis.cell.vector_arrays == material.lattice.vector_arrays
+
+
 def test_material_to_json():
     material = Material.create_default()
     # Remove all keys that are null in the config
@@ -74,6 +88,6 @@ def test_basis_cell_lattice_sync():
     new_lattice = Lattice.from_vectors_array(new_vectors)
     material.set_lattice(new_lattice)
     # Verify basis.cell matches new lattice vectors
-    assertion_utils.assert_deep_almost_equal(new_vectors, material.basis.cell.vectors_as_array)
+    assertion_utils.assert_deep_almost_equal(new_vectors, material.basis.cell.vector_arrays)
     assertion_utils.assert_deep_almost_equal(new_vectors, material.lattice.vector_arrays)
     # Verify basis coordinates are still correct

package/tests/py/unit/test_tools_build.py

@@ -1,54 +1,36 @@
-from ase.build import bulk
 from mat3ra.made.material import Material
 from mat3ra.made.tools.build.utils import merge_materials
-from mat3ra.made.tools.convert import from_ase
-from mat3ra.made.tools.modify import filter_by_layers
 from mat3ra.utils import assertion as assertion_utils
+from unit.fixtures.cuts import (
+    CAVITY_MATERIAL_BASIS,
+    FULL_MATERIAL,
+    MERGED_CAVITY_SECTION_BASIS,
+    MERGED_SECTION_CAVITY_BASIS,
+    SECTION_MATERIAL_BASIS,
+    SECTION_MATERIAL_BASIS_EXTRA_ATOM,
+)
 
-ase_ni = bulk("Ni", "fcc", a=3.52, cubic=True)
-material = Material.create(from_ase(ase_ni))
-section = filter_by_layers(material, central_atom_id=0, layer_thickness=1.0)
-cavity = filter_by_layers(material, central_atom_id=0, layer_thickness=1.0, invert_selection=True)
+section = Material.create({**FULL_MATERIAL, **SECTION_MATERIAL_BASIS})
+cavity = Material.create({**FULL_MATERIAL, **CAVITY_MATERIAL_BASIS})
+section_with_extra_atom = Material.create({**FULL_MATERIAL, **SECTION_MATERIAL_BASIS_EXTRA_ATOM})
 
-# Change 0th element
-section.basis.elements.values[0] = "Ge"
 
-# Add element to cavity for collision test
-cavity.basis.elements.add_item("S", id=4)
-coordinate_value = section.basis.coordinates.values[1]
-cavity.basis.coordinates.add_item(coordinate_value, id=4)
-
-expected_merged_material_basis = {
-    "elements": [{"id": 0, "value": "Ge"}, {"id": 1, "value": "Ni"}, {"id": 2, "value": "Ni"}, {"id": 4, "value": "S"}],
-    "coordinates": [
-        {"id": 0, "value": [0.0, 0.0, 0.0]},
-        {"id": 1, "value": [0.0, 0.5, 0.5]},
-        {"id": 2, "value": [0.5, 0.0, 0.5]},
-        {"id": 4, "value": [0.5, 0.5, 0.0]},
-    ],
-    "labels": [],
-}
-
-
-expected_merged_material_reverse_basis = {
-    "elements": [
-        {"id": 1, "value": "Ni"},
-        {"id": 2, "value": "Ni"},
-        {"id": 0, "value": "Ge"},
-        {"id": 3, "value": "Ni"},
-    ],
-    "coordinates": [
-        {"id": 1, "value": [0.0, 0.5, 0.5]},
-        {"id": 2, "value": [0.5, 0.0, 0.5]},
-        {"id": 0, "value": [0.0, 0.0, 0.0]},
-        {"id": 3, "value": [0.5, 0.5, 0.0]},
-    ],
-    "labels": [],
-}
+def test_merge_materials():
+    merged_material = merge_materials([section, cavity])
+    merged_material_reverse = merge_materials([cavity, section])
+    assertion_utils.assert_deep_almost_equal(merged_material.basis, MERGED_CAVITY_SECTION_BASIS)
+    assertion_utils.assert_deep_almost_equal(merged_material_reverse.basis, MERGED_SECTION_CAVITY_BASIS)
 
 
-def test_merge_materials():
+def test_resolve_close_coordinates_basis():
     merged_material = merge_materials([section, cavity])
     merged_material_reverse = merge_materials([cavity, section])
-    assertion_utils.assert_deep_almost_equal(merged_material.basis, expected_merged_material_basis)
-    assertion_utils.assert_deep_almost_equal(merged_material_reverse.basis, expected_merged_material_reverse_basis)
+    assertion_utils.assert_deep_almost_equal(merged_material.basis, MERGED_CAVITY_SECTION_BASIS)
+    assertion_utils.assert_deep_almost_equal(merged_material_reverse.basis, MERGED_SECTION_CAVITY_BASIS)
+
+
+def test_resolve_close_coordinates_basis_extra_atom():
+    merged_material = merge_materials([section_with_extra_atom, cavity])
+    merged_material_reverse = merge_materials([cavity, section_with_extra_atom])
+    assertion_utils.assert_deep_almost_equal(merged_material.basis, MERGED_CAVITY_SECTION_BASIS)
+    assertion_utils.assert_deep_almost_equal(merged_material_reverse.basis, MERGED_SECTION_CAVITY_BASIS)

package/tests/py/unit/test_tools_build_defect.py

@@ -195,7 +195,14 @@ def test_create_terrace():
         number_of_added_layers=1,
     )
     new_slab = TerraceSlabDefectBuilder().get_material(configuration=config)
-    assertion_utils.assert_deep_almost_equal([0.777786396, 0.5, 0.414655236], new_slab.basis.coordinates.values[42])
+    coordinate_macosx = [0.777786396, 0.5, 0.414655236]
+    coordinate_linux_and_emscripten = [0.627786404, 0.25, 0.439235145]
+    defect_coordinate = new_slab.basis.coordinates.values[42]
+    atol = 10 ** (-COORDINATE_TOLERANCE)
+    try:
+        assertion_utils.assert_deep_almost_equal(coordinate_macosx, defect_coordinate, atol=atol)
+    except AssertionError:
+        assertion_utils.assert_deep_almost_equal(coordinate_linux_and_emscripten, defect_coordinate, atol=atol)
 
 
 def test_create_defect_pair():

package/tests/py/unit/test_tools_build_grain_boundary.py

@@ -91,4 +91,4 @@ def test_create_surface_grain_boundary():
     ]
 
     assert len(gb) == 1
-    assertion_utils.assert_deep_almost_equal(expected_cell_vectors, gb[0].basis.cell.vectors_as_array)
+    assertion_utils.assert_deep_almost_equal(expected_cell_vectors, gb[0].basis.cell.vector_arrays)

package/tests/py/unit/test_tools_build_interface.py

@@ -85,6 +85,6 @@ def test_create_commensurate_supercell_twisted_interface():
     assert len(interfaces) == 1
     interface = interfaces[0]
     expected_cell_vectors = [[10.754672133, 0.0, 0.0], [5.377336066500001, 9.313819276550575, 0.0], [0.0, 0.0, 20.0]]
-    assertion_utils.assert_deep_almost_equal(expected_cell_vectors, interface.basis.cell.vectors_as_array)
+    assertion_utils.assert_deep_almost_equal(expected_cell_vectors, interface.basis.cell.vector_arrays)
     expected_angle = 13.174
     assert interface.metadata["build"]["configuration"]["actual_twist_angle"] == expected_angle