initializing spectroscopy

src/quantem/__init__.py

@@ -9,6 +9,7 @@
 from quantem.core import visualization as visualization
 
 from quantem import imaging as imaging
+from quantem import spectroscopy as spectroscopy
 from quantem import diffractive_imaging as diffractive_imaging
 
 __version__ = version("quantem")

src/quantem/core/datastructures/__init__.py

@@ -5,3 +5,4 @@
 from quantem.core.datastructures.dataset4d import Dataset4d as Dataset4d
 from quantem.core.datastructures.dataset3d import Dataset3d as Dataset3d
 from quantem.core.datastructures.dataset2d import Dataset2d as Dataset2d
+from quantem.core.datastructures.dataset1d import Dataset1d as Dataset1d

src/quantem/core/datastructures/dataset1d.py

@@ -0,0 +1,213 @@
+from typing import Self
+
+import matplotlib.pyplot as plt
+import numpy as np
+from numpy.typing import NDArray
+
+from quantem.core.datastructures.dataset import Dataset
+from quantem.core.utils.validators import ensure_valid_array
+
+
+@Dataset.register_dimension(1)
+class Dataset1d(Dataset):
+    """1D dataset class that inherits from Dataset.
+
+    This class represents a 1D dataset, such as spectra from XEDS or EELS.
+
+    Attributes
+    ----------
+    None beyond base Dataset.
+    """
+
+    def __init__(
+        self,
+        array: NDArray,
+        name: str,
+        origin: NDArray | tuple | list | float | int,
+        sampling: NDArray | tuple | list | float | int,
+        units: list[str] | tuple | list | None = None,
+        signal_units: str = "arb. units",
+        metadata: dict = {},
+        _token: object | None = None,
+    ):
+        """Initialize a 1D dataset.
+
+        Parameters
+        ----------
+        array : NDArray
+            The underlying 1D array data
+        name : str
+            A descriptive name for the dataset
+        origin : NDArray | tuple | list | float | int
+            The origin coordinates for each dimension
+        sampling : NDArray | tuple | list | float | int
+            The sampling rate/spacing for each dimension
+        units : list[str] | tuple | list
+            Units for each dimension
+        signal_units : str, optional
+            Units for the array values, by default "arb. units"
+        _token : object | None, optional
+            Token to prevent direct instantiation, by default None
+        """
+        super().__init__(
+            array=array,
+            name=name,
+            origin=origin,
+            sampling=sampling,
+            units=units,
+            signal_units=signal_units,
+            metadata=metadata,
+            _token=_token,
+        )
+
+    @classmethod
+    def from_array(
+        cls,
+        array: NDArray,
+        name: str | None = None,
+        origin: NDArray | tuple | list | float | int | None = None,
+        sampling: NDArray | tuple | list | float | int | None = None,
+        units: list[str] | tuple | list | None = None,
+        signal_units: str = "arb. units",
+    ) -> Self:
+        """Create a Dataset1d from a 1D array.
+
+        Parameters
+        ----------
+        array : NDArray
+            1D array with shape (length)
+        name : str | None
+            Dataset name. Default: "1D dataset"
+        origin : NDArray | tuple | list | float | int | None
+            Origin for each dimension. Default: [0]
+        sampling : NDArray | tuple | list | float | int | None
+            Sampling for each dimension. Default: [1]
+        units : list[str] | tuple | list | None
+            Units for each dimension. Default: ["pixels"]
+        signal_units : str
+            Units for array values. Default: "arb. units"
+
+        Returns
+        -------
+        Dataset1d
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from quantem.core.datastructures import Dataset1d
+        >>> arr = np.random.rand(10)
+        >>> data = Dataset1d.from_array(arr)
+        >>> data.shape
+        (10,)
+
+        With calibration:
+
+        >>> data = Dataset1d.from_array(
+        ...     arr,
+        ...     sampling=[0.15],
+        ...     units=["eV"],
+        ... )
+
+        Visualize:
+
+        >>> data.show()              # all frames in grid
+        >>> data.show(index=0)       # single frame
+        >>> data.show(ncols=2)       # 2 columns
+        """
+        array = ensure_valid_array(array, ndim=1)
+        return cls(
+            array=array,
+            name=name if name is not None else "1D dataset",
+            origin=origin if origin is not None else np.zeros(1),
+            sampling=sampling if sampling is not None else np.ones(1),
+            units=units if units is not None else ["pixels"],
+            signal_units=signal_units,
+            _token=cls._token,
+        )
+
+    @classmethod
+    def from_shape(
+        cls,
+        shape: tuple[int],
+        name: str = "constant 1D dataset",
+        fill_value: float = 0.0,
+        origin: NDArray | tuple | list | float | int | None = None,
+        sampling: NDArray | tuple | list | float | int | None = None,
+        units: list[str] | tuple | list | None = None,
+        signal_units: str = "arb. units",
+    ) -> Self:
+        """Create a Dataset1d filled with a constant value.
+
+        Parameters
+        ----------
+        shape : tuple[int]
+            Shape (length)
+        name : str
+            Dataset name. Default: "constant 1D dataset"
+        fill_value : float
+            Value to fill array with. Default: 0.0
+        origin : NDArray | tuple | list | float | int | None
+            Origin for each dimension
+        sampling : NDArray | tuple | list | float | int | None
+            Sampling for each dimension
+        units : list[str] | tuple | list | None
+            Units for each dimension
+        signal_units : str
+            Units for array values
+
+        Returns
+        -------
+        Dataset1d
+
+        Examples
+        --------
+        >>> data = Dataset1d.from_shape((10000))
+        >>> data.shape
+        (10000,)
+        >>> data.array.max()
+        0.0
+        """
+        array = np.full(shape, fill_value, dtype=np.float32)
+        return cls.from_array(
+            array=array,
+            name=name,
+            origin=origin,
+            sampling=sampling,
+            units=units,
+            signal_units=signal_units,
+        )
+
+    def show(
+        self,
+        title: str | None = None,
+        returnfig: bool = False,
+    ):
+        """
+        Plots 1D dataset
+
+        Parameters
+        ----------
+        title: str
+            Title of Dataset
+        returnfig: bool
+            Option to include figure as return value for method
+        """
+
+        if title is None:
+            title = self.name
+
+        fig, (ax) = plt.subplots(1, 1, figsize=(4, 4))
+
+        ax.plot(
+            float(self.origin[0]) + float(self.sampling[0]) * np.arange(self.shape[0]),
+            self.array,
+            linewidth=1.5,
+        )
+        ax.set_xlabel(self.units[0])
+        ax.set_ylabel(self.signal_units)
+        ax.set_title(title)
+
+        fig.tight_layout()
+        plt.show()
+
+        return (fig, ax) if returnfig else None

src/quantem/core/datastructures/dataset3d.py

@@ -30,6 +30,7 @@ def __init__(
         sampling: NDArray | tuple | list | float | int,
         units: list[str] | tuple | list,
         signal_units: str = "arb. units",
+        metadata: dict = {},
         _token: object | None = None,
     ):
         """Initialize a 3D dataset.
@@ -58,6 +59,7 @@ def __init__(
             sampling=sampling,
             units=units,
             signal_units=signal_units,
+            metadata=metadata,
             _token=_token,
         )
 

src/quantem/core/io/__init__.py

@@ -1,7 +1,7 @@
 from quantem.core.io.file_readers import read_2d as read_2d
 from quantem.core.io.file_readers import read_4dstem as read_4dstem
 from quantem.core.io.file_readers import (
-    read_emdfile_to_4dstem as read_emdfile_to_4dstem,
+    read_3d_spectroscopy as read_3d_spectroscopy,
 )
 from quantem.core.io.serialize import AutoSerialize as AutoSerialize
 from quantem.core.io.serialize import load as load

src/quantem/core/io/file_readers.py

@@ -9,6 +9,20 @@
 from quantem.core.datastructures import Dataset2d as Dataset2d
 from quantem.core.datastructures import Dataset3d as Dataset3d
 from quantem.core.datastructures import Dataset4dstem as Dataset4dstem
+from quantem.spectroscopy import (
+    Dataset3deels as Dataset3deels,
+)
+from quantem.spectroscopy import Dataset3dspectroscopy as Dataset3dspectroscopy
+from quantem.spectroscopy import (
+    Dataset3dxeds as Dataset3dxeds,
+)
+
+
+def _print_available_datasets(data_list):
+    print("Available datasets:")
+    for index, entry in enumerate(data_list):
+        array = entry["data"]
+        print(f"  Dataset {index}: shape {array.shape}, ndim={array.ndim}")
 
 
 def read_4dstem(
@@ -98,19 +112,17 @@ def read_4dstem(
     else:
         # Automatically find first 4D dataset
         four_d_datasets = [(i, d) for i, d in enumerate(data_list) if d["data"].ndim == 4]
+        _print_available_datasets(data_list)
 
         if len(four_d_datasets) == 0:
-            print(f"No 4D datasets found in {file_path}. Available datasets:")
-            for i, d in enumerate(data_list):
-                print(f"  Dataset {i}: shape {d['data'].shape}, ndim={d['data'].ndim}")
+            print(f"No 4D datasets found in {file_path}.")
             raise ValueError("No 4D dataset found in file")
 
         dataset_index, imported_data = four_d_datasets[0]
 
-        if len(data_list) > 1:
-            print(
-                f"File contains {len(data_list)} dataset(s). Using dataset {dataset_index} with shape {imported_data['data'].shape}"
-            )
+        print(
+            f"Using first 4D dataset at index {dataset_index} with shape {imported_data['data'].shape}"
+        )
 
     imported_axes = imported_data["axes"]
 
@@ -147,6 +159,94 @@ def read_4dstem(
     return dataset
 
 
+def read_3d_spectroscopy(
+    file_path: str, file_type: str, data_type: str, dataset_index: int | None = None
+) -> Dataset3dspectroscopy:
+    """
+    File reader for 3D spectroscopy data
+
+    Parameters
+    ----------
+    file_path: str
+        Path to data
+    file_type: str
+        The type of file reader needed. See rosettasciio for supported formats
+        https://hyperspy.org/rosettasciio/supported_formats/index.html
+    data_type: str
+        type of spectroscopy data 'EELS' or 'XEDS'
+    Returns
+    --------
+    Dataset3dspectroscopy
+    """
+    data_type_normalized = str(data_type).upper()
+
+    file_reader = importlib.import_module(f"rsciio.{file_type}").file_reader  # type: ignore
+    data_list = file_reader(file_path)
+
+    # If specific index provided, use it
+    if dataset_index is not None:
+        imported_data = data_list[dataset_index]
+        if imported_data["data"].ndim != 3:
+            raise ValueError(
+                f"Dataset at index {dataset_index} has {imported_data['data'].ndim} dimensions, "
+                f"expected 3D. Shape: {imported_data['data'].shape}"
+            )
+    else:
+        # Automatically find first 3D dataset
+        three_d_datasets = [(i, d) for i, d in enumerate(data_list) if d["data"].ndim == 3]
+        _print_available_datasets(data_list)
+
+        if len(three_d_datasets) == 0:
+            print(f"No 3D datasets found in {file_path}.")
+            raise ValueError("No 3D dataset found in file")
+
+        dataset_index, imported_data = three_d_datasets[0]
+
+        dataset_indices = [entry[0] for entry in three_d_datasets]
+        print(
+            f"Using first 3D dataset at index {dataset_index} with shape {imported_data['data'].shape}. "
+            f"3D dataset indices: {', '.join(map(str, dataset_indices))}"
+        )
+
+    imported_axes = imported_data["axes"]
+    # axis_order = (0, 1, 2) if file_type == "digitalmicrograph" else (2, 0, 1)
+    axis_order = (1, 2, 0) if file_type == "digitalmicrograph" else (0, 1, 2)
+    array = (
+        imported_data["data"].transpose(axis_order)
+        if file_type == "digitalmicrograph"
+        else imported_data["data"]
+    )
+    ordered_axes = [imported_axes[idx] for idx in axis_order]
+    sampling = [ax.get("scale", 1) for ax in ordered_axes]
+    origin = [ax.get("offset", 0) for ax in ordered_axes]
+    units = [
+        "pixels" if ax.get("units", "1") == "1" else ax.get("units", "pixels")
+        for ax in ordered_axes
+    ]
+
+    for i, unit in enumerate(units):
+        if unit == "eV" and data_type_normalized == "XEDS":
+            sampling[i] = sampling[i] / 1000
+            origin[i] = origin[i] / 1000
+            units[i] = "keV"
+
+    if data_type_normalized == "EELS":
+        dataset_cls = Dataset3deels
+    elif data_type_normalized == "XEDS":
+        dataset_cls = Dataset3dxeds
+    else:
+        raise ValueError(f"`data_type` must be `XEDS` or `EELS` not `{data_type}`")
+
+    dataset = dataset_cls.from_array(
+        array=array,
+        sampling=sampling,
+        origin=origin,
+        units=units,
+    )
+
+    return dataset
+
+
 def read_2d(
     file_path: str | PathLike,
     file_type: str | None = None,