polarpy.polar_data.POLARData.__init__() - Code Metrics - grburgess/polarpy - Measure and Improve Code Quality continuously with Scrutinizer

polarpy.polar_data.POLARData.init() A
last analyzed 2020-05-01 16:02 UTC

↳ Parent: polarpy.polar_data

Complexity

Conditions

Size

Total Lines	83
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	28
nop	4
dl	0
loc	83
rs	9.208
c	0
b	0
f	0

How to fix Long Method

import numpy as np
from threeML.utils.OGIP.response import InstrumentResponse
import h5py


class POLARData(object):

    def __init__(self, polar_hdf5_file, polar_hdf5_response=None, reference_time=0.):
        """
        container class that converts raw POLAR HDF5 data into useful python
        variables

        This can build both the polarization and spectral data
        

        :param polar_root_file: path to polar event file
        :param reference_time: reference time of the events (tunix?)
        :param rsp_file: path to rsp file
        """

        with h5py.File(polar_hdf5_file, 'r') as f:

            # This gets the spectral response
            rsp_grp = f['rsp']

            matrix = rsp_grp['matrix'].value
            ebounds = rsp_grp['ebounds'].value
            mc_low = rsp_grp['mc_low'].value
            mc_high = rsp_grp['mc_high'].value

            # open the event file

            # extract the pedestal corrected ADC channels
            # which are non-integer and possibly
            # less than zero
            pha = f['energy'].value

            # non-zero ADC channels are invalid
            idx = pha >= 0
            #pha = pha[idx]

            idx2 = (pha <= ebounds.max()) & (pha >= ebounds.min())

            pha = pha[idx2 & idx]

            # get the dead time fraction
            self._dead_time_fraction = (f['dead_ratio'].value)[idx & idx2]

            # get the arrival time, in tunix of the events
            self._time = (f['time'].value)[idx & idx2] - reference_time

            # digitize the ADC channels into bins
            # these bins are preliminary

            # now do the scattering angles

            scattering_angles = f['scatter_angle'].value

            # clear the bad scattering angles
            idx = scattering_angles != -1

            self._scattering_angle_time = (f['time'].value)[idx] - reference_time
            self._scattering_angle_dead_time_fraction = (f['dead_ratio'].value)[idx]
            self._scattering_angles = scattering_angles[idx]

        # build the POLAR response

        mc_energies = np.append(mc_low, mc_high[-1])

        self._rsp = InstrumentResponse(matrix=matrix, ebounds=ebounds, monte_carlo_energies=mc_energies)

        # bin the ADC channels

        self._binned_pha = np.digitize(pha, ebounds)

        # bin the scattering_angles

        if polar_hdf5_response is not None:

            with h5py.File(polar_hdf5_response, 'r') as f:

                scatter_bounds = f['bins'].value

            self._scattering_bins = scatter_bounds
            self._binned_scattering_angles = np.digitize(self._scattering_angles, scatter_bounds)

        else:

            self._scattering_bins = None
            self._binned_scattering_angles = None

    @property
    def pha(self):
        return self._binned_pha

    @property
    def time(self):
        return self._time

    @property
    def dead_time_fraction(self):
        return self._dead_time_fraction

    @property
    def rsp(self):
        return self._rsp

    @property
    def n_channels(self):

        return len(self._rsp.ebounds) - 1

    @property
    def scattering_angles(self):

        return self._binned_scattering_angles

    @property
    def scattering_angle_time(self):

        return self._scattering_angle_time

    @property
    def scattering_angle_dead_time_fraction(self):
        return self._scattering_angle_dead_time_fraction

    @property
    def n_scattering_bins(self):

        return len(self._scattering_bins) - 1

    @property
    def scattering_edges(self):

        return self._scattering_bins


1			import numpy as np
2			from threeML.utils.OGIP.response import InstrumentResponse
3			import h5py
4
5
6			class POLARData(object):
7
8			def __init__(self, polar_hdf5_file, polar_hdf5_response=None, reference_time=0.):
9			"""
10			container class that converts raw POLAR HDF5 data into useful python
11			variables
12
13			This can build both the polarization and spectral data
14
15
16			:param polar_root_file: path to polar event file
17			:param reference_time: reference time of the events (tunix?)
18			:param rsp_file: path to rsp file
19			"""
20
21			with h5py.File(polar_hdf5_file, 'r') as f:
22
23			# This gets the spectral response
24			rsp_grp = f['rsp']
25
26			matrix = rsp_grp['matrix'].value
27			ebounds = rsp_grp['ebounds'].value
28			mc_low = rsp_grp['mc_low'].value
29			mc_high = rsp_grp['mc_high'].value
30
31			# open the event file
32
33			# extract the pedestal corrected ADC channels
34			# which are non-integer and possibly
35			# less than zero
36			pha = f['energy'].value
37
38			# non-zero ADC channels are invalid
39			idx = pha >= 0
40			#pha = pha[idx]
41
42			idx2 = (pha <= ebounds.max()) & (pha >= ebounds.min())
43
44			pha = pha[idx2 & idx]
45
46			# get the dead time fraction
47			self._dead_time_fraction = (f['dead_ratio'].value)[idx & idx2]
48
49			# get the arrival time, in tunix of the events
50			self._time = (f['time'].value)[idx & idx2] - reference_time
51
52			# digitize the ADC channels into bins
53			# these bins are preliminary
54
55			# now do the scattering angles
56
57			scattering_angles = f['scatter_angle'].value
58
59			# clear the bad scattering angles
60			idx = scattering_angles != -1
61
62			self._scattering_angle_time = (f['time'].value)[idx] - reference_time
63			self._scattering_angle_dead_time_fraction = (f['dead_ratio'].value)[idx]
64			self._scattering_angles = scattering_angles[idx]
65
66			# build the POLAR response
67
68			mc_energies = np.append(mc_low, mc_high[-1])
69
70			self._rsp = InstrumentResponse(matrix=matrix, ebounds=ebounds, monte_carlo_energies=mc_energies)
71
72			# bin the ADC channels
73
74			self._binned_pha = np.digitize(pha, ebounds)
75
76			# bin the scattering_angles
77
78			if polar_hdf5_response is not None:
79
80			with h5py.File(polar_hdf5_response, 'r') as f:
81
82			scatter_bounds = f['bins'].value
83
84			self._scattering_bins = scatter_bounds
85			self._binned_scattering_angles = np.digitize(self._scattering_angles, scatter_bounds)
86
87			else:
88
89			self._scattering_bins = None
90			self._binned_scattering_angles = None
91
92			@property
93			def pha(self):
94			return self._binned_pha
95
96			@property
97			def time(self):
98			return self._time
99
100			@property
101			def dead_time_fraction(self):
102			return self._dead_time_fraction
103
104			@property
105			def rsp(self):
106			return self._rsp
107
108			@property
109			def n_channels(self):
110
111			return len(self._rsp.ebounds) - 1
112
113			@property
114			def scattering_angles(self):
115
116			return self._binned_scattering_angles
117
118			@property
119			def scattering_angle_time(self):
120
121			return self._scattering_angle_time
122
123			@property
124			def scattering_angle_dead_time_fraction(self):
125			return self._scattering_angle_dead_time_fraction
126
127			@property
128			def n_scattering_bins(self):
129
130			return len(self._scattering_bins) - 1
131
132			@property
133			def scattering_edges(self):
134
135			return self._scattering_bins
136

grburgess / polarpy

polarpy.polar_data.POLARData.__init__() A last analyzed 2020-05-01 16:02 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

polarpy.polar_data.POLARData.init() A
last analyzed 2020-05-01 16:02 UTC