hawc_hal.psf_fast.psf_wrapper.PSFWrapper.__init__() - Code Metrics - Inspection of "The InvalidPSF objects should not be used, but we..." - giacomov/hawc_hal - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#7)

unknown

created 2018-07-18 23:44 UTC

PSFWrapper.init() A

↳ Parent: hawc_hal.psf_fast.psf_wrapper

Complexity

Conditions

Size

Total Lines	38
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	20
dl	0
loc	38
rs	9.4
c	0
b	0
f	0
cc	4
nop	5

import numpy as np
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
import scipy.interpolate
import scipy.optimize
import pandas as pd

_INTEGRAL_OUTER_RADIUS = 15.0


class InvalidPSFError(ValueError):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    pass


class PSFWrapper(object):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    def __init__(self, xs, ys, brightness_interp_x=None, brightness_interp_y=None):

        self._xs = xs
        self._ys = ys

        self._psf_interpolated = scipy.interpolate.InterpolatedUnivariateSpline(xs, ys, k=2,
                                                                                ext='raise',
                                                                                check_finite=True)

        # Memorize the total integral (will use it for normalization)

        self._total_integral = self._psf_interpolated.integral(self._xs[0], _INTEGRAL_OUTER_RADIUS)

        # Now compute the truncation radius, which is a very conservative measurement
        # of the size of the PSF

        self._truncation_radius = self.find_eef_radius(0.9999)

        # Let's also compute another measurement more appropriate for convolution
        self._kernel_radius = self.find_eef_radius(0.999)

        assert self._kernel_radius <= self._truncation_radius
        assert self._truncation_radius <= _INTEGRAL_OUTER_RADIUS

        # Prepare brightness interpolation

        if brightness_interp_x is None:

            brightness_interp_x, brightness_interp_y = self._prepare_brightness_interpolation_points()

        self._brightness_interp_x = brightness_interp_x
        self._brightness_interp_y = brightness_interp_y

        self._brightness_interpolation = scipy.interpolate.InterpolatedUnivariateSpline(brightness_interp_x,
                                                                                        brightness_interp_y,
                                                                                        k=2,
                                                                                        ext='extrapolate',
                                                                                        check_finite=True)

    def _prepare_brightness_interpolation_points(self):

        # Get the centers of the bins
        interp_x = (self._xs[1:] + self._xs[:-1]) / 2.0

        # Compute the density

        interp_y = np.array(map(lambda (a, b): self.integral(a, b) / (np.pi * (b ** 2 - a ** 2)) / self._total_integral,

                                zip(self._xs[:-1], self._xs[1:])))

        # Add zero at r = _INTEGRAL_OUTER_RADIUS so that the extrapolated values will be correct
        interp_x = np.append(interp_x, [_INTEGRAL_OUTER_RADIUS])
        interp_y = np.append(interp_y, [0.0])

        return interp_x, interp_y

    def find_eef_radius(self, fraction):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

        f = lambda r: fraction - self.integral(1e-4, r) / self._total_integral


        radius, status = scipy.optimize.brentq(f, 0.005, _INTEGRAL_OUTER_RADIUS, full_output = True)


        assert status.converged, "Brentq did not converged"

        return radius

    def brightness(self, r):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

        return self._brightness_interpolation(r)

    @property
    def xs(self):

        """
        X of the interpolation data
        """
        return self._xs

    @property
    def ys(self):

        """
        Y of the interpolation data
        """
        return self._ys

    def combine_with_other_psf(self, other_psf, w1, w2):

        """
        Return a PSF which is the linear interpolation between this one and the other one provided

        :param other_psf: another psf
        :param w1: weight for self (i.e., this PSF)
        :param w2: weight for the other psf
        :return: another PSF instance
        """

        if isinstance(self, InvalidPSF) or isinstance(other_psf, InvalidPSF):
            return InvalidPSF()

        # Weight the ys
        new_ys = w1 * self.ys + w2 * other_psf.ys

        # Also weight the brightness interpolation points
        new_br_interp_y = w1 * self._brightness_interp_y + w2 * other_psf._brightness_interp_y
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent

        return PSFWrapper(self.xs, new_ys,
                          brightness_interp_x=self._brightness_interp_x,
                          brightness_interp_y=new_br_interp_y)

    def to_pandas(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

        items = (('xs', self._xs), ('ys', self._ys))

        return pd.DataFrame.from_dict(dict(items))

    @classmethod
    def from_pandas(cls, df):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

        return cls(df.loc[:, 'xs'].values, df.loc[:, 'ys'].values)

    @classmethod
    def from_TF1(cls, tf1_instance):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

        # Annoyingly, some PSFs for some Dec bins (at large Zenith angles) have
        # zero or negative integrals, i.e., they are useless. Return an unusable PSF
        # object in that case
        if tf1_instance.Integral(0, _INTEGRAL_OUTER_RADIUS) <= 0.0:

            return InvalidPSF()

        # Make interpolation
        xs = np.logspace(-3, np.log10(_INTEGRAL_OUTER_RADIUS), 500)

        ys = np.array(map(lambda x:tf1_instance.Eval(x), xs), float)


        assert np.all(np.isfinite(xs))
        assert np.all(np.isfinite(ys))

        instance = cls(xs, ys)

        instance._tf1 = tf1_instance.Clone()
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent

        return instance

    def integral(self, a, b):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

        return self._psf_interpolated.integral(a, b)

    @property
    def truncation_radius(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._truncation_radius

    @property
    def total_integral(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._total_integral

    @property
    def kernel_radius(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._kernel_radius


# This is a class that, whatever you try to use it for, will raise an exception.
# This is to make sure that we never use an invalid PSF without knowing it
class InvalidPSF(object):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    # It can be useful to copy an invalid PSF. For instance HAL.get_simulated_dataset() makes a
    # copy of the HAL instance, including detector response, which can contain InvalidPSF (which
    # is fine as long as they are not used).
    def __deepcopy__(self, memo):
        return InvalidPSF()

    def __getattribute__(self, item):

        if item == "__deepcopy__":
            return object.__getattribute__(self, item)
        raise InvalidPSFError("Trying to use an invalid PSF")


1			import numpy as np
			0 ignored issues – show Coding Style introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report This module should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
2			import scipy.interpolate
3			import scipy.optimize
4			import pandas as pd
5
6			_INTEGRAL_OUTER_RADIUS = 15.0
7
8
9			class InvalidPSFError(ValueError):
			0 ignored issues – show Coding Style introduced 2018-07-06 22:00 UTC by Report Bug Copy Issue Report This class should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
10
11			pass
12
13
14			class PSFWrapper(object):
			0 ignored issues – show Coding Style introduced 2018-07-06 22:00 UTC by Report Bug Copy Issue Report This class should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history... best-practice introduced 2018-07-06 22:00 UTC by Report Bug Copy Issue Report Too many instance attributes (10/7) Loading history...
15
16			def __init__(self, xs, ys, brightness_interp_x=None, brightness_interp_y=None):
17
18			self._xs = xs
19			self._ys = ys
20
21			self._psf_interpolated = scipy.interpolate.InterpolatedUnivariateSpline(xs, ys, k=2,
22			ext='raise',
23			check_finite=True)
24
25			# Memorize the total integral (will use it for normalization)
26
27			self._total_integral = self._psf_interpolated.integral(self._xs[0], _INTEGRAL_OUTER_RADIUS)
28
29			# Now compute the truncation radius, which is a very conservative measurement
30			# of the size of the PSF
31
32			self._truncation_radius = self.find_eef_radius(0.9999)
33
34			# Let's also compute another measurement more appropriate for convolution
35			self._kernel_radius = self.find_eef_radius(0.999)
36
37			assert self._kernel_radius <= self._truncation_radius

giacomov / hawc_hal

Pull Request — master (#7)

PSFWrapper.__init__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

PSFWrapper.init() A