hawc_hal.psf_fast.psf_convolutor

Complexity

Total Complexity

4

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	PSFConvolutor.kernel()	0	3	1
A	PSFConvolutor.__init__()	0	38	1
A	PSFConvolutor.extended_source_image()	0	11	1

import numpy as np

This module should have a docstring.

from numpy.fft import rfftn, irfftn
#from scipy.signal import fftconvolve
from scipy.fftpack import helper


from psf_interpolator import PSFInterpolator

Relative import 'psf_interpolator', should be 'hawc_hal.psf_fast.psf_interpolator'

from psf_wrapper import PSFWrapper

Relative import 'psf_wrapper', should be 'hawc_hal.psf_fast.psf_wrapper'

Unused PSFWrapper imported from psf_wrapper

class PSFConvolutor(object):

This class should have a docstring.

    def __init__(self, psf_wrapper, flat_sky_proj):

        self._psf = psf_wrapper  # type: PSFWrapper
        self._flat_sky_proj = flat_sky_proj

        # Compute an image of the PSF on the current defined flat sky projection
        interpolator = PSFInterpolator(psf_wrapper, flat_sky_proj)
        psf_stamp = interpolator.point_source_image(flat_sky_proj.ra_center, flat_sky_proj.dec_center)

        # Crop the kernel at the appropriate radius for this PSF (making sure is divisible by 2)
        kernel_radius_px = int(np.ceil(self._psf.kernel_radius / flat_sky_proj.pixel_size))
        pixels_to_keep = kernel_radius_px * 2

        assert pixels_to_keep <= psf_stamp.shape[0] and \
               pixels_to_keep <= psf_stamp.shape[1], \
            "The kernel is too large with respect to the model image. Enlarge your model radius."

        xoff = (psf_stamp.shape[0] - pixels_to_keep) // 2
        yoff = (psf_stamp.shape[1] - pixels_to_keep) // 2

        self._kernel = psf_stamp[yoff:-yoff, xoff:-xoff]

        assert np.isclose(self._kernel.sum(), 1.0, rtol=1e-2), "Failed to generate proper kernel normalization: got _kernel.sum() = %f; expected 1.0+-0.01." % self._kernel.sum()

This line is too long as per the coding-style (177/120).

        # Renormalize to exactly 1
        self._kernel = self._kernel / self._kernel.sum()

        self._expected_shape = (flat_sky_proj.npix_height, flat_sky_proj.npix_width)

        s1 = np.array(self._expected_shape)

Variable name "s1" doesn't conform to snake_case naming style ('(([a-z_][a-z0-9_]2,30)|(_[a-z0-9_]*)|(__[a-z][a-z0-9_]+__))$' pattern)

        s2 = np.array(self._kernel.shape)

Variable name "s2" doesn't conform to snake_case naming style ('(([a-z_][a-z0-9_]2,30)|(_[a-z0-9_]*)|(__[a-z][a-z0-9_]+__))$' pattern)

        shape = s1 + s2 - 1

        self._fshape = [helper.next_fast_len(int(d)) for d in shape]
        self._fslice = tuple([slice(0, int(sz)) for sz in shape])

        self._psf_fft = rfftn(self._kernel, self._fshape)

    @property
    def kernel(self):

This method should have a docstring.

        return self._kernel

    # def extended_source_image(self, ideal_image):
    #
    #     conv = fftconvolve(ideal_image, self._kernel, mode='same')
    #
    #     return conv

    def extended_source_image(self, ideal_image):

This method should have a docstring.

        # Convolve

        assert np.alltrue(ideal_image.shape == self._expected_shape), "Shape of image to be convolved is not correct."

        ret = irfftn(rfftn(ideal_image, self._fshape) * self._psf_fft, self._fshape)[self._fslice].copy()

        conv = _centered(ret, self._expected_shape)

        return conv


def _centered(arr, newsize):
    # Return the center newsize portion of the array.
    newsize = np.asarray(newsize)
    currsize = np.array(arr.shape)
    startind = (currsize - newsize) // 2
    endind = startind + newsize
    myslice = [slice(startind[k], endind[k]) for k in range(len(endind))]
    return arr[tuple(myslice)]