nbodykit_lab_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import nbodykit.lab as nlab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'nbodykit.cosmology' from '/Users/ding/miniconda3/lib/python3.6/site-packages/nbodykit/cosmology/__init__.py'>\n"
     ]
    }
   ],
   "source": [
    "print(nlab.cosmology)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cosmo = nlab.cosmology.Planck15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'H0': <Quantity 67.74 km / (Mpc s)>, 'Om0': 0.3075, 'sigma8': 0.8159, 'n_s': 0.9667, 'name': 'Planck15', 'Ob0': 0.0486, 'Tcmb0': <Quantity 2.7255 K>, 'Neff': 3.046, 'm_nu': <Quantity [ 0.  , 0.  , 0.06] eV>}\n"
     ]
    }
   ],
   "source": [
    "print(cosmo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "Plin = nlab.cosmology.EHPower(cosmo, redshift=0.55)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class EHPower in module nbodykit.cosmology.ehpower:\n",
      "\n",
      "class EHPower(LinearPowerBase)\n",
      " |  Eisenstein & Hu (1998) fitting function with BAO wiggles\n",
      " |  \n",
      " |  From EH 1998, Eqs. 26,28-31.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      EHPower\n",
      " |      LinearPowerBase\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, cosmo, redshift)\n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      cosmo : nbodykit.cosmology.Cosmology\n",
      " |          the cosmology instance; must have 'Ob0', 'n_s', and 'sigma8'\n",
      " |          parameters\n",
      " |      redshift : float\n",
      " |          the redshift to compute the power spectrum at\n",
      " |  \n",
      " |  transfer(self, k)\n",
      " |      Return the transfer function with BAO wiggles\n",
      " |      \n",
      " |      This is normalized to unity on large scales\n",
      " |      \n",
      " |      Paramters\n",
      " |      ---------\n",
      " |      k : float, array_like\n",
      " |          the wavenumbers in units of h/Mpc\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __abstractmethods__ = frozenset()\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from LinearPowerBase:\n",
      " |  \n",
      " |  __call__(self, k, no_BAO=False)\n",
      " |      Return the linear power spectrum in units of [Mpc/h]^3\n",
      " |      at the redshift :attr:`z`\n",
      " |      \n",
      " |      The amplitude scales with redshift through the square of the\n",
      " |      growth function, evaluated using ``cosmo.growth_function``\n",
      " |      \n",
      " |      Paramters\n",
      " |      ---------\n",
      " |      k : float, array_like\n",
      " |          the wavenumbers in units of h/Mpc\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Plin : float, array_like\n",
      " |          the linear power spectrum evaluated at k in [Mpc/h]^3\n",
      " |  \n",
      " |  sigma_r(self, r)\n",
      " |      The mass fluctuation within a sphere of radius ``R``, in\n",
      " |      units of Mpc/h\n",
      " |      \n",
      " |      The value of this function with ``R=8`` returns\n",
      " |      :attr:`sigma8`, within numerical precision\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      r : float\n",
      " |          the scale to compute the mass fluctation over, in\n",
      " |          units of `Mpc/h`\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from LinearPowerBase:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  attrs\n",
      " |      Cosmology parameters stored in `attrs` dictionary\n",
      " |  \n",
      " |  sigma8\n",
      " |      The present day value of ``sigma_r(r=8 Mpc/h)``, used to normalize\n",
      " |      the power spectrum, which is proportional to the square of this value.\n",
      " |      \n",
      " |      The power spectrum can re-normalized by setting a different\n",
      " |      value for this parameter\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(nlab.cosmology.EHPower)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class LogNormalCatalog in module nbodykit.source.catalog.lognormal:\n",
      "\n",
      "class LogNormalCatalog(nbodykit.base.catalog.CatalogSource)\n",
      " |  A catalog source containing (biased) particles that have \n",
      " |  been Poisson-sampled from a log-normal density field\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      LogNormalCatalog\n",
      " |      nbodykit.base.catalog.CatalogSource\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  Position(self)\n",
      " |      Position assumed to be in Mpc/h\n",
      " |  \n",
      " |  Velocity(self)\n",
      " |      Velocity in km/s\n",
      " |  \n",
      " |  VelocityOffset(self)\n",
      " |      The corresponding RSD offset, in Mpc/h\n",
      " |  \n",
      " |  __init__(self, Plin, nbar, BoxSize, Nmesh, bias=2.0, seed=None, cosmo=None, redshift=None, comm=None, use_cache=False)\n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      Plin : callable\n",
      " |          callable specifying the linear power spectrum\n",
      " |      nbar : float\n",
      " |          the number density of the particles in the box, assumed constant across the box; \n",
      " |          this is used when Poisson sampling the density field\n",
      " |      BoxSize : float, 3-vector of floats\n",
      " |          the size of the box to generate the grid on\n",
      " |      Nmesh : int\n",
      " |          the mesh size to use when generating the density and displacement fields, which\n",
      " |          are Poisson-sampled to particles\n",
      " |      bias : float, optional\n",
      " |          the desired bias of the particles; applied while applying a log-normal transformation\n",
      " |          to the density field\n",
      " |      seed : int, optional\n",
      " |          the global random seed; if set to ``None``, the seed will be set randomly\n",
      " |      cosmo : nbodykit.cosmology.Cosmology, optional\n",
      " |          this must be supplied if `Plin` does not carry ``cosmo`` attribute\n",
      " |      redshift : float, optional\n",
      " |          this must be supplied if `Plin` does not carry a ``redshift`` attribute\n",
      " |      comm : MPI Communicator, optional\n",
      " |          the MPI communicator instance; default (``None``) sets to the\n",
      " |          current communicator  \n",
      " |      use_cache : bool, optional\n",
      " |          whether to cache data read from disk; default is ``False``\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  size\n",
      " |      The number of particles in the source on the local rank. This\n",
      " |      property must be defined for all subclasses\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __abstractmethods__ = frozenset()\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  Selection(self)\n",
      " |      Override the ``Selection`` column to select a subset slice of a\n",
      " |      CatalogSource.\n",
      " |      \n",
      " |      By default, this column is set to ``True`` for all particles.\n",
      " |  \n",
      " |  Weight(self)\n",
      " |      When interpolating a CatalogSource on to a mesh, the value of this\n",
      " |      array is used as the Weight that each particle contributes to a given\n",
      " |      mesh cell.\n",
      " |      \n",
      " |      By default, this array is set to unity for all particles\n",
      " |  \n",
      " |  __contains__(self, col)\n",
      " |  \n",
      " |  __getitem__(self, sel)\n",
      " |      The following types of indexing supported are supported\n",
      " |      for CatalogSource:\n",
      " |      \n",
      " |          1.  strings specifying a column in the CatalogSource; returns\n",
      " |              a dask array holding the column data\n",
      " |          2.  boolean arrays specifying a slice of the CatalogSource;\n",
      " |              returns a CatalogSubset holding only the revelant slice\n",
      " |          3.  slice object specifying which particles to select\n",
      " |  \n",
      " |  __iter__(self)\n",
      " |  \n",
      " |  __len__(self)\n",
      " |      The length of CatalogSource is equal to :attr:`size`; this is the\n",
      " |      local size of the source on a given rank\n",
      " |  \n",
      " |  __setitem__(self, col, value)\n",
      " |      Add columns to the CatalogSource, overriding any existing columns\n",
      " |      with the name ``col``\n",
      " |  \n",
      " |  compute(self, *args, **kwargs)\n",
      " |      Our version of :func:`dask.compute` that computes\n",
      " |      multiple delayed dask collections at once\n",
      " |      \n",
      " |      This should be called on the return value of :func:`read`\n",
      " |      to converts any dask arrays to numpy arrays\n",
      " |      \n",
      " |      Parameters\n",
      " |      -----------\n",
      " |      args : object\n",
      " |          Any number of objects. If the object is a dask\n",
      " |          collection, it's computed and the result is returned.\n",
      " |          Otherwise it's passed through unchanged.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The dask default optimizer induces too many (unnecesarry)\n",
      " |      IO calls -- we turn this off feature off by default.\n",
      " |      \n",
      " |      Eventually we want our own optimizer probably.\n",
      " |  \n",
      " |  get_hardcolumn(self, col)\n",
      " |      Construct and return a hard-coded column. These are usually produced by calling\n",
      " |      member functions marked by the @column decorator.\n",
      " |      \n",
      " |      Subclasses may override this method and the hardcolumns attribute to bypass\n",
      " |      the decorator logic.\n",
      " |  \n",
      " |  read(self, columns)\n",
      " |      Return the requested columns as dask arrays\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      columns : list of str\n",
      " |          the names of the requested columns\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of dask.array.Array :\n",
      " |          the list of column data, in the form of dask arrays\n",
      " |  \n",
      " |  save(self, output, columns, datasets=None, header='Header')\n",
      " |      Save the CatalogSource to a :class:`bigfile.BigFile`\n",
      " |      \n",
      " |      Only the selected columns are saved and :attr:`attrs` are saved in\n",
      " |      ``header``. The attrs of columns are stored in the datasets.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      output : str\n",
      " |          the name of the file to write to\n",
      " |      columns : list of str\n",
      " |          the names of the columns to save in the file\n",
      " |      datasets : list of str, optional\n",
      " |          names for the data set where each column is stored; defaults to\n",
      " |          the name of the column\n",
      " |      header : str, optional\n",
      " |          the name of the data set holding the header information, where\n",
      " |          :attr:`attrs` is stored\n",
      " |  \n",
      " |  to_mesh(self, Nmesh=None, BoxSize=None, dtype='f4', interlaced=False, compensated=False, window='cic', weight='Weight', selection='Selection')\n",
      " |      Convert the CatalogSource to a MeshSource\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      Nmesh : int, optional\n",
      " |          the number of cells per side on the mesh; must be provided if\n",
      " |          not stored in :attr:`attrs`\n",
      " |      BoxSize : scalar, 3-vector, optional\n",
      " |          the size of the box; must be provided if\n",
      " |          not stored in :attr:`attrs`\n",
      " |      dtype : string, optional\n",
      " |          the data type of the mesh array\n",
      " |      interlaced : bool, optional\n",
      " |          use the interlacing technique of Sefusatti et al. 2015 to reduce\n",
      " |          the effects of aliasing on Fourier space quantities computed\n",
      " |          from the mesh\n",
      " |      compensated : bool, optional\n",
      " |          whether to correct for the window introduced by the grid\n",
      " |          interpolation scheme\n",
      " |      window : str, optional\n",
      " |          the string specifying which window interpolation scheme to use;\n",
      " |          see `pmesh.window.methods`\n",
      " |      weight : str, optional\n",
      " |          the name of the column specifying the weight for each particle\n",
      " |      selection : str, optional\n",
      " |          the name of the column that specifies which (if any) slice\n",
      " |          of the CatalogSource to take\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      mesh : CatalogMeshSource\n",
      " |          a mesh object that provides an interface for gridding particle\n",
      " |          data onto a specified mesh\n",
      " |  \n",
      " |  update_csize(self)\n",
      " |      Set the collective size, :attr:`csize`\n",
      " |      \n",
      " |      This function should be called in :func:`__init__` of a subclass,\n",
      " |      after :attr:`size` has been set to a valid value (not ``NotImplemented``)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  make_column(array)\n",
      " |      Utility function to convert a numpy array to a column object\n",
      " |      (dask.array.Array)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  attrs\n",
      " |      Dictionary storing relevant meta-data\n",
      " |  \n",
      " |  columns\n",
      " |      All columns in this Source, which include:\n",
      " |      \n",
      " |          1.  the columns hard-coded into the class's defintion\n",
      " |          2.  override columns provided by the user\n",
      " |  \n",
      " |  csize\n",
      " |      The total, collective size of the Source, i.e., summed across all\n",
      " |      ranks.\n",
      " |      \n",
      " |      It is the sum of :attr:`size` across all available ranks.\n",
      " |  \n",
      " |  hardcolumns\n",
      " |      A list of the hard-coded columns in the Source. These are usually\n",
      " |      member functions marked by @column decorator.\n",
      " |      \n",
      " |      Subclasses may override this method and :func:`get_hardcolumn` to bypass\n",
      " |      the decorator logic.\n",
      " |  \n",
      " |  use_cache\n",
      " |      If set to ``True``, use the builtin cache features of ``dask``\n",
      " |      to cache data in memory\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  logger = <Logger CatalogSource (WARNING)>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(nlab.LogNormalCatalog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class ArrayCatalog in module nbodykit.source.catalog.array:\n",
      "\n",
      "class ArrayCatalog(nbodykit.base.catalog.CatalogSource)\n",
      " |  A catalog source initialized from a dictionary or structred ndarray object\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      ArrayCatalog\n",
      " |      nbodykit.base.catalog.CatalogSource\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, data, comm=None, use_cache=False, **kwargs)\n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      data : dict or ndarray\n",
      " |          a dictionary or structured ndarray; items are interpreted\n",
      " |          as the columns of the catalog; the length of any item is used\n",
      " |          as the size of the catalogue.\n",
      " |      comm : MPI Communicator, optional\n",
      " |          the MPI communicator instance; default (``None``) sets to the\n",
      " |          current communicator  \n",
      " |      use_cache : bool, optional\n",
      " |          whether to cache data read from disk; default is ``False``\n",
      " |      **kwargs : \n",
      " |          additional keywords to store as meta-data in :attr:`attrs`\n",
      " |  \n",
      " |  get_hardcolumn(self, col)\n",
      " |      Return a column from the underlying file source\n",
      " |      \n",
      " |      Columns are returned as dask arrays\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  hardcolumns\n",
      " |      The union of the columns in the file and any transformed columns\n",
      " |  \n",
      " |  size\n",
      " |      The number of particles in the source on the local rank. This\n",
      " |      property must be defined for all subclasses\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __abstractmethods__ = frozenset()\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  Selection(self)\n",
      " |      Override the ``Selection`` column to select a subset slice of a\n",
      " |      CatalogSource.\n",
      " |      \n",
      " |      By default, this column is set to ``True`` for all particles.\n",
      " |  \n",
      " |  Weight(self)\n",
      " |      When interpolating a CatalogSource on to a mesh, the value of this\n",
      " |      array is used as the Weight that each particle contributes to a given\n",
      " |      mesh cell.\n",
      " |      \n",
      " |      By default, this array is set to unity for all particles\n",
      " |  \n",
      " |  __contains__(self, col)\n",
      " |  \n",
      " |  __getitem__(self, sel)\n",
      " |      The following types of indexing supported are supported\n",
      " |      for CatalogSource:\n",
      " |      \n",
      " |          1.  strings specifying a column in the CatalogSource; returns\n",
      " |              a dask array holding the column data\n",
      " |          2.  boolean arrays specifying a slice of the CatalogSource;\n",
      " |              returns a CatalogSubset holding only the revelant slice\n",
      " |          3.  slice object specifying which particles to select\n",
      " |  \n",
      " |  __iter__(self)\n",
      " |  \n",
      " |  __len__(self)\n",
      " |      The length of CatalogSource is equal to :attr:`size`; this is the\n",
      " |      local size of the source on a given rank\n",
      " |  \n",
      " |  __setitem__(self, col, value)\n",
      " |      Add columns to the CatalogSource, overriding any existing columns\n",
      " |      with the name ``col``\n",
      " |  \n",
      " |  compute(self, *args, **kwargs)\n",
      " |      Our version of :func:`dask.compute` that computes\n",
      " |      multiple delayed dask collections at once\n",
      " |      \n",
      " |      This should be called on the return value of :func:`read`\n",
      " |      to converts any dask arrays to numpy arrays\n",
      " |      \n",
      " |      Parameters\n",
      " |      -----------\n",
      " |      args : object\n",
      " |          Any number of objects. If the object is a dask\n",
      " |          collection, it's computed and the result is returned.\n",
      " |          Otherwise it's passed through unchanged.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The dask default optimizer induces too many (unnecesarry)\n",
      " |      IO calls -- we turn this off feature off by default.\n",
      " |      \n",
      " |      Eventually we want our own optimizer probably.\n",
      " |  \n",
      " |  read(self, columns)\n",
      " |      Return the requested columns as dask arrays\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      columns : list of str\n",
      " |          the names of the requested columns\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of dask.array.Array :\n",
      " |          the list of column data, in the form of dask arrays\n",
      " |  \n",
      " |  save(self, output, columns, datasets=None, header='Header')\n",
      " |      Save the CatalogSource to a :class:`bigfile.BigFile`\n",
      " |      \n",
      " |      Only the selected columns are saved and :attr:`attrs` are saved in\n",
      " |      ``header``. The attrs of columns are stored in the datasets.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      output : str\n",
      " |          the name of the file to write to\n",
      " |      columns : list of str\n",
      " |          the names of the columns to save in the file\n",
      " |      datasets : list of str, optional\n",
      " |          names for the data set where each column is stored; defaults to\n",
      " |          the name of the column\n",
      " |      header : str, optional\n",
      " |          the name of the data set holding the header information, where\n",
      " |          :attr:`attrs` is stored\n",
      " |  \n",
      " |  to_mesh(self, Nmesh=None, BoxSize=None, dtype='f4', interlaced=False, compensated=False, window='cic', weight='Weight', selection='Selection')\n",
      " |      Convert the CatalogSource to a MeshSource\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      Nmesh : int, optional\n",
      " |          the number of cells per side on the mesh; must be provided if\n",
      " |          not stored in :attr:`attrs`\n",
      " |      BoxSize : scalar, 3-vector, optional\n",
      " |          the size of the box; must be provided if\n",
      " |          not stored in :attr:`attrs`\n",
      " |      dtype : string, optional\n",
      " |          the data type of the mesh array\n",
      " |      interlaced : bool, optional\n",
      " |          use the interlacing technique of Sefusatti et al. 2015 to reduce\n",
      " |          the effects of aliasing on Fourier space quantities computed\n",
      " |          from the mesh\n",
      " |      compensated : bool, optional\n",
      " |          whether to correct for the window introduced by the grid\n",
      " |          interpolation scheme\n",
      " |      window : str, optional\n",
      " |          the string specifying which window interpolation scheme to use;\n",
      " |          see `pmesh.window.methods`\n",
      " |      weight : str, optional\n",
      " |          the name of the column specifying the weight for each particle\n",
      " |      selection : str, optional\n",
      " |          the name of the column that specifies which (if any) slice\n",
      " |          of the CatalogSource to take\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      mesh : CatalogMeshSource\n",
      " |          a mesh object that provides an interface for gridding particle\n",
      " |          data onto a specified mesh\n",
      " |  \n",
      " |  update_csize(self)\n",
      " |      Set the collective size, :attr:`csize`\n",
      " |      \n",
      " |      This function should be called in :func:`__init__` of a subclass,\n",
      " |      after :attr:`size` has been set to a valid value (not ``NotImplemented``)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  make_column(array)\n",
      " |      Utility function to convert a numpy array to a column object\n",
      " |      (dask.array.Array)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  attrs\n",
      " |      Dictionary storing relevant meta-data\n",
      " |  \n",
      " |  columns\n",
      " |      All columns in this Source, which include:\n",
      " |      \n",
      " |          1.  the columns hard-coded into the class's defintion\n",
      " |          2.  override columns provided by the user\n",
      " |  \n",
      " |  csize\n",
      " |      The total, collective size of the Source, i.e., summed across all\n",
      " |      ranks.\n",
      " |      \n",
      " |      It is the sum of :attr:`size` across all available ranks.\n",
      " |  \n",
      " |  use_cache\n",
      " |      If set to ``True``, use the builtin cache features of ``dask``\n",
      " |      to cache data in memory\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  logger = <Logger CatalogSource (WARNING)>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(nlab.ArrayCatalog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class ArrayCatalog in module nbodykit.source.catalog.array:\n",
      "\n",
      "class ArrayCatalog(nbodykit.base.catalog.CatalogSource)\n",
      " |  A catalog source initialized from a dictionary or structred ndarray object\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      ArrayCatalog\n",
      " |      nbodykit.base.catalog.CatalogSource\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, data, comm=None, use_cache=False, **kwargs)\n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      data : dict or ndarray\n",
      " |          a dictionary or structured ndarray; items are interpreted\n",
      " |          as the columns of the catalog; the length of any item is used\n",
      " |          as the size of the catalogue.\n",
      " |      comm : MPI Communicator, optional\n",
      " |          the MPI communicator instance; default (``None``) sets to the\n",
      " |          current communicator  \n",
      " |      use_cache : bool, optional\n",
      " |          whether to cache data read from disk; default is ``False``\n",
      " |      **kwargs : \n",
      " |          additional keywords to store as meta-data in :attr:`attrs`\n",
      " |  \n",
      " |  get_hardcolumn(self, col)\n",
      " |      Return a column from the underlying file source\n",
      " |      \n",
      " |      Columns are returned as dask arrays\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  hardcolumns\n",
      " |      The union of the columns in the file and any transformed columns\n",
      " |  \n",
      " |  size\n",
      " |      The number of particles in the source on the local rank. This\n",
      " |      property must be defined for all subclasses\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __abstractmethods__ = frozenset()\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  Selection(self)\n",
      " |      Override the ``Selection`` column to select a subset slice of a\n",
      " |      CatalogSource.\n",
      " |      \n",
      " |      By default, this column is set to ``True`` for all particles.\n",
      " |  \n",
      " |  Weight(self)\n",
      " |      When interpolating a CatalogSource on to a mesh, the value of this\n",
      " |      array is used as the Weight that each particle contributes to a given\n",
      " |      mesh cell.\n",
      " |      \n",
      " |      By default, this array is set to unity for all particles\n",
      " |  \n",
      " |  __contains__(self, col)\n",
      " |  \n",
      " |  __getitem__(self, sel)\n",
      " |      The following types of indexing supported are supported\n",
      " |      for CatalogSource:\n",
      " |      \n",
      " |          1.  strings specifying a column in the CatalogSource; returns\n",
      " |              a dask array holding the column data\n",
      " |          2.  boolean arrays specifying a slice of the CatalogSource;\n",
      " |              returns a CatalogSubset holding only the revelant slice\n",
      " |          3.  slice object specifying which particles to select\n",
      " |  \n",
      " |  __iter__(self)\n",
      " |  \n",
      " |  __len__(self)\n",
      " |      The length of CatalogSource is equal to :attr:`size`; this is the\n",
      " |      local size of the source on a given rank\n",
      " |  \n",
      " |  __setitem__(self, col, value)\n",
      " |      Add columns to the CatalogSource, overriding any existing columns\n",
      " |      with the name ``col``\n",
      " |  \n",
      " |  compute(self, *args, **kwargs)\n",
      " |      Our version of :func:`dask.compute` that computes\n",
      " |      multiple delayed dask collections at once\n",
      " |      \n",
      " |      This should be called on the return value of :func:`read`\n",
      " |      to converts any dask arrays to numpy arrays\n",
      " |      \n",
      " |      Parameters\n",
      " |      -----------\n",
      " |      args : object\n",
      " |          Any number of objects. If the object is a dask\n",
      " |          collection, it's computed and the result is returned.\n",
      " |          Otherwise it's passed through unchanged.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The dask default optimizer induces too many (unnecesarry)\n",
      " |      IO calls -- we turn this off feature off by default.\n",
      " |      \n",
      " |      Eventually we want our own optimizer probably.\n",
      " |  \n",
      " |  read(self, columns)\n",
      " |      Return the requested columns as dask arrays\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      columns : list of str\n",
      " |          the names of the requested columns\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list of dask.array.Array :\n",
      " |          the list of column data, in the form of dask arrays\n",
      " |  \n",
      " |  save(self, output, columns, datasets=None, header='Header')\n",
      " |      Save the CatalogSource to a :class:`bigfile.BigFile`\n",
      " |      \n",
      " |      Only the selected columns are saved and :attr:`attrs` are saved in\n",
      " |      ``header``. The attrs of columns are stored in the datasets.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      output : str\n",
      " |          the name of the file to write to\n",
      " |      columns : list of str\n",
      " |          the names of the columns to save in the file\n",
      " |      datasets : list of str, optional\n",
      " |          names for the data set where each column is stored; defaults to\n",
      " |          the name of the column\n",
      " |      header : str, optional\n",
      " |          the name of the data set holding the header information, where\n",
      " |          :attr:`attrs` is stored\n",
      " |  \n",
      " |  to_mesh(self, Nmesh=None, BoxSize=None, dtype='f4', interlaced=False, compensated=False, window='cic', weight='Weight', selection='Selection')\n",
      " |      Convert the CatalogSource to a MeshSource\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      Nmesh : int, optional\n",
      " |          the number of cells per side on the mesh; must be provided if\n",
      " |          not stored in :attr:`attrs`\n",
      " |      BoxSize : scalar, 3-vector, optional\n",
      " |          the size of the box; must be provided if\n",
      " |          not stored in :attr:`attrs`\n",
      " |      dtype : string, optional\n",
      " |          the data type of the mesh array\n",
      " |      interlaced : bool, optional\n",
      " |          use the interlacing technique of Sefusatti et al. 2015 to reduce\n",
      " |          the effects of aliasing on Fourier space quantities computed\n",
      " |          from the mesh\n",
      " |      compensated : bool, optional\n",
      " |          whether to correct for the window introduced by the grid\n",
      " |          interpolation scheme\n",
      " |      window : str, optional\n",
      " |          the string specifying which window interpolation scheme to use;\n",
      " |          see `pmesh.window.methods`\n",
      " |      weight : str, optional\n",
      " |          the name of the column specifying the weight for each particle\n",
      " |      selection : str, optional\n",
      " |          the name of the column that specifies which (if any) slice\n",
      " |          of the CatalogSource to take\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      mesh : CatalogMeshSource\n",
      " |          a mesh object that provides an interface for gridding particle\n",
      " |          data onto a specified mesh\n",
      " |  \n",
      " |  update_csize(self)\n",
      " |      Set the collective size, :attr:`csize`\n",
      " |      \n",
      " |      This function should be called in :func:`__init__` of a subclass,\n",
      " |      after :attr:`size` has been set to a valid value (not ``NotImplemented``)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  make_column(array)\n",
      " |      Utility function to convert a numpy array to a column object\n",
      " |      (dask.array.Array)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  attrs\n",
      " |      Dictionary storing relevant meta-data\n",
      " |  \n",
      " |  columns\n",
      " |      All columns in this Source, which include:\n",
      " |      \n",
      " |          1.  the columns hard-coded into the class's defintion\n",
      " |          2.  override columns provided by the user\n",
      " |  \n",
      " |  csize\n",
      " |      The total, collective size of the Source, i.e., summed across all\n",
      " |      ranks.\n",
      " |      \n",
      " |      It is the sum of :attr:`size` across all available ranks.\n",
      " |  \n",
      " |  use_cache\n",
      " |      If set to ``True``, use the builtin cache features of ``dask``\n",
      " |      to cache data in memory\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from nbodykit.base.catalog.CatalogSource:\n",
      " |  \n",
      " |  logger = <Logger CatalogSource (WARNING)>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(nlab.ArrayCatalog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = nlab.LogNormalCatalog(Plin=Plin, nbar=3.e-7, BoxSize=1380., Nmesh=8, seed=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cosmo.H0': 67.74, 'cosmo.Om0': 0.3075, 'cosmo.sigma8': 0.8159, 'cosmo.n_s': 0.9667, 'cosmo.name': 'Planck15', 'cosmo.Ob0': 0.0486, 'cosmo.Tcmb0': 2.7255, 'cosmo.Neff': 3.046, 'cosmo.m_nu': array([ 0.  ,  0.  ,  0.06]), 'nbar': 3e-07, 'redshift': 0.55, 'bias': 2.0, 'seed': 42, 'Nmesh': array([8, 8, 8]), 'BoxSize': array([ 1380.,  1380.,  1380.])}\n"
     ]
    }
   ],
   "source": [
    "print(source.attrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogNormalCatalog(seed=42, bias=2)\n"
     ]
    }
   ],
   "source": [
    "print(source)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "source['Position'] += source['VelocityOffset']*[0, 0, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute P(k,mu) and multipoles\n",
    "result = nlab.FFTPower(source, mode='2d', poles=[0,2,4], los=[0,0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<DataSet: dims: (k: 4, mu: 5), variables: ('k', 'mu', 'power', 'modes')>\n"
     ]
    }
   ],
   "source": [
    "print(result.power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and save\n",
    "output = \"./nbkit_example_power.json\"\n",
    "result.save(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}