@mat3ra/made 2026.6.29-0 → 2026.7.8-0

package/src/js/lattice/lattice.ts

@@ -1,6 +1,4 @@
-import { HASH_TOLERANCE } from "@mat3ra/code/dist/js/constants";
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     Coordinate3DSchema,
     LatticeSchema,
@@ -9,6 +7,7 @@ import {
     LatticeVectorsSchema,
     Matrix3X3Schema,
 } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import * as lodash from "lodash";
 
 import { Cell } from "../cell/cell";
@@ -16,6 +15,7 @@ import { getPrimitiveLatticeVectorsFromConfig } from "../cell/primitive_cell";
 import { LATTICE_TYPE_CONFIGS } from "./lattice_types";
 import { UnitCell, UnitCellProps } from "./unit_cell";
 
+const { HASH_TOLERANCE } = Utils.constants;
 /**
  * Scaling factor used to calculate the new lattice size for non-periodic systems.
  * The scaling factor ensures that a non-periodic structure will have have a lattice greater than the structures size.
@@ -86,19 +86,21 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
         const { b } = this;
         const { c } = this;
 
-        const alphaRad = math.unit(this.alpha, "deg").toNumber("rad");
-        const betaRad = math.unit(this.beta, "deg").toNumber("rad");
-        const gammaRad = math.unit(this.gamma, "deg").toNumber("rad");
+        const alphaRad = Utils.math.unit(this.alpha, "deg").toNumber("rad");
+        const betaRad = Utils.math.unit(this.beta, "deg").toNumber("rad");
+        const gammaRad = Utils.math.unit(this.gamma, "deg").toNumber("rad");
 
-        const cosAlpha = math.cos(alphaRad);
-        const cosBeta = math.cos(betaRad);
-        const cosGamma = math.cos(gammaRad);
-        const sinAlpha = math.sin(alphaRad);
-        const sinBeta = math.sin(betaRad);
+        const cosAlpha = Utils.math.cos(alphaRad);
+        const cosBeta = Utils.math.cos(betaRad);
+        const cosGamma = Utils.math.cos(gammaRad);
+        const sinAlpha = Utils.math.sin(alphaRad);
+        const sinBeta = Utils.math.sin(betaRad);
 
-        const gammaStar = math.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
-        const cosGammaStar = math.cos(gammaStar);
-        const sinGammaStar = math.sin(gammaStar);
+        const gammaStar = Utils.math.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
+        // @ts-ignore - mathjs v12 acos return type includes Complex, but inputs are always real
+        const cosGammaStar = Utils.math.cos(gammaStar);
+        // @ts-ignore
+        const sinGammaStar = Utils.math.sin(gammaStar);
 
         const vectorA: Coordinate3DSchema = [a * sinBeta, 0.0, a * cosBeta];
         const vectorB: Coordinate3DSchema = [
@@ -121,12 +123,12 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
         type: LatticeTypeEnum = "TRI",
     ): Lattice {
         const [aVec, bVec, cVec] = vectors;
-        const a = math.vlen(aVec);
-        const b = math.vlen(bVec);
-        const c = math.vlen(cVec);
-        const alpha = math.angle(bVec, cVec, "deg");
-        const beta = math.angle(aVec, cVec, "deg");
-        const gamma = math.angle(aVec, bVec, "deg");
+        const a = Utils.math.vlen(aVec);
+        const b = Utils.math.vlen(bVec);
+        const c = Utils.math.vlen(cVec);
+        const alpha = Utils.math.angle(bVec, cVec, "deg");
+        const beta = Utils.math.angle(aVec, cVec, "deg");
+        const gamma = Utils.math.angle(aVec, bVec, "deg");
 
         return new Lattice({
             a,
@@ -183,7 +185,7 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
      */
     get typeExtended(): LatticeTypeExtendedEnum {
         const { a, b, c, alpha, beta, gamma, type } = this;
-        const cosAlpha = math.cos((alpha / 180) * math.PI);
+        const cosAlpha = Utils.math.cos((alpha / 180) * Utils.math.PI);
 
         switch (type) {
             case "BCT":
@@ -220,7 +222,7 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
      * Calculate the volume of the lattice cell.
      */
     get volume(): number {
-        return math.abs(math.det(this.vectorArrays));
+        return Utils.math.abs(Utils.math.det(this.vectorArrays));
     }
 
     /*
@@ -228,7 +230,7 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
      * @param latticeConfig {Object} LatticeBravais config (see constructor)
      */
     static getDefaultPrimitiveLatticeConfigByType(latticeConfig: LatticeSchema) {
-        const f_ = math.roundArrayOrNumber;
+        const f_ = Utils.math.roundArrayOrNumber;
         // construct new primitive cell using lattice parameters and skip rounding the vectors
         const vectors = getPrimitiveLatticeVectorsFromConfig(latticeConfig);
         // create new lattice from primitive cell
@@ -268,7 +270,7 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
             scaledLattice.beta,
             scaledLattice.gamma,
         ]
-            .map((x) => math.round(x, HASH_TOLERANCE))
+            .map((x) => Utils.math.roundCustom(x, HASH_TOLERANCE))
             .join(";")};`;
     }
 

package/src/js/lattice/reciprocal/lattice_reciprocal.ts

@@ -1,12 +1,13 @@
 import { ATOMIC_COORD_UNITS, units as UNITS } from "@mat3ra/code/dist/js/constants";
-import { math } from "@mat3ra/code/dist/js/math";
 import { Vector3DSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import lodash from "lodash";
 
 import { Lattice } from "../lattice";
 import { paths } from "./paths";
 import { symmetryPoints } from "./symmetry_points";
 
+
 export type KPointCoordinates = number[];
 export type KPointPath = Array<{
     point: string;
@@ -39,16 +40,16 @@ export class ReciprocalLattice extends Lattice {
      */
     get reciprocalVectors(): Vector3DSchema[] {
         const vectors_: Vector3DSchema[] = this.vectors.vectorArrays as Vector3DSchema[];
-        const a: number = math.vlen(vectors_[0]);
+        const a: number = Utils.math.vlen(vectors_[0]);
         const divider: number =
-            (math.multiply(
+            (Utils.math.multiply(
                 vectors_[0],
-                math.cross(vectors_[1], vectors_[2]),
+                Utils.math.cross(vectors_[1], vectors_[2]),
             ) as unknown as number) / a;
         return [
-            math.multiply(math.cross(vectors_[1], vectors_[2]), 1 / divider) as Vector3DSchema,
-            math.multiply(math.cross(vectors_[2], vectors_[0]), 1 / divider) as Vector3DSchema,
-            math.multiply(math.cross(vectors_[0], vectors_[1]), 1 / divider) as Vector3DSchema,
+            Utils.math.multiply(Utils.math.cross(vectors_[1], vectors_[2]), 1 / divider) as Vector3DSchema,
+            Utils.math.multiply(Utils.math.cross(vectors_[2], vectors_[0]), 1 / divider) as Vector3DSchema,
+            Utils.math.multiply(Utils.math.cross(vectors_[0], vectors_[1]), 1 / divider) as Vector3DSchema,
         ];
     }
 
@@ -56,7 +57,7 @@ export class ReciprocalLattice extends Lattice {
      * Norms of reciprocal vectors.
      */
     get reciprocalVectorNorms(): Vector3DSchema {
-        return this.reciprocalVectors.map((vec) => math.norm(vec) as number) as Vector3DSchema;
+        return this.reciprocalVectors.map((vec) => Utils.math.norm(vec) as number) as Vector3DSchema;
     }
 
     /**
@@ -64,7 +65,7 @@ export class ReciprocalLattice extends Lattice {
      */
     get reciprocalVectorRatios(): Vector3DSchema {
         const norms: number[] = this.reciprocalVectorNorms;
-        const maxNorm: number = math.max(...norms) as number;
+        const maxNorm: number = Utils.math.max(...norms) as number;
         return norms.map((n: number) => n / maxNorm) as Vector3DSchema;
     }
 
@@ -74,7 +75,7 @@ export class ReciprocalLattice extends Lattice {
      * @return {KPointCoordinates}
      */
     getCartesianCoordinates(point: KPointCoordinates): KPointCoordinates {
-        return math.multiply(point, this.reciprocalVectors) as KPointCoordinates;
+        return Utils.math.multiply(point, this.reciprocalVectors) as KPointCoordinates;
     }
 
     /**
@@ -105,7 +106,7 @@ export class ReciprocalLattice extends Lattice {
 
         dataPoints.forEach((point: KPointCoordinates, index: number) => {
             const symmPoint: SymmetryPoint | undefined = symmPoints.find((x) => {
-                return math.vEqualWithTolerance(x.coordinates, point, 1e-4);
+                return Utils.math.vEqualWithTolerance(x.coordinates, point, 1e-4);
             });
             if (symmPoint) {
                 kpointPath.push({
@@ -128,10 +129,10 @@ export class ReciprocalLattice extends Lattice {
     calculateDimension(nPoints: number, index: number): number {
         const norms: number[] = this.reciprocalVectorNorms;
         const [j, k] = [0, 1, 2].filter((i) => i !== index); // get indices of other two dimensions
-        const N: number = math.cbrt(
+        const N: number = Utils.math.cbrt(
             (nPoints * norms[index] ** 2) / (norms[j] * norms[k]),
         ) as number;
-        return math.max(1, math.ceil(N)) as number;
+        return Utils.math.max(1, Utils.math.ceil(N)) as number;
     }
 
     /**
@@ -148,10 +149,10 @@ export class ReciprocalLattice extends Lattice {
         const { a } = this;
         return {
             [ATOMIC_COORD_UNITS.cartesian]: {
-                [UNITS.angstrom]: (2 * math.PI) / a,
+                [UNITS.angstrom]: (2 * Utils.math.PI) / a,
             },
             [UNITS.angstrom]: {
-                [ATOMIC_COORD_UNITS.cartesian]: a / (2 * math.PI),
+                [ATOMIC_COORD_UNITS.cartesian]: a / (2 * Utils.math.PI),
             },
         };
     }
@@ -166,7 +167,7 @@ export class ReciprocalLattice extends Lattice {
     getDimensionsFromSpacing(spacing: number, units: string = ATOMIC_COORD_UNITS.cartesian) {
         const factor: number = this.conversionTable[units][ATOMIC_COORD_UNITS.cartesian] || 1;
         return this.reciprocalVectorNorms.map((norm: number) => {
-            return math.max(1, math.ceil(lodash.round(norm / (spacing * factor), 4))) as number;
+            return Utils.math.max(1, Utils.math.ceil(lodash.round(norm / (spacing * factor), 4))) as number;
         }) as Vector3DSchema;
     }
 
@@ -184,8 +185,8 @@ export class ReciprocalLattice extends Lattice {
         const norms: number[] = this.reciprocalVectorNorms;
         return (
             factor *
-            (math.mean(
-                dimensions.map((dim: number, i: number) => norms[i] / math.max(1, dim)),
+            (Utils.math.mean(
+                dimensions.map((dim: number, i: number) => norms[i] / Utils.math.max(1, dim)),
             ) as number)
         );
     }

package/src/js/parsers/poscar.ts

@@ -1,4 +1,3 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     BasisSchema,
     Coordinate3DSchema,
@@ -16,7 +15,8 @@ import { ATOMIC_COORD_UNITS } from "../constants";
 import { AtomicConstraintValue } from "../constraints/constraints";
 import { Lattice } from "../lattice/lattice";
 
-const _print = (x: number, printFormat = "%14.9f") => s.sprintf(printFormat, math.precise(x));
+
+const _print = (x: number, printFormat = "%14.9f") => s.sprintf(printFormat, Utils.math.precise(x));
 const _latticeVectorsToString = (vectors: Vector3DSchema[]) =>
     vectors.map((v) => v.map((c) => _print(c)).join("\t")).join("\n");
 const atomicConstraintsCharFromBool = (bool: boolean): string => (bool ? "T" : "F");

package/src/js/parsers/xyz_combinatorial_basis.ts

@@ -1,5 +1,5 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { BasisSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import { chain, last, map } from "lodash";
 import * as s from "underscore.string";
 
@@ -8,6 +8,7 @@ import { AtomicCoordinateValue } from "../basis/coordinates";
 import { AtomicElementValue } from "../basis/elements";
 import { Cell } from "../cell/cell";
 
+
 /**
  * @summary Combinatorial XYZ basis class and related. Create and get all information about basis and elements in it.
  * Constructor accepts string in extended XYZ format. Extended XYZ format is as follows:
@@ -224,7 +225,7 @@ export class CombinatorialBasis {
             dimensions.push(itemsSet);
         });
         // @ts-ignore // We're multiplying objects with math, not numbers. No type casting will help.
-        const basisSet = math.cartesianProduct.apply(null, dimensions) as ElementWithCoordinate[][];
+        const basisSet = Utils.math.cartesianProduct.apply(null, dimensions) as ElementWithCoordinate[][];
         return basisSet.map((basis: ElementWithCoordinate[]) =>
             basis.filter((entry) => entry.element !== VACANCY_CHARACTER),
         );

package/src/js/tools/basis.ts

@@ -1,12 +1,13 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { Coordinate3DSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import { chunk, flatten } from "lodash";
 
 import { Basis } from "../basis/basis";
 import { AtomicCoordinateValue, Coordinate } from "../basis/coordinates";
 
-const ADD = math.add;
-const MULT = math.multiply;
+
+const ADD = Utils.math.add;
+const MULT = Utils.math.multiply;
 
 /**
  * Returns a repeated basis of a crystal.

package/src/js/tools/cell.ts

@@ -1,8 +1,9 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { Coordinate3DSchema, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import { Cell } from "../cell/cell";
 
+
 /**
  * Returns the list of points on the original lattice contained in the supercell in fractional coordinates.
  * Source: https://pymatgen.org/_modules/pymatgen/util/coord.html
@@ -22,8 +23,8 @@ function latticePointsInSupercell(supercellMatrix: Matrix3X3Schema) {
     const d_points = diagonals.map((point) =>
         supercell.convertPointToCartesian(point as Coordinate3DSchema),
     );
-    const mins = [0, 1, 2].map((i) => math.min(...d_points.map((p) => p[i])));
-    const maxes = [0, 1, 2].map((i) => math.max(...d_points.map((p) => p[i])) + 1);
+    const mins = [0, 1, 2].map((i) => Utils.math.min(...d_points.map((p) => p[i])));
+    const maxes = [0, 1, 2].map((i) => Utils.math.max(...d_points.map((p) => p[i])) + 1);
     const points = [];
     for (let i = mins[0]; i <= maxes[0]; i++) {
         for (let j = mins[1]; j <= maxes[1]; j++) {

package/src/js/tools/material.ts

@@ -1,10 +1,11 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { LatticeSchema, Vector3DSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import { ATOMIC_COORD_UNITS } from "../constants";
 import { Lattice } from "../lattice/lattice";
 import { Material } from "../material";
 
+
 /**
  * Scales one lattice vector for the given material
  * @param material {Material} The material acted upon.
@@ -44,11 +45,11 @@ function translateAtomsToCenter(material: Material) {
     material.toCartesian();
     const updatedBasis = material.Basis;
     const centerOfCoordinates = updatedBasis.centerOfCoordinatesPoint;
-    const centerOfLattice = math.multiply(
+    const centerOfLattice = Utils.math.multiply(
         0.5,
-        material.Lattice.vectorArrays.reduce((a, b) => math.add(a, b) as Vector3DSchema),
+        material.Lattice.vectorArrays.reduce((a, b) => Utils.math.add(a, b) as Vector3DSchema),
     );
-    const translationVector = math.subtract(centerOfLattice, centerOfCoordinates);
+    const translationVector = Utils.math.subtract(centerOfLattice, centerOfCoordinates);
     updatedBasis.translateByVector(translationVector as Vector3DSchema);
     material.setBasis(updatedBasis.toJSON());
     if (originalUnits !== ATOMIC_COORD_UNITS.cartesian) material.toCrystal();

package/src/js/tools/supercell.ts

@@ -1,5 +1,5 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { Coordinate3DSchema, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import { Basis } from "../basis/basis";
 import { ConstrainedBasis } from "../basis/constrained_basis";
@@ -8,7 +8,8 @@ import { Lattice } from "../lattice/lattice";
 import type { Material } from "../material";
 import cellTools from "./cell";
 
-const ADD = math.add;
+
+const ADD = Utils.math.add;
 
 /**
  * @summary Generates new basis for a supercell. For each site from basis generates shifts that are within supercell.
@@ -56,7 +57,7 @@ function generateNewBasisWithinSupercell(
  * @param supercellMatrix {Number[][]}
  */
 function generateConfig(material: Material, supercellMatrix: Matrix3X3Schema) {
-    const det = math.det(supercellMatrix);
+    const det = Utils.math.det(supercellMatrix);
     if (det === 0) {
         throw new Error("Scaling matrix is degenerate.");
     }

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/cell/primitive_cell.py

@@ -0,0 +1,156 @@
+"""
+Routines for calculating primitive cell vectors from conventional cell Bravais parameters.
+Python equivalent of src/js/cell/primitive_cell.ts.
+
+Following Setyawan, W., & Curtarolo, S. (2010). doi:10.1016/j.commatsci.2010.05.010
+"""
+
+import math
+from typing import List
+
+from mat3ra.esse.models.properties_directory.structural.lattice import LatticeSchema
+from mat3ra.made.cell import Cell
+
+Matrix3x3 = List[List[float]]
+
+
+def _rhl(p: LatticeSchema) -> Matrix3x3:
+    a = p.a
+    alpha_rad = math.radians(p.alpha)
+
+    cos_alpha = math.cos(alpha_rad)
+    cos_half_alpha = math.cos(alpha_rad / 2.0)
+    sin_half_alpha = math.sin(alpha_rad / 2.0)
+
+    z_comp = a * math.sqrt(1.0 - (cos_alpha / cos_half_alpha) ** 2)
+
+    return [
+        [a * cos_half_alpha, -a * sin_half_alpha, 0.0],
+        [a * cos_half_alpha, a * sin_half_alpha, 0.0],
+        [(a * cos_alpha) / cos_half_alpha, 0.0, z_comp],
+    ]
+
+
+def _tri(p: LatticeSchema) -> Matrix3x3:
+    """
+    Algorithm from pymatgen (from_params).
+    Mirrors the TRI case in primitive_cell.ts exactly.
+    """
+    alpha = math.radians(p.alpha)
+    beta = math.radians(p.beta)
+    gamma = math.radians(p.gamma)
+
+    cos_alpha = math.cos(alpha)
+    cos_beta = math.cos(beta)
+    cos_gamma = math.cos(gamma)
+    sin_alpha = math.sin(alpha)
+    sin_beta = math.sin(beta)
+
+    acos_arg = (cos_alpha * cos_beta - cos_gamma) / (sin_alpha * sin_beta)
+    # Clamp to [-1, 1] to guard against floating-point drift
+    acos_arg = max(-1.0, min(1.0, acos_arg))
+
+    gamma_star = math.acos(acos_arg)
+    cos_gamma_star = math.cos(gamma_star)
+    sin_gamma_star = math.sin(gamma_star)
+
+    a, b, c = p.a, p.b, p.c
+    return [
+        [a * sin_beta, 0.0, a * cos_beta],
+        [-b * sin_alpha * cos_gamma_star, b * sin_alpha * sin_gamma_star, b * cos_alpha],
+        [0.0, 0.0, c],
+    ]
+
+
+PRIMITIVE_CELLS = {
+    "CUB": lambda p: [
+        [p.a, 0, 0],
+        [0, p.a, 0],
+        [0, 0, p.a],
+    ],
+    "FCC": lambda p: [
+        [0.0, p.a / 2, p.a / 2],
+        [p.a / 2, 0.0, p.a / 2],
+        [p.a / 2, p.a / 2, 0.0],
+    ],
+    "BCC": lambda p: [
+        [-p.a / 2, p.a / 2, p.a / 2],
+        [p.a / 2, -p.a / 2, p.a / 2],
+        [p.a / 2, p.a / 2, -p.a / 2],
+    ],
+    "TET": lambda p: [
+        [p.a, 0, 0],
+        [0, p.a, 0],
+        [0, 0, p.c],
+    ],
+    "BCT": lambda p: [
+        [-p.a / 2, p.a / 2, p.c / 2],
+        [p.a / 2, -p.a / 2, p.c / 2],
+        [p.a / 2, p.a / 2, -p.c / 2],
+    ],
+    "ORC": lambda p: [
+        [p.a, 0, 0],
+        [0, p.b, 0],
+        [0, 0, p.c],
+    ],
+    "ORCF": lambda p: [
+        [0, p.b / 2, p.c / 2],
+        [p.a / 2, 0, p.c / 2],
+        [p.a / 2, p.b / 2, 0],
+    ],
+    "ORCI": lambda p: [
+        [-p.a / 2, p.b / 2, p.c / 2],
+        [p.a / 2, -p.b / 2, p.c / 2],
+        [p.a / 2, p.b / 2, -p.c / 2],
+    ],
+    "ORCC": lambda p: [
+        [p.a / 2, p.b / 2, 0],
+        [-p.a / 2, p.b / 2, 0],
+        [0, 0, p.c],
+    ],
+    "HEX": lambda p: [
+        [p.a / 2, -(p.a * math.sqrt(3)) / 2, 0],
+        [p.a / 2, (p.a * math.sqrt(3)) / 2, 0],
+        [0, 0, p.c],
+    ],
+    "RHL": _rhl,
+    "MCL": lambda p: [
+        [p.a, 0, 0],
+        [0, p.b, 0],
+        [0, p.c * math.cos(math.radians(p.alpha)), p.c * math.sin(math.radians(p.alpha))],
+    ],
+    "MCLC": lambda p: [
+        [p.a / 2, p.b / 2, 0],
+        [-p.a / 2, p.b / 2, 0],
+        [0, p.c * math.cos(math.radians(p.alpha)), p.c * math.sin(math.radians(p.alpha))],
+    ],
+    "TRI": _tri,
+}
+
+
+def get_primitive_lattice_vectors_from_config(lattice_config: LatticeSchema) -> Matrix3x3:
+    """
+    Returns lattice vectors for a primitive cell for a given lattice config.
+    Python equivalent of getPrimitiveLatticeVectorsFromConfig() in primitive_cell.ts.
+
+    Args:
+        lattice_config: LatticeSchema instance with fields:
+            type, a, b, c, alpha, beta, gamma.
+
+    Returns:
+        3x3 list of lists (rows = vectors a, b, c) in the same units as the
+        input lattice parameters (typically Angstroms).
+    """
+    lattice_type = lattice_config.type.value if lattice_config.type else "TRI"
+    generator = PRIMITIVE_CELLS.get(lattice_type)
+    if generator is None:
+        raise ValueError(
+            f"Unsupported lattice type '{lattice_type}'. " f"Must be one of: {list(PRIMITIVE_CELLS.keys())}"
+        )
+    return generator(lattice_config)
+
+
+def get_primitive_cell_from_config(lattice_config: LatticeSchema) -> Cell:
+    """Returns a full Cell object instantiated with the primitive lattice vectors."""
+    vectors = get_primitive_lattice_vectors_from_config(lattice_config)
+    return Cell.from_vectors_array(vectors)

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,