# Example Applications¶

Below are some examples demonstrating interesting combinations of `ytree` functionality. Each of the scripts shown below can be found in the `doc/source/examples` directory. If you have made something not seen here, please considering adding it to this document.

## Plot the Tree of the Most Massive Halo¶

Script: plot_most_massive.py

Below we make a plot of the most massive halo in the arbor. We use the NumPy `argmax` function to get the index within the arbor of the most massive halo.

```import ytree

imax = a["mass"].argmax()
my_tree = a[imax]
print(f"Most massive halo is {my_tree} with M = {my_tree['mass']}.")

p = ytree.TreePlot(my_tree)
p.min_mass_ratio = 0.001
p.save("most_massive.png")
```

We use the `min_mass_ratio` attribute to plot only halos with masses of at least 10-3 of the main halo.

## Plot the Tree with the Most Halos¶

Script: plot_most_halos.py

Similar to above, it is often useful to find the tree containing the most halos. To do this, we make an array containing the sizes of all trees using the `tree_size` attribute of the `TreeNode` class. The `Arbor` class’s `arr` method is useful for creating `unyt_array` objects with the unit system of the dataset.

```import ytree

tree_size = a.arr([t.tree_size for t in a])
imax = tree_size.argmax()
my_tree = a[imax]
print(f"Tree with most halos is {my_tree} with {my_tree.tree_size} halos.")

p = ytree.TreePlot(my_tree)
p.min_mass_ratio = 0.001
p.save("most_halos.png")
```

## Halo Age (a50)¶

Script: halo_age.py

Note

This script includes extra code to make it run within the test suite. To run conventionally, remove the lines indicated in the header of script.

One way to define the age of a halo is by calculating the scale factor when it reached 50% of its current mass. This is often referred to as “a50”. In the example below, this is calculated by linearly interpolating from the mass of the main progenitor.

```import numpy as np

def calc_a50(node):
# main progenitor masses
pmass = node["prog", "mass"]

mh = 0.5 * node["mass"]
m50 = pmass <= mh

if not m50.any():
th = node["scale_factor"]
else:
pscale = node["prog", "scale_factor"]
# linearly interpolate
i = np.where(m50)
slope = (pscale[i-1] - pscale[i]) / (pmass[i-1] - pmass[i])
th = slope * (mh - pmass[i]) + pscale[i]

node["a50"] = th
```

Then, we setup an Analysis Pipeline including this function and use `parallel_nodes` to loop over all halos in the dataset in parallel.

```import yt
yt.enable_parallelism()
import ytree

ap = ytree.AnalysisPipeline()

trees = list(a[:])
for tree in ytree.parallel_nodes(trees, filename="halo_age"):
yt.mylog.info(f"Processing {tree}.")
ap.process_target(tree)
```

Finally, we reload the saved data and print the age of the first halo.

```        if yt.is_root():
print (a2["a50"])
```

Do the following to run the script on two processors:

```\$ mpirun -np 2 python halo_age.py
```

## Significance¶

Script: halo_significance.py

Note

This script includes extra code to make it run within the test suite. To run conventionally, remove the lines indicated in the header of script.

Brought to you by John Wise, a halo’s significance is calculated by recursively summing over all ancestors the mass multiplied by the time between snapshots. When determining the main progenitor of a halo, the significance measure will select for the ancestor with the deeper history instead of just the higher mass. This can be helpful in cases of near 1:1 mergers.

First, we define a function that calculates the significance for every halo in a single tree.

```def calc_significance(node):
if node.descendent is None:
dt = 0. * node["time"]
else:
dt = node.descendent["time"] - node["time"]

sig = node["mass"] * dt
if node.ancestors is not None:
for anc in node.ancestors:
sig += calc_significance(anc)

node["significance"] = sig
return sig
```

Then, we use the The AnalysisPipeline to calculate the significance for all trees and save a new dataset. Because the `calc_significance` function defined above works on all halos in a given tree at once, we parallelize this by allocating a whole tree to each processor using the `parallel_trees` function.

```import yt
yt.enable_parallelism()
import ytree

ap = ytree.AnalysisPipeline()

trees = list(a[:])
for tree in ytree.parallel_trees(trees, filename="halo_significance"):
yt.mylog.info(f"Processing {tree}.")
ap.process_target(tree)
```

After loading the new arbor, we use the `set_selector` function to use the new significance field to determine the progenitor line.

```        if yt.is_root():
```\$ mpirun -np 2 python halo_significance.py