code.rst 9.52 KB
 Martin Reinecke committed Feb 17, 2018 1 .. currentmodule:: nifty4  Mihai Baltac committed Feb 12, 2018 2   Martin Reinecke committed Feb 17, 2018 3 4 Code Overview =============  Mihai Baltac committed Feb 12, 2018 5   Martin Reinecke committed Feb 17, 2018 6 7 The fundamental building blocks required for IFT computations are best recognized from a large distance, ignoring all technical details.  Mihai Baltac committed Feb 12, 2018 8   Martin Reinecke committed Feb 17, 2018 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 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 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 From such a perspective, - IFT problems largely consist of *minimization* problems involving a large number of equations. - The equations are built mostly from the application of *linear operators*, but there may also be nonlinear functions involved. - The unknowns in the equations represent either continuous physical *fields*, or they are simply individual measured *data* points. - The locations and volume elements attached to discretized *field* values are supplied by *domain* objects. There are many variants of such discretized *domains* supported by NIFTy4, including Cartesian and spherical geometries and their harmonic counterparts. *Fields* can live on arbitrary products of such *domains*. In the following sections, the concepts briefly presented here will be discussed in more detail; this is done in reversed order of their introduction, to avoid forward references. Domains ======= Abstract base class ------------------- One of the fundamental building blocks of the NIFTy4 framework is the *domain*. Its required capabilities are expressed by the abstract :class:Domain class. A domain must be able to answer the following queries: - its total number of data entries (pixels), which is accessible via the :attr:~Domain.size property - the shape of the array that is supposed to hold these data entries (obtainable by means of the :attr:~Domain.shape property) - equality comparison to another :class:Domain instance Unstructured domains -------------------- Domains can be either *structured* (i.e. there is geometrical information associated with them, like position in space and volume factors), or *unstructured* (meaning that the data points have no associated manifold). Unstructured domains can be described by instances of NIFTy's :class:UnstructuredDomain class. Structured domains ------------------ In contrast to unstructured domains, these domains have an assigned geometry. NIFTy requires them to provide the volume elements of their grid cells. The additional methods are specified in the abstract class :class:StructuredDomain: - The attributes :attr:~StructuredDomain.scalar_dvol, :attr:~StructuredDomain.dvol, and :attr:~StructuredDomain.total_volume provide information about the domain's pixel volume(s) and its total volume. - The property :attr:~StructuredDomain.harmonic specifies whether a domain is harmonic (i.e. describes a frequency space) or not - Iff the domain is harmonic, the methods :meth:~StructuredDomain.get_k_length_array, :meth:~StructuredDomain.get_unique_k_lengths, and :meth:~StructuredDomain.get_fft_smoothing_kernel_function provide absolute distances of the individual grid cells from the origin and assist with Gaussian convolution. NIFTy comes with several concrete subclasses of :class:StructuredDomain: - :class:RGSpace represents a regular Cartesian grid with an arbitrary number of dimensions, which is supposed to be periodic in each dimension. - :class:HPSpace and :class:GLSpace describe pixelisations of the 2-sphere; their counterpart in harmonic space is :class:LMSpace, which contains spherical harmonic coefficients. - :class:PowerSpace is used to describe one-dimensional power spectra. Among these, :class:RGSpace can be harmonic or not (depending on constructor arguments), :class:GLSpace, :class:HPSpace, and :class:PowerSpace are pure position domains (i.e. nonharmonic), and :class:LMSpace is always harmonic. Combinations of domains ======================= The fundamental classes described above are often sufficient to specify the domain of a field. In some cases, however, it will be necessary to have the field live on a product of elementary domains instead of a single one. Some examples are: - sky emission depending on location and energy. This could be represented by a product of an :class:HPSpace (for location) with an :class:RGSpace (for energy). - a polarised field, which could be modeled as a product of any structured domain representing location with a four-element :class:UnstructuredDomain holding Stokes I, Q, U and V components. Consequently, NIFTy defines a class called :class:DomainTuple holding a sequence of :class:Domain objects, which is used to specify full field domains. In principle, a :class:DomainTuple can even be empty, which implies that the field living on it is a scalar. Fields ====== A :class:Field object consists of the following components: - a domain in form of a :class:DomainTuple object - a data type (e.g. numpy.float64) - an array containing the actual values Fields support arithmetic operations, contractions, etc. Linear Operators ================ A linear operator (represented by NIFTy4's abstract :class:LinearOperator class) can be interpreted as an (implicitly defined) matrix. It can be applied to :class:Field instances, resulting in other :class:Field instances that potentially live on other domains. There are four basic ways of applying an operator :math:A to a field :math:f: - direct multiplication: :math:A\cdot f - adjoint multiplication: :math:A^\dagger \cdot f - inverse multiplication: :math:A^{-1}\cdot f - adjoint inverse multiplication: :math:(A^\dagger)^{-1}\cdot f (For linear operators, inverse adjoint multiplication and adjoint inverse multiplication are equivalent.) These different actions of an operator Op on a field f can be invoked in various ways: - direct multiplication: Op(f) or Op.times(f) or Op.apply(f, Op.TIMES) - adjoint multiplication: Op.adjoint_times(f) or Op.apply(f, Op.ADJOINT_TIMES) - inverse multiplication: Op.inverse_times(f) or Op.apply(f, Op.INVERSE_TIMES) - adjoint inverse multiplication: Op.adjoint_inverse_times(f) or Op.apply(f, Op.ADJOINT_INVERSE_TIMES) Operator classes defined in NIFTy may implement an arbitrary subset of these four operations. This subset can be queried using the :attr:~LinearOperator.capability property. If needed, the set of supported operations can be enhanced by iterative inversion methods; for example, an operator defining direct and adjoint multiplication could be enhanced to support the complete set by this method. This functionality is provided by NIFTy's :class:InversionEnabler class, which is itself a linear operator. There are two :class:DomainTuple objects associated with a :class:LinearOperator: a :attr:~LinearOperator.domain and a :attr:~LinearOperator.target. Direct multiplication and adjoint inverse multiplication transform a field living on the operator's :attr:~LinearOperator.domain to one living on the operator's :attr:~LinearOperator.target, whereas adjoint multiplication and inverse multiplication transform from :attr:~LinearOperator.target to :attr:~LinearOperator.domain. Operators with identical domain and target can be derived from :class:EndomorphicOperator; typical examples for this category are the :class:ScalingOperator, which simply multiplies its input by a scalar value, and :class:DiagonalOperator, which multiplies every value of its input field with potentially different values. Further operator classes provided by NIFTy are - :class:HarmonicTransformOperator for transforms from harmonic domain to their counterparts in position space, and their adjoint - :class:PowerDistributor for transforms from a :class:PowerSpace to the associated harmonic domain, and their adjoint - :class:GeometryRemover, which transforms from structured domains to unstructured ones. This is typically needed when building instrument response operators. Nifty4 allows simple and intuitive construction of altered and combined operators. As an example, if A, B and C are of type :class:LinearOperator and f1 and f2 are :class:Field s, writing:: X = A*B.inverse*A.adjoint + C f2 = X(f1) will perform the operation suggested intuitively by the notation, checking domain compatibility while building the composed operator. The combined operator infers its domain and target from its constituents, as well as the set of operations it can support. The properties :attr:~LinearOperator.adjoint and :attr:~LinearOperator.inverse return a new operator which behaves as if it were the original operator's adjoint or inverse, respectively. .. _minimization: Minimization ============ Most problems in IFT are solved by (possibly nested) minimizations of high-dimensional functions, which are often nonlinear. In NIFTy4 such functions are represented by objects of type :class:Energy. These hold the prescription how to calculate the function's value, gradient and (optionally) curvature at any given position. Function values are floating-point scalars, gradients have the form of fields living on the energy's position domain, and curvatures are represented by linear operator objects. Some examples of concrete energy classes delivered with NIFTy4 are :class:QuadraticEnergy (with position-independent curvature, mainly used with conjugate gradient minimization) and :class:WienerFilterEnergy. Energies are classes that typically have to be provided by the user when tackling new IFT problems. The minimization procedure can be carried out by one of several algorithms; NIFTy4 currently ships solvers based on - the conjugate gradient method (for quadratic energies) - the steepest descent method - the VL-BFGS method - the relaxed Newton method, and - a nonlinear conjugate gradient method  Mihai Baltac committed Feb 12, 2018 220