Skip to content

GitLab

Commit c8796913 authored by Martin Reinecke's avatar Martin Reinecke
Browse files
Options

first batch of merges

parent 94c83d36
Pipeline #11546 canceled with stage
    in 3 minutes and 30 seconds
    Hide whitespace changes
    Inline Side-by-side
    Showing with 11 additions and 550 deletions
    nifty/__init__.py
    View file @ c8796913
    ......@@ -24,8 +24,6 @@ from .version import __version__
    from keepers import MPILogger
    logger = MPILogger()
    import dummys
    # it is important to import config before d2o such that NIFTy is able to
    # pre-create d2o's configuration object with the corrected path
    from config import dependency_injector,\
    ......@@ -55,5 +53,3 @@ from operators import *
    from probing import *
    from sugar import *
    #import pyximport; pyximport.install(pyimport = True)
    nifty/basic_arithmetics.py
    View file @ c8796913
    ......@@ -26,24 +26,17 @@ __all__ = ['cos', 'sin', 'cosh', 'sinh', 'tan', 'tanh', 'arccos', 'arcsin',
    'conjugate']
    def _math_helper(x, function, inplace=False):
    def _math_helper(x, function):
    if isinstance(x, Field):
    if inplace:
    x.val.apply_scalar_function(function, inplace=True)
    result = x
    else:
    result_val = x.val.apply_scalar_function(function)
    result = x.copy_empty(dtype=result_val.dtype)
    result.val = result_val
    result_val = x.val.apply_scalar_function(function)
    result = x.copy_empty(dtype=result_val.dtype)
    result.val = result_val
    elif isinstance(x, distributed_data_object):
    result = x.apply_scalar_function(function, inplace=inplace)
    result = x.apply_scalar_function(function, inplace=False)
    else:
    result = function(np.asarray(x))
    if inplace:
    x[:] = result
    result = x
    return result
    ......
    nifty/dummys/__init__.py deleted 100644 → 0
    View file @ 94c83d36
    # NIFTy
    # Copyright (C) 2017 Theo Steininger
    #
    # Author: Theo Steininger
    #
    # 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.
    #
    # This program is distributed in the hope that it will be useful,
    # but WITHOUT ANY WARRANTY; without even the implied warranty of
    # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    # GNU General Public License for more details.
    #
    # You should have received a copy of the GNU General Public License
    # along with this program. If not, see <http://www.gnu.org/licenses/>.
    import gfft_dummy
    nifty/dummys/gfft_dummy.py deleted 100644 → 0
    View file @ 94c83d36
    ## NIFTY (Numerical Information Field Theory) has been developed at the
    ## Max-Planck-Institute for Astrophysics.
    ##
    ## Copyright (C) 2015 Max-Planck-Society
    ##
    ## Author: Michael Bell, Henrik Junklewitz, Marco Selig
    ## Project homepage: <http://www.mpa-garching.mpg.de/ift/nifty/>
    ##
    ## 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.
    ##
    ## This program is distributed in the hope that it will be useful,
    ## but WITHOUT ANY WARRANTY; without even the implied warranty of
    ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    ## See the GNU General Public License for more details.
    ##
    ## You should have received a copy of the GNU General Public License
    ## along with this program. If not, see <http://www.gnu.org/licenses/>.
    ## This is a "plain" version of gfft.py that was originally created as part of
    ## GFFT v0.1.0 by Michael Bell and Henrik Junklewitz.
    import numpy as np
    import warnings
    def gfft(inp, in_ax=[], out_ax=[], ftmachine='fft', in_zero_center=True, \
    out_zero_center=True, enforce_hermitian_symmetry=False, W=6, alpha=1.5,\
    verbose=True):
    """
    gfft (Generalized FFT)
    def gfft(inp, in_ax=[], out_ax=[], ftmachine='fft', in_zero_center=True, \
    out_zero_center=True, out_is_real=False, W=6, alpha=1.5)
    This is a generalized Fourier transformation function that can transform
    between regularly- or irregularly-spaced, 1- 2- or 3-D fields. Gridding and
    degridding is performed when irregularly spaced fields are requested.
    input
    ------------------
    inp: The input data to be transformed. This can be a 1-, 2- or 3-D
    (henceforth N-D) numpy array.
    in_ax, out_ax: The axes on which the input/output arrays are defined. There
    are a few options here depending on the types of fields that are to be
    transformed:
    To go from regularly spaced input to regularly spaced output: in can be
    an N-D array, leave in_ax and out_ax blank. No gridding is
    performed, it just does an fft or ifft directly.
    To go from irregularly spaced input to regularly spaced output: in must
    be a list of 1-D arrays, in_ax = [N*array([...])] and
    out_ax = [N*(dx, nx)]. So in_ax is a length N list of numpy arrays
    (each of length len(in)) that contain the coordinates for which the
    input data are defined. out_ax is a length N list of tuples
    containing the number of pixels and size of the pixels in the
    regularly spaced N-D out array. Gridding is performed on the input
    data before performing the fft or ifft.
    To go from regularly spaced input to irregularly spaced output: same as
    above except in_ax and out_ax are reversed. out will always be a 1D
    array. De-gridding is performed.
    To go from irregularly spaced input to irregularly spaced output: This
    gets a bit tricky. In this case either in_ax or out_ax =
    ([N x array([...])], [N x (dx, nx)]) **this is a tuple** and the
    other is just [N x array([...])] as before. In this mode, the code
    grids in, Fourier transforms, then degrids onto the coordinates
    given in out_ax. The N tuples of (nx,dx) are necessary because a
    grid must be defined in the middle even though neither the input or
    output arrays live on a grid. The grid can be defined either for the
    input or output space (which is why either in_ax or out_ax can be
    given as a tuple).
    ftmachine: a length N list of strings, with each entry containing either
    'fft' or 'ifft'. This defines whether an FFT or and IFFT should be
    performed for each axis. So, if you have a 3D dataset and you want to do
    an FFT on the first two axes, but an IFFT on the last, you would pass
    ftmachine=['fft', 'fft', 'ifft']. In principle, we could also make DFTs
    an option here, and the code would just do a DFT rather than gridding.
    For an N-D input array, one could also just use ftmachine='fft' and it
    would do an fft for all axes.
    For now, options include: 'fft', 'ifft', and 'none'.
    in_zero_center/out_zero_center: a length N list of booleans. True indicates
    that the zero frequency is in (or should be in) the central pixel, false
    indicates that it is in pixel 0. Basically this indicates whether
    fftshifts should be performed before and after Fourier transforming. For
    an N-D array, in_zero_center=T would indicate that all axes should have
    the zero channel in the central pixel.
    W, alpha: These are gridding parameters.
    enforce_hermitian_symmetry: A length N list of booleans. If the in array is
    to be gridded, setting this to 'True' indicates that the Hermitian
    conjugate of the input array needs to be generated during gridding.
    This can be set for each axis independently. This is ignored when going
    from a regular grid to another regular grid.
    output
    ------------------
    out: A numpy array that contains the FT or IFT of inp.
    """
    VERSION = "0.2.1"
    if verbose:
    print "gfft v. "+VERSION
    ############################################################################
    # Set some global variables
    # different modes of operation
    MODE_RR = 0 # regular grid to regular grid
    MODE_IR = 1 # irregular grid to regular grid
    MODE_RI = 2 # regular grid to irregular grid
    MODE_II = 3 # irregular grid to irregular grid
    mode_types = {MODE_RR:"regular to regular (no gridding)", \
    MODE_IR:"irregular to regular (gridding)", \
    MODE_RI:"regular to irregular (de-gridding)", \
    MODE_II:"irregular to irregular (gridding and degridding)"}
    # Different ftmachine options
    FTM_FFT = 'fft'
    FTM_IFFT = 'ifft'
    # FTM_NONE = 'none'
    ############################################################################
    # Validate the inputs...
    if type(inp) != np.ndarray:
    raise TypeError('inp must be a numpy array.')
    if type(in_ax) != list and type(in_ax) != tuple:
    raise TypeError('in_ax must be either a list or a tuple.')
    if type(out_ax) != list and type(out_ax) != tuple:
    raise TypeError('out_ax must be either a list or a tuple.')
    if type(out_ax) == tuple and type(in_ax) == tuple:
    raise TypeError('out_ax and in_ax cannot both be tuples')
    if type(in_ax) == tuple and (not validate_iterrable_types(in_ax, list)\
    or len(in_ax) != 2):
    raise TypeError('If in_ax is a tuple, it must contain two lists.')
    if type(out_ax) == tuple and (not validate_iterrable_types(out_ax, list)\
    or len(out_ax) != 2):
    raise TypeError('If out_ax is a tuple, it must contain two lists.')
    if type(in_ax) == tuple and \
    not validate_iterrable_types(in_ax[0], np.ndarray):
    raise TypeError('If in_ax is a tuple, it must contain two lists,' +\
    ' the first of which is a list of arrays.')
    if type(in_ax) == tuple and \
    not validate_iterrable_types(in_ax[1], tuple):
    raise TypeError('If in_ax is a tuple, it must contain two lists,' +\
    ' the second of which is a list of tuples.')
    if type(out_ax) == tuple and \
    not validate_iterrable_types(out_ax[0], np.ndarray):
    raise TypeError('If out_ax is a tuple, it must contain two lists,'+\
    ' the first of which is a list of arrays.')
    if type(out_ax) == tuple and \
    not validate_iterrable_types(out_ax[1], tuple):
    raise TypeError('If out_ax is a tuple, it must contain two lists,'+\
    ' the second of which is a list of tuples.')
    if type(W) != int:
    raise TypeError('W must be an integer.')
    if type(alpha) != float and type(alpha) != int:
    raise TypeError('alpha must be a float or int.')
    if (type(ftmachine) != str and type(ftmachine) != list) or \
    (type(ftmachine) == list and \
    not validate_iterrable_types(ftmachine, str)):
    raise TypeError('ftmachine must be a string or a list of strings.')
    if (type(in_zero_center) != bool and type(in_zero_center) != list) or \
    (type(in_zero_center) == list and \
    not validate_iterrable_types(in_zero_center, bool)):
    raise TypeError('in_zero_center must be a Bool or list of Bools.')
    if (type(out_zero_center) != bool and type(out_zero_center) != list) or \
    (type(out_zero_center) == list and \
    not validate_iterrable_types(out_zero_center, bool)):
    raise TypeError('out_zero_center must be a Bool or list of Bools.')
    if (type(enforce_hermitian_symmetry) != bool and \
    type(enforce_hermitian_symmetry) != list) or \
    (type(enforce_hermitian_symmetry) == list and \
    not validate_iterrable_types(enforce_hermitian_symmetry, bool)):
    raise TypeError('enforce_hermitian_symmetry must be a Bool '\
    +'or list of Bools.')
    ############################################################################
    # figure out how many dimensions we are talking about, and what mode we
    # want to use
    N = 0 # number of dimensions
    mode = -1
    if len(in_ax) == 0:
    # regular to regular transformation
    mode = MODE_RR
    N = inp.ndim
    if len(out_ax) != 0:
    warnings.warn('in_ax is empty, indicating regular to regular '\
    +'transformation is requested, but out_ax is not empty. '+\
    'Ignoring out_ax and proceeding with regular to regular mode.')
    elif type(in_ax)==tuple or type(out_ax)==tuple:
    # irregular to irregular transformation
    mode = MODE_II
    if type(out_ax)==tuple:
    if len(out_ax) != 2:
    raise TypeError('Invalid out_ax for '+\
    'irregular to irregular mode.')
    N = len(in_ax)
    else:
    if len(in_ax) != 2:
    raise TypeError('Invalid in_ax for '+\
    'irregular to irregular mode.')
    N = len(out_ax)
    else:
    if type(in_ax[0])==tuple:
    # regular to irregular transformation
    mode = MODE_RI
    else:
    # irregular to regular transformation
    mode = MODE_IR
    N = len(in_ax)
    if len(out_ax) != len(in_ax):
    raise TypeError('For regular to irregular mode, len(in_ax) must '+\
    'equal len(out_ax).')
    if N==0 or mode == -1:
    raise Exception('Something went wrong in setting the mode and ' \
    + 'dimensionality.')
    if N > 3 and mode != MODE_RR:
    raise Exception('Gridding has been requested for an unsupported '+\
    'number of dimensions!')
    if verbose:
    print 'Requested mode = ' + mode_types[mode]
    print "Number of dimensions = " + str(N)
    ############################################################################
    # Figure out which axes should have which transforms applied to them
    # flags to determine whether I need to use fftn and/or ifftn
    do_fft = False
    do_ifft = False
    # if you give an empty list to fftn in the axes position, nothing happens
    fftaxes = []
    ifftaxes = []
    if type(ftmachine) == str:
    if ftmachine.lower() == FTM_FFT:
    do_fft = True
    fftaxes = None
    elif ftmachine.lower() == FTM_IFFT:
    do_ifft = True
    ifftaxes = None
    elif type(ftmachine) == list:
    if len(ftmachine) != N:
    raise Exception('ftmachine is a list with invalid length')
    for i in range(len(ftmachine)):
    if ftmachine[i].lower() == FTM_FFT:
    do_fft = True
    fftaxes += [i]
    elif ftmachine[i].lower() == FTM_IFFT:
    do_ifft = True
    ifftaxes += [i]
    if (do_fft == False and do_ifft == False) or \
    (fftaxes == [] and ifftaxes == []):
    # warnings.warn('No Fourier transformation requested, only '+\
    # 'shifting will be performed!')
    if verbose:
    print "No Fourier transformation requested, only "+\
    "shifting will be performed!"
    mode = MODE_RR #Since gridding will not be needed, just use RR mode
    ############################################################################
    # figure out which axes need to be shifted (before and after FT)
    do_preshift = False
    do_postshift = False
    preshift_axes = []
    postshift_axes = []
    if type(in_zero_center) == bool:
    if in_zero_center:
    do_preshift = True
    preshift_axes = None
    elif type(in_zero_center) == list:
    if len(in_zero_center) != N:
    raise Exception('in_zero_center is a list with invalid length')
    for i in range(len(in_zero_center)):
    if in_zero_center[i]:
    do_preshift = True
    preshift_axes += [i]
    if type(out_zero_center) == bool:
    if out_zero_center:
    do_postshift = True
    postshift_axes = None
    elif type(out_zero_center) == list:
    if len(out_zero_center) != N:
    raise Exception('out_zero_center is a list with invalid length')
    for i in range(len(out_zero_center)):
    if out_zero_center[i]:
    do_postshift = True
    postshift_axes += [i]
    ############################################################################
    # figure out which axes need to be hermitianized
    hermitianized_axes = []
    if type(enforce_hermitian_symmetry) == bool:
    if enforce_hermitian_symmetry:
    for i in range(N):
    hermitianized_axes += [True]
    else:
    for i in range(N):
    hermitianized_axes += [False]
    elif type(enforce_hermitian_symmetry) == list:
    if len(enforce_hermitian_symmetry) != N:
    raise Exception('enforce_hermitian_symmetry is a list with '+\
    'invalid length')
    for i in range(len(enforce_hermitian_symmetry)):
    if enforce_hermitian_symmetry[i]:
    hermitianized_axes += [True]
    else:
    hermitianized_axes += [False]
    if len(hermitianized_axes) != N:
    raise Exception('Something went wrong when setting up the '+\
    'hermitianized_axes list!')
    ############################################################################
    # Print operation summary
    if verbose:
    print ""
    print "Axis#, FFT, IFFT, ZCIN, ZCOUT, HERM"
    for i in range(N):
    pstr = str(N)+', '
    if fftaxes == None or fftaxes.count(i)>0:
    pstr = pstr + 'True, '
    else:
    pstr = pstr + 'False, '
    if ifftaxes == None or ifftaxes.count(i)>0:
    pstr = pstr + 'True, '
    else:
    pstr = pstr + 'False, '
    if preshift_axes == None or preshift_axes.count(i)>0:
    pstr = pstr + 'True, '
    else:
    pstr = pstr + 'False, '
    if postshift_axes == None or postshift_axes.count(i)>0:
    pstr = pstr + 'True, '
    else:
    pstr = pstr + 'False, '
    if hermitianized_axes[i]:
    pstr = pstr + 'True'
    else:
    pstr = pstr + 'False'
    print pstr
    ############################################################################
    # Do MODE_RR transform
    if mode == MODE_RR:
    if do_preshift:
    inp = np.fft.fftshift(inp, axes=preshift_axes)
    if do_fft:
    out = np.fft.fftn(inp, axes=fftaxes)
    else:
    out = inp.copy()
    if do_ifft:
    out = np.fft.ifftn(out, axes=ifftaxes)
    if do_postshift:
    out = np.fft.fftshift(out, axes=postshift_axes)
    if verbose:
    print "Done!"
    print ""
    return out
    ############################################################################
    # Do MODE_IR transform
    elif mode == MODE_IR:
    raise NotImplementedError('Mode irregular-to-regular is not part of this "plain" GFFT version.')
    ############################################################################
    # Do MODE_RI transform
    elif mode == MODE_RI:
    raise NotImplementedError('Mode regular-to-irregular is not part of this "plain" GFFT version.')
    ############################################################################
    # Do MODE_II transform
    elif mode == MODE_II:
    raise NotImplementedError('Mode irregular-to-irregular is not part of this "plain" GFFT version.')
    def validate_iterrable_types(l, t):
    """
    Used to check whether the types of the items within the list or tuple l are
    of the type t. Returns True if all items are of type t, False otherwise.
    """
    is_valid = True
    for i in range(len(l)):
    if type(l[i]) != t:
    is_valid = False
    return is_valid
    nifty/field.py
    View file @ c8796913
    ......@@ -131,7 +131,7 @@ class Field(Loggable, Versionable, object):
    f=f,
    **kwargs)
    # extract the distributed_dato_object from f and apply the appropriate
    # extract the distributed_data_object from f and apply the appropriate
    # random number generator to it
    sample = f.get_val(copy=False)
    generator_function = getattr(Random, random_type)
    ......@@ -596,7 +596,7 @@ class Field(Loggable, Versionable, object):
    raise ValueError("The dot-partner must be an instance of " +
    "the NIFTy field class")
    # Compute the dot respecting the fact of discrete/continous spaces
    # Compute the dot respecting the fact of discrete/continuous spaces
    if bare:
    y = self
    else:
    ......
    nifty/minimization/line_searching/line_search.py
    View file @ c8796913
    ......@@ -46,7 +46,6 @@ class LineSearch(Loggable, object):
    derivation.
    """
    self.pk = None
    self.line_energy = None
    self.f_k_minus_1 = None
    self.prefered_initial_step_size = None
    ......
    nifty/minimization/line_searching/line_search_strong_wolfe.py
    View file @ c8796913
    ......@@ -61,7 +61,6 @@ class LineSearchStrongWolfe(LineSearch):
    self.max_step_size = max_step_size
    self.max_iterations = int(max_iterations)
    self.max_zoom_iterations = int(max_zoom_iterations)
    self._last_alpha_star = 1.
    def perform_line_search(self, energy, pk, f_k_minus_1=None):
    self._set_line_energy(energy, pk, f_k_minus_1=f_k_minus_1)
    ......@@ -147,8 +146,6 @@ class LineSearchStrongWolfe(LineSearch):
    energy_star = energy_alpha1
    self.logger.error("The line search algorithm did not converge.")
    self._last_alpha_star = alpha_star
    # extract the full energy from the line_energy
    energy_star = energy_star.energy
    ......
    nifty/minimization/vl_bfgs.py
    View file @ c8796913
    ......@@ -76,9 +76,6 @@ class InformationStore(object):
    self._ss_store = {}
    self._sy_store = {}
    self._yy_store = {}
    self._sgrad_store = {}
    self._ygrad_store = {}
    self._gradgrad_store = None
    # self.dot_matrix = {}
    ......
    nifty/operators/fft_operator/transformations/rg_transforms.py
    View file @ c8796913
    ......@@ -555,11 +555,6 @@ class NUMPYFFT(Transform):
    """
    The numpy fft pendant of a fft object.
    Parameters
    ----------
    fft_module_name : String
    Switch between the gfft module used: 'gfft' and 'gfft_dummy'
    """
    def transform(self, val, axes, **kwargs):
    ......
    nifty/operators/fft_operator/transformations/rgrgtransformation.py
    View file @ c8796913
    ......@@ -54,7 +54,7 @@ class RGRGTransformation(Transformation):
    ----------
    domain: RGSpace
    Space for which a codomain is to be generated
    cozerocenter : {bool, numpy.ndarray}, *optional*
    zerocenter : {bool, numpy.ndarray}, *optional*
    Whether or not the grid is zerocentered for each axis or not
    (default: None).
    ......@@ -66,7 +66,7 @@ class RGRGTransformation(Transformation):
    if not isinstance(domain, RGSpace):
    raise TypeError('ERROR: domain needs to be a RGSpace')
    # parse the cozerocenter input
    # parse the zerocenter input
    if zerocenter is None:
    zerocenter = domain.zerocenter
    # if the input is something scalar, cast it to a boolean
    ......
    nifty/operators/smoothing_operator/smoothing_operator.py
    View file @ c8796913
    ......@@ -33,7 +33,6 @@ class SmoothingOperator(EndomorphicOperator):
    if len(self.domain) != 1:
    raise ValueError(
    'ERROR: SmoothOperator accepts only exactly one '
    'space as input domain.'
    )
    ......
    nifty/spaces/power_space/power_indices.py
    View file @ c8796913
    ......@@ -29,7 +29,7 @@ class PowerIndices(object):