space.py 3.75 KB
Newer Older
1
2
3
4
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
5
#
6
7
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
8
9
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
11
# You should have received a copy of the GNU General Public License
12
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
Theo Steininger's avatar
Theo Steininger committed
13
14
15
16
17
#
# Copyright(C) 2013-2017 Max-Planck-Society
#
# NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik
# and financially supported by the Studienstiftung des deutschen Volkes.
Marco Selig's avatar
Marco Selig committed
18

19
20
import abc

Martin Reinecke's avatar
Martin Reinecke committed
21
from ...domain_object import DomainObject
Ultimanet's avatar
Ultimanet committed
22

23

24
class Space(DomainObject):
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
    """ The abstract base class for all NIFTy spaces.

    An instance of a space contains information about the manifolds
    geometry and enhances the functionality of DomainObject by methods that
    are needed for powerspectrum analysis and smoothing.

    Parameters
    ----------
    None

    Attributes
    ----------
    dim : np.int
        Total number of dimensionality, i.e. the number of pixels.
    harmonic : bool
        Specifies whether the space is a signal or harmonic space.
    shape : tuple of np.ints
        The shape of the space's data array.

    Raises
    ------
    TypeError
        Raised if instantiated directly.

    Notes
    -----
    `Space` is an abstract base class. In order to allow for instantiation
Martin Reinecke's avatar
Martin Reinecke committed
52
53
    the method `copy` must be implemented as well as the abstract methods
    inherited from `DomainObject`.
54
55

    """
56

57
    def __init__(self):
Martin Reinecke's avatar
Martin Reinecke committed
58
        super(Space, self).__init__()
theos's avatar
theos committed
59

60
61
    @abc.abstractproperty
    def harmonic(self):
Theo Steininger's avatar
Theo Steininger committed
62
        """ Returns True if this space is a harmonic space.
63
        """
64
        raise NotImplementedError
65

66
    def get_k_length_array(self):
Martin Reinecke's avatar
Martin Reinecke committed
67
68
        """ The length of the k vector for every pixel.
        This method is only implemented for harmonic spaces.
Theo Steininger's avatar
Theo Steininger committed
69

70
71
        Returns
        -------
Martin Reinecke's avatar
stage1    
Martin Reinecke committed
72
        numpy.ndarray
Martin Reinecke's avatar
Martin Reinecke committed
73
            An array containing the  k vector lengths
Theo Steininger's avatar
Theo Steininger committed
74

75
        """
Martin Reinecke's avatar
Martin Reinecke committed
76
        raise NotImplementedError
77

78
    def get_unique_k_lengths(self):
Martin Reinecke's avatar
Martin Reinecke committed
79
80
81
82
        """ Returns an array of floats containing the unique k vector lengths
        for this space.
        This method is only implemented for harmonic spaces.
        """
Martin Reinecke's avatar
Martin Reinecke committed
83
84
        raise NotImplementedError

85
    def get_fft_smoothing_kernel_function(self, sigma):
Theo Steininger's avatar
Theo Steininger committed
86
87
88
89
90
91
92
93
        """ This method returns a smoothing kernel function.

        This method, which is only implemented for harmonic spaces, helps
        smoothing fields that live in a position space that has this space as
        its harmonic space. The returned function multiplies field values of a
        field with a zero centered Gaussian which corresponds to a convolution
        with a Gaussian kernel and sigma standard deviation in position space.

94
95
        Parameters
        ----------
Theo Steininger's avatar
Theo Steininger committed
96
97
98
99
100
101
102
103
        sigma : float
            A real number representing a physical scale on which the smoothing
            takes place. The smoothing is defined with respect to the real
            physical field and points that are closer together than one sigma
            are blurred together. Mathematically sigma is the standard
            deviation of a convolution with a normalized, zero-centered
            Gaussian that takes place in position space.

104
105
        Returns
        -------
Theo Steininger's avatar
Theo Steininger committed
106
107
108
109
        function (array-like -> array-like)
            A smoothing operation that multiplies values with a Gaussian
            kernel.

110
        """
Theo Steininger's avatar
Theo Steininger committed
111

112
113
        raise NotImplementedError(
            "There is no generic co-smoothing kernel for Space base class.")