Source code for halotools.mock_observables.radial_profiles.radial_profile_3d

r""" Module containing the `~halotools.mock_observables.radial_profile_3d` function
used to calculate radial profiles as a function of 3d separation.
from __future__ import absolute_import, division, print_function, unicode_literals

import numpy as np
import multiprocessing
from functools import partial

from .radial_profiles_helpers import (bounds_check_sample2_quantity,
    get_normalized_rbins, enforce_maximum_search_length_3d)
from .engines import radial_profile_3d_engine

from ..mock_observables_helpers import get_num_threads, get_period, enforce_sample_respects_pbcs
from ..pair_counters.mesh_helpers import (_set_approximate_cell_sizes,
    _cell1_parallelization_indices, _enclose_in_box)
from ..pair_counters.rectangular_mesh import RectangularDoubleMesh

np.seterr(divide='ignore', invalid='ignore')  # ignore divide by zero in e.g. marked_counts/counts

__author__ = ('Andrew Hearin', )
__all__ = ('radial_profile_3d', )

[docs] def radial_profile_3d(sample1, sample2, sample2_quantity, rbins_absolute=None, rbins_normalized=None, normalize_rbins_by=None, return_counts=False, period=None, num_threads=1, approx_cell1_size=None, approx_cell2_size=None): r""" Function used to calculate the mean value of some quantity in ``sample2`` as a function of 3d distance from the points in ``sample1``. As illustrated in the Examples section below, and also in :ref:`halo_catalog_analysis_tutorial2`, the ``normalize_rbins_by`` argument allows you to optionally normalize the 3d distances according to some scaling factor defined by the points in ``sample1``. The documentation below shows how to calculate the mean mass accretion rate of ``sample2`` as a function of :math:`r / R_{\rm vir}`, the Rvir-normalized halo-centric distance from points in ``sample1``. Note that this function can also be used to calculate number density profiles of ``sample2`` points as a function of halo-centric distance from ``sample1`` points. If you are only interested in number counts, you can pass in any dummy array for the input ``sample2_quantity``, and set the ``return_counts`` argument to True. See the Examples below for an explicit demonstration. Parameters ----------- sample1 : array_like Length-*Npts1 x 3* numpy array containing 3-D positions of points. See the :ref:`mock_obs_pos_formatting` documentation page, or the Examples section below, for instructions on how to transform your coordinate position arrays into the format accepted by the ``sample1`` and ``sample2`` arguments. Length units are comoving and assumed to be in Mpc/h, here and throughout Halotools. sample2 : array_like, optional Length-*Npts2 x 3* array containing 3-D positions of points. sample2_quantity: array_like Length-*Npts2* array containing the ``sample2`` quantity whose mean value is being calculated as a function of distance from points in ``sample1``. rbins_absolute : array_like, optional Array of length *Nrbins+1* defining the boundaries of bins in which mean quantities and number counts are computed. Either ``rbins_absolute`` must be passed, or ``rbins_normalized`` and ``normalize_rbins_by`` must be passed. Length units are comoving and assumed to be in Mpc/h, here and throughout Halotools. rbins_normalized : array_like, optional Array of length *Nrbins+1* defining the bin boundaries *x*, where :math:`x = r / R_{\rm vir}`, in which mean quantities and number counts are computed. The quantity :math:`R_{\rm vir}` can vary from point to point in ``sample1`` and is passed in via the ``normalize_rbins_by`` argument. While scaling by :math:`R_{\rm vir}` is common, you are not limited to this normalization choice; in principle you can use the ``rbins_normalized`` and ``normalize_rbins_by`` arguments to scale your distances by any length-scale associated with points in ``sample1``. Default is None, in which case the ``rbins_absolute`` argument must be passed. normalize_rbins_by : array_like, optional Numpy array of length *Npts1* defining how the distance between each pair of points will be normalized. For example, if ``normalize_rbins_by`` is defined to be the virial radius of each point in ``sample1``, then the input numerical values *x* stored in ``rbins_normalized`` will be interpreted as referring to bins of :math:`x = r / R_{\rm vir}`. Default is None, in which case the input ``rbins_absolute`` argument must be passed instead of ``rbins_normalized``. Pay special attention to length-units in whatever halo catalog you are using: while Halotools-provided catalogs will always have length units pre-processed to be Mpc/h, commonly used default settings for ASCII catalogs produced by Rockstar return the ``Rvir`` column in kpc/h units, but halo centers in Mpc/h units. return_counts : bool, optional If set to True, `radial_profile_3d` will additionally return the number of pairs in each separation bin. Default is False. period : array_like, optional Length-3 sequence defining the periodic boundary conditions in each dimension. If you instead provide a single scalar, Lbox, period is assumed to be the same in all Cartesian directions. num_threads : int, optional Number of threads to use in calculation, where parallelization is performed using the python ``multiprocessing`` module. Default is 1 for a purely serial calculation, in which case a multiprocessing Pool object will never be instantiated. A string 'max' may be used to indicate that the pair counters should use all available cores on the machine. approx_cell1_size : array_like, optional Length-3 array serving as a guess for the optimal manner by how points will be apportioned into subvolumes of the simulation box. The optimum choice unavoidably depends on the specs of your machine. Default choice is to use Lbox/10 in each dimension, which will return reasonable result performance for most use-cases. Performance can vary sensitively with this parameter, so it is highly recommended that you experiment with this parameter when carrying out performance-critical calculations. approx_cell2_size : array_like, optional Analogous to ``approx_cell1_size``, but for sample2. See comments for ``approx_cell1_size`` for details. Returns -------- result : array_like Numpy array of length *Nrbins* containing the mean value of ``sample2_quantity`` as a function of 3d distance from the points in ``sample1``. counts : array_like, optional Numpy array of length *Nrbins* containing the number of pairs of points in ``sample1`` and ``sample2`` as a function of 3d distance from the points. Only returned if ``return_counts`` is set to True (default is False). Examples -------- In this example, we'll select two samples of halos, and calculate how the mass accretion of halos in the second set varies as a function of distance from the halos in the first set. For demonstration purposes we'll use fake halos provided by `~halotools.sim_manager.FakeSim`, but the same syntax works for real halos, and likewise for a mock galaxy catalog. >>> from halotools.sim_manager import FakeSim >>> halocat = FakeSim() >>> median_mass = np.median(halocat.halo_table['halo_mvir']) >>> sample1_mask = halocat.halo_table['halo_mvir'] > median_mass >>> halo_sample1 = halocat.halo_table[sample1_mask] >>> halo_sample2 = halocat.halo_table[~sample1_mask] We transform our *x, y, z* points into the array shape used by the pair-counter by taking the transpose of the result of `numpy.vstack`. This boilerplate transformation is used throughout the `~halotools.mock_observables` sub-package: >>> sample1 = np.vstack([halo_sample1['halo_x'], halo_sample1['halo_y'], halo_sample1['halo_z']]).T >>> sample2 = np.vstack([halo_sample2['halo_x'], halo_sample2['halo_y'], halo_sample2['halo_z']]).T >>> dmdt_sample2 = halo_sample2['halo_mass_accretion_rate'] >>> rbins_absolute = np.logspace(-1, 1.5, 15) >>> result1 = radial_profile_3d(sample1, sample2, dmdt_sample2, rbins_absolute=rbins_absolute, period=halocat.Lbox) The array ``result1`` contains the mean mass accretion rate of halos in ``sample2`` in the bins of distance from halos in ``sample1`` determined by ``rbins_absolute``. You can retrieve the number counts in these separation bins as follows: >>> result1, counts = radial_profile_3d(sample1, sample2, dmdt_sample2, rbins_absolute=rbins_absolute, period=halocat.Lbox, return_counts=True) Now suppose that you wish to calculate the same quantity, but instead as a function of :math:`x = r / R_{\rm vir}`. In this case, we use the ``rbins_normalized`` and ``normalize_rbins_by`` arguments. The following choices for these arguments will give us 15 separation bins linearly spaced in *x* between :math:`\frac{1}{2}R_{\rm vir}` and :math:`10R_{\rm vir}`. >>> rvir = halo_sample1['halo_rvir'] >>> rbins_normalized = np.linspace(0.5, 10, 15) >>> result1 = radial_profile_3d(sample1, sample2, dmdt_sample2, rbins_normalized=rbins_normalized, normalize_rbins_by=rvir, period=halocat.Lbox) See also --------- :ref:`halo_catalog_analysis_tutorial2` """ num_threads = get_num_threads(num_threads, enforce_max_cores=False) rbins_normalized, normalize_rbins_by = get_normalized_rbins( rbins_absolute, rbins_normalized, normalize_rbins_by, sample1) squared_normalize_rbins_by = normalize_rbins_by*normalize_rbins_by max_rbins_absolute = np.amax(rbins_normalized)*np.amax(normalize_rbins_by) period, PBCs = get_period(period) # At this point, period may still be set to None, # in which case we must remap our points inside the smallest enclosing cube # and set ``period`` equal to this cube size. if period is None: x1in, y1in, z1in, x2in, y2in, z2in, period = ( _enclose_in_box( sample1[:, 0], sample1[:, 1], sample1[:, 2], sample2[:, 0], sample2[:, 1], sample2[:, 2], min_size=[max_rbins_absolute*3.0, max_rbins_absolute*3.0, max_rbins_absolute*3.0])) else: x1in = sample1[:, 0] y1in = sample1[:, 1] z1in = sample1[:, 2] x2in = sample2[:, 0] y2in = sample2[:, 1] z2in = sample2[:, 2] xperiod, yperiod, zperiod = period enforce_maximum_search_length_3d(rbins_normalized, normalize_rbins_by, period) enforce_sample_respects_pbcs(x1in, y1in, z1in, period) enforce_sample_respects_pbcs(x2in, y2in, z2in, period) search_xlength = max_rbins_absolute search_ylength = max_rbins_absolute search_zlength = max_rbins_absolute # Compute the estimates for the cell sizes approx_cell1_size, approx_cell2_size = ( _set_approximate_cell_sizes(approx_cell1_size, approx_cell2_size, period) ) approx_x1cell_size, approx_y1cell_size, approx_z1cell_size = approx_cell1_size approx_x2cell_size, approx_y2cell_size, approx_z2cell_size = approx_cell2_size sample2_quantity = bounds_check_sample2_quantity(sample2, sample2_quantity) # Build the rectangular mesh double_mesh = RectangularDoubleMesh(x1in, y1in, z1in, x2in, y2in, z2in, approx_x1cell_size, approx_y1cell_size, approx_z1cell_size, approx_x2cell_size, approx_y2cell_size, approx_z2cell_size, search_xlength, search_ylength, search_zlength, xperiod, yperiod, zperiod, PBCs) # Create a function object that has a single argument, for parallelization purposes engine = partial(radial_profile_3d_engine, double_mesh, x1in, y1in, z1in, x2in, y2in, z2in, squared_normalize_rbins_by, sample2_quantity, rbins_normalized) # Calculate the cell1 indices that will be looped over by the engine num_threads, cell1_tuples = _cell1_parallelization_indices( double_mesh.mesh1.ncells, num_threads) # print(rbins_normalized) # print(set(normalize_rbins_by)) if num_threads > 1: pool = multiprocessing.Pool(num_threads) result = np.array(, cell1_tuples)) marked_counts, counts = result[:, 0, :], result[:, 1, :] marked_counts = np.sum(np.array(marked_counts), axis=0) counts = np.sum(np.array(counts), axis=0) pool.close() else: marked_counts, counts = engine(cell1_tuples[0]) marked_counts = np.diff(marked_counts) counts = np.diff(counts) result = marked_counts/counts if return_counts is True: return result, counts else: return result