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
a = ytree.load("consistent_trees/tree_0_0_0.dat")
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
a = ytree.load("consistent_trees/tree_0_0_0.dat")
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)[0][0]
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
a = ytree.load("tiny_ctrees/locations.dat")
a.add_analysis_field("a50", "")
ap = ytree.AnalysisPipeline()
ap.add_operation(calc_a50)
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():
a2 = ytree.load("halo_age/halo_age.h5")
print (a2[0]["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
a = ytree.load("tiny_ctrees/locations.dat")
a.add_analysis_field("significance", "Msun*Myr")
ap = ytree.AnalysisPipeline()
ap.add_operation(calc_significance)
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():
a2 = ytree.load("halo_significance/halo_significance.h5")
a2.set_selector("max_field_value", "significance")
prog = list(a2[0]["prog"])
print (prog)
Do the following to run the script on two processors:
$ mpirun -np 2 python halo_significance.py