Struct RectangularChunkGrid

pub struct RectangularChunkGrid { /* private fields */ }

A rectangular chunk grid.

Implementations

impl RectangularChunkGrid

pub fn new(chunk_shapes: &[RectangularChunkGridDimensionConfiguration]) -> Self

Create a new rectangular chunk grid with chunk shapes chunk_shapes.

Examples found in repository

examples/rectangular_array_write_read.rs (lines 62-65)

fn rectangular_array_write_read() -> Result<(), Box<dyn std::error::Error>> {
    use rayon::prelude::{IntoParallelIterator, ParallelIterator};
    use zarrs::array::ChunkGrid;
    use zarrs::{
        array::{chunk_grid::RectangularChunkGrid, codec, FillValue},
        node::Node,
    };
    use zarrs::{
        array::{DataType, ZARR_NAN_F32},
        array_subset::ArraySubset,
        storage::store,
    };

    // Create a store
    // let path = tempfile::TempDir::new()?;
    // let mut store: ReadableWritableListableStorage =
    //     Arc::new(zarrs::filesystem::FilesystemStore::new(path.path())?);
    let mut store: ReadableWritableListableStorage = Arc::new(store::MemoryStore::new());
    if let Some(arg1) = std::env::args().collect::<Vec<_>>().get(1) {
        if arg1 == "--usage-log" {
            let log_writer = Arc::new(std::sync::Mutex::new(
                // std::io::BufWriter::new(
                std::io::stdout(),
                //    )
            ));
            store = Arc::new(UsageLogStorageAdapter::new(store, log_writer, || {
                chrono::Utc::now().format("[%T%.3f] ").to_string()
            }));
        }
    }

    // Create the root group
    zarrs::group::GroupBuilder::new()
        .build(store.clone(), "/")?
        .store_metadata()?;

    // Create a group with attributes
    let group_path = "/group";
    let mut group = zarrs::group::GroupBuilder::new().build(store.clone(), group_path)?;
    group
        .attributes_mut()
        .insert("foo".into(), serde_json::Value::String("bar".into()));
    group.store_metadata()?;

    println!(
        "The group metadata is:\n{}\n",
        group.metadata().to_string_pretty()
    );

    // Create an array
    let array_path = "/group/array";
    let array = zarrs::array::ArrayBuilder::new(
        vec![8, 8], // array shape
        DataType::Float32,
        ChunkGrid::new(RectangularChunkGrid::new(&[
            [1, 2, 3, 2].try_into()?,
            4.try_into()?,
        ])),
        FillValue::from(ZARR_NAN_F32),
    )
    .bytes_to_bytes_codecs(vec![
        #[cfg(feature = "gzip")]
        Arc::new(codec::GzipCodec::new(5)?),
    ])
    .dimension_names(["y", "x"].into())
    // .storage_transformers(vec![].into())
    .build(store.clone(), array_path)?;

    // Write array metadata to store
    array.store_metadata()?;

    // Write some chunks (in parallel)
    (0..4).into_par_iter().try_for_each(|i| {
        let chunk_grid = array.chunk_grid();
        let chunk_indices = vec![i, 0];
        if let Some(chunk_shape) = chunk_grid.chunk_shape(&chunk_indices, array.shape())? {
            let chunk_array = ndarray::ArrayD::<f32>::from_elem(
                chunk_shape
                    .iter()
                    .map(|u| u.get() as usize)
                    .collect::<Vec<_>>(),
                i as f32,
            );
            array.store_chunk_ndarray(&chunk_indices, chunk_array)
        } else {
            Err(zarrs::array::ArrayError::InvalidChunkGridIndicesError(
                chunk_indices.to_vec(),
            ))
        }
    })?;

    println!(
        "The array metadata is:\n{}\n",
        array.metadata().to_string_pretty()
    );

    // Write a subset spanning multiple chunks, including updating chunks already written
    array.store_array_subset_ndarray(
        &[3, 3], // start
        ndarray::ArrayD::<f32>::from_shape_vec(
            vec![3, 3],
            vec![0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
        )?,
    )?;

    // Store elements directly, in this case set the 7th column to 123.0
    array.store_array_subset_elements::<f32>(
        &ArraySubset::new_with_ranges(&[0..8, 6..7]),
        &[123.0; 8],
    )?;

    // Store elements directly in a chunk, in this case set the last row of the bottom right chunk
    array.store_chunk_subset_elements::<f32>(
        // chunk indices
        &[3, 1],
        // subset within chunk
        &ArraySubset::new_with_ranges(&[1..2, 0..4]),
        &[-4.0; 4],
    )?;

    // Read the whole array
    let data_all = array.retrieve_array_subset_ndarray::<f32>(&array.subset_all())?;
    println!("The whole array is:\n{data_all}\n");

    // Read a chunk back from the store
    let chunk_indices = vec![1, 0];
    let data_chunk = array.retrieve_chunk_ndarray::<f32>(&chunk_indices)?;
    println!("Chunk [1,0] is:\n{data_chunk}\n");

    // Read the central 4x2 subset of the array
    let subset_4x2 = ArraySubset::new_with_ranges(&[2..6, 3..5]); // the center 4x2 region
    let data_4x2 = array.retrieve_array_subset_ndarray::<f32>(&subset_4x2)?;
    println!("The middle 4x2 subset is:\n{data_4x2}\n");

    // Show the hierarchy
    let node = Node::open(&store, "/").unwrap();
    let tree = node.hierarchy_tree();
    println!("The Zarr hierarchy tree is:\n{tree}");

    Ok(())
}

Trait Implementations

impl ChunkGridTraits for RectangularChunkGrid

unsafe fn chunk_element_indices_unchecked( &self, array_indices: &[u64], array_shape: &[u64], ) -> Option<ArrayIndices>

Safety

The length of array_indices and array_shape must match the dimensionality of the chunk grid.

fn create_metadata(&self) -> MetadataV3

Create metadata.

fn dimensionality(&self) -> usize

The dimensionality of the grid.

unsafe fn grid_shape_unchecked(&self, array_shape: &[u64]) -> Option<ArrayShape>

See ChunkGridTraits::grid_shape.

unsafe fn chunk_shape_unchecked( &self, chunk_indices: &[u64], _array_shape: &[u64], ) -> Option<ChunkShape>

See ChunkGridTraits::chunk_shape.

unsafe fn chunk_shape_u64_unchecked( &self, chunk_indices: &[u64], _array_shape: &[u64], ) -> Option<ArrayShape>

See ChunkGridTraits::chunk_shape_u64.

unsafe fn chunk_origin_unchecked( &self, chunk_indices: &[u64], _array_shape: &[u64], ) -> Option<ArrayIndices>

See ChunkGridTraits::chunk_origin.

unsafe fn chunk_indices_unchecked( &self, array_indices: &[u64], _array_shape: &[u64], ) -> Option<ArrayIndices>

See ChunkGridTraits::chunk_indices.

fn array_indices_inbounds( &self, array_indices: &[u64], array_shape: &[u64], ) -> bool

Check if array indices are in-bounds.

fn grid_shape( &self, array_shape: &[u64], ) -> Result<Option<ArrayShape>, IncompatibleDimensionalityError>

The grid shape (i.e. number of chunks).

fn chunk_shape( &self, chunk_indices: &[u64], array_shape: &[u64], ) -> Result<Option<ChunkShape>, IncompatibleDimensionalityError>

The shape of the chunk at chunk_indices.

fn chunk_shape_u64( &self, chunk_indices: &[u64], array_shape: &[u64], ) -> Result<Option<ArrayShape>, IncompatibleDimensionalityError>

The shape of the chunk at chunk_indices as an ArrayShape (Vec<u64>).

fn chunk_origin( &self, chunk_indices: &[u64], array_shape: &[u64], ) -> Result<Option<ArrayIndices>, IncompatibleDimensionalityError>

The origin of the chunk at chunk_indices.

fn subset( &self, chunk_indices: &[u64], array_shape: &[u64], ) -> Result<Option<ArraySubset>, IncompatibleDimensionalityError>

Return the ArraySubset of the chunk at chunk_indices.

fn chunks_subset( &self, chunks: &ArraySubset, array_shape: &[u64], ) -> Result<Option<ArraySubset>, IncompatibleDimensionalityError>

Return the ArraySubset of the chunks in chunks.

fn chunk_indices( &self, array_indices: &[u64], array_shape: &[u64], ) -> Result<Option<ArrayIndices>, IncompatibleDimensionalityError>

The indices of a chunk which has the element at array_indices.

fn chunk_element_indices( &self, array_indices: &[u64], array_shape: &[u64], ) -> Result<Option<ArrayIndices>, IncompatibleDimensionalityError>

The indices within the chunk of the element at array_indices.

fn chunk_indices_inbounds( &self, chunk_indices: &[u64], array_shape: &[u64], ) -> bool

Check if chunk indices are in-bounds.

unsafe fn subset_unchecked( &self, chunk_indices: &[u64], array_shape: &[u64], ) -> Option<ArraySubset>

See ChunkGridTraits::subset.

fn chunks_in_array_subset( &self, array_subset: &ArraySubset, array_shape: &[u64], ) -> Result<Option<ArraySubset>, IncompatibleDimensionalityError>

Return an array subset indicating the chunks intersecting array_subset.

impl Clone for RectangularChunkGrid

fn clone(&self) -> RectangularChunkGrid

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RectangularChunkGrid

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.