Implement change requests.

napytau/core/chi.py

@@ -1,5 +1,5 @@
-from napytau.core.polynomials import polynomial_sum_at_measuring_distances
-from napytau.core.polynomials import differentiated_polynomial_sum_at_measuring_distances # noqa E501
+from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances
+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
@@ -9,7 +9,6 @@
 from typing import Tuple
 
 
-# chi^2 function for fixed t_hyp
 def chi_squared_fixed_t(
     doppler_shifted_intensities: ndarray,
     unshifted_intensities: ndarray,
@@ -47,19 +46,18 @@ def chi_squared_fixed_t(
 
     # Compute the difference between Doppler-shifted intensities and polynomial model
     shifted_intensity_difference: ndarray = (
-                    doppler_shifted_intensities
-                    - polynomial_sum_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
-                * differentiated_polynomial_sum_at_measuring_distances(distances,
+        - (t_hyp
+           * evaluate_differentiated_polynomial_at_measuring_distances(distances,
                                                                        coefficients)
-        )
+           )
     ) / delta_unshifted_intensities
 
     # combine the weighted sum of squared differences
@@ -179,10 +177,8 @@ def optimize_t_hyp(
         # Initial guess for t_hyp. Startíng with the mean reduces likelihood of
         # biasing the optimization process toward one boundary.
         x0=mean(t_hyp_range),
-        bounds=[(t_hyp_range[0], t_hyp_range[1])],  # Boundaries for optimization
+        bounds=[(t_hyp_range[0], t_hyp_range[1])],
     )
 
     # Return optimized t_hyp value
-    optimized_t_hyp: float = result.x
-
-    return optimized_t_hyp
+    return float(result.x)

napytau/core/core.py

@@ -1,7 +1,7 @@
 import numpy as np
-from napytau.core.tau import optimize_t_hyp
-from napytau.core.tau import optimize_coefficients
-from napytau.core.tau import calculate_tau_i
+from napytau.core.chi import optimize_t_hyp
+from napytau.core.chi import optimize_coefficients
+from napytau.core.tau import calculate_tau_i_values
 from napytau.core.delta_tau import calculate_error_propagation_terms
 from napytau.core.tau_final import calculate_tau_final
 from typing import Tuple, Optional
@@ -46,15 +46,15 @@ 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(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(

napytau/core/delta_tau.py

@@ -1,5 +1,5 @@
-from napytau.core.polynomials import differentiated_polynomial_sum_at_measuring_distances # noqa E501
-from napytau.core.polynomials import polynomial_sum_at_measuring_distances
+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
 from numpy import zeros
@@ -20,7 +20,7 @@ def calculate_jacobian_matrix(distances: ndarray, coefficients: ndarray) -> ndar
 
     Returns:
         ndarray:
-        The computed Jacobian matrix with shape (len(times), len(coefficients)).
+        The computed Jacobian matrix with shape (len(distances), len(coefficients)).
     """
 
     # initializes the jacobian matrix
@@ -33,16 +33,18 @@ def calculate_jacobian_matrix(distances: ndarray, coefficients: ndarray) -> ndar
         perturbed_coefficients: ndarray = array(coefficients, dtype=float)
         perturbed_coefficients[i] += epsilon  # slightly disturb the current coefficient
 
-        # Compute the disturbed and original polynomial values at the given times
-        perturbed_function: ndarray = polynomial_sum_at_measuring_distances(
+        # Compute the disturbed and original polynomial values at the given distances
+        perturbed_function: ndarray = evaluate_polynomial_at_measuring_distances(
             distances, perturbed_coefficients
         )
-        original_function: ndarray = polynomial_sum_at_measuring_distances(
+        original_function: ndarray = evaluate_polynomial_at_measuring_distances(
             distances, coefficients
         )
 
         # Calculate the partial derivative coefficients and store it in the
         # Jacobian matrix
+        # jacobian_matrix[:, i] selects the entire column i of the jacobian matrix
+        # The colon (:) indicates all rows and i specifies the column
         jacobian_matrix[:, i] = (perturbed_function - original_function) / epsilon
 
     return jacobian_matrix
@@ -63,16 +65,13 @@ def calculate_covariance_matrix(
         ndarray: The computed covariance matrix for the polynomial coefficients.
     """
 
-    # Compute the Jacobian matrix for the polynomial
     jacobian_matrix: ndarray = calculate_jacobian_matrix(distances, coefficients)
 
     # Construct the weight matrix from the inverse squared errors
     weight_matrix: ndarray = diag(1 / power(delta_shifted_intensities, 2))
 
-    # Compute the fit matrix
     fit_matrix: ndarray = jacobian_matrix.T @ weight_matrix @ jacobian_matrix
 
-    # Invert the fit matrix to get the covariance matrix
     covariance_matrix: ndarray = linalg.inv(fit_matrix)
 
     return covariance_matrix
@@ -98,19 +97,18 @@ def calculate_error_propagation_terms(
         taufactor (float): Scaling factor related to the Doppler-shift model.
 
     Returns:
-        ndarray: The combined error propagation terms for each time point.
+        ndarray: The combined error propagation terms for each distance point.
     """
 
-    calculated_differentiated_polynomial_sum_at_measuring_times = (
-        differentiated_polynomial_sum_at_measuring_distances(  # noqa E501
+    calculated_differentiated_polynomial_sum_at_measuring_distances = (
+        evaluate_differentiated_polynomial_at_measuring_distances(  # noqa E501
             distances,
             coefficients,
         )
     )
 
-    # First summand: Contribution from unshifted intensity errors
-    first_summand: ndarray = power(delta_unshifted_intensities, 2) / power(
-        calculated_differentiated_polynomial_sum_at_measuring_times,
+    gaussian_error_from_unshifted_intensity: ndarray = power(delta_unshifted_intensities, 2) / power(
+        calculated_differentiated_polynomial_sum_at_measuring_distances,
         2,
     )
 
@@ -128,21 +126,19 @@ def calculate_error_propagation_terms(
                 + power(distances, k) * power(distances, l) * covariance_matrix[k, l]
             )
 
-    # Second summand: Contribution from polynomial uncertainties
-    second_summand: ndarray = (
+    gaussian_error_from_polynomial_uncertainties: ndarray = (
         power(unshifted_intensities, 2)
         / power(
-            calculated_differentiated_polynomial_sum_at_measuring_times,
+            calculated_differentiated_polynomial_sum_at_measuring_distances,
             4,
         )
     ) * power(delta_p_j_i_squared, 2)
 
-    # Third summand: Mixed covariance contribution
-    third_summand: ndarray = (
+    error_from_covariance: ndarray = (
         unshifted_intensities * taufactor * delta_p_j_i_squared
-    ) / power(calculated_differentiated_polynomial_sum_at_measuring_times, 3)
+    ) / 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
     # Return the sum of all three contributions
-    result: ndarray = first_summand + second_summand + third_summand
-
-    return result
+    return res

napytau/core/polynomials.py

@@ -1,12 +1,10 @@
 from numpy import ndarray
-from numpy import array
 from numpy import power
-from numpy import zeros
 from numpy import zeros_like
 
 
-def polynomial_sum_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.
 
@@ -21,18 +19,18 @@ def polynomial_sum_at_measuring_distances(distances: ndarray,
         ndarray: Array of polynomial values evaluated at the given distance points.
     """
 
-    # If no coefficients are provided, return a ndarray of zeros
     if len(coefficients) == 0:
-        return zeros(array(len(distances)), dtype=float)
+        return zeros_like(distances)
 
     # Evaluate the polynomial sum at the given time points
-    result: ndarray = zeros_like(distances)
-    for i, c in enumerate(coefficients):
-        result += c * power(distances, i)
-    return result
+    sum_at_measuring_distances: ndarray = zeros_like(distances)
+    for exponent, coefficient in enumerate(coefficients):
+        sum_at_measuring_distances += coefficient * power(distances, exponent)
 
+    return sum_at_measuring_distances
 
-def differentiated_polynomial_sum_at_measuring_distances(
+
+def evaluate_differentiated_polynomial_at_measuring_distances(
     distances: ndarray, coefficients: ndarray
 ) -> ndarray:
     """
@@ -50,8 +48,9 @@ def differentiated_polynomial_sum_at_measuring_distances(
         ndarray:
         Array of the derivative values of the polynomial at the given distance points.
     """
-    result: ndarray = zeros_like(distances)
-    for i, c in enumerate(coefficients):
-        if i > 0:
-            result += i * c * power(distances, (i - 1))
-    return result
+    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))
+
+    return sum_of_derivative_at_measuring_distances

napytau/core/tau.py

@@ -1,11 +1,11 @@
 from napytau.core.chi import optimize_t_hyp
 from napytau.core.chi import optimize_coefficients
-from napytau.core.polynomials import differentiated_polynomial_sum_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
 
 
-def calculate_tau_i(
+def calculate_tau_i_values(
     doppler_shifted_intensities: ndarray,
     unshifted_intensities: ndarray,
     delta_doppler_shifted_intensities: ndarray,
@@ -70,11 +70,11 @@ def calculate_tau_i(
     )[0]
 
     # calculate decay times using the optimized coefficients
-    tau_i: ndarray = (
+    tau_i_values: ndarray = (
             unshifted_intensities
-            / differentiated_polynomial_sum_at_measuring_distances(
+            / evaluate_differentiated_polynomial_at_measuring_distances(
             distances, optimized_coefficients
         )
     )
 
-    return tau_i
+    return tau_i_values