# DataTree

## Creating a DataTree

Methods of creating a `DataTree`.

| [`DataTree`](../generated/xarray.DataTree.html.md#xarray.DataTree)([dataset, children, name])                        | A tree-like hierarchical collection of xarray objects.                                 |
|-----------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------|
| [`DataTree.from_dict`](../generated/xarray.DataTree.from_dict.html.md#xarray.DataTree.from_dict)([data, coords, name, nested]) | Create a datatree from a dictionary of data objects, organised by paths into the tree. |

## Tree Attributes

Attributes relating to the recursive tree-like structure of a `DataTree`.

| [`DataTree.parent`](../generated/xarray.DataTree.parent.html.md#xarray.DataTree.parent)                       | Parent of this node.                                                          |
|---------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------|
| [`DataTree.children`](../generated/xarray.DataTree.children.html.md#xarray.DataTree.children)                   | Child nodes of this node, stored under a mapping via their names.             |
| [`DataTree.name`](../generated/xarray.DataTree.name.html.md#xarray.DataTree.name)                           | The name of this node.                                                        |
| [`DataTree.path`](../generated/xarray.DataTree.path.html.md#xarray.DataTree.path)                           | Return the file-like path from the root to this node.                         |
| [`DataTree.root`](../generated/xarray.DataTree.root.html.md#xarray.DataTree.root)                           | Root node of the tree                                                         |
| [`DataTree.is_root`](../generated/xarray.DataTree.is_root.html.md#xarray.DataTree.is_root)                     | Whether this node is the tree root.                                           |
| [`DataTree.is_leaf`](../generated/xarray.DataTree.is_leaf.html.md#xarray.DataTree.is_leaf)                     | Whether this node is a leaf node.                                             |
| [`DataTree.leaves`](../generated/xarray.DataTree.leaves.html.md#xarray.DataTree.leaves)                       | All leaf nodes.                                                               |
| [`DataTree.level`](../generated/xarray.DataTree.level.html.md#xarray.DataTree.level)                         | Level of this node.                                                           |
| [`DataTree.depth`](../generated/xarray.DataTree.depth.html.md#xarray.DataTree.depth)                         | Maximum level of this tree.                                                   |
| [`DataTree.width`](../generated/xarray.DataTree.width.html.md#xarray.DataTree.width)                         | Number of nodes at this level in the tree.                                    |
| [`DataTree.subtree`](../generated/xarray.DataTree.subtree.html.md#xarray.DataTree.subtree)                     | Iterate over all nodes in this tree, including both self and all descendants. |
| [`DataTree.subtree_with_keys`](../generated/xarray.DataTree.subtree_with_keys.html.md#xarray.DataTree.subtree_with_keys) | Iterate over relative paths and node pairs for all nodes in this tree.        |
| [`DataTree.descendants`](../generated/xarray.DataTree.descendants.html.md#xarray.DataTree.descendants)             | Child nodes and all their child nodes.                                        |
| [`DataTree.siblings`](../generated/xarray.DataTree.siblings.html.md#xarray.DataTree.siblings)                   | Nodes with the same parent as this node.                                      |
| [`DataTree.lineage`](../generated/xarray.DataTree.lineage.html.md#xarray.DataTree.lineage)                     | All parent nodes and their parent nodes, starting with the closest.           |
| [`DataTree.parents`](../generated/xarray.DataTree.parents.html.md#xarray.DataTree.parents)                     | All parent nodes and their parent nodes, starting with the closest.           |
| [`DataTree.ancestors`](../generated/xarray.DataTree.ancestors.html.md#xarray.DataTree.ancestors)                 | All parent nodes and their parent nodes, starting with the most distant.      |
| [`DataTree.groups`](../generated/xarray.DataTree.groups.html.md#xarray.DataTree.groups)                       | Return all groups in the tree, given as a tuple of path-like strings.         |
| [`DataTree.xindexes`](../generated/xarray.DataTree.xindexes.html.md#xarray.DataTree.xindexes)                   | Mapping of xarray Index objects used for label based indexing.                |

## Data Contents

Interface to the data objects (optionally) stored inside a single `DataTree` node.
This interface echoes that of `xarray.Dataset`.

| [`DataTree.dims`](../generated/xarray.DataTree.dims.html.md#xarray.DataTree.dims)                        | Mapping from dimension names to lengths.                                     |
|------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------|
| [`DataTree.sizes`](../generated/xarray.DataTree.sizes.html.md#xarray.DataTree.sizes)                      | Mapping from dimension names to lengths.                                     |
| [`DataTree.data_vars`](../generated/xarray.DataTree.data_vars.html.md#xarray.DataTree.data_vars)              | Dictionary of DataArray objects corresponding to data variables              |
| [`DataTree.ds`](../generated/xarray.DataTree.ds.html.md#xarray.DataTree.ds)                            | An immutable Dataset-like view onto the data in this node.                   |
| [`DataTree.coords`](../generated/xarray.DataTree.coords.html.md#xarray.DataTree.coords)                    | Dictionary of xarray.DataArray objects corresponding to coordinate variables |
| [`DataTree.attrs`](../generated/xarray.DataTree.attrs.html.md#xarray.DataTree.attrs)                      | Dictionary of global attributes on this node object.                         |
| [`DataTree.encoding`](../generated/xarray.DataTree.encoding.html.md#xarray.DataTree.encoding)                | Dictionary of global encoding attributes on this node object.                |
| [`DataTree.indexes`](../generated/xarray.DataTree.indexes.html.md#xarray.DataTree.indexes)                  | Mapping of pandas.Index objects used for label based indexing.               |
| [`DataTree.nbytes`](../generated/xarray.DataTree.nbytes.html.md#xarray.DataTree.nbytes)                    |                                                                              |
| [`DataTree.dataset`](../generated/xarray.DataTree.dataset.html.md#xarray.DataTree.dataset)                  | An immutable Dataset-like view onto the data in this node.                   |
| [`DataTree.to_dataset`](../generated/xarray.DataTree.to_dataset.html.md#xarray.DataTree.to_dataset)([inherit]) | Return the data in this node as a new xarray.Dataset object.                 |
| [`DataTree.has_data`](../generated/xarray.DataTree.has_data.html.md#xarray.DataTree.has_data)                | Whether or not there are any variables in this node.                         |
| [`DataTree.has_attrs`](../generated/xarray.DataTree.has_attrs.html.md#xarray.DataTree.has_attrs)              | Whether or not there are any metadata attributes in this node.               |
| [`DataTree.is_empty`](../generated/xarray.DataTree.is_empty.html.md#xarray.DataTree.is_empty)                | False if node contains any data or attrs.                                    |
| [`DataTree.is_hollow`](../generated/xarray.DataTree.is_hollow.html.md#xarray.DataTree.is_hollow)              | True if only leaf nodes contain data.                                        |
| [`DataTree.chunksizes`](../generated/xarray.DataTree.chunksizes.html.md#xarray.DataTree.chunksizes)            | Mapping from group paths to a mapping of chunksizes.                         |

## Dictionary Interface

`DataTree` objects also have a dict-like interface mapping keys to either `xarray.DataArray`s or to child `DataTree` nodes.

| [`DataTree.__getitem__`](../generated/xarray.DataTree.__getitem__.html.md#xarray.DataTree.__getitem__)(key)        | Access child nodes, variables, or coordinates stored anywhere in this tree.   |
|---------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------|
| [`DataTree.__setitem__`](../generated/xarray.DataTree.__setitem__.html.md#xarray.DataTree.__setitem__)(key, value) | Add either a child node or an array to the tree, at any position.             |
| [`DataTree.__delitem__`](../generated/xarray.DataTree.__delitem__.html.md#xarray.DataTree.__delitem__)(key)        | Remove a variable or child node from this datatree node.                      |
| [`DataTree.update`](../generated/xarray.DataTree.update.html.md#xarray.DataTree.update)(other)                | Update this node's children and / or variables.                               |
| [`DataTree.get`](../generated/xarray.DataTree.get.html.md#xarray.DataTree.get)(key[, default])             | Access child nodes, variables, or coordinates stored in this node.            |
| [`DataTree.items`](../generated/xarray.DataTree.items.html.md#xarray.DataTree.items)()                       |                                                                               |
| [`DataTree.keys`](../generated/xarray.DataTree.keys.html.md#xarray.DataTree.keys)()                         |                                                                               |
| [`DataTree.values`](../generated/xarray.DataTree.values.html.md#xarray.DataTree.values)()                     |                                                                               |

## Tree Manipulation

For manipulating, traversing, navigating, or mapping over the tree structure.

| [`DataTree.orphan`](../generated/xarray.DataTree.orphan.html.md#xarray.DataTree.orphan)()                                             | Detach this node from its parent.                                                                 |
|---------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------|
| [`DataTree.same_tree`](../generated/xarray.DataTree.same_tree.html.md#xarray.DataTree.same_tree)(other)                                  | True if other node is in the same tree as this node.                                              |
| [`DataTree.relative_to`](../generated/xarray.DataTree.relative_to.html.md#xarray.DataTree.relative_to)(other)                              | Compute the relative path from this node to node other.                                           |
| [`DataTree.iter_lineage`](../generated/xarray.DataTree.iter_lineage.html.md#xarray.DataTree.iter_lineage)()                                 | Iterate up the tree, starting from the current node.                                              |
| [`DataTree.find_common_ancestor`](../generated/xarray.DataTree.find_common_ancestor.html.md#xarray.DataTree.find_common_ancestor)(other)            | Find the first common ancestor of two nodes in the same tree.                                     |
| [`DataTree.map_over_datasets`](../generated/xarray.DataTree.map_over_datasets.html.md#xarray.DataTree.map_over_datasets)(func, \*args[, kwargs]) | Apply a function to every dataset in this subtree, returning a new tree which stores the results. |
| [`DataTree.pipe`](../generated/xarray.DataTree.pipe.html.md#xarray.DataTree.pipe)(func, \*args, \*\*kwargs)                         | Apply `func(self, *args, **kwargs)`                                                               |
| [`DataTree.match`](../generated/xarray.DataTree.match.html.md#xarray.DataTree.match)(pattern)                                        | Return nodes with paths matching pattern.                                                         |
| [`DataTree.filter`](../generated/xarray.DataTree.filter.html.md#xarray.DataTree.filter)(filterfunc)                                   | Filter nodes according to a specified condition.                                                  |
| [`DataTree.filter_like`](../generated/xarray.DataTree.filter_like.html.md#xarray.DataTree.filter_like)(other)                              | Filter a datatree like another datatree.                                                          |

## Pathlib-like Interface

`DataTree` objects deliberately echo some of the API of [`pathlib.PurePath`](https://docs.python.org/3/library/pathlib.html#pathlib.PurePath).

| [`DataTree.name`](../generated/xarray.DataTree.name.html.md#xarray.DataTree.name)                      | The name of this node.                                              |
|----------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------|
| [`DataTree.parent`](../generated/xarray.DataTree.parent.html.md#xarray.DataTree.parent)                  | Parent of this node.                                                |
| [`DataTree.parents`](../generated/xarray.DataTree.parents.html.md#xarray.DataTree.parents)                | All parent nodes and their parent nodes, starting with the closest. |
| [`DataTree.relative_to`](../generated/xarray.DataTree.relative_to.html.md#xarray.DataTree.relative_to)(other) | Compute the relative path from this node to node other.             |
<!-- Missing: -->
<!-- .. -->
<!-- ``DataTree.glob`` -->
<!-- ``DataTree.joinpath`` -->
<!-- ``DataTree.with_name`` -->
<!-- ``DataTree.walk`` -->
<!-- ``DataTree.rename`` -->
<!-- ``DataTree.replace`` -->

## DataTree Contents

Manipulate the contents of all nodes in a `DataTree` simultaneously.

| [`DataTree.copy`](../generated/xarray.DataTree.copy.html.md#xarray.DataTree.copy)(\*[, inherit, deep])   | Returns a copy of this subtree.   |
|------------------------------------------------------------------------------------------------------------|-----------------------------------|

## DataTree Node Contents

Manipulate the contents of a single `DataTree` node.

| [`DataTree.assign`](../generated/xarray.DataTree.assign.html.md#xarray.DataTree.assign)([items])                     | Assign new data variables or child nodes to a DataTree, returning a new object with all the original items in addition to the new ones.   |
|----------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------|
| [`DataTree.drop_nodes`](../generated/xarray.DataTree.drop_nodes.html.md#xarray.DataTree.drop_nodes)(names, \*[, errors]) | Drop child nodes from this node.                                                                                                          |

## DataTree Operations

Apply operations over multiple `DataTree` objects.

| [`map_over_datasets`](../generated/xarray.map_over_datasets.html.md#xarray.map_over_datasets)(func, \*args[, kwargs])   | Applies a function to every dataset in one or more DataTree objects with the same structure (ie.., that are isomorphic), returning new trees which store the results.   |
|-----------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [`group_subtrees`](../generated/xarray.group_subtrees.html.md#xarray.group_subtrees)(\*trees)                        | Iterate over subtrees grouped by relative paths in breadth-first order.                                                                                                 |

## Comparisons

Compare one `DataTree` object to another.

| [`DataTree.isomorphic`](../generated/xarray.DataTree.isomorphic.html.md#xarray.DataTree.isomorphic)(other)   | Two DataTrees are considered isomorphic if the set of paths to their descendent nodes are the same.                                                                                    |
|----------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [`DataTree.equals`](../generated/xarray.DataTree.equals.html.md#xarray.DataTree.equals)(other)           | Two DataTrees are equal if they have isomorphic node structures, with matching node names, and if they have matching variables and coordinates, all of which are equal.                |
| [`DataTree.identical`](../generated/xarray.DataTree.identical.html.md#xarray.DataTree.identical)(other)     | Like equals, but also checks attributes on all datasets, variables and coordinates, and requires that any inherited coordinates at the tree root are also inherited on the other tree. |

## Indexing

Index into all nodes in the subtree simultaneously.

| [`DataTree.isel`](../generated/xarray.DataTree.isel.html.md#xarray.DataTree.isel)([indexers, drop, missing_dims])    | Returns a new data tree with each array indexed along the specified dimension(s).                |
|------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------|
| [`DataTree.sel`](../generated/xarray.DataTree.sel.html.md#xarray.DataTree.sel)([indexers, method, tolerance, drop]) | Returns a new data tree with each array indexed by tick labels along the specified dimension(s). |
<!-- DataTree.drop_sel -->
<!-- DataTree.drop_isel -->
<!-- DataTree.head -->
<!-- DataTree.tail -->
<!-- DataTree.thin -->
<!-- DataTree.squeeze -->
<!-- DataTree.interp -->
<!-- DataTree.interp_like -->
<!-- DataTree.reindex -->
<!-- DataTree.reindex_like -->
<!-- DataTree.set_index -->
<!-- DataTree.reset_index -->
<!-- DataTree.reorder_levels -->
<!-- DataTree.query -->
<!-- .. -->
<!-- Missing: -->
<!-- ``DataTree.loc`` -->
<!-- Missing Value Handling -->
<!-- ---------------------- -->
<!-- .. autosummary:: -->
<!-- :toctree: ../generated/ -->
<!-- DataTree.isnull -->
<!-- DataTree.notnull -->
<!-- DataTree.combine_first -->
<!-- DataTree.dropna -->
<!-- DataTree.fillna -->
<!-- DataTree.ffill -->
<!-- DataTree.bfill -->
<!-- DataTree.interpolate_na -->
<!-- DataTree.where -->
<!-- DataTree.isin -->
<!-- Computation -->
<!-- ----------- -->
<!-- Apply a computation to the data in all nodes in the subtree simultaneously. -->
<!-- .. autosummary:: -->
<!-- :toctree: ../generated/ -->
<!-- DataTree.map -->
<!-- DataTree.reduce -->
<!-- DataTree.diff -->
<!-- DataTree.quantile -->
<!-- DataTree.differentiate -->
<!-- DataTree.integrate -->
<!-- DataTree.map_blocks -->
<!-- DataTree.polyfit -->
<!-- DataTree.curvefit -->

## Aggregation

Aggregate data in all nodes in the subtree simultaneously.

| [`DataTree.all`](../generated/xarray.DataTree.all.html.md#xarray.DataTree.all)([dim, keep_attrs])                 | Reduce this DataTree's data by applying `all` along some dimension(s).                                |
|----------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------|
| [`DataTree.any`](../generated/xarray.DataTree.any.html.md#xarray.DataTree.any)([dim, keep_attrs])                 | Reduce this DataTree's data by applying `any` along some dimension(s).                                |
| [`DataTree.max`](../generated/xarray.DataTree.max.html.md#xarray.DataTree.max)([dim, skipna, keep_attrs])         | Reduce this DataTree's data by applying `max` (i.e., maximum) along some dimension(s).                |
| [`DataTree.min`](../generated/xarray.DataTree.min.html.md#xarray.DataTree.min)([dim, skipna, keep_attrs])         | Reduce this DataTree's data by applying `min` (i.e., minimum) along some dimension(s).                |
| [`DataTree.mean`](../generated/xarray.DataTree.mean.html.md#xarray.DataTree.mean)([dim, skipna, keep_attrs])       | Reduce this DataTree's data by applying `mean` along some dimension(s).                               |
| [`DataTree.median`](../generated/xarray.DataTree.median.html.md#xarray.DataTree.median)([dim, skipna, keep_attrs])   | Reduce this DataTree's data by applying `median` along some dimension(s).                             |
| [`DataTree.prod`](../generated/xarray.DataTree.prod.html.md#xarray.DataTree.prod)([dim, skipna, min_count, ...])   | Reduce this DataTree's data by applying `prod` (i.e., product) along some dimension(s).               |
| [`DataTree.sum`](../generated/xarray.DataTree.sum.html.md#xarray.DataTree.sum)([dim, skipna, min_count, ...])     | Reduce this DataTree's data by applying `sum` along some dimension(s).                                |
| [`DataTree.std`](../generated/xarray.DataTree.std.html.md#xarray.DataTree.std)([dim, skipna, ddof, keep_attrs])   | Reduce this DataTree's data by applying `std` (i.e., standard deviation) along some dimension(s).     |
| [`DataTree.var`](../generated/xarray.DataTree.var.html.md#xarray.DataTree.var)([dim, skipna, ddof, keep_attrs])   | Reduce this DataTree's data by applying `var` (i.e., variance) along some dimension(s).               |
| [`DataTree.cumsum`](../generated/xarray.DataTree.cumsum.html.md#xarray.DataTree.cumsum)([dim, skipna, keep_attrs])   | Reduce this DataTree's data by applying `cumsum` (i.e., cumulative sum) along some dimension(s).      |
| [`DataTree.cumprod`](../generated/xarray.DataTree.cumprod.html.md#xarray.DataTree.cumprod)([dim, skipna, keep_attrs]) | Reduce this DataTree's data by applying `cumprod` (i.e., cumulative product) along some dimension(s). |

## ndarray methods

Methods copied from [`numpy.ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray) objects, here applying to the data in all nodes in the subtree.

| [`DataTree.argsort`](../generated/xarray.DataTree.argsort.html.md#xarray.DataTree.argsort)([axis, kind, order, ...])   | Returns the indices that would sort this array.   |
|-----------------------------------------------------------------------------------------------------------------------|---------------------------------------------------|
| [`DataTree.conj`](../generated/xarray.DataTree.conj.html.md#xarray.DataTree.conj)()                                 | Complex-conjugate all elements.                   |
| [`DataTree.conjugate`](../generated/xarray.DataTree.conjugate.html.md#xarray.DataTree.conjugate)(\*args, \*\*kwargs)     | a.conj()                                          |
| [`DataTree.round`](../generated/xarray.DataTree.round.html.md#xarray.DataTree.round)(\*args, \*\*kwargs)             |                                                   |
<!-- DataTree.astype -->
<!-- DataTree.clip -->
<!-- DataTree.rank -->
<!-- Reshaping and reorganising -->
<!-- -------------------------- -->
<!-- Reshape or reorganise the data in all nodes in the subtree. -->
<!-- .. autosummary:: -->
<!-- :toctree: ../generated/ -->
<!-- DataTree.transpose -->
<!-- DataTree.stack -->
<!-- DataTree.unstack -->
<!-- DataTree.shift -->
<!-- DataTree.roll -->
<!-- DataTree.pad -->
<!-- DataTree.sortby -->
<!-- DataTree.broadcast_like -->
