Merge branch 'NIFTy_5' into 'docstrings_torsten'

# Conflicts:
#   nifty5/operators/energy_operators.py

.gitignore

@@ -11,6 +11,7 @@ setup.cfg
 .svn/
 *.csv
 .pytest_cache/
+*.png
 
 # from https://github.com/github/gitignore/blob/master/Python.gitignore
 

demos/getting_started_3.py

@@ -46,32 +46,32 @@ if __name__ == '__main__':
     mode = 1
 
     position_space = ift.RGSpace([128, 128])
+    harmonic_space = position_space.get_default_codomain()
+    ht = ift.HarmonicTransformOperator(harmonic_space, position_space)
+    power_space = ift.PowerSpace(harmonic_space)
 
     # Set up an amplitude operator for the field
-    # The parameters mean:
-    # 64 spectral bins
-    #
-    # Spectral smoothness (affects Gaussian process part)
-    # 3 = relatively high variance of spectral curbvature
-    # 0.4 = quefrency mode below which cepstrum flattens
-    #
-    # Power-law part of spectrum:
-    # -5 = preferred power-law slope
-    # 0.5 = low variance of power-law slope
-    # 0.4 = y-intercept mean
-    # 0.3 = relatively high y-intercept variance
-    A = ift.AmplitudeOperator(position_space, 64, 3, 0.4, -5., 0.5, 0.4, 0.3)
+    dct = {
+        'target': power_space,
+        'n_pix': 64,  # 64 spectral bins
+
+        # Spectral smoothness (affects Gaussian process part)
+        'a': 3,  # relatively high variance of spectral curbvature
+        'k0': .4,  # quefrency mode below which cepstrum flattens
+
+        # Power-law part of spectrum:
+        'sm': -5,  # preferred power-law slope
+        'sv': .5,  # low variance of power-law slope
+        'im': .4,  # y-intercept mean
+        'iv': .3  # relatively high y-intercept variance
+    }
+    A = ift.AmplitudeOperator(**dct)
 
     # Build the operator for a correlated signal
-    harmonic_space = position_space.get_default_codomain()
-    ht = ift.HarmonicTransformOperator(harmonic_space, position_space)
-    power_space = A.target[0]
     power_distributor = ift.PowerDistributor(harmonic_space, power_space)
-
-    vol = ift.ScalingOperator(harmonic_space.scalar_dvol**(-0.5),
-                              harmonic_space)
-    correlated_field = ht(
-        vol(power_distributor(A))*ift.ducktape(harmonic_space, None, 'xi'))
+    vol = harmonic_space.scalar_dvol**-0.5
+    xi = ift.ducktape(harmonic_space, None, 'xi')
+    correlated_field = ht(vol*power_distributor(A)*xi)
     # Alternatively, one can use:
     # correlated_field = ift.CorrelatedField(position_space, A)
 

docs/generate.sh

-sphinx-apidoc -l -e -d 2 -o docs/source/mod nifty5
+sphinx-apidoc -e -o docs/source/mod nifty5
 sphinx-build -b html docs/source/ docs/build/

docs/source/conf.py

@@ -10,6 +10,9 @@ master_doc = 'index'
 napoleon_google_docstring = False
 napoleon_numpy_docstring = True
 napoleon_use_ivar = True
+napoleon_use_admonition_for_notes = True
+napoleon_use_admonition_for_examples = True
+napoleon_use_admonition_for_references = True
 
 project = u'NIFTy5'
 copyright = u'2013-2019, Max-Planck-Society'

nifty5/__init__.py

@@ -76,7 +76,8 @@ from .plot import Plot
 from .library.amplitude_operator import AmplitudeOperator
 from .library.inverse_gamma_operator import InverseGammaOperator
 from .library.los_response import LOSResponse
-from .library.dynamic_operator import dynamic_operator, dynamic_lightcone_operator
+from .library.dynamic_operator import (dynamic_operator,
+                                       dynamic_lightcone_operator)
 from .library.light_cone_operator import LightConeOperator
 
 from .library.wiener_filter_curvature import WienerFilterCurvature

nifty5/domain_tuple.py

@@ -103,7 +103,7 @@ class DomainTuple(object):
         """tuple of int: number of pixels along each axis
 
         The shape of the array-like object required to store information
-        living on the DomainTuple.
+        defined on the DomainTuple.
         """
         return self._shape
 
@@ -112,7 +112,7 @@ class DomainTuple(object):
         """tuple of int: number of pixels along each axis on the local task
 
         The shape of the array-like object required to store information
-        living on part of the domain which is stored on the local MPI task.
+        defined on part of the domain which is stored on the local MPI task.
         """
         from .dobj import local_shape
         return local_shape(self._shape)

nifty5/domains/domain.py

@@ -80,7 +80,7 @@ class Domain(NiftyMetaBase()):
         """tuple of int: number of pixels along each axis
 
         The shape of the array-like object required to store information
-        living on the domain.
+        defined on the domain.
         """
         raise NotImplementedError
 
@@ -89,7 +89,7 @@ class Domain(NiftyMetaBase()):
         """tuple of int: number of pixels along each axis on the local task
 
         The shape of the array-like object required to store information
-        living on part of the domain which is stored on the local MPI task.
+        defined on part of the domain which is stored on the local MPI task.
         """
         from ..dobj import local_shape
         return local_shape(self.shape)

nifty5/domains/lm_space.py

@@ -32,13 +32,13 @@ class LMSpace(StructuredDomain):
     lmax : int
         The maximum :math:`l` value of any spherical harmonic coefficient
         :math:`a_{lm}` that is represented by this object.
-        Must be :math:`\ge 0`.
+        Must be :math:`\\ge 0`.
 
     mmax : int, optional
         The maximum :math:`m` value of any spherical harmonic coefficient
         :math:`a_{lm}` that is represented by this object.
         If not supplied, it is set to `lmax`.
-        Must be :math:`\ge 0` and :math:`\le` `lmax`.
+        Must be :math:`\\ge 0` and :math:`\\le` `lmax`.
     """
 
     _needed_for_hash = ["_lmax", "_mmax"]

nifty5/domains/log_rg_space.py

@@ -38,7 +38,7 @@ class LogRGSpace(StructuredDomain):
         FIXME
     harmonic : bool, optional
         Whether the space represents a grid in position or harmonic space.
-        (default: False).
+        Default: False.
     """
     _needed_for_hash = ['_shape', '_bindistances', '_t_0', '_harmonic']
 

nifty5/domains/power_space.py

@@ -31,13 +31,13 @@ class PowerSpace(StructuredDomain):
     ----------
     harmonic_partner : StructuredDomain
         The harmonic domain of which this is the power space.
-    binbounds : None, or tuple of float (default: None)
-        if None:
-            There will be as many bins as there are distinct k-vector lengths
-            in the harmonic partner space.
-            The `binbounds` property of the PowerSpace will also be None.
+    binbounds : None, or tuple of float
+        By default (binbounds=None):
+            There are as many bins as there are distinct k-vector lengths in
+            the harmonic partner space.
+            The `binbounds` property of the PowerSpace will be None.
         else:
-            the bin bounds requested for this PowerSpace. The array
+            The bin bounds requested for this PowerSpace. The array
             must be sorted and strictly ascending. The first entry is the right
             boundary of the first bin, and the last entry is the left boundary
             of the last bin, i.e. thee will be `len(binbounds)+1` bins in

nifty5/domains/rg_space.py

@@ -31,19 +31,21 @@ class RGSpace(StructuredDomain):
     shape : int or tuple of int
         Number of grid points or numbers of gridpoints along each axis.
     distances : None or float or tuple of float, optional
-        Distance between two grid points along each axis
-        (default: None).
+        Distance between two grid points along each axis.
 
-        If distances is None:
-
-          - if harmonic==True, all distances will be set to 1
-
-          - if harmonic==False, the distance along each axis will be
+        By default (distances=None):
+          - If harmonic==True, all distances will be set to 1
+          - If harmonic==False, the distance along each axis will be
             set to the inverse of the number of points along that axis.
 
     harmonic : bool, optional
         Whether the space represents a grid in position or harmonic space.
-        (default: False).
+        Default: False.
+
+    Notes
+    -----
+    Topologically, a n-dimensional RGSpace is a n-Torus, i.e. it has periodic
+    boundary conditions.
     """
     _needed_for_hash = ["_distances", "_shape", "_harmonic"]
 

nifty5/field.py

@@ -25,7 +25,7 @@ from .domain_tuple import DomainTuple
 class Field(object):
     _scalar_dom = DomainTuple.scalar_domain()
 
-    """ The discrete representation of a continuous field over multiple spaces.
+    """The discrete representation of a continuous field over multiple spaces.
 
     In NIFTy, Fields are used to store data arrays and carry all the needed
     metainformation (i.e. the domain) for operators to be able to work on them.
@@ -159,13 +159,13 @@ class Field(object):
         Returns
         -------
         Field
-            Field living on `new_domain`, but with the same data as `self`.
+            Field defined on `new_domain`, but with the same data as `self`.
         """
         return Field(DomainTuple.make(new_domain), self._val)
 
     @staticmethod
     def from_random(random_type, domain, dtype=np.float64, **kwargs):
-        """ Draws a random field with the given parameters.
+        """Draws a random field with the given parameters.
 
         Parameters
         ----------
@@ -284,7 +284,7 @@ class Field(object):
         return res
 
     def weight(self, power=1, spaces=None):
-        """ Weights the pixels of `self` with their invidual pixel-volume.
+        """Weights the pixels of `self` with their invidual pixel-volume.
 
         Parameters
         ----------
@@ -325,7 +325,7 @@ class Field(object):
         return Field.from_local_data(self._domain, aout)
 
     def outer(self, x):
-        """ Computes the outer product of 'self' with x.
+        """Computes the outer product of 'self' with x.
 
         Parameters
         ----------
@@ -342,21 +342,21 @@ class Field(object):
         return OuterProduct(self, x.domain)(x)
 
     def vdot(self, x=None, spaces=None):
-        """ Computes the dot product of 'self' with x.
+        """Computes the dot product of 'self' with x.
 
         Parameters
         ----------
         x : Field
             x must be defined on the same domain as `self`.
 
-        spaces : None, int or tuple of int (default: None)
+        spaces : None, int or tuple of int
             The dot product is only carried out over the sub-domains in this
             tuple. If None, it is carried out over all sub-domains.
+            Default: None.
 
         Returns
         -------
-        float, complex, either scalar (for full dot products)
-                              or Field (for partial dot products)
+        float, complex, either scalar (for full dot products) or Field (for partial dot products).
         """
         if not isinstance(x, Field):
             raise TypeError("The dot-partner must be an instance of " +
@@ -375,12 +375,12 @@ class Field(object):
         return (self.conjugate()*x).sum(spaces=spaces)
 
     def norm(self, ord=2):
-        """ Computes the L2-norm of the field values.
+        """Computes the L2-norm of the field values.
 
         Parameters
         ----------
-        ord : int, default=2
-            accepted values: 1, 2, ..., np.inf
+        ord : int
+            Accepted values: 1, 2, ..., np.inf. Default: 2.
 
         Returns
         -------
@@ -390,7 +390,7 @@ class Field(object):
         return dobj.norm(self._val, ord)
 
     def conjugate(self):
-        """ Returns the complex conjugate of the field.
+        """Returns the complex conjugate of the field.
 
         Returns
         -------
@@ -441,9 +441,9 @@ class Field(object):
 
         Parameters
         ----------
-        spaces : None, int or tuple of int (default: None)
+        spaces : None, int or tuple of int
             The summation is only carried out over the sub-domains in this
-            tuple. If None, it is carried out over all sub-domains.
+            tuple. If None, it is carried out over all sub-domains. Default: None.
 
         Returns
         -------
@@ -461,9 +461,10 @@ class Field(object):
 
         Parameters
         ----------
-        spaces : None, int or tuple of int (default: None)
+        spaces : None, int or tuple of int
             The summation is only carried out over the sub-domains in this
             tuple. If None, it is carried out over all sub-domains.
+            Default: None.
 
         Returns
         -------
@@ -484,9 +485,10 @@ class Field(object):
 
         Parameters
         ----------
-        spaces : None, int or tuple of int (default: None)
+        spaces : None, int or tuple of int
             The operation is only carried out over the sub-domains in this
             tuple. If None, it is carried out over all sub-domains.
+            Default: None.
 
         Returns
         -------
@@ -544,9 +546,9 @@ class Field(object):
 
         Parameters
         ----------
-        spaces : None, int or tuple of int (default: None)
+        spaces : None, int or tuple of int
             The operation is only carried out over the sub-domains in this
-            tuple. If None, it is carried out over all sub-domains.
+            tuple. If None, it is carried out over all sub-domains. Default: None.
 
         Returns
         -------
@@ -566,9 +568,10 @@ class Field(object):
 
         Parameters
         ----------
-        spaces : None, int or tuple of int (default: None)
+        spaces : None, int or tuple of int
             The operation is only carried out over the sub-domains in this
             tuple. If None, it is carried out over all sub-domains.
+            Default: None.
 
         Returns
         -------
@@ -594,9 +597,10 @@ class Field(object):
 
         Parameters
         ----------
-        spaces : None, int or tuple of int (default: None)
+        spaces : None, int or tuple of int
             The operation is only carried out over the sub-domains in this
             tuple. If None, it is carried out over all sub-domains.
+            Default: None.
 
         Returns
         -------

nifty5/library/adjust_variances.py

@@ -30,7 +30,7 @@ def make_adjust_variances(a,
                           samples=[],
                           scaling=None,
                           ic_samp=None):
-    """ Creates a Hamiltonian for constant likelihood optimizations.
+    """Creates a Hamiltonian for constant likelihood optimizations.
 
     Constructs a Hamiltonian to solve constant likelihood optimizations of the
     form phi = a * xi under the constraint that phi remains constant.

nifty5/library/amplitude_operator.py

@@ -19,76 +19,51 @@ import numpy as np
 
 from ..domains.power_space import PowerSpace
 from ..field import Field
-from ..sugar import makeOp, sqrt
+from ..sugar import makeOp
 
 
 def _ceps_kernel(dof_space, k, a, k0):
     return a**2/(1 + (k/k0)**2)**2
 
 
-def create_cepstrum_amplitude_field(domain, cepstrum):
-    """Creates a ...
-    Writes the sum of all modes into the zero-mode.
-
-    Parameters
-    ----------
-    domain: ???
-        ???
-    cepstrum: Callable
-        ???
-    """
-
+def _create_cepstrum_amplitude_field(domain, cepstrum):
     dim = len(domain.shape)
     shape = domain.shape
-
     q_array = domain.get_k_array()
 
-    # Fill cepstrum field (all non-zero modes)
-    no_zero_modes = (slice(1, None),)*dim
-    ks = q_array[(slice(None),) + no_zero_modes]
+    # Fill all non-zero modes
+    no_zero_modes = (slice(1, None), )*dim
+    ks = q_array[(slice(None), ) + no_zero_modes]
     cepstrum_field = np.zeros(shape)
     cepstrum_field[no_zero_modes] = cepstrum(ks)
 
-    # Fill cepstrum field (zero-mode subspaces)
+    # Fill zero-mode subspaces
     for i in range(dim):
-        # Prepare indices
-        fst_dims = (slice(None),)*i
-        sl = fst_dims + (slice(1, None),)
-        sl2 = fst_dims + (0,)
-
-        # Do summation
+        fst_dims = (slice(None), )*i
+        sl = fst_dims + (slice(1, None), )
+        sl2 = fst_dims + (0, )
         cepstrum_field[sl2] = np.sum(cepstrum_field[sl], axis=i)
-
     return Field.from_global_data(domain, cepstrum_field)
 
 
-def _CepstrumOperator(logk_space, ceps_a, ceps_k, zero_mode=True):
+def CepstrumOperator(domain, a, k0):
     '''
-    Parameters
-    ----------
-    ceps_a, ceps_k0 : Smoothness parameters in ceps_kernel
-                        eg. ceps_kernel(k) = (a/(1+(k/k0)**2))**2
-                        a = ceps_a,  k0 = ceps_k0
+    .. math::
+        C(k) = \\left(\\frac{a}{1+(k/k0)^2}\\right)^2
     '''
-
     from ..operators.qht_operator import QHTOperator
     from ..operators.symmetrizing_operator import SymmetrizingOperator
-    qht = QHTOperator(target=logk_space)
+
+    # FIXME a>0 k0>0
+    qht = QHTOperator(target=domain)
     dof_space = qht.domain[0]
-    sym = SymmetrizingOperator(logk_space)
-    kern = lambda k: _ceps_kernel(dof_space, k, ceps_a, ceps_k)
-    cepstrum = create_cepstrum_amplitude_field(dof_space, kern)
+    sym = SymmetrizingOperator(domain)
+    kern = lambda k: _ceps_kernel(dof_space, k, a, k0)
+    cepstrum = _create_cepstrum_amplitude_field(dof_space, kern)