docs

nifty4/operators/diagonal_operator.py

@@ -35,18 +35,13 @@ class DiagonalOperator(EndomorphicOperator):
     Parameters
     ----------
     diagonal : Field
-        The diagonal entries of the operator
-        (already containing volume factors).
-    domain : tuple of DomainObjects
+        The diagonal entries of the operator.
+    domain : Domain, tuple of Domain or DomainTuple, optional
         The domain on which the Operator's input Field lives.
         If None, use the domain of "diagonal".
-    spaces : tuple of int
+    spaces : int or tuple of int, optional
         The elements of "domain" on which the operator acts.
         If None, it acts on all elements.
-
-    NOTE: the fields given to __init__ and returned from .diagonal are
-    considered to be non-bare, i.e. during operator application, no additional
-    volume factors are applied!
     """
 
     def __init__(self, diagonal, domain=None, spaces=None):

nifty4/operators/fft_operator.py

@@ -30,15 +30,16 @@ class FFTOperator(LinearOperator):
 
     Parameters
     ----------
-    domain: Space, tuple of Spaces or DomainObject
+    domain: Domain, tuple of Domain o DomainTuple
         The domain of the data that is input by "times" and output by
         "adjoint_times".
-    target: Space
-        The target space of the transform operation.
-        If omitted, a space will be chosen automatically.
-    space: the index of the space on which the operator should act
-        If None, it is set to 0 if domain contains exactly one space.
-        domain[space] must be an RGSpace.
+    target: Domain, optional
+        The target (sub-)domain of the transform operation.
+        If omitted, a domain will be chosen automatically.
+    space: int, optional
+        The index of the subdomain on which the operator should act
+        If None, it is set to 0 if `domain` contains exactly one space.
+        `domain[space]` must be an RGSpace.
     """
 
     def __init__(self, domain, target=None, space=None):

nifty4/operators/fft_smoothing_operator.py

@@ -32,12 +32,10 @@ def FFTSmoothingOperator(domain, sigma, space=None):
     ----------
     domain : Domain, tuple of Domain, or DomainTuple
        The total domain of the operator's input and output fields
-
     sigma : float>=0
        The sigma of the Gaussian used for smoothing. It has the same units as
        the RGSpace the operator is working on.
        If `sigma==0`, an identity operator will be returned.
-
     space : int, optional
        The index of the sub-domain on which the smoothing is performed.
        Can be omitted if `domain` only has one sub-domain.

nifty4/operators/geometry_remover.py

@@ -23,7 +23,19 @@ from .linear_operator import LinearOperator
 
 class GeometryRemover(LinearOperator):
     """Operator which transforms between a structured and an unstructured
-    domain."""
+    domain.
+
+    Parameters
+    ----------
+    domain: Domain, tuple of Domain, or DomainTuple:
+        the full input domain of the operator.
+
+    Notes
+    -----
+    The operator will convert every sub-domain of its input domain to an
+    UnstructuredDomain with the same shape. No weighting by volume factors
+    is carried out.
+    """
 
     def __init__(self, domain):
         super(GeometryRemover, self).__init__()

nifty4/operators/power_distributor.py

@@ -23,7 +23,20 @@ from ..domains.power_space import PowerSpace
 
 
 class PowerDistributor(DOFDistributor):
-    """Operator which transforms between a PowerSpace and a harmonic domain."""
+    """Operator which transforms between a PowerSpace and a harmonic domain.
+
+    Parameters
+    ----------
+    target: Domain, tuple of Domain, or DomainTuple
+        the total *target* domain of the operator.
+    power_space: PowerSpace, optional
+        the input sub-domain on which the operator acts.
+        If not supplied, a matching PowerSpace with natural binbounds will be
+        used.
+    space: int, optional:
+       The index of the sub-domain on which the operator acts.
+       Can be omitted if `target` only has one sub-domain.
+    """
 
     def __init__(self, target, power_space=None, space=None):
         # Initialize domain and target

nifty4/operators/scaling_operator.py

@@ -33,7 +33,7 @@ class ScalingOperator(EndomorphicOperator):
     ----------
     factor : scalar
         The multiplication factor
-    domain : tuple of DomainObjects
+    domain : Domain or tuple of Domain or DomainTuple
         The domain on which the Operator's input Field lives.
     """
 

nifty4/operators/smoothness_operator.py

@@ -35,11 +35,16 @@ def SmoothnessOperator(domain, strength=1., logarithmic=True, space=None):
 
     Parameters
     ----------
+    domain : Domain, tuple of Domain, or DomainTuple
+       The total domain of the operator's input and output fields
     strength : nonnegative float
         Specifies the strength of the SmoothnessOperator
     logarithmic : bool, optional
         Whether smoothness is calculated on a logarithmic scale or linear scale
         default : True
+    space : int, optional
+       The index of the sub-domain on which the operator acts.
+       Can be omitted if `domain` only has one sub-domain.
     """
     if strength < 0:
         raise ValueError("ERROR: strength must be nonnegative.")