materialite 0.1.0__py3-none-any.whl

materialite/__init__.py

@@ -0,0 +1,28 @@
+# Copyright 2025 United States Government as represented by the Administrator of the
+# National Aeronautics and Space Administration.  All Rights Reserved.
+#
+# The Materialite platform is licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+# Skip isort on this file to avoid circular imports
+# isort: skip_file
+
+from .material import Material, Sphere, Superellipsoid, Feature, Box
+from .tensor import (
+    Orientation,
+    Scalar,
+    Vector,
+    Order2Tensor,
+    Order2SymmetricTensor,
+    Order4SymmetricTensor,
+)
+from .slip_system import SlipSystem
+from .json_operations import read_from_json, write_to_json
+from .get_ipf_colors import get_ipf_colors, get_ipf, add_ipf_colors_field
+from .importers import import_dream3d, import_evpfft, import_spparks, import_vgstudio

materialite/basis_operations.py

@@ -0,0 +1,118 @@
+# Copyright 2025 United States Government as represented by the Administrator of the
+# National Aeronautics and Space Administration.  All Rights Reserved.
+#
+# The Materialite platform is licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+import numpy as np
+
+
+# Not particularly liking calling this the natural basis but it is here for now
+def natural_basis():
+    r2 = 1 / np.sqrt(2)
+    r3 = 1 / np.sqrt(3)
+    r6 = 1 / np.sqrt(6)
+    return np.array(
+        [
+            r3 * np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+            r6 * np.array([[-1, 0, 0], [0, -1, 0], [0, 0, 2]]),
+            r2 * np.array([[-1, 0, 0], [0, 1, 0], [0, 0, 0]]),
+            r2 * np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0]]),
+            r2 * np.array([[0, 0, 1], [0, 0, 0], [1, 0, 0]]),
+            r2 * np.array([[0, 1, 0], [1, 0, 0], [0, 0, 0]]),
+        ]
+    )
+
+
+def natural_product_basis():
+    return np.einsum("mij, nkl -> mnijkl", natural_basis(), natural_basis())
+
+
+def mandel_basis():
+    r2 = 1 / np.sqrt(2)
+    return np.array(
+        [
+            [[1.0, 0, 0], [0, 0, 0], [0, 0, 0]],
+            [[0, 0, 0], [0, 1.0, 0], [0, 0, 0]],
+            [[0, 0, 0], [0, 0, 0], [0, 0, 1.0]],
+            [[0, 0, 0], [0, 0, r2], [0, r2, 0]],
+            [[0, 0, r2], [0, 0, 0], [r2, 0, 0]],
+            [[0, r2, 0], [r2, 0, 0], [0, 0, 0]],
+        ]
+    )
+
+
+def mandel_product_basis():
+    return np.einsum("mij, nkl -> mnijkl", mandel_basis(), mandel_basis())
+
+
+def mises_basis():
+    r2 = 1 / np.sqrt(2)
+    r3 = 1 / np.sqrt(3)
+    r6 = 1 / np.sqrt(6)
+    return np.array(
+        [
+            r2 * np.array([[-1, 0, 0], [0, 1, 0], [0, 0, 0]]),
+            r6 * np.array([[-1, 0, 0], [0, -1, 0], [0, 0, 2]]),
+            r2 * np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0]]),
+            r2 * np.array([[0, 0, 1], [0, 0, 0], [1, 0, 0]]),
+            r2 * np.array([[0, 1, 0], [1, 0, 0], [0, 0, 0]]),
+            r3 * np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
+        ]
+    )
+
+
+def mises_product_basis():
+    return np.einsum("mij, nkl -> mnijkl", mises_basis(), mises_basis())
+
+
+def strain_voigt_basis():
+    return np.array(
+        [
+            np.array([[1, 0, 0], [0, 0, 0], [0, 0, 0]]),
+            np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]),
+            np.array([[0, 0, 0], [0, 0, 0], [0, 0, 1]]),
+            0.5 * np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0]]),
+            0.5 * np.array([[0, 0, 1], [0, 0, 0], [1, 0, 0]]),
+            0.5 * np.array([[0, 1, 0], [1, 0, 0], [0, 0, 0]]),
+        ]
+    )
+
+
+def stress_voigt_basis():
+    return np.array(
+        [
+            [[1.0, 0, 0], [0, 0, 0], [0, 0, 0]],
+            [[0, 0, 0], [0, 1.0, 0], [0, 0, 0]],
+            [[0, 0, 0], [0, 0, 0], [0, 0, 1.0]],
+            [[0, 0, 0], [0, 0, 1.0], [0, 1.0, 0]],
+            [[0, 0, 1.0], [0, 0, 0], [1.0, 0, 0]],
+            [[0, 1.0, 0], [1.0, 0, 0], [0, 0, 0]],
+        ]
+    )
+
+
+def strain_voigt_dual_basis():
+    return stress_voigt_basis()
+
+
+def stress_voigt_dual_basis():
+    return strain_voigt_basis()
+
+
+def voigt_product_basis():
+    return np.einsum(
+        "mij, nkl -> mnijkl", stress_voigt_basis(), strain_voigt_dual_basis()
+    )
+
+
+def voigt_dual_product_basis():
+    return np.einsum(
+        "mij, nkl -> mnijkl", stress_voigt_dual_basis(), strain_voigt_basis()
+    )

materialite/get_ipf_colors.py

@@ -0,0 +1,199 @@
+# Copyright 2025 United States Government as represented by the Administrator of the
+# National Aeronautics and Space Administration.  All Rights Reserved.
+#
+# The Materialite platform is licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+import numpy as np
+from materialite.tensor import Vector
+from numpy.linalg import norm
+
+
+def add_ipf_colors_field(
+    material,
+    orientation_label="orientation",
+    specimen_frame_direction=Vector([0, 0, 1]),
+    unit_cell="cubic",
+    ipf_color_label="ipf_color",
+):
+    orientations = material.extract(orientation_label)
+    ipf_colors = get_ipf_colors(specimen_frame_direction, orientations, unit_cell)
+    return material.create_fields({ipf_color_label: ipf_colors.tolist()})
+
+
+def get_ipf_colors(specimen_frame_direction, orientations, unit_cell):
+    specimen_frame_direction = Vector(specimen_frame_direction)
+    direction = specimen_frame_direction / specimen_frame_direction.norm
+    crystal_directions = direction.to_crystal_frame(orientations)
+    ipf_points = _convert_to_fundamental_region(crystal_directions, unit_cell)
+    return _get_ipf_colors_from_fundamental_points(ipf_points, unit_cell)
+
+
+def get_ipf(specimen_frame_direction, orientations, unit_cell):
+    specimen_frame_direction = Vector(specimen_frame_direction)
+    direction = specimen_frame_direction / specimen_frame_direction.norm
+    crystal_directions = direction.to_crystal_frame(orientations)
+    ipf_points_3D = _convert_to_fundamental_region(crystal_directions, unit_cell)
+    ipf_points = _get_stereographic_projection(ipf_points_3D)
+    ipf_boundary = _get_ipf_boundary(unit_cell)
+    return ipf_points, ipf_boundary
+
+
+def _convert_to_fundamental_region(directions, unit_cell):
+    if unit_cell.lower() in ["cubic", "fcc", "bcc"]:
+        p = np.atleast_2d(directions.components)
+        p[p[:, 0] < 0, 0] *= -1
+        p[p[:, 1] < 0, 1] *= -1
+        p[p[:, 2] < 0, 2] *= -1
+
+        cond = p[:, 0] < p[:, 1]
+        p[cond, 0], p[cond, 1] = p[cond, 1], p[cond, 0].copy()
+
+        cond = p[:, 2] < p[:, 0]
+        p[cond, 2], p[cond, 0] = p[cond, 0], p[cond, 2].copy()
+
+        cond = p[:, 0] < p[:, 1]
+        p[cond, 0], p[cond, 1] = p[cond, 1], p[cond, 0].copy()
+    elif unit_cell.lower() in ["hcp", "hexagonal"]:
+        p = np.atleast_2d(directions.components).copy()
+        p[p[:, 0] < 0, 0] *= -1
+        p[p[:, 1] < 0, 1] *= -1
+        p[p[:, 2] < 0, 2] *= -1
+        angles = np.arctan2(p[:, 1], p[:, 0])
+        reduce_cond = angles >= np.pi / 3
+        c60 = 0.5
+        s60 = np.sqrt(3) / 2
+        reduce_R = np.array([[c60, s60], [-s60, c60]])
+        p[reduce_cond, :2] = np.einsum("ij, bj -> bi", reduce_R, p[reduce_cond, :2])
+        angles[reduce_cond] -= np.pi / 3
+
+        reflect_cond = angles >= np.pi / 6
+        reflect_R = np.array([[c60, s60], [s60, -c60]])
+        p[reflect_cond, :2] = np.einsum("ij, bj -> bi", reflect_R, p[reflect_cond, :2])
+        np.arctan2(p[:, 1], p[:, 0]) * 180 / np.pi
+
+    return p
+
+
+def _get_ipf_colors_from_fundamental_points(points, unit_cell):
+    if unit_cell.lower() in ["cubic", "fcc", "bcc"]:
+        u = points[:, 2] - points[:, 0]
+        v = np.sqrt(2) * (points[:, 0] - points[:, 1])
+        w = np.sqrt(3) * points[:, 1]
+        uvw = np.c_[u, v, w]
+    elif unit_cell.lower() in ["hexagonal", "hcp"]:
+        u = points[:, 2]
+        v = points[:, 0] - np.sqrt(3) * points[:, 1]
+        w = 2 * points[:, 1]
+        uvw = np.c_[u, v, w]
+    return _adjust_colors(uvw)
+
+
+def _adjust_colors(uvw):
+    uvw = uvw / np.max(np.abs(uvw), axis=1, keepdims=True)
+    return np.sqrt(uvw)
+
+
+def _get_stereographic_projection(ipf_points):
+    azimuth, elevation = _cartesian_to_spherical(ipf_points)
+    P = 1.0 / np.cos(elevation / 2.0)
+    x_projected = P * np.sin(elevation / 2) * np.cos(azimuth)
+    y_projected = P * np.sin(elevation / 2) * np.sin(azimuth)
+    return np.c_[x_projected, y_projected]
+
+
+def _cartesian_to_spherical(xyz):
+    xy = xyz[:, 0] ** 2 + xyz[:, 1] ** 2
+    elevation = np.arctan2(np.sqrt(xy), xyz[:, 2])
+    azimuth = np.arctan2(xyz[:, 1], xyz[:, 0])
+    return azimuth, elevation
+
+
+def _get_ipf_boundary(unit_cell):
+    num_points = 1001
+    if unit_cell.lower() in ["cubic", "fcc", "bcc"]:
+        great_circle_xz = np.ones(num_points)
+        great_circle_points_3D = np.c_[
+            great_circle_xz, np.linspace(0, 1, num_points), great_circle_xz
+        ]
+        great_circle_points_3D = great_circle_points_3D / norm(
+            great_circle_points_3D, axis=1, keepdims=True
+        )
+        great_circle_points = _get_stereographic_projection(great_circle_points_3D)
+        ipf_boundary = np.concatenate([[[0, 0]], great_circle_points, [[0, 0]]], axis=0)
+    elif unit_cell.lower() in ["hexagonal", "hcp"]:
+        pole_1 = np.array([1, 0, 0])
+        pole_2 = np.array([np.sqrt(3) / 2, 0.5, 0])
+        great_circle_direction = pole_2 - pole_1
+        increments = np.linspace(0, 1, num_points)
+        great_circle_points_3D = (
+            increments[:, np.newaxis] * great_circle_direction + pole_1
+        )
+        great_circle_points_3D = great_circle_points_3D / norm(
+            great_circle_points_3D, axis=1, keepdims=True
+        )
+        great_circle_points = _get_stereographic_projection(great_circle_points_3D)
+        ipf_boundary = np.concatenate([[[0, 0]], great_circle_points, [[0, 0]]], axis=0)
+    return ipf_boundary
+
+
+def get_symmetry_operators(unit_cell):
+    # source: Rollett lecture notes on symmetry; corrected from Kocks, Tome,
+    #    and Wenk, Texture and Anisotropy
+    i = np.array([1, 0, 0])
+    j = np.array([0, 1, 0])
+    k = np.array([0, 0, 1])
+    if unit_cell.lower() in ["hexagonal", "hcp"]:
+        a = np.sqrt(3) / 2
+        p5 = 0.5
+        m5 = -0.5
+        symmetry_matrices = [0] * 12
+        symmetry_matrices[0] = np.eye(3)
+        symmetry_matrices[1] = np.array([[m5, a, 0], [-a, m5, 0], k])
+        symmetry_matrices[2] = np.array([[m5, -a, 0], [a, m5, 0], k])
+        symmetry_matrices[3] = np.array([[p5, a, 0], [-a, p5, 0], k])
+        symmetry_matrices[4] = np.array([-i, -j, k])
+        symmetry_matrices[5] = np.array([[p5, -a, 0], [a, p5, 0], k])
+        symmetry_matrices[6] = np.array([[m5, -a, 0], [-a, p5, 0], -k])
+        symmetry_matrices[7] = np.array([i, -j, -k])
+        symmetry_matrices[8] = np.array([[m5, a, 0], [a, p5, 0], -k])
+        symmetry_matrices[9] = np.array([[p5, a, 0], [a, m5, 0], -k])
+        symmetry_matrices[10] = np.array([-i, j, -k])
+        symmetry_matrices[11] = np.array([[p5, -a, 0], [-a, m5, 0], -k])
+
+    elif unit_cell.lower() in ["cubic", "fcc", "bcc"]:
+        symmetry_matrices = [0] * 24
+        symmetry_matrices[0] = np.eye(3)
+        symmetry_matrices[1] = np.array([k, i, j])
+        symmetry_matrices[2] = np.array([j, k, i])
+        symmetry_matrices[3] = np.array([-j, k, -i])
+        symmetry_matrices[4] = np.array([-j, -k, i])
+        symmetry_matrices[5] = np.array([j, -k, -i])
+        symmetry_matrices[6] = np.array([-k, i, -j])
+        symmetry_matrices[7] = np.array([-k, -i, j])
+        symmetry_matrices[8] = np.array([k, -i, -j])
+        symmetry_matrices[9] = np.array([-i, j, -k])
+        symmetry_matrices[10] = np.array([-i, -j, k])
+        symmetry_matrices[11] = np.array([i, -j, -k])
+        symmetry_matrices[12] = np.array([-k, -j, -i])
+        symmetry_matrices[13] = np.array([k, -j, i])
+        symmetry_matrices[14] = np.array([k, j, -i])
+        symmetry_matrices[15] = np.array([-k, j, i])
+        symmetry_matrices[16] = np.array([-i, -k, -j])
+        symmetry_matrices[17] = np.array([i, -k, j])
+        symmetry_matrices[18] = np.array([i, k, -j])
+        symmetry_matrices[19] = np.array([-i, k, j])
+        symmetry_matrices[20] = np.array([-j, -i, -k])
+        symmetry_matrices[21] = np.array([j, -i, k])
+        symmetry_matrices[22] = np.array([j, i, -k])
+        symmetry_matrices[23] = np.array([-j, i, k])
+
+    else:
+        raise ValueError(f"{unit_cell} is not a valid unit cell")
+    return np.array(symmetry_matrices)

materialite/importers.py

@@ -0,0 +1,182 @@
+# Copyright 2025 United States Government as represented by the Administrator of the
+# National Aeronautics and Space Administration.  All Rights Reserved.
+#
+# The Materialite platform is licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+import h5py
+import numpy as np
+import pandas as pd
+from materialite import Material
+from materialite.util import camel_to_snake
+
+
+def import_dream3d(
+    file,
+    simpl_geometry_path,
+    field_paths=None,
+    region_id_path=None,
+    region_field_paths=None,
+):
+    if region_id_path is None and region_field_paths is not None:
+        raise ValueError(
+            "region_id_path must be specified if region_field_paths are provided"
+        )
+    d3d = h5py.File(file, mode="r")
+
+    simpl_geometry_data = d3d.get(simpl_geometry_path)
+
+    dimensions = list(simpl_geometry_data.get("DIMENSIONS"))
+    num_points = np.prod(dimensions)
+    origin = list(simpl_geometry_data.get("ORIGIN"))
+    spacing = list(simpl_geometry_data.get("SPACING"))
+
+    fields = _initialize_fields(dimensions, origin, spacing)
+
+    field_paths = [] if field_paths is None else field_paths
+    for field_path in field_paths:
+        label = camel_to_snake(field_path.split("/")[-1])
+        field = d3d.get(field_path)[:]
+        field = field.reshape((num_points, field.shape[-1]))
+        num_components = field.shape[1]
+        for ii in range(num_components):
+            suffix = "" if num_components == 1 else "_" + str(ii + 1)
+            fields[label + suffix] = field[:, ii]
+
+    regional_fields = {}
+    if region_id_path is not None:
+        region_id_label = camel_to_snake(region_id_path.split("/")[-1])
+        region_id_field = d3d.get(region_id_path)[:].reshape(-1)
+        fields[region_id_label] = region_id_field
+        if region_field_paths is not None:
+            regional_fields[region_id_label] = np.unique(region_id_field)
+
+    region_field_paths = [] if region_field_paths is None else region_field_paths
+    for region_field_path in region_field_paths:
+        region_label = camel_to_snake(region_field_path.split("/")[-1])
+        region_field = d3d.get(region_field_path)[:]
+        num_components = region_field.shape[1]
+        for ii in range(num_components):
+            suffix = "" if num_components == 1 else "_" + str(ii + 1)
+            regional_fields[region_label + suffix] = region_field[1:, ii]
+
+    material = Material(
+        dimensions=dimensions, origin=origin, spacing=spacing, fields=fields
+    )
+    if regional_fields:
+        material = material.create_regional_fields(
+            region_label=region_id_label, regional_fields=regional_fields
+        )
+    return material
+
+
+def _initialize_fields(dimensions, origin, spacing):
+    grid = np.indices(dimensions).T.reshape(-1, 3)
+    return pd.DataFrame(
+        {
+            "x": grid[:, 0] * spacing[0] + origin[0],
+            "y": grid[:, 1] * spacing[1] + origin[1],
+            "z": grid[:, 2] * spacing[2] + origin[2],
+        }
+    )
+
+
+def import_spparks(
+    file,
+    usecols=[1, 2, 3, 4],
+    names=["feature", "x", "y", "z"],
+    skiprows=9,
+    voxel_size=1,
+):
+    fields = pd.read_csv(
+        file,
+        sep=" ",
+        header=None,
+        skiprows=skiprows,
+        usecols=[1, 2, 3, 4],
+        names=["feature", "x", "y", "z"],
+    )
+    fields.sort_values(by=["z", "y", "x"], inplace=True)
+
+    dimensions = [fields[dim].max() - fields[dim].min() + 1 for dim in ["x", "y", "z"]]
+
+    origin = [0, 0, 0]
+    fields[["x", "y", "z"]] = voxel_size * fields[["x", "y", "z"]]
+    spacing = [voxel_size, voxel_size, voxel_size]
+
+    return Material(
+        dimensions=dimensions, origin=origin, spacing=spacing, fields=fields
+    )
+
+
+def import_vgstudio(
+    file,
+    dimensions,
+    label="xct",
+    spacing=[1, 1, 1],
+    origin=[0, 0, 0],
+    dtype=np.float32,
+    x_range=None,
+    y_range=None,
+    z_range=None,
+):
+    if x_range is None:
+        x_range = [0, dimensions[0]]
+    if y_range is None:
+        y_range = [0, dimensions[1]]
+    if z_range is None:
+        z_range = [0, dimensions[2]]
+
+    field = np.fromfile(file, dtype)
+    field = field.reshape(np.array(dimensions)[::-1])
+    field = field[
+        z_range[0] : z_range[1], y_range[0] : y_range[1], x_range[0] : x_range[1]
+    ]
+    dimensions = field.shape[::-1]
+
+    return Material(
+        dimensions=dimensions,
+        spacing=spacing,
+        origin=origin,
+        fields={label: field.ravel()},
+    )
+
+
+def import_evpfft(
+    file,
+    spacing=[1, 1, 1],
+    origin=[0, 0, 0],
+):
+
+    fields = pd.read_csv(
+        file,
+        header=None,
+        delimiter=" ",
+        names=[
+            "euler_angle_1",
+            "euler_angle_2",
+            "euler_angle_3",
+            "x_id",
+            "y_id",
+            "z_id",
+            "feature",
+            "phase",
+        ],
+    ).sort_values(by=["x_id", "y_id", "z_id"])
+
+    fields[["euler_angle_1", "euler_angle_2", "euler_angle_3"]] *= np.pi / 180
+
+    dimensions = fields[["x_id", "y_id", "z_id"]].max().to_numpy()
+
+    return Material(
+        dimensions=dimensions,
+        spacing=spacing,
+        origin=origin,
+        fields=fields,
+    )

materialite/json_operations.py

@@ -0,0 +1,122 @@
+# Copyright 2025 United States Government as represented by the Administrator of the
+# National Aeronautics and Space Administration.  All Rights Reserved.
+#
+# The Materialite platform is licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+import gzip
+import json
+
+import materialite.tensor
+import numpy as np
+import pandas as pd
+from materialite import Material
+from materialite.tensor import Orientation, Tensor
+
+
+class MaterialEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, Tensor):
+            return {
+                "data": obj.components.tolist(),
+                "type": type(obj).__name__,
+                "dims": obj.dims_str,
+            }
+        elif isinstance(obj, Orientation):
+            return {"data": obj.rotation_matrix.tolist(), "type": type(obj).__name__}
+        elif isinstance(obj, (np.number, np.ndarray)):
+            return {"data": obj.tolist()}
+        return super().default(obj)
+
+
+def decoder_object_hook(dct):
+    data = dct.get("data", None)
+    if data is None:
+        return dct
+    data_type = dct.get("type", None)
+    dims = dct.get("dims", None)
+    if data_type is None:
+        return data
+    elif dims is None:
+        tensor_type = getattr(materialite.tensor, data_type)
+        return tensor_type(data)
+    else:
+        tensor_type = getattr(materialite.tensor, data_type)
+        return tensor_type(data, dims)
+
+
+def read_from_json(filename, decompress=False):
+    if decompress:
+        r_string = "rb"
+    else:
+        r_string = "r"
+    with open(filename, r_string) as f:
+        loaded_data = f.read()
+    if decompress:
+        loaded_data = gzip.decompress(loaded_data).decode("utf-8")
+    loaded_data = json.loads(loaded_data, object_hook=decoder_object_hook)
+    state = dict()
+    fields = dict()
+    regional_fields = dict()
+    for k, v in loaded_data.items():
+        if k == "metadata":
+            origin = v["origin"]
+            dimensions = v["dimensions"]
+            spacing = v["spacing"]
+            continue
+        elif k == "state":
+            state = v
+        elif k == "regional_fields":
+            regional_fields = v
+        else:
+            fields[k] = v
+    if not fields:
+        material = Material(dimensions=dimensions, origin=origin, spacing=spacing)
+    else:
+        fields = pd.DataFrame(fields)
+        material = Material(
+            dimensions=dimensions, origin=origin, spacing=spacing, fields=fields
+        )
+    material.state = state
+    for k, v in regional_fields.items():
+        material = material.create_regional_fields(k, pd.DataFrame(v))
+    return material
+
+
+def write_to_json(material, filename, compress=False):
+    coord_labels = ["x", "y", "z", "x_id", "y_id", "z_id"]
+    labels = list(material.fields.drop(coord_labels, axis=1))
+    material_dict = {
+        "metadata": {
+            "origin": material.origin.tolist(),
+            "dimensions": material.dimensions.tolist(),
+            "spacing": material.spacing.tolist(),
+        }
+    }
+    if material.state:
+        material_dict["state"] = material.state
+    if material._regional_fields:
+        material_dict["regional_fields"] = dict()
+        for k in material._regional_fields.keys():
+            regional_labels = list(material.extract_regional_field(k))
+            material_dict["regional_fields"][k] = dict()
+            for l in regional_labels:
+                material_dict["regional_fields"][k][l] = (
+                    material.extract_regional_field(k, l)
+                )
+    for l in labels:
+        material_dict[l] = material.extract(l)
+    json_material = json.dumps(material_dict, cls=MaterialEncoder)
+    if compress:
+        json_material = gzip.compress(json_material.encode("utf-8"))
+        w_string = "wb"
+    else:
+        w_string = "w"
+    with open(filename, w_string) as f:
+        f.write(json_material)