or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

array-creation.mdbinning-histogramming.mdcoordinate-systems.mdcore-data-structures.mdindex.mdinput-output.mdmathematical-operations.mdreduction-operations.mdscipy-integration.mdshape-operations.mdspatial-operations.mdtesting-utilities.mdunits-system.mdvisualization.md
tile.json

tessl/pypi-scipp

Multi-dimensional data arrays with labeled dimensions for scientific computing

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
pypipkg:pypi/scipp@24.11.x

To install, run

npx @tessl/cli install tessl/pypi-scipp@24.11.0

index.mddocs/

Scipp

Scipp is a comprehensive Python library for multi-dimensional data arrays with labeled dimensions, designed for scientific computing with built-in physical units, uncertainty propagation, and advanced data manipulation capabilities. It provides a powerful foundation for neutron scattering data analysis and other scientific applications requiring efficient manipulation of complex, multi-dimensional datasets with proper error propagation and metadata handling.

Package Information

  • Package Name: scipp
  • Language: Python
  • Installation: pip install scipp
  • Optional Dependencies: pip install scipp[all] for complete functionality
  • Documentation: https://scipp.github.io/
  • Source: https://github.com/scipp/scipp

Core Imports

import scipp as sc

Alternative imports for specific modules:

import scipp.units as units
import scipp.spatial as spatial
import scipp.data as data
import scipp.io as io

Basic Usage

import scipp as sc
import numpy as np

# Create a Variable with physical units
data = sc.array(dims=['x'], values=[1, 2, 3, 4, 5], unit='m')
print(data)

# Create a DataArray with coordinates
x_coord = sc.linspace(dim='x', start=0.0, stop=10.0, num=5, unit='mm')
da = sc.DataArray(data=data, coords={'x': x_coord})
print(da)

# Perform operations that preserve units and propagate uncertainties
result = da * 2  # Units are preserved
print(result)

# Create data with uncertainties
uncertain_data = sc.array(dims=['x'], values=[1, 2, 3], variances=[0.1, 0.2, 0.3], unit='counts')
print(uncertain_data)

# Reduction operations
total = sc.sum(uncertain_data)  # Uncertainty propagation is automatic
print(total)

# Binning operations for histogram creation
events = sc.data.table_xyz(1000)  # Generate sample event data
binned = events.bin(x=10)  # Bin into 10 x-bins
histogram = sc.hist(events, x=10)  # Create histogram directly

Architecture

Scipp's architecture is built around labeled, multi-dimensional arrays with integrated metadata:

  • Variable: Core data structure holding multi-dimensional arrays with units, variances, and dimensions
  • DataArray: Variable with associated coordinate variables and masks for enhanced data organization
  • Dataset: Dictionary-like container for multiple related DataArrays sharing coordinate systems
  • DataGroup: Hierarchical container for complex, nested data structures
  • Units: Physical unit system with automatic propagation through all operations
  • Binning: Advanced binning and histogramming with support for irregular bins and event data

This design enables scientific workflows with automatic unit checking, uncertainty propagation, and metadata preservation throughout all operations.

Capabilities

Core Data Structures

Foundation classes for multi-dimensional labeled arrays with physical units, uncertainty propagation, and comprehensive metadata handling.

class Variable:
    """Multi-dimensional array with labeled dimensions, units, and optional variances"""
    
class DataArray:
    """Variable with coordinates and masks for enhanced data organization"""
    
class Dataset:
    """Dictionary-like container for multiple DataArrays"""
    
class DataGroup:
    """Hierarchical container for nested data structures"""
    
class Unit:
    """Physical unit with arithmetic operations"""
    
class DType:
    """Data type enumeration for scipp arrays"""

Core Data Structures

Array Creation and Manipulation

Functions for creating arrays, scalars, vectors, and structured data with comprehensive shape manipulation and broadcasting capabilities.

def array(dims, values, *, variances=None, unit=None, dtype=None): ...
def scalar(value, *, variance=None, unit=None, dtype=None): ...
def zeros(dims, shape, *, unit=None, dtype=None): ...
def ones(dims, shape, *, unit=None, dtype=None): ...
def linspace(dim, start, stop, num, *, unit=None, dtype=None): ...
def arange(dim, start, stop=None, step=None, *, unit=None, dtype=None): ...

Array Creation

Mathematical Operations

Comprehensive mathematical functions including arithmetic, trigonometric, logarithmic, and specialized operations with automatic unit propagation and uncertainty handling.

def add(x, y): ...
def multiply(x, y): ...
def sin(x): ...
def cos(x): ...
def exp(x): ...
def log(x): ...
def sqrt(x): ...
def abs(x): ...

Mathematical Operations

Reduction and Statistical Operations

Statistical reduction functions along dimensions with comprehensive NaN handling and uncertainty propagation.

def sum(x, dim=None): ...
def mean(x, dim=None): ...
def std(x, dim=None): ...
def var(x, dim=None): ...
def min(x, dim=None): ...
def max(x, dim=None): ...
def median(x, dim=None): ...

Reduction Operations

Shape Operations and Broadcasting

Functions for manipulating array shapes, dimensions, and broadcasting with full metadata preservation.

def broadcast(x, *, dims=None, shape=None): ...
def transpose(x, dims=None): ...
def squeeze(x, dim=None): ...
def flatten(x, dims, to): ...
def fold(x, dim, dims, shape): ...
def concat(x, dim): ...

Shape Operations

Binning and Histogramming

Advanced binning operations for event data, histogram creation, and data grouping with support for irregular bins and multi-dimensional binning.

def bin(x, /, **edges): ...
def hist(x, /, **edges): ...
def rebin(x, **edges): ...
def group(x, /, **groups): ...
def groupby(x, group, *, dim=None): ...

Binning and Histogramming

Physical Units System

Comprehensive physical unit system with predefined units, unit conversion, and alias management.

class Unit:
    def __init__(self, unit_string): ...
    
def to_unit(x, unit): ...

# Predefined units
dimensionless: Unit
m: Unit  # meter
kg: Unit  # kilogram
s: Unit  # second
K: Unit  # kelvin
rad: Unit  # radian
deg: Unit  # degree

Units System

Spatial Transformations

Vector operations, coordinate transformations, rotations, translations, and spatial geometry functions.

def vector(value, *, unit=None): ...
def vectors(dims, values, *, unit=None): ...
def rotation(*, value): ...
def translation(*, value, unit=None): ...
def linear_transform(*, value, unit=None): ...
def as_vectors(x, y, z): ...

Spatial Operations

Data Input/Output

File I/O operations supporting HDF5 and CSV formats with full metadata preservation.

def load_hdf5(filename): ...
def save_hdf5(data, filename): ...
def load_csv(filename, **kwargs): ...

Input/Output

Visualization and Display

Data visualization functions for interactive plotting, HTML representation, and table display.

def plot(data, **kwargs): ...
def show(data): ...
def table(data): ...
def make_html(data): ...
def make_svg(data): ...

Visualization

SciPy Integration

Wrappers for SciPy functionality including optimization, interpolation, signal processing, and image processing.

# scipy.optimize
def curve_fit(f, data, **kwargs): ...

# scipy.interpolate  
def interp1d(data, dim, **kwargs): ...

# scipy.ndimage
def gaussian_filter(x, *, sigma, **kwargs): ...

SciPy Integration

Coordinate Systems

Coordinate transformation functions and graph-based coordinate system management.

def transform_coords(x, targets, **kwargs): ...
def show_graph(coords): ...

Coordinate Systems

Testing and Assertions

Testing utilities for scientific data validation and comparison.

def assert_identical(a, b): ...
def assert_allclose(a, b, **kwargs): ...

Testing Utilities

Types

from typing import Union, Optional, Dict, List, Any, Sequence, Mapping
from numpy.typing import ArrayLike

# Core types
VariableLike = Union[Variable, DataArray]
DimMapping = Dict[str, Union[int, slice, Variable]]
Dims = Union[str, Sequence[str]]
Shape = Union[int, Sequence[int]]
Values = Union[ArrayLike, Sequence]

# Exception types
class BinEdgeError(Exception): ...
class BinnedDataError(Exception): ...
class CoordError(Exception): ...
class DataArrayError(Exception): ...
class DatasetError(Exception): ...
class DimensionError(Exception): ...
class DTypeError(Exception): ...
class UnitError(Exception): ...
class VariableError(Exception): ...
class VariancesError(Exception): ...