def healpix_interp_along_axis(indata, theta_phi=None, inloc_axis=None, outloc_axis=None, axis=-1, kind='linear', bounds_error=True, fill_value=NP.nan, assume_sorted=False, nest=False): """ ----------------------------------------------------------------------------- Interpolate healpix data to specified angular locations (HEALPIX interpolation) and along one other specified axis (usually frequency axis, for instance) via SciPy interpolation. Wraps HEALPIX and SciPy interpolations into one routine. Inputs: indata [numpy array] input data to be interpolated. Must be of shape (nhpy x nax1 x nax2 x ...). Currently works only for (nhpy x nax1). nhpy is a HEALPIX compatible npix theta_phi [numpy array] spherical angle locations (in radians) at which the healpix data is to be interpolated to at each of the other given axes. It must be of size nang x 2 where nang is the number of spherical angle locations, 2 denotes theta and phi. If set to None (default), no healpix interpolation is performed inloc_axis [numpy array] locations along the axis specified in axis (to be interpolated with SciPy) in which indata is specified. It should be of size nax1, nax2, ... or naxm. Currently it works only if set to nax1 outloc_axis [numpy array] locations along the axis specified in axis to be interpolated to with SciPy. The axis over which this interpolation is to be done is specified in axis. It must be of size nout. If this is set exactly equal to inloc_axis, no interpolation along this axis is performed axis [integer] axis along which SciPy interpolation is to be done. If set to -1 (default), the interpolation happens over the last axis. Since the first axis of indata is reserved for the healpix pixels, axis must be set to 1 or above (upto indata.ndim-1). kind [str or int] Specifies the kind of interpolation as a string ('linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic' where 'slinear', 'quadratic' and 'cubic' refer to a spline interpolation of first, second or third order) or as an integer specifying the order of the spline interpolator to use. Default is 'linear'. bounds_error [bool, optional] If True, a ValueError is raised any time interpolation is attempted on a value outside of the range of x (where extrapolation is necessary). If False, out of bounds values are assigned fill_value. By default, an error is raised. fill_value [float] If provided, then this value will be used to fill in for requested points outside of the data range. If not provided, then the default is NaN. assume_sorted [bool] If False, values of inloc_axis can be in any order and they are sorted first. If True, inloc_axis has to be an array of monotonically increasing values. nest [bool] if True, the is assumed to be in NESTED ordering. Outputs: HEALPIX interpolated and SciPy interpolated output. Will be of size nang x ... x nout x ... x naxm. Currently returns an array of shape nang x nout ----------------------------------------------------------------------------- """ try: indata except NameError: raise NameError('input data not specified') if not isinstance(indata, NP.ndarray): raise TypeError('input data must be a numpy array') if theta_phi is not None: if not isinstance(theta_phi, NP.ndarray): raise TypeError('output locations must be a numpy array') if theta_phi.ndim != 2: raise ValueError('Output locations must be a 2D array') if axis == -1: axis = indata.ndim - 1 if (axis < 1) or (axis >= indata.ndim): raise ValueError('input axis out of range') if theta_phi is not None: intermediate_data_shape = list(indata.shape) intermediate_data_shape[0] = theta_phi.shape[0] intermediate_data_shape = tuple(intermediate_data_shape) intermediate_data = NP.zeros(intermediate_data_shape, dtype=NP.float64) for ax in range(1,indata.ndim): for i in xrange(indata.shape[ax]): intermediate_data[:,i] = HP.get_interp_val(indata[:,i], theta_phi[:,0], theta_phi[:,1], nest=nest) else: intermediate_data = NP.copy(indata) if outloc_axis is not None: if inloc_axis is not None: outloc_axis = outloc_axis.flatten() inloc_axis = inloc_axis.flatten() eps = 1e-8 if (outloc_axis.size == inloc_axis.size) and (NP.abs(inloc_axis-outloc_axis).max() <= eps): outdata = intermediate_data else: if kind == 'fft': df_inp = NP.mean(NP.diff(inloc_axis)) df_out = NP.mean(NP.diff(outloc_axis)) ntau = df_inp / df_out * inloc_axis.size ntau = NP.round(ntau).astype(int) tau_inp = DSP.spectral_axis(inloc_axis.size, delx=df_inp, shift=True) fftinp = NP.fft.fft(intermediate_data, axis=axis) fftinp_shifted = NP.fft.fftshift(fftinp, axes=axis) if fftinp.size % 2 == 0: fftinp_shifted[:,0] = 0.0 # Blank out the N/2 element (0 element when FFT-shifted) for conjugate symmetry npad = ntau - inloc_axis.size if npad % 2 == 0: npad_before = npad/2 npad_after = npad/2 else: npad_before = npad/2 + 1 npad_after = npad/2 fftinp_shifted_padded = NP.pad(fftinp_shifted, [(0,0), (npad_before, npad_after)], mode='constant') fftinp_padded = NP.fft.ifftshift(fftinp_shifted_padded, axes=axis) ifftout = NP.fft.ifft(fftinp_padded, axis=axis) * (1.0 * ntau / inloc_axis.size) eps_imag = 1e-10 if NP.any(NP.abs(ifftout.imag) > eps_imag): raise ValueError('Significant imaginary component has been introduced unintentionally during the FFT based interpolation. Debug the code.') else: ifftout = ifftout.real fout = DSP.spectral_axis(ntau, delx=tau_inp[1]-tau_inp[0], shift=True) fout -= fout.min() fout += inloc_axis.min() ind_outloc, ind_fout, dfreq = LKP.find_1NN(fout.reshape(-1,1), outloc_axis.reshape(-1,1), distance_ULIM=0.5*(fout[1]-fout[0]), remove_oob=True) outdata = ifftout[:,ind_fout] # npad = 2 * (outloc_axis.size - inloc_axis.size) # dt_inp = DSP.spectral_axis(2*inloc_axis.size, delx=inloc_axis[1]-inloc_axis[0], shift=True) # dt_out = DSP.spectral_axis(2*outloc_axis.size, delx=outloc_axis[1]-outloc_axis[0], shift=True) # fftinp = NP.fft.fft(NP.pad(intermediate_data, [(0,0), (0,inloc_axis.size)], mode='constant'), axis=axis) * (1.0 * outloc_axis.size / inloc_axis.size) # fftinp = NP.fft.fftshift(fftinp, axes=axis) # fftinp[0,0] = 0.0 # Blank out the N/2 element for conjugate symmetry # fftout = NP.pad(fftinp, [(0,0), (npad/2, npad/2)], mode='constant') # fftout = NP.fft.ifftshift(fftout, axes=axis) # outdata = NP.fft.ifft(fftout, axis=axis) # outdata = outdata[0,:outloc_axis.size] else: interp_func = interpolate.interp1d(inloc_axis, intermediate_data, axis=axis, kind=kind, bounds_error=bounds_error, fill_value=fill_value, assume_sorted=assume_sorted) outdata = interp_func(outloc_axis) else: raise ValueError('input inloc_axis not specified') else: outdata = intermediate_data return outdata
def rms(inp, axis=None, filter_dict=None, mask=None, verbose=True): """ ----------------------------------------------------------------------------- Estimate the rms of multi-dimensional (complex) input data along an axis (if specified). Optionally, fourier frequency filtering and masks can be used to refine the data before estimating rms. Inputs: inp [Numpy array] input data for which RMS has to be estimated. Keyword Inputs: axis [scalar integer] Axis over which FFT is performed. Default = None (last axis). Any negative value or values exceeding the number of axes in the input data will be reset to use the last axis. filter_dict [dictionary] Filter parameters in the Fourier (frequency) domain. Default is None (no filtering to be applied). If set, the filtering will be applied along the specified axis. If axis is not specified, no frequency domain filtering will be applied. This is a dictionary consisting of the following keys and info: 'freqwts' [Numpy array] frequency window of weights. Should either have same shape as inp or have number of elements equal to the number of elements in input data along specified axis. Default = None. If not set, then it will be set to a rectangular window of width specified by key 'width' (see below) and will be applied as a filter identically to the entire data along the specified axis. 'width' [scalar] Width of the frequency window as a fraction of the bandwidth. Has to be positive. Default is None. If width is None, wts should be set. One and only one among wts and width should be set. 'passband' [string scalar] String specifying the passband ('low' or 'high') to be used. Default = 'low'. mask [Numpy array] Numpy array with same dimensions as the input data. The values can be Boolean or can be integers which in turn will be converted to Boolean values. Mask values with True will be masked and ignored in the rms estimates while mask values with False will only be considered in obtaining the rms estimates. Default = None (no masking to be applied) verbose [boolean] If set to True (default), print messages indicating progress Output: RMS estimate of the input data. If the input data is complex, the output consists of rms estimate of the real and imaginary parts of the data after applying the specified filtering and/or masking. ----------------------------------------------------------------------------- """ try: inp except NameError: raise NameError('No input data specified.') if isinstance(inp, list): inp = NP.asarray(inp) elif not isinstance(inp, NP.ndarray): raise TypeError('inp must be a list or numpy array') if axis is not None: if not isinstance(axis, int): raise TypeError('axis must be an integer') else: if (axis < 0) or (axis >= len(inp.shape)): axis = len(inp.shape) - 1 if verbose: print '\tSetting axis to be the last dimension of data' tempinp = NP.copy(inp) if filter_dict is not None: if not isinstance(filter_dict, dict): raise TypeError('filter_dict must be a dictionary') else: freqwts = None if 'freqwts' in filter_dict: freqwts = filter_dict['freqwts'] width = None if 'width' in filter_dict: width = filter_dict['width'] passband = 'low' if 'passband' in filter_dict: passband = filter_dict['passband'] if verbose: print '\tInvoking fft_filter() in the DSP module...' tempinp = DSP.fft_filter(inp, axis=axis, wts=freqwts, width=width, passband=passband, verbose=verbose) if mask is not None: # Check for broadcastability if mask.shape != tempinp.shape: if mask.size != tempinp.shape[axis]: raise ValueError('mask and inp cannot be broadcast as numpy arrays') try: msk = NP.ones_like(inp) * mask.astype(NP.bool) except ValueError: raise ValueError('mask and inp cannot be broadcast as compatible numpy arrays in order to create the mask') tempinp = NP.ma.masked_array(tempinp, mask=msk) # create a masked array if NP.iscomplexobj(inp): rms = NP.std(tempinp.real, axis=axis, keepdims=True) + 1j * NP.std(tempinp.imag, axis=axis, keepdims=True) else: rms = NP.std(tempinp.real, axis=axis, keepdims=True) if len(rms.shape) < len(tempinp.shape): rms = NP.expand_dims(rms, axis) else: tempinp = NP.copy(inp) if mask is not None: if mask.shape != inp.shape: raise ValueError('mask and inp cannot be broadcasted as numpy arrays') try: msk = NP.ones_like(inp) * mask.astype(NP.bool) except ValueError: raise ValueError('mask and inp cannot be broadcast as compatible numpy arrays in order to create the mask') tempinp = NP.ma.masked_array(tempinp, mask=msk) if NP.iscomplexobj(inp): rms = NP.std(tempinp.real) + 1j * NP.std(tempinp.imag) else: rms = NP.std(tempinp.real) return rms