diff --git a/napytau/core/chi.py b/napytau/core/chi.py index 26f70cc..0ff72f3 100644 --- a/napytau/core/chi.py +++ b/napytau/core/chi.py @@ -1,5 +1,7 @@ from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances -from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances # noqa E501 +from napytau.core.polynomials import ( + evaluate_differentiated_polynomial_at_measuring_distances, +) # noqa E501 from numpy import ndarray from numpy import sum from numpy import mean @@ -46,18 +48,20 @@ def chi_squared_fixed_t( # Compute the difference between Doppler-shifted intensities and polynomial model shifted_intensity_difference: ndarray = ( - doppler_shifted_intensities - - evaluate_polynomial_at_measuring_distances(distances, coefficients) + doppler_shifted_intensities + - evaluate_polynomial_at_measuring_distances(distances, coefficients) ) / delta_doppler_shifted_intensities # Compute the difference between unshifted intensities and # scaled derivative of the polynomial model unshifted_intensity_difference: ndarray = ( unshifted_intensities - - (t_hyp - * evaluate_differentiated_polynomial_at_measuring_distances(distances, - coefficients) - ) + - ( + t_hyp + * evaluate_differentiated_polynomial_at_measuring_distances( + distances, coefficients + ) + ) ) / delta_unshifted_intensities # combine the weighted sum of squared differences @@ -104,14 +108,15 @@ def optimize_coefficients( tuple: Optimized coefficients (ndarray) and minimized chi-squared value (float). """ chi_squared = lambda coefficients: chi_squared_fixed_t( - doppler_shifted_intensities, - unshifted_intensities, - delta_doppler_shifted_intensities, - delta_unshifted_intensities, - coefficients, - distances, - t_hyp, - weight_factor) + doppler_shifted_intensities, + unshifted_intensities, + delta_doppler_shifted_intensities, + delta_unshifted_intensities, + coefficients, + distances, + t_hyp, + weight_factor, + ) result: OptimizeResult = minimize( chi_squared, diff --git a/napytau/core/core.py b/napytau/core/core.py index 7748d83..d21ef1f 100644 --- a/napytau/core/core.py +++ b/napytau/core/core.py @@ -7,29 +7,33 @@ from typing import Tuple, Optional -def calculate_lifetime(doppler_shifted_intensities: np.ndarray, - unshifted_intensities: np.ndarray, - delta_doppler_shifted_intensities: np.ndarray, - delta_unshifted_intensities: np.ndarray, - initial_coefficients: np.ndarray, - distances: np.ndarray, - t_hyp_range: Tuple[float, float], - weight_factor: float, - custom_t_hyp_estimate: Optional[float]) -> Tuple[float, float]: - +def calculate_lifetime( + doppler_shifted_intensities: np.ndarray, + unshifted_intensities: np.ndarray, + delta_doppler_shifted_intensities: np.ndarray, + delta_unshifted_intensities: np.ndarray, + initial_coefficients: np.ndarray, + distances: np.ndarray, + t_hyp_range: Tuple[float, float], + weight_factor: float, + custom_t_hyp_estimate: Optional[float], +) -> Tuple[float, float]: + t_hyp: float = 0 # If a custom t_hyp is given, we will use it for the further calculations # If no custom t_hyp is given, we will use the optimal taufactor instead if custom_t_hyp_estimate is not None: - t_hyp: float = custom_t_hyp_estimate + t_hyp = custom_t_hyp_estimate else: - t_hyp: float = optimize_t_hyp(doppler_shifted_intensities, - unshifted_intensities, - delta_doppler_shifted_intensities, - delta_unshifted_intensities, - initial_coefficients, - distances, - t_hyp_range, - weight_factor) + t_hyp = optimize_t_hyp( + doppler_shifted_intensities, + unshifted_intensities, + delta_doppler_shifted_intensities, + delta_unshifted_intensities, + initial_coefficients, + distances, + t_hyp_range, + weight_factor, + ) # Now we find the optimal coefficients for the given taufactor optimized_coefficients: np.ndarray = ( @@ -46,15 +50,17 @@ def calculate_lifetime(doppler_shifted_intensities: np.ndarray, )[0] # We now calculate the lifetimes tau_i for all measured distances - tau_i_values: np.ndarray = calculate_tau_i_values(doppler_shifted_intensities, - unshifted_intensities, - delta_doppler_shifted_intensities, - delta_unshifted_intensities, - initial_coefficients, - distances, - t_hyp_range, - weight_factor, - custom_t_hyp_estimate) + tau_i_values: np.ndarray = calculate_tau_i_values( + doppler_shifted_intensities, + unshifted_intensities, + delta_doppler_shifted_intensities, + delta_unshifted_intensities, + initial_coefficients, + distances, + t_hyp_range, + weight_factor, + custom_t_hyp_estimate, + ) # And we calculate the respective errors for the lifetimes delta_tau_i_values: np.ndarray = calculate_error_propagation_terms( @@ -63,10 +69,13 @@ def calculate_lifetime(doppler_shifted_intensities: np.ndarray, delta_unshifted_intensities, distances, optimized_coefficients, - t_hyp) + t_hyp, + ) # From lifetimes and associated errors we can now calculate the weighted mean # and the uncertainty - tau_final: (float, float) = calculate_tau_final(tau_i_values, delta_tau_i_values) + tau_final: Tuple[float, float] = calculate_tau_final( + tau_i_values, delta_tau_i_values + ) - return tau_final \ No newline at end of file + return tau_final diff --git a/napytau/core/delta_tau.py b/napytau/core/delta_tau.py index 3cfc05b..697b685 100644 --- a/napytau/core/delta_tau.py +++ b/napytau/core/delta_tau.py @@ -1,4 +1,6 @@ -from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances # noqa E501 +from napytau.core.polynomials import ( + evaluate_differentiated_polynomial_at_measuring_distances, +) # noqa E501 from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances from numpy import array from numpy import ndarray @@ -107,7 +109,9 @@ def calculate_error_propagation_terms( ) ) - gaussian_error_from_unshifted_intensity: ndarray = power(delta_unshifted_intensities, 2) / power( + gaussian_error_from_unshifted_intensity: ndarray = power( + delta_unshifted_intensities, 2 + ) / power( calculated_differentiated_polynomial_sum_at_measuring_distances, 2, ) @@ -138,7 +142,10 @@ def calculate_error_propagation_terms( unshifted_intensities * taufactor * delta_p_j_i_squared ) / power(calculated_differentiated_polynomial_sum_at_measuring_distances, 3) - test = gaussian_error_from_unshifted_intensity + gaussian_error_from_polynomial_uncertainties - res = test + error_from_covariance + interim_result: ndarray = ( + gaussian_error_from_unshifted_intensity + + gaussian_error_from_polynomial_uncertainties + ) + errors: ndarray = interim_result + error_from_covariance # Return the sum of all three contributions - return res + return errors diff --git a/napytau/core/polynomials.py b/napytau/core/polynomials.py index 62a8fd7..6abb8fd 100644 --- a/napytau/core/polynomials.py +++ b/napytau/core/polynomials.py @@ -3,8 +3,9 @@ from numpy import zeros_like -def evaluate_polynomial_at_measuring_distances(distances: ndarray, - coefficients: ndarray) -> ndarray: +def evaluate_polynomial_at_measuring_distances( + distances: ndarray, coefficients: ndarray +) -> ndarray: """ Computes the sum of a polynomial evaluated at given distance points. @@ -51,6 +52,8 @@ def evaluate_differentiated_polynomial_at_measuring_distances( sum_of_derivative_at_measuring_distances: ndarray = zeros_like(distances) for exponent, coefficient in enumerate(coefficients): if exponent > 0: - sum_of_derivative_at_measuring_distances += exponent * coefficient * power(distances, (exponent - 1)) + sum_of_derivative_at_measuring_distances += ( + exponent * coefficient * power(distances, (exponent - 1)) + ) return sum_of_derivative_at_measuring_distances diff --git a/napytau/core/tau.py b/napytau/core/tau.py index 6488780..80a54a6 100644 --- a/napytau/core/tau.py +++ b/napytau/core/tau.py @@ -1,6 +1,8 @@ from napytau.core.chi import optimize_t_hyp from napytau.core.chi import optimize_coefficients -from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances # noqa E501 +from napytau.core.polynomials import ( + evaluate_differentiated_polynomial_at_measuring_distances, +) # noqa E501 from numpy import ndarray from typing import Tuple, Optional @@ -14,7 +16,8 @@ def calculate_tau_i_values( distances: ndarray, t_hyp_range: Tuple[float, float], weight_factor: float, - custom_t_hyp_estimate: Optional[float]) -> ndarray: + custom_t_hyp_estimate: Optional[float], +) -> ndarray: """ Calculates the decay times (tau_i) based on the provided intensities and time points. @@ -46,14 +49,16 @@ def calculate_tau_i_values( if custom_t_hyp_estimate is not None: t_hyp: float = custom_t_hyp_estimate else: - t_hyp = optimize_t_hyp(doppler_shifted_intensities, - unshifted_intensities, - delta_doppler_shifted_intensities, - delta_unshifted_intensities, - initial_coefficients, - distances, - t_hyp_range, - weight_factor) + t_hyp = optimize_t_hyp( + doppler_shifted_intensities, + unshifted_intensities, + delta_doppler_shifted_intensities, + delta_unshifted_intensities, + initial_coefficients, + distances, + t_hyp_range, + weight_factor, + ) # optimize the polynomial coefficients with the optimized t_hyp optimized_coefficients: ndarray = ( @@ -71,8 +76,8 @@ def calculate_tau_i_values( # calculate decay times using the optimized coefficients tau_i_values: ndarray = ( - unshifted_intensities - / evaluate_differentiated_polynomial_at_measuring_distances( + unshifted_intensities + / evaluate_differentiated_polynomial_at_measuring_distances( distances, optimized_coefficients ) ) diff --git a/napytau/core/tau_final.py b/napytau/core/tau_final.py index b10a2b1..72a111b 100644 --- a/napytau/core/tau_final.py +++ b/napytau/core/tau_final.py @@ -5,8 +5,9 @@ from typing import Tuple -def calculate_tau_final(tau_i_values: ndarray, - delta_tau_i_values: ndarray) -> Tuple[float, float]: +def calculate_tau_final( + tau_i_values: ndarray, delta_tau_i_values: ndarray +) -> Tuple[float, float]: """ Computes the final decay time (tau_final) and its associated uncertainty diff --git a/tests/core/chi_test.py b/tests/core/chi_test.py index e0286a7..623efbe 100644 --- a/tests/core/chi_test.py +++ b/tests/core/chi_test.py @@ -30,14 +30,18 @@ def test_CanCalculateChiForValidData(self): polynomials_mock, numpy_module_mock, scipy_optimize_module_mock = set_up_mocks() # Mocked return values of called functions - polynomials_mock.evaluate_polynomial_at_measuring_distances\ - .return_value = array([5, 15, 57]) - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances\ - .return_value = array([4, 20, 72]) + polynomials_mock.evaluate_polynomial_at_measuring_distances.return_value = ( + array([5, 15, 57]) + ) + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.return_value = array( + [4, 20, 72] + ) numpy_module_mock.sum.return_value = 628.3486168 - numpy_module_mock.power.side_effect = [array([4, 18.77777778, 182.25]), - array([0.64, 34.02777778, 388.65306122])] + numpy_module_mock.power.side_effect = [ + array([4, 18.77777778, 182.25]), + array([0.64, 34.02777778, 388.65306122]), + ] with patch.dict( "sys.modules", @@ -76,18 +80,23 @@ def test_CanCalculateChiForValidData(self): ) self.assertEqual( - len(polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls), 1 + len( + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls + ), + 1, ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances - .mock_calls[0].args[0], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[0], (array([0, 1, 2])), ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances - .mock_calls[0].args[1], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], (array([5, 4, 3, 2, 1])), ) @@ -99,58 +108,51 @@ def test_CanCalculateChiForValidData(self): ) testing.assert_array_equal( - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances - .mock_calls[0].args[0], + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[0], (array([0, 1, 2])), ) testing.assert_array_equal( - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances - .mock_calls[0].args[1], + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], (array([5, 4, 3, 2, 1])), ) self.assertEqual( - len( - numpy_module_mock.sum.mock_calls - ), + len(numpy_module_mock.sum.mock_calls), 1, ) testing.assert_array_almost_equal( - numpy_module_mock.sum - .mock_calls[0].args[0], + numpy_module_mock.sum.mock_calls[0].args[0], (array([4.64, 52.80555556, 570.90306122])), ) self.assertEqual( - len( - numpy_module_mock.power.mock_calls - ), + len(numpy_module_mock.power.mock_calls), 2, ) testing.assert_array_almost_equal( - numpy_module_mock.power - .mock_calls[0].args[0], + numpy_module_mock.power.mock_calls[0].args[0], (array([-2, -4.33333333, -13.5])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[0].args[1], + numpy_module_mock.power.mock_calls[0].args[1], 2, ) testing.assert_array_almost_equal( - numpy_module_mock.power - .mock_calls[1].args[0], + numpy_module_mock.power.mock_calls[1].args[0], (array([-0.8, -5.83333333, -19.71428571])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[1].args[1], + numpy_module_mock.power.mock_calls[1].args[1], 2, ) @@ -159,13 +161,15 @@ def test_CanHandleEmptyDataArraysForChiCalculation(self): polynomials_mock, numpy_module_mock, scipy_optimize_module_mock = set_up_mocks() # Mocked return values of called functions - polynomials_mock.evaluate_polynomial_at_measuring_distances\ - .return_value = array([]) - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances\ - .return_value = array([]) + polynomials_mock.evaluate_polynomial_at_measuring_distances.return_value = ( + array([]) + ) + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.return_value = array( + [] + ) numpy_module_mock.sum.return_value = 0 - numpy_module_mock.power.side_effect = [array([]),array([])] + numpy_module_mock.power.side_effect = [array([]), array([])] with patch.dict( "sys.modules", @@ -204,20 +208,23 @@ def test_CanHandleEmptyDataArraysForChiCalculation(self): ) self.assertEqual( - len(polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls), 1 + len( + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls + ), + 1, ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[0].args[ + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ 0 - ], + ].args[0], (array([])), ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[0].args[ - 1 - ], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], (array([])), ) @@ -243,46 +250,37 @@ def test_CanHandleEmptyDataArraysForChiCalculation(self): ) self.assertEqual( - len( - numpy_module_mock.sum.mock_calls - ), + len(numpy_module_mock.sum.mock_calls), 1, ) testing.assert_array_equal( - numpy_module_mock.sum - .mock_calls[0].args[0], + numpy_module_mock.sum.mock_calls[0].args[0], array([]), ) self.assertEqual( - len( - numpy_module_mock.power.mock_calls - ), + len(numpy_module_mock.power.mock_calls), 2, ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[0].args[0], + numpy_module_mock.power.mock_calls[0].args[0], (array([])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[0].args[1], + numpy_module_mock.power.mock_calls[0].args[1], 2, ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[1].args[0], + numpy_module_mock.power.mock_calls[1].args[0], (array([])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[1].args[1], + numpy_module_mock.power.mock_calls[1].args[1], 2, ) @@ -291,9 +289,12 @@ def test_CanCalculateChiForSingleDatapoint(self): polynomials_mock, numpy_module_mock, scipy_optimize_module_mock = set_up_mocks() # Mocked return values of called functions - polynomials_mock.evaluate_polynomial_at_measuring_distances.return_value = array([57]) - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances\ - .return_value = array([72]) + polynomials_mock.evaluate_polynomial_at_measuring_distances.return_value = ( + array([57]) + ) + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.return_value = array( + [72] + ) numpy_module_mock.sum.return_value = 1608.69444444 numpy_module_mock.power.side_effect = [array([348.44444444]), array([1260.25])] @@ -335,20 +336,23 @@ def test_CanCalculateChiForSingleDatapoint(self): ) self.assertEqual( - len(polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls), 1 + len( + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls + ), + 1, ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[0].args[ + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ 0 - ], + ].args[0], (array([2])), ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[0].args[ - 1 - ], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], (array([5, 4, 3, 2, 1])), ) @@ -374,46 +378,37 @@ def test_CanCalculateChiForSingleDatapoint(self): ) self.assertEqual( - len( - numpy_module_mock.sum.mock_calls - ), + len(numpy_module_mock.sum.mock_calls), 1, ) testing.assert_array_almost_equal( - numpy_module_mock.sum - .mock_calls[0].args[0], + numpy_module_mock.sum.mock_calls[0].args[0], (array([1608.69444444])), ) self.assertEqual( - len( - numpy_module_mock.power.mock_calls - ), + len(numpy_module_mock.power.mock_calls), 2, ) testing.assert_array_almost_equal( - numpy_module_mock.power - .mock_calls[0].args[0], + numpy_module_mock.power.mock_calls[0].args[0], (array([-18.66666667])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[0].args[1], + numpy_module_mock.power.mock_calls[0].args[1], 2, ) testing.assert_array_almost_equal( - numpy_module_mock.power - .mock_calls[1].args[0], + numpy_module_mock.power.mock_calls[1].args[0], (array([-35.5])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[1].args[1], + numpy_module_mock.power.mock_calls[1].args[1], 2, ) @@ -422,14 +417,18 @@ def test_CanCalculateChiIfDenominatorIsZero(self): polynomials_mock, numpy_module_mock, scipy_optimize_module_mock = set_up_mocks() # Mocked return values of called functions - polynomials_mock.evaluate_polynomial_at_measuring_distances\ - .return_value = array([5, 15]) - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances\ - .return_value = array([4, 20]) + polynomials_mock.evaluate_polynomial_at_measuring_distances.return_value = ( + array([5, 15]) + ) + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.return_value = array( + [4, 20] + ) numpy_module_mock.sum.return_value = float("inf") - numpy_module_mock.power.side_effect = [array([float("inf"), 169]), - array([float("inf"), 1296])] + numpy_module_mock.power.side_effect = [ + array([float("inf"), 169]), + array([float("inf"), 1296]), + ] with patch.dict( "sys.modules", @@ -468,18 +467,23 @@ def test_CanCalculateChiIfDenominatorIsZero(self): ) self.assertEqual( - len(polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls), 1 + len( + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls + ), + 1, ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances - .mock_calls[0].args[0], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[0], (array([0, 1])), ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances - .mock_calls[0].args[1], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], (array([5, 4, 3, 2, 1])), ) @@ -491,58 +495,51 @@ def test_CanCalculateChiIfDenominatorIsZero(self): ) testing.assert_array_equal( - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances - .mock_calls[0].args[0], + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[0], (array([0, 1])), ) testing.assert_array_equal( - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances - .mock_calls[0].args[1], - (array([5, 4, 3, 2, 1])) + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], + (array([5, 4, 3, 2, 1])), ) self.assertEqual( - len( - numpy_module_mock.sum.mock_calls - ), + len(numpy_module_mock.sum.mock_calls), 1, ) testing.assert_array_equal( - numpy_module_mock.sum - .mock_calls[0].args[0], + numpy_module_mock.sum.mock_calls[0].args[0], (array([float("inf"), 1465])), ) self.assertEqual( - len( - numpy_module_mock.power.mock_calls - ), + len(numpy_module_mock.power.mock_calls), 2, ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[0].args[0], + numpy_module_mock.power.mock_calls[0].args[0], (array([-float("inf"), -13])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[0].args[1], + numpy_module_mock.power.mock_calls[0].args[1], 2, ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[1].args[0], + numpy_module_mock.power.mock_calls[1].args[0], (array([-float("inf"), -36])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[1].args[1], + numpy_module_mock.power.mock_calls[1].args[1], 2, ) @@ -551,14 +548,18 @@ def test_CanCalculateChiForNegativeValues(self): polynomials_mock, numpy_module_mock, scipy_optimize_module_mock = set_up_mocks() # Mocked return values of called functions - polynomials_mock.evaluate_polynomial_at_measuring_distances\ - .return_value = array([-5, -5]) - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances\ - .return_value = array([-4, -4]) + polynomials_mock.evaluate_polynomial_at_measuring_distances.return_value = ( + array([-5, -5]) + ) + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.return_value = array( + [-4, -4] + ) numpy_module_mock.sum.return_value = 22.02777778 - numpy_module_mock.power.side_effect = [array([16, 2.25]), - array([2.77777778, 1])] + numpy_module_mock.power.side_effect = [ + array([16, 2.25]), + array([2.77777778, 1]), + ] with patch.dict( "sys.modules", @@ -597,18 +598,23 @@ def test_CanCalculateChiForNegativeValues(self): ) self.assertEqual( - len(polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls), 1 + len( + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls + ), + 1, ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances - .mock_calls[0].args[0], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[0], (array([0, 1])), ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances - .mock_calls[0].args[1], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], (array([-5, -4, 3, 2, -1])), ) @@ -620,58 +626,51 @@ def test_CanCalculateChiForNegativeValues(self): ) testing.assert_array_equal( - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances - .mock_calls[0].args[0], + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[0], (array([0, 1])), ) testing.assert_array_equal( - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances - .mock_calls[0].args[1], + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], (array([-5, -4, 3, 2, -1])), ) self.assertEqual( - len( - numpy_module_mock.sum.mock_calls - ), + len(numpy_module_mock.sum.mock_calls), 1, ) testing.assert_array_almost_equal( - numpy_module_mock.sum - .mock_calls[0].args[0], + numpy_module_mock.sum.mock_calls[0].args[0], (array([18.77777778, 3.25])), ) self.assertEqual( - len( - numpy_module_mock.power.mock_calls - ), + len(numpy_module_mock.power.mock_calls), 2, ) testing.assert_array_almost_equal( - numpy_module_mock.power - .mock_calls[0].args[0], + numpy_module_mock.power.mock_calls[0].args[0], (array([4, 1.5])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[0].args[1], + numpy_module_mock.power.mock_calls[0].args[1], 2, ) testing.assert_array_almost_equal( - numpy_module_mock.power - .mock_calls[1].args[0], + numpy_module_mock.power.mock_calls[1].args[0], (array([1.66666667, 1])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[1].args[1], + numpy_module_mock.power.mock_calls[1].args[1], 2, ) @@ -680,14 +679,18 @@ def test_CanCalculateChiForWeightFactorZero(self): polynomials_mock, numpy_module_mock, scipy_optimize_module_mock = set_up_mocks() # Mocked return values of called functions - polynomials_mock.evaluate_polynomial_at_measuring_distances\ - .return_value = array([5, 15, 57]) - polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances\ - .return_value = array([4, 20, 72]) + polynomials_mock.evaluate_polynomial_at_measuring_distances.return_value = ( + array([5, 15, 57]) + ) + polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.return_value = array( + [4, 20, 72] + ) numpy_module_mock.sum.return_value = 205.02777778 - numpy_module_mock.power.side_effect = [array([4, 18.77777778, 182.25]), - array([0.64, 34.02777778, 388.65306122])] + numpy_module_mock.power.side_effect = [ + array([4, 18.77777778, 182.25]), + array([0.64, 34.02777778, 388.65306122]), + ] with patch.dict( "sys.modules", @@ -726,20 +729,23 @@ def test_CanCalculateChiForWeightFactorZero(self): ) self.assertEqual( - len(polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls), 1 + len( + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls + ), + 1, ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[0].args[ + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ 0 - ], + ].args[0], (array([0, 1, 2])), ) testing.assert_array_equal( - polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[0].args[ - 1 - ], + polynomials_mock.evaluate_polynomial_at_measuring_distances.mock_calls[ + 0 + ].args[1], (array([5, 4, 3, 2, 1])), ) @@ -765,46 +771,37 @@ def test_CanCalculateChiForWeightFactorZero(self): ) self.assertEqual( - len( - numpy_module_mock.sum.mock_calls - ), + len(numpy_module_mock.sum.mock_calls), 1, ) testing.assert_array_equal( - numpy_module_mock.sum - .mock_calls[0].args[0], + numpy_module_mock.sum.mock_calls[0].args[0], (array([4, 18.77777778, 182.25])), ) self.assertEqual( - len( - numpy_module_mock.power.mock_calls - ), + len(numpy_module_mock.power.mock_calls), 2, ) testing.assert_array_almost_equal( - numpy_module_mock.power - .mock_calls[0].args[0], + numpy_module_mock.power.mock_calls[0].args[0], (array([-2, -4.33333333, -13.5])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[0].args[1], + numpy_module_mock.power.mock_calls[0].args[1], 2, ) testing.assert_array_almost_equal( - numpy_module_mock.power - .mock_calls[1].args[0], + numpy_module_mock.power.mock_calls[1].args[0], (array([-0.8, -5.83333333, -19.71428571])), ) testing.assert_array_equal( - numpy_module_mock.power - .mock_calls[1].args[1], + numpy_module_mock.power.mock_calls[1].args[1], 2, ) @@ -930,6 +927,4 @@ def test_CanOptimizeTHypValue(self): self.assertEqual(len(numpy_module_mock.mean.mock_calls), 1) - self.assertEqual( - numpy_module_mock.mean.mock_calls[0].args[0], (-5, 5) - ) + self.assertEqual(numpy_module_mock.mean.mock_calls[0].args[0], (-5, 5)) diff --git a/tests/core/core_test.py b/tests/core/core_test.py index 70d0c87..9b4479c 100644 --- a/tests/core/core_test.py +++ b/tests/core/core_test.py @@ -32,18 +32,20 @@ def test_CanCalculateLifetime(self): tau_mock.calculate_tau_i_values.return_value = np.array([3, 1.66666667]) - delta_tau_mock.calculate_error_propagation_terms.return_value = np.array([0.6, 0.2]) + delta_tau_mock.calculate_error_propagation_terms.return_value = np.array( + [0.6, 0.2] + ) tau_final_mock.calculate_tau_final.return_value = (1.8, 0.18973666) with patch.dict( - "sys.modules", - { - "napytau.core.chi": chi_mock, - "napytau.core.tau": tau_mock, - "napytau.core.delta_tau": delta_tau_mock, - "napytau.core.tau_final": tau_final_mock, - }, + "sys.modules", + { + "napytau.core.chi": chi_mock, + "napytau.core.tau": tau_mock, + "napytau.core.delta_tau": delta_tau_mock, + "napytau.core.tau_final": tau_final_mock, + }, ): from napytau.core.core import calculate_lifetime @@ -59,152 +61,161 @@ def test_CanCalculateLifetime(self): custom_t_hyp_estimate: Optional[float] = None actual_result: Tuple[float, float] = calculate_lifetime( - doppler_shifted_intensities, - unshifted_intensities, - delta_doppler_shifted_intensities, - delta_unshifted_intensities, - initial_coefficients, - distances, - t_hyp_range, - weight_factor, - custom_t_hyp_estimate) + doppler_shifted_intensities, + unshifted_intensities, + delta_doppler_shifted_intensities, + delta_unshifted_intensities, + initial_coefficients, + distances, + t_hyp_range, + weight_factor, + custom_t_hyp_estimate, + ) - self.assertAlmostEqual(actual_result[0],1.8) + self.assertAlmostEqual(actual_result[0], 1.8) - self.assertAlmostEqual(actual_result[1],0.18973666) + self.assertAlmostEqual(actual_result[1], 0.18973666) self.assertEqual(len(chi_mock.optimize_t_hyp.mock_calls), 1) - np.testing.assert_array_equal(chi_mock.optimize_t_hyp.mock_calls[0].args[0], - np.array([2, 6])) + np.testing.assert_array_equal( + chi_mock.optimize_t_hyp.mock_calls[0].args[0], np.array([2, 6]) + ) - np.testing.assert_array_equal(chi_mock.optimize_t_hyp.mock_calls[0].args[1], - np.array([6, 10])) + np.testing.assert_array_equal( + chi_mock.optimize_t_hyp.mock_calls[0].args[1], np.array([6, 10]) + ) - np.testing.assert_array_equal(chi_mock.optimize_t_hyp.mock_calls[0].args[2], - np.array([1, 1])) + np.testing.assert_array_equal( + chi_mock.optimize_t_hyp.mock_calls[0].args[2], np.array([1, 1]) + ) - np.testing.assert_array_equal(chi_mock.optimize_t_hyp.mock_calls[0].args[3], - np.array([1, 1])) + np.testing.assert_array_equal( + chi_mock.optimize_t_hyp.mock_calls[0].args[3], np.array([1, 1]) + ) - np.testing.assert_array_equal(chi_mock.optimize_t_hyp.mock_calls[0].args[4], - np.array([1, 1, 1])) + np.testing.assert_array_equal( + chi_mock.optimize_t_hyp.mock_calls[0].args[4], np.array([1, 1, 1]) + ) - np.testing.assert_array_equal(chi_mock.optimize_t_hyp.mock_calls[0].args[5], - np.array([0, 1])) + np.testing.assert_array_equal( + chi_mock.optimize_t_hyp.mock_calls[0].args[5], np.array([0, 1]) + ) - self.assertEqual(chi_mock.optimize_t_hyp.mock_calls[0].args[6], - (-5, 5)) + self.assertEqual(chi_mock.optimize_t_hyp.mock_calls[0].args[6], (-5, 5)) - self.assertEqual(chi_mock.optimize_t_hyp.mock_calls[0].args[7], - 1.0) + self.assertEqual(chi_mock.optimize_t_hyp.mock_calls[0].args[7], 1.0) self.assertEqual(len(chi_mock.optimize_coefficients.mock_calls), 1) np.testing.assert_array_equal( - chi_mock.optimize_coefficients.mock_calls[0].args[0], - np.array([2, 6]) + chi_mock.optimize_coefficients.mock_calls[0].args[0], np.array([2, 6]) ) np.testing.assert_array_equal( - chi_mock.optimize_coefficients.mock_calls[0].args[1], - np.array([6, 10]) + chi_mock.optimize_coefficients.mock_calls[0].args[1], np.array([6, 10]) ) np.testing.assert_array_equal( - chi_mock.optimize_coefficients.mock_calls[0].args[2], - np.array([1, 1]) + chi_mock.optimize_coefficients.mock_calls[0].args[2], np.array([1, 1]) ) np.testing.assert_array_equal( - chi_mock.optimize_coefficients.mock_calls[0].args[3], - np.array([1, 1]) + chi_mock.optimize_coefficients.mock_calls[0].args[3], np.array([1, 1]) ) np.testing.assert_array_equal( chi_mock.optimize_coefficients.mock_calls[0].args[4], - np.array([1, 1, 1]) + np.array([1, 1, 1]), ) np.testing.assert_array_equal( - chi_mock.optimize_coefficients.mock_calls[0].args[5], - np.array([0, 1]) + chi_mock.optimize_coefficients.mock_calls[0].args[5], np.array([0, 1]) ) - self.assertEqual( - chi_mock.optimize_coefficients.mock_calls[0].args[6], - 2.0 - ) + self.assertEqual(chi_mock.optimize_coefficients.mock_calls[0].args[6], 2.0) - self.assertEqual( - chi_mock.optimize_coefficients.mock_calls[0].args[7], - 1.0 - ) + self.assertEqual(chi_mock.optimize_coefficients.mock_calls[0].args[7], 1.0) self.assertEqual(len(tau_mock.calculate_tau_i_values.mock_calls), 1) - np.testing.assert_array_equal(tau_mock.calculate_tau_i_values.mock_calls[0].args[0], - np.array([2, 6])) + np.testing.assert_array_equal( + tau_mock.calculate_tau_i_values.mock_calls[0].args[0], np.array([2, 6]) + ) - np.testing.assert_array_equal(tau_mock.calculate_tau_i_values.mock_calls[0].args[1], - np.array([6, 10])) + np.testing.assert_array_equal( + tau_mock.calculate_tau_i_values.mock_calls[0].args[1], np.array([6, 10]) + ) - np.testing.assert_array_equal(tau_mock.calculate_tau_i_values.mock_calls[0].args[2], - np.array([1, 1])) + np.testing.assert_array_equal( + tau_mock.calculate_tau_i_values.mock_calls[0].args[2], np.array([1, 1]) + ) - np.testing.assert_array_equal(tau_mock.calculate_tau_i_values.mock_calls[0].args[3], - np.array([1, 1])) + np.testing.assert_array_equal( + tau_mock.calculate_tau_i_values.mock_calls[0].args[3], np.array([1, 1]) + ) - np.testing.assert_array_equal(tau_mock.calculate_tau_i_values.mock_calls[0].args[4], - np.array([1, 1, 1])) + np.testing.assert_array_equal( + tau_mock.calculate_tau_i_values.mock_calls[0].args[4], + np.array([1, 1, 1]), + ) - np.testing.assert_array_equal(tau_mock.calculate_tau_i_values.mock_calls[0].args[5], - np.array([0, 1])) + np.testing.assert_array_equal( + tau_mock.calculate_tau_i_values.mock_calls[0].args[5], np.array([0, 1]) + ) - self.assertEqual(tau_mock.calculate_tau_i_values.mock_calls[0].args[6], - (-5, 5)) + self.assertEqual( + tau_mock.calculate_tau_i_values.mock_calls[0].args[6], (-5, 5) + ) - self.assertEqual(tau_mock.calculate_tau_i_values.mock_calls[0].args[7], - 1.0) + self.assertEqual(tau_mock.calculate_tau_i_values.mock_calls[0].args[7], 1.0) - self.assertEqual(tau_mock.calculate_tau_i_values.mock_calls[0].args[8], - None) + self.assertEqual( + tau_mock.calculate_tau_i_values.mock_calls[0].args[8], None + ) - self.assertEqual(len(delta_tau_mock.calculate_error_propagation_terms.mock_calls), 1) + self.assertEqual( + len(delta_tau_mock.calculate_error_propagation_terms.mock_calls), 1 + ) np.testing.assert_array_equal( delta_tau_mock.calculate_error_propagation_terms.mock_calls[0].args[0], - np.array([6, 10])) + np.array([6, 10]), + ) np.testing.assert_array_equal( delta_tau_mock.calculate_error_propagation_terms.mock_calls[0].args[1], - np.array([1, 1])) + np.array([1, 1]), + ) np.testing.assert_array_equal( delta_tau_mock.calculate_error_propagation_terms.mock_calls[0].args[2], - np.array([1, 1])) + np.array([1, 1]), + ) np.testing.assert_array_equal( delta_tau_mock.calculate_error_propagation_terms.mock_calls[0].args[3], - np.array([0, 1])) + np.array([0, 1]), + ) np.testing.assert_array_equal( delta_tau_mock.calculate_error_propagation_terms.mock_calls[0].args[4], - np.array([2, 3, 1])) + np.array([2, 3, 1]), + ) self.assertEqual( delta_tau_mock.calculate_error_propagation_terms.mock_calls[0].args[5], - 2.0 + 2.0, ) self.assertEqual(len(tau_final_mock.calculate_tau_final.mock_calls), 1) np.testing.assert_array_equal( tau_final_mock.calculate_tau_final.mock_calls[0].args[0], - np.array([3, 1.66666667]) + np.array([3, 1.66666667]), ) np.testing.assert_array_equal( tau_final_mock.calculate_tau_final.mock_calls[0].args[1], - np.array([0.6, 0.2]) + np.array([0.6, 0.2]), ) diff --git a/tests/core/delta_tau_test.py b/tests/core/delta_tau_test.py index 4ba62b4..302554f 100644 --- a/tests/core/delta_tau_test.py +++ b/tests/core/delta_tau_test.py @@ -226,15 +226,13 @@ def testCanCalculateErrorPropagation(self): unshifted_intensities: np.array = np.array([4, 5, 6]) taufactor = 0.4 - calculated_error_propagation_terms = ( - calculate_error_propagation_terms( - unshifted_intensities, - delta_shifted_intensities, - delta_unshifted_intensities, - distances, - coefficients, - taufactor, - ) + calculated_error_propagation_terms = calculate_error_propagation_terms( + unshifted_intensities, + delta_shifted_intensities, + delta_unshifted_intensities, + distances, + coefficients, + taufactor, ) np.testing.assert_array_equal( diff --git a/tests/core/polynomials_test.py b/tests/core/polynomials_test.py index f330b51..01e4dbe 100644 --- a/tests/core/polynomials_test.py +++ b/tests/core/polynomials_test.py @@ -1,7 +1,6 @@ import unittest from unittest.mock import MagicMock, patch -from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances from numpy import ndarray from numpy import array from numpy import testing @@ -22,16 +21,22 @@ def test_CanEvaluateAValidPolynomialAtMeasuringDistances(): numpy_module_mock = set_up_mocks() # Mocked return values of called functions - numpy_module_mock.power.side_effect = [array([1, 1, 1]), array([1, 2, 3]), array([1, 4, 9])] + numpy_module_mock.power.side_effect = [ + array([1, 1, 1]), + array([1, 2, 3]), + array([1, 4, 9]), + ] numpy_module_mock.zeros_like.return_value = array([0, 0, 0]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_polynomial_at_measuring_distances, + ) # Test for a simple quadratic polynomial: 2 + 3x + 4x^2 distances: ndarray = array([1, 2, 3]) @@ -41,7 +46,8 @@ def test_CanEvaluateAValidPolynomialAtMeasuringDistances(): # At x = 3: 2 + 3(3) + 4(3^2) = 2 + 9 + 36 = 47 expected_result: ndarray = array([9, 24, 47]) testing.assert_array_equal( - evaluate_polynomial_at_measuring_distances(distances, coefficients), expected_result + evaluate_polynomial_at_measuring_distances(distances, coefficients), + expected_result, ) @staticmethod @@ -50,24 +56,26 @@ def test_CanEvaluateAPolynomialAtMeasuringDistancesForEmptyDistanceInput(): numpy_module_mock = set_up_mocks() # Mocked return values of called functions - numpy_module_mock.power.side_effect = [array([]), array([]), - array([])] + numpy_module_mock.power.side_effect = [array([]), array([]), array([])] numpy_module_mock.zeros_like.return_value = array([]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_polynomial_at_measuring_distances, + ) distances: ndarray = array([]) coefficients: ndarray = array([2, 3, 4]) # With an empty input array, the result should also be an empty array expected_result: ndarray = array([]) testing.assert_array_equal( - evaluate_polynomial_at_measuring_distances(distances, coefficients), expected_result + evaluate_polynomial_at_measuring_distances(distances, coefficients), + expected_result, ) @staticmethod @@ -76,17 +84,18 @@ def test_CanEvaluateAPolynomialAtMeasuringDistancesForSingleDistanceMeasurement( numpy_module_mock = set_up_mocks() # Mocked return values of called functions - numpy_module_mock.power.side_effect = [array([1]), array([2]), - array([4])] + numpy_module_mock.power.side_effect = [array([1]), array([2]), array([4])] numpy_module_mock.zeros_like.return_value = array([0]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_polynomial_at_measuring_distances, + ) distances: ndarray = array([2]) coefficients: ndarray = array([1, 2]) @@ -94,7 +103,8 @@ def test_CanEvaluateAPolynomialAtMeasuringDistancesForSingleDistanceMeasurement( # At x = 2: 1 + 2(2) = 5 expected_result: ndarray = array([5]) testing.assert_array_equal( - evaluate_polynomial_at_measuring_distances(distances, coefficients), expected_result + evaluate_polynomial_at_measuring_distances(distances, coefficients), + expected_result, ) @staticmethod @@ -103,17 +113,22 @@ def test_CanEvaluateASingleValuePolynomialAtMeasuringDistances(): numpy_module_mock = set_up_mocks() # Mocked return values of called functions - numpy_module_mock.power.side_effect = [array([1, 1, 1]), array([1, 2, 3]), - array([1, 4, 9])] + numpy_module_mock.power.side_effect = [ + array([1, 1, 1]), + array([1, 2, 3]), + array([1, 4, 9]), + ] numpy_module_mock.zeros_like.return_value = array([0, 0, 0]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_polynomial_at_measuring_distances, + ) distances: ndarray = array([1, 2, 3]) coefficients: ndarray = array([5]) @@ -121,7 +136,8 @@ def test_CanEvaluateASingleValuePolynomialAtMeasuringDistances(): # All values should be 5 expected_result: ndarray = array([5, 5, 5]) testing.assert_array_equal( - evaluate_polynomial_at_measuring_distances(distances, coefficients), expected_result + evaluate_polynomial_at_measuring_distances(distances, coefficients), + expected_result, ) @staticmethod @@ -133,12 +149,14 @@ def test_CanEvaluateAnEmptyPolynomialAtMeasuringDistances(): numpy_module_mock.zeros_like.return_value = array([0, 0]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_polynomial_at_measuring_distances, + ) distances: ndarray = array([1, 2]) coefficients: ndarray = array([]) @@ -146,7 +164,8 @@ def test_CanEvaluateAnEmptyPolynomialAtMeasuringDistances(): # with the same length as 'distances' expected_result: ndarray = array([0, 0], float) testing.assert_array_equal( - evaluate_polynomial_at_measuring_distances(distances, coefficients), expected_result + evaluate_polynomial_at_measuring_distances(distances, coefficients), + expected_result, ) @staticmethod @@ -159,12 +178,14 @@ def test_CanEvaluateAValidDifferentiatedPolynomialAtMeasuringDistances(): numpy_module_mock.zeros_like.return_value = array([0, 0, 0]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_differentiated_polynomial_at_measuring_distances, + ) # Test for a simple quadratic polynomial: 2 + 3x + 4x^2 distances: ndarray = array([1, 2, 3]) @@ -175,7 +196,9 @@ def test_CanEvaluateAValidDifferentiatedPolynomialAtMeasuringDistances(): # At x = 3: 3 + 8(3) = 3 + 24 = 27 expected_result: ndarray = array([11, 19, 27]) testing.assert_array_equal( - evaluate_differentiated_polynomial_at_measuring_distances(distances, coefficients), + evaluate_differentiated_polynomial_at_measuring_distances( + distances, coefficients + ), expected_result, ) @@ -189,19 +212,23 @@ def test_CanEvaluateADifferentiatedPolynomialAtMeasuringDistancesForEmptyDistanc numpy_module_mock.zeros_like.return_value = array([]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_differentiated_polynomial_at_measuring_distances, + ) distances: ndarray = array([]) coefficients: ndarray = array([2, 3, 4]) # With an empty input array, the result should also be an empty array expected_result: ndarray = array([]) testing.assert_array_equal( - evaluate_differentiated_polynomial_at_measuring_distances(distances, coefficients), + evaluate_differentiated_polynomial_at_measuring_distances( + distances, coefficients + ), expected_result, ) @@ -215,12 +242,14 @@ def test_CanEvaluateADifferentiatedPolynomialAtMeasuringDistancesForSingleDistan numpy_module_mock.zeros_like.return_value = array([0]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_differentiated_polynomial_at_measuring_distances, + ) distances: ndarray = array([2]) coefficients: ndarray = array([1, 2]) @@ -228,7 +257,9 @@ def test_CanEvaluateADifferentiatedPolynomialAtMeasuringDistancesForSingleDistan # At x = 2: 2 expected_result: ndarray = array([2]) testing.assert_array_equal( - evaluate_differentiated_polynomial_at_measuring_distances(distances, coefficients), + evaluate_differentiated_polynomial_at_measuring_distances( + distances, coefficients + ), expected_result, ) @@ -242,12 +273,14 @@ def test_CanEvaluateADifferentiatedSingleValuePolynomialAtMeasuringDistances(): numpy_module_mock.zeros_like.return_value = array([0, 0, 0]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_differentiated_polynomial_at_measuring_distances, + ) distances: ndarray = array([1, 2, 3]) coefficients: ndarray = array([5]) @@ -255,7 +288,9 @@ def test_CanEvaluateADifferentiatedSingleValuePolynomialAtMeasuringDistances(): # All values should therefore be 0 expected_result: ndarray = array([0, 0, 0]) testing.assert_array_equal( - evaluate_differentiated_polynomial_at_measuring_distances(distances, coefficients), + evaluate_differentiated_polynomial_at_measuring_distances( + distances, coefficients + ), expected_result, ) @@ -268,12 +303,14 @@ def test_CanEvaluateADifferentiatedEmptyPolynomialAtMeasuringDistances(): numpy_module_mock.zeros_like.return_value = array([0, 0]) with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): - from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances + from napytau.core.polynomials import ( + evaluate_differentiated_polynomial_at_measuring_distances, + ) distances: ndarray = array([1, 2]) coefficients: ndarray = array([]) @@ -281,7 +318,9 @@ def test_CanEvaluateADifferentiatedEmptyPolynomialAtMeasuringDistances(): # with the same length as 'distances' expected_result: ndarray = array([0, 0]) testing.assert_array_equal( - evaluate_differentiated_polynomial_at_measuring_distances(distances, coefficients), + evaluate_differentiated_polynomial_at_measuring_distances( + distances, coefficients + ), expected_result, ) diff --git a/tests/core/tau_final_test.py b/tests/core/tau_final_test.py index ecb454b..67b864d 100644 --- a/tests/core/tau_final_test.py +++ b/tests/core/tau_final_test.py @@ -23,10 +23,10 @@ def test_calculateTauFinalForValidData(self): numpy_module_mock.sqrt.return_value: float = 0.894427191 with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): from napytau.core.tau_final import calculate_tau_final @@ -35,12 +35,8 @@ def test_calculateTauFinalForValidData(self): expected_tau_final: float = 2.4 expected_uncertainty: float = 0.894427191 tau_final: (float, float) = calculate_tau_final(tau_i, delta_tau_i) - self.assertAlmostEqual( - tau_final[0], expected_tau_final - ) - self.assertAlmostEqual( - tau_final[1], expected_uncertainty - ) + self.assertAlmostEqual(tau_final[0], expected_tau_final) + self.assertAlmostEqual(tau_final[1], expected_uncertainty) def test_calculateTauFinalForEmptyInput(self): """Returns (-1, -1) if input arrays are empty""" @@ -52,10 +48,10 @@ def test_calculateTauFinalForEmptyInput(self): numpy_module_mock.sqrt.return_value: float = 0 with patch.dict( - "sys.modules", - { - "numpy": numpy_module_mock, - }, + "sys.modules", + { + "numpy": numpy_module_mock, + }, ): from napytau.core.tau_final import calculate_tau_final @@ -63,7 +59,9 @@ def test_calculateTauFinalForEmptyInput(self): delta_tau_i: ndarray = array([]) expected_tau_final: float = -1 expected_uncertainty: float = -1 - self.assertEqual(calculate_tau_final(tau_i, delta_tau_i)[0], expected_tau_final) + self.assertEqual( + calculate_tau_final(tau_i, delta_tau_i)[0], expected_tau_final + ) self.assertEqual( calculate_tau_final(tau_i, delta_tau_i)[1], expected_uncertainty ) diff --git a/tests/core/tau_test.py b/tests/core/tau_test.py index b9482b5..12c20fb 100644 --- a/tests/core/tau_test.py +++ b/tests/core/tau_test.py @@ -108,7 +108,6 @@ def test_CanCalculateTau(self): self.assertEqual(chi_mock.optimize_coefficients.mock_calls[0].args[7], 1.0) - self.assertEqual(len(chi_mock.optimize_t_hyp.mock_calls), 1) testing.assert_array_equal( @@ -148,7 +147,6 @@ def test_CanCalculateTau(self): self.assertEqual(chi_mock.optimize_t_hyp.mock_calls[0].args[7], 1.0) - self.assertEqual( len( polynomials_mock.evaluate_differentiated_polynomial_at_measuring_distances.mock_calls