Fixed conversion to energy. Cleaned up code. this refs ##230

JeanBilheux · JeanBilheux · commit 7de87cc2743e · 2025-05-26T11:04:42.000-04:00
diff --git a/notebooks/__code/normalization_tof/normalization_for_timepix.py b/notebooks/__code/normalization_tof/normalization_for_timepix.py
@@ -13,8 +13,11 @@
 from IPython.core.display import HTML
 import pandas as pd
 import matplotlib.pyplot as plt
-from enum import Enum
-from scipy.constants import h, c, electron_volt, m_n
+# from enum import Enum
+# from scipy.constants import h, c, electron_volt, m_n
+
+from __code.normalization_tof.units import convert_array_from_time_to_lambda, convert_array_from_time_to_energy
+from __code.normalization_tof.units import TimeUnitOptions, DistanceUnitOptions, EnergyUnitOptions
 
 LOG_PATH = "/SNS/VENUS/shared/log/"
 LOAD_DTYPE = np.uint16
@@ -84,194 +87,6 @@ def retrieve_list_of_tif(folder: str) -> list:
     return list_tif
 
 
-class TimeUnitOptions(str, Enum):
-    s = "s"
-    ms = "ms"
-    us = "us"
-    ns = "ns"
-    ps = "ps"
-
-
-class DistanceUnitOptions(str, Enum):
-    cm = "cm"
-    nm = "nm"
-    pm = "pm"
-    m = "m"
-    angstrom = "angstrom"
-
-
-class EnergyUnitOptions(str, Enum):
-    meV = "meV"
-    eV = "eV"
-    keV = "keV"
-    MeV = "MeV"
-    GeV = "GeV"
-    J = "J"
-
-
-def convert_time_units(from_unit, to_unit):
-    """Convert time from one unit to another unit
-    based on TimeUnitOptions options
-
-    Args:
-        from_unit (TimeUnitOptions): Unit to convert from.
-        to_unit (TimeUnitOptions): Unit to convert to.
-
-    Returns:
-        float: Time in the new unit.
-    """
-
-    # Conversion factors
-    conversion_factors = {
-        TimeUnitOptions.s: 1,
-        TimeUnitOptions.ms: 1e-3,
-        TimeUnitOptions.us: 1e-6,
-        TimeUnitOptions.ns: 1e-9,
-        TimeUnitOptions.ps: 1e-12,
-    }
-
-    return conversion_factors[from_unit] / conversion_factors[to_unit]
-
-
-def convert_to_energy(from_unit, to_unit):
-    """Convert energy from one unit to another unit
-    based on EnergyUnitOptions options
-
-    Args:
-        from_unit (EnergyUnitOptions): Unit to convert from.
-        to_unit (EnergyUnitOptions): Unit to convert to.
-
-    Returns:
-        float: Energy in the new unit.
-    """
-
-    # Conversion factors
-    conversion_factors = {
-        EnergyUnitOptions.meV: 1e-3,
-        EnergyUnitOptions.eV: 1,
-        EnergyUnitOptions.keV: 1e3,
-        EnergyUnitOptions.MeV: 1e6,
-        EnergyUnitOptions.GeV: 1e9,
-        # EnergyUnitOptions.J: 6.242e12,
-        EnergyUnitOptions.J: 1/electron_volt,
-    }
-
-    return conversion_factors[from_unit] / conversion_factors[to_unit]
-
-
-def convert_distance_units(from_unit, to_unit):
-    """Convert distance from one unit to another unit
-    based on DistanceUnitOptions options
-
-    Args:
-        from_unit (DistanceUnitOptions): Unit to convert from.
-        to_unit (DistanceUnitOptions): Unit to convert to.
-
-    Returns:
-        float: distance in the new unit.
-    """
-
-    # Conversion factors
-    conversion_factors = {
-        DistanceUnitOptions.nm: 1e-9,
-        DistanceUnitOptions.cm: 1e-2,
-        DistanceUnitOptions.pm: 1e-12,
-        DistanceUnitOptions.m: 1,
-        DistanceUnitOptions.angstrom: 1e-10,
-    }
-
-    return conversion_factors[from_unit] / conversion_factors[to_unit]
-
-
-def convert_array_from_time_to_lambda(time_array: np.ndarray, 
-                                      time_unit: TimeUnitOptions,       
-                                      distance_source_detector: float,
-                                      distance_source_detector_unit: DistanceUnitOptions,
-                                      detector_offset: float,   
-                                      detector_offset_unit: DistanceUnitOptions,
-                                      lambda_unit: DistanceUnitOptions) -> np.ndarray:
-    """Convert an array of time values to wavelength values.
-
-    Args:
-        time_array (np.ndarray): Array of time values.
-        time_unit (TimeUnitOptions): Unit of the input time.
-        distance_source_detector (float): Distance from the source to the detector.
-        distance_source_detector_unit (DistanceUnitOptions): Unit of the distance.
-        detector_offset (float): Offset of the detector.
-        detector_offset_unit (DistanceUnitOptions): Unit of the offset.
-        lambda_unit (DistanceUnitOptions): Unit of the output wavelength.
-
-    This is using the formula: lambda_m = h/(m_n * distance_source_detector_m) * (time_array_s + detector_offset_s)
-
-    Returns:
-        np.ndarray: Array of wavelength values.
-    """
-    time_array_s = time_array * convert_time_units(time_unit, TimeUnitOptions.s)
-    detector_offset_s = detector_offset * convert_time_units(detector_offset_unit, TimeUnitOptions.s)
-    distance_source_detector_m = distance_source_detector * convert_distance_units(distance_source_detector_unit, DistanceUnitOptions.m)
-
-    h_over_mn = h / m_n
-    lambda_m = h_over_mn * (time_array_s + detector_offset_s) / distance_source_detector_m
-
-    lambda_converted = lambda_m * convert_distance_units(DistanceUnitOptions.m, lambda_unit)
-
-    return lambda_converted
-
-
-def convert_from_wavelength_to_energy_ev(wavelength, 
-                                         unit_from=DistanceUnitOptions.angstrom): 
-    """Convert wavelength to energy based on the given units.
-
-    Args:
-        wavelength (float): Wavelength value.
-        unit_from (WavelengthUnitOptions): Unit of the input wavelength.
-
-    Returns:
-        float: Energy in the new unit.
-    """
-    wavelength_m = wavelength * convert_distance_units(unit_from, DistanceUnitOptions.m)
-    energy = h * c / wavelength_m
-    energy = energy * convert_to_energy(EnergyUnitOptions.J, EnergyUnitOptions.eV)
-    return energy
-
-
-def convert_array_from_time_to_energy(time_array: np.ndarray, 
-                                      time_unit: TimeUnitOptions,       
-                                      distance_source_detector: float,
-                                      distance_source_detector_unit: DistanceUnitOptions,
-                                      detector_offset: float,   
-                                      detector_offset_unit: DistanceUnitOptions,
-                                      energy_unit: EnergyUnitOptions) -> np.ndarray:
-    """Convert an array of time values to energy values.
-
-    Args:
-        time_array (np.ndarray): Array of time values.
-        time_unit (TimeUnitOptions): Unit of the input time.
-        distance_source_detector (float): Distance from the source to the detector.
-        distance_source_detector_unit (DistanceUnitOptions): Unit of the distance.
-        detector_offset (float): Offset of the detector.
-        detector_offset_unit (DistanceUnitOptions): Unit of the offset.
-        energy_unit (EnergyUnitOptions): Unit of the output energy.
-
-    This is using the formula: E = h/(m_n * distance_source_detector_m) * (time_array_s + detector_offset_s)
-
-    Returns:
-        np.ndarray: Array of energy values.
-    """
-    lambda_in_angstroms = convert_array_from_time_to_lambda(time_array, 
-                                                            time_unit, 
-                                                            distance_source_detector,
-                                                            distance_source_detector_unit, 
-                                                            detector_offset, 
-                                                            detector_offset_unit, 
-                                                            DistanceUnitOptions.angstrom)
-
-    energy_array_ev = [convert_from_wavelength_to_energy_ev(l, DistanceUnitOptions.angstrom) for l in lambda_in_angstroms]
-    energy_array = np.array(energy_array_ev)
-
-    return energy_array
-
-
 def normalization_with_list_of_runs(sample_run_numbers: list = None, 
                                     ob_run_numbers: list = None, 
                                     output_folder: str ="./", 
@@ -448,12 +263,12 @@ def normalization_with_list_of_runs(sample_run_numbers: list = None,
                                                           detector_offset_unit=TimeUnitOptions.us,
                                                           lambda_unit=DistanceUnitOptions.angstrom)
         energy_array = convert_array_from_time_to_energy(time_array=time_spectra,
-                                                          time_unit=TimeUnitOptions.s,
-                                                          distance_source_detector=distance_source_detector_m,
-                                                          distance_source_detector_unit=DistanceUnitOptions.m,
-                                                          detector_offset=detector_delay_us,
-                                                          detector_offset_unit=TimeUnitOptions.us,
-                                                          energy_unit=EnergyUnitOptions.eV)
+                                                         time_unit=TimeUnitOptions.s,
+                                                         distance_source_detector=distance_source_detector_m,
+                                                         distance_source_detector_unit=DistanceUnitOptions.m,
+                                                         detector_offset=detector_delay_us,
+                                                         detector_offset_unit=TimeUnitOptions.us,
+                                                         energy_unit=EnergyUnitOptions.eV)
 
         if preview:
 
diff --git a/notebooks/__code/normalization_tof/normalization_tof.py b/notebooks/__code/normalization_tof/normalization_tof.py
@@ -69,8 +69,6 @@ def manually_set_runs(self):
 
         display(HTML("<span style='font-size: 16px; color:red'>You have the option here to enter the runs manually or just use the widgets (following cells) to define them!</span>"))
 
-
-
         if self.debug:
             sample_runs = DEBUG_DATA.sample_runs_selected
             sample_run_numbers_list = []
diff --git a/notebooks/__code/normalization_tof/units.py b/notebooks/__code/normalization_tof/units.py
@@ -205,20 +205,31 @@ def convert_array_from_time_to_energy(time_array: np.ndarray,
         detector_offset_unit (DistanceUnitOptions): Unit of the offset.
         energy_unit (EnergyUnitOptions): Unit of the output energy.
 
-    This is using the formula: E = h/(m_n * distance_source_detector_m) * (time_array_s + detector_offset_s)
-
+    #This is using the formula: E = h/(m_n * distance_source_detector_m) * (time_array_s + detector_offset_s)
+    this is using the formula: E_ev = 1/2 m_n v^2
+    with t_tof = L/v (L distance source to detector in m, v velocity of the neutron in m/s)
+    so E_ev = 1/2 m_n (L/t_tof)^2
+    
     Returns:
         np.ndarray: Array of energy values.
     """
-    lambda_in_angstroms = convert_array_from_time_to_lambda(time_array, 
-                                                            time_unit, 
-                                                            distance_source_detector,
-                                                            distance_source_detector_unit, 
-                                                            detector_offset, 
-                                                            detector_offset_unit, 
-                                                            DistanceUnitOptions.angstrom)
-
-    energy_array_ev = [convert_from_wavelength_to_energy_ev(l, DistanceUnitOptions.angstrom) for l in lambda_in_angstroms]
-    energy_array = np.array(energy_array_ev)
+    
+    time_units_factor = convert_time_units(time_unit, TimeUnitOptions.s)
+    time_array_s = time_array * time_units_factor
+    
+    detector_units_factor = convert_time_units(detector_offset_unit, TimeUnitOptions.s)
+    detector_offset = detector_units_factor * detector_offset
+
+    distance_source_detector_factor = convert_distance_units(distance_source_detector_unit, DistanceUnitOptions.m)
+    distance_source_detector_m = distance_source_detector * distance_source_detector_factor
+    
+    # Calculate the energy in eV using the formula E_ev = 1/2 m_n (L/t_tof)^2 / electron_volt
+
+    full_time_array_s = time_array_s + detector_offset
+    energy_array_ev = 0.5 * m_n * (distance_source_detector_m / full_time_array_s) ** 2 / electron_volt
+
+    energy_array_factor = convert_to_energy(EnergyUnitOptions.eV, energy_unit)
+    energy_array = energy_array_ev * energy_array_factor
+    energy_array = np.array(energy_array)
 
     return energy_array
diff --git a/notebooks/normalization_tof.ipynb b/notebooks/normalization_tof.ipynb
@@ -178,20 +178,6 @@
    "source": [
     "o_norm.run_normalization_with_list_of_runs(preview=True)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
