libra-toolbox 0.6.1.post1__py3-none-any.whl

libra_toolbox/__init__.py

@@ -0,0 +1,21 @@
+try:
+    # Python 3.8+
+    from importlib import metadata
+except ImportError:
+    try:
+        # For older Python versions
+        import importlib_metadata as metadata
+    except ImportError:
+        # If both imports fail, set version to unknown
+        __version__ = "unknown"
+
+try:
+    # Attempt to get the version of the package
+    __version__ = metadata.version("libra_toolbox")
+except Exception:
+    # If it fails, set version to unknown
+    __version__ = "unknown"
+
+from . import tritium
+from . import neutron_detection
+from . import neutronics

libra_toolbox/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.6.1.post1'
+__version_tuple__ = version_tuple = (0, 6, 1)

libra_toolbox/neutron_detection/__init__.py

@@ -0,0 +1 @@
+from . import activation_foils, diamond

libra_toolbox/neutron_detection/activation_foils/__init__.py

@@ -0,0 +1 @@
+from . import explicit, settings, calculations

libra_toolbox/neutron_detection/activation_foils/calculations.py

@@ -0,0 +1,188 @@
+import numpy as np
+import sympy as sp
+from .settings import *
+import datetime
+import matplotlib.pyplot as plt
+
+t = sp.Symbol("t")
+neutron_flux = sp.Symbol("\Gamma_n")
+number_of_Nb93 = sp.Symbol(r"N_{Nb93}")
+decay_constant = sp.Symbol("\lambda", positive=True)
+cross_section = sp.Symbol("\sigma")
+overall_efficiency = sp.Symbol("\eta")
+
+
+def n93_number(foil_mass: float):
+    n93_molar_mass = 92.90637 * ureg.g / ureg.mol
+    return (foil_mass / n93_molar_mass).to(ureg.particle)
+
+
+def delay_time(start_time: str, end_time: str):
+    # convert string to time with datetime
+    start_time = datetime.datetime.strptime(start_time, "%m/%d/%Y %H:%M:%S")
+    end_time = datetime.datetime.strptime(end_time, "%m/%d/%Y %H:%M:%S")
+    return (end_time - start_time).total_seconds() * ureg.s
+
+
+def N_during_irradiation(
+    N0, t, decay_constant, neutron_flux, cross_section, nb_Nb93, t_0, mod=sp
+):
+    A = nb_Nb93 * neutron_flux * cross_section / decay_constant
+    return A + (N0 - A) * mod.exp(-decay_constant * (t - t_0))
+
+
+def N_during_rest(N0, t, decay_constant, t_0, mod=sp):
+    return N0 * mod.exp(-decay_constant * (t - t_0))
+
+
+def get_number_of_Nb92m_after_last_irradiations(irradiations: list):
+    """
+    Returns the number of Nb92m at the end of the last irradiation
+    as a symbolic expression with sympy
+
+
+    Args:
+        irradiations (list): list of dictionaries with keys "t_on" and "t_off"
+
+    Returns:
+        sp.Expression: symbolic expression for the number of Nb92m at the end of the last irradiation
+    """
+
+    # there is a series of irradiation and rest, get the number of Nb92m at the end of the last irradiation
+    t_on = irradiations[0]["t_on"]
+    t_off = irradiations[0]["t_off"]
+    N_after_irradiation = N_during_irradiation(
+        0, t_off, decay_constant, neutron_flux, cross_section, number_of_Nb93, t_on
+    )
+    for irr in irradiations[1:]:
+        N_at_end_of_rest = N_during_rest(
+            N_after_irradiation, irr["t_on"], decay_constant, t_0=t_off
+        )
+        N_after_irradiation = N_during_irradiation(
+            N0=N_at_end_of_rest,
+            t=irr["t_off"],
+            decay_constant=decay_constant,
+            neutron_flux=neutron_flux,
+            cross_section=cross_section,
+            nb_Nb93=number_of_Nb93,
+            t_0=irr["t_on"],
+        )
+        t_off = irr["t_off"]
+
+    return N_after_irradiation
+
+
+def get_number_ofNb92m_numpy(
+    irradiations: list, times: np.ndarray, neutron_flux: float, nb_Nb93: float
+):
+    """
+    Returns the number of Nb92m at different times as a numpy array
+
+    Args:
+        irradiations (list): list of dictionaries with keys "t_on" and "t_off"
+        times (np.ndarray): array of times
+        neutron_flux (float): neutron flux
+        nb_Nb93 (float): number of Nb93 atoms in the foil
+
+    Returns:
+        np.ndarray: array of the number of Nb92m at different times
+    """
+    N = np.zeros_like(times)
+    N[0] = 0
+    decay_constant = Nb92m_decay_constant.to(1 / ureg.s).magnitude
+    cross_section = Nb93_n_2n_Nb92m_cross_section_at_14Mev.to(ureg.cm**2).magnitude
+    t_on = irradiations[0]["t_on"]
+    t_off = irradiations[0]["t_off"]
+    previous_irradiation_off = t_off
+    idx = np.where(
+        np.logical_and(
+            (times >= irradiations[0]["t_on"]), (times <= irradiations[0]["t_off"])
+        )
+    )
+    N[idx] = N_during_irradiation(
+        0,
+        times[idx],
+        decay_constant,
+        neutron_flux,
+        cross_section,
+        nb_Nb93,
+        t_on,
+        mod=np,
+    )
+    current_N = N[idx][-1]
+
+    for irr in irradiations[1:]:
+
+        idx_rest = np.where((times > previous_irradiation_off) & (times <= irr["t_on"]))
+        N[idx_rest] = N_during_rest(
+            current_N,
+            times[idx_rest],
+            decay_constant,
+            t_0=previous_irradiation_off,
+            mod=np,
+        )
+
+        idx_irr = np.where(
+            np.logical_and((times > irr["t_on"]), (times <= irr["t_off"]))
+        )
+        N[idx_irr] = N_during_irradiation(
+            N[idx_rest][-1],
+            times[idx_irr],
+            decay_constant,
+            neutron_flux,
+            cross_section,
+            nb_Nb93,
+            t_0=irr["t_on"],
+            mod=np,
+        )
+        previous_irradiation_off = irr["t_off"]
+        current_N = N[idx_irr][-1]
+
+    if times[-1] not in irradiations[-1].values():
+        idx_rest = np.where((times > previous_irradiation_off))
+        N[idx_rest] = N_during_rest(
+            current_N,
+            times[idx_rest],
+            decay_constant,
+            t_0=previous_irradiation_off,
+            mod=np,
+        )
+    return N
+
+
+if __name__ == "__main__":
+
+    irradiations = [
+        {"t_on": 0, "t_off": 12 * 3600},
+        {"t_on": 24 * 3600, "t_off": 36 * 3600},
+    ]
+
+    times = np.linspace(0, 48 * 3600, 1000)
+    neutron_flux_val = 3.51e9 * ureg["1/(cm^2 h)"]  # 1/(cm^2 h)
+    nb_Nb93 = 1.78e21
+    N = get_number_ofNb92m_numpy(
+        irradiations, times, neutron_flux_val.to(ureg["1/(cm^2 s)"]).magnitude, nb_Nb93
+    )
+    plt.plot(times / 3600, N)
+
+    N_analytical = get_number_of_Nb92m_after_last_irradiations(irradiations)
+
+    N_analytical = (
+        N_analytical.subs(
+            cross_section,
+            Nb93_n_2n_Nb92m_cross_section_at_14Mev.to(ureg.cm**2).magnitude,
+        )
+        .subs(decay_constant, Nb92m_decay_constant.to(1 / ureg.s).magnitude)
+        .subs(neutron_flux, neutron_flux_val.to(ureg["1/(cm^2 s)"]).magnitude)
+        .subs(number_of_Nb93, nb_Nb93)
+    )
+
+    plt.scatter([irradiations[-1]["t_off"] / 3600], [N_analytical], color="red")
+    plt.xlabel("Time (h)")
+    plt.ylabel("Number of Nb92m")
+
+    for irr in irradiations:
+        plt.gca().axvspan(
+            irr["t_on"] / 3600, irr["t_off"] / 3600, alpha=0.2, color="red"
+        )
+    plt.show()

libra_toolbox/neutron_detection/activation_foils/calibration.py

@@ -0,0 +1,39 @@
+import datetime
+
+def get_decay_lines(nuclides:list[str])->dict:
+    """ Creates dictionary of check source data
+    given a list of check source nuclides. """
+    # energy is the gamma energy in units of eV
+    # intensity is the percentage of decays that result in this energy gamma
+    all_decay_lines = {'Ba133':{'energy':[80.9979, 276.3989, 302.8508, 356.0129, 383.8485],
+                         'intensity':[0.329, 0.0716, 0.1834, 0.6205, 0.0894],
+                         'half_life':[10.551*365.25*24*3600],
+                         'activity_date':datetime.date(2014, 3, 19),
+                         'activity':1 * 3.7e4},
+                'Co60':{'energy':[1173.228, 1332.492],
+                        'intensity':[0.9985, 0.999826],
+                        'half_life':[1925.28*24*3600],
+                        'actvity_date':datetime.date(2014, 3, 19),
+                        'activity':0.872 * 3.7e4},
+                'Na22':{'energy':[511, 1274.537],
+                        'intensity':[1.80, 0.9994],
+                        'half_life':[2.6018*365.25*24*3600],
+                        'actvity_date':datetime.date(2014, 3, 19),
+                        'activity': 5 * 3.7e4},
+                'Cs137':{'energy':[661.657],
+                         'intensity':[0.851],
+                         'half_life':[30.08*365.25*24*3600],
+                         'actvity_date':datetime.date(2014, 3, 19),
+                         'activity':4.66 * 3.7e4},
+                'Mn54':{'energy':[834.848],
+                        'intensity':[0.99976],
+                        'half_life':[312.20*24*3600],
+                        'actvity_date':datetime.date(2016, 5, 2),
+                        'activity':6.27 * 3.7e4}}
+    decay_lines = {}
+    for nuclide in nuclides:
+        if nuclide in all_decay_lines.keys():
+            decay_lines[nuclide] = all_decay_lines[nuclide]
+        else:
+            raise ValueError(f'{nuclide} not yet added to get_decay_lines()')
+    return decay_lines

libra_toolbox/neutron_detection/activation_foils/compass.py

@@ -0,0 +1,26 @@
+
+
+def get_channel(filename):
+    """
+    Extract the channel number from a given filename string.
+
+    Parameters
+    ----------
+    filename : str
+        The input filename string containing the channel information.
+        Should look something like : "Data_CH<channel_number>@V...CSV"
+
+    Returns
+    -------
+    int
+        The extracted channel number.
+
+    Example
+    -------
+    >>> get_channel("Data_CH4@V1725_292_Background_250322.CSV")
+    4
+    """
+    return int(filename.split('@')[0][7:])
+
+
+

libra_toolbox/neutron_detection/activation_foils/explicit.py

@@ -0,0 +1,110 @@
+from .settings import *
+from .calculations import n93_number, delay_time
+import numpy as np
+
+
+def get_chain(irradiations):
+    """
+    Returns the value of
+    (1 - exp(-\lambda * \Delta t_1)) * (1 - exp(-\lambda * \Delta t_2)) * ... * (1 - exp(-\lambda * \Delta t_n))
+    where \Delta t_i is the time between the end of the i-th period (rest or irradiation) and the start of the next one
+
+    Args:
+        irradiations (list): list of dictionaries with keys "t_on" and "t_off" for irradiations
+
+    Returns:
+        float or pint.Quantity: the value of the chain
+    """
+    result = 1
+    periods = [{"start": irradiations[0]["t_on"], "end": irradiations[0]["t_off"]}]
+    for irr in irradiations[1:]:
+        periods.append({"start": periods[-1]["end"], "end": irr["t_on"]})
+        periods.append({"start": irr["t_on"], "end": irr["t_off"]})
+
+    for period in periods:
+        delta_t = period["end"] - period["start"]
+        result = 1 - result * np.exp(-Nb92m_decay_constant * delta_t)
+    return result
+
+
+def get_neutron_flux(experiment: dict, irradiations: list):
+    """calculates the neutron flux during the irradiation
+
+    Args:
+        experiment (dict): dictionary containing the experiment data
+        irradiations (list): list of dictionaries with keys "t_on" and "t_off" for irradiations
+
+    Returns:
+        pint.Quantity: neutron flux
+    """
+    overall_efficiency = (
+        (geometric_efficiency * nal_gamma_efficiency * branching_ratio)
+        * ureg.count
+        / ureg.particle
+    )
+    number_of_Nb92m_decays_measured = experiment["photon_counts"] / overall_efficiency
+
+    number_of_Nb92m_decays_measured *= 0.5  # times by 0.5 because of double counting
+
+    flux = (
+        number_of_Nb92m_decays_measured
+        / n93_number(experiment["foil_mass"])
+        / Nb93_n_2n_Nb92m_cross_section_at_14Mev
+    )
+
+    flux *= get_chain(irradiations) ** -1
+    time_between_generator_off_and_start_of_counting = delay_time(
+        experiment["time_generator_off"], experiment["start_time_counting"]
+    )
+    flux *= (
+        -1
+        / Nb92m_decay_constant
+        * (
+            np.exp(
+                -Nb92m_decay_constant
+                * (
+                    time_between_generator_off_and_start_of_counting
+                    + experiment["counting_time"]
+                )
+            )
+            - np.exp(
+                -Nb92m_decay_constant * time_between_generator_off_and_start_of_counting
+            )
+        )
+    ) ** -1
+
+    # convert n/cm2/s to n/s
+    area_of_sphere = 4 * np.pi * experiment["distance_from_center_of_target_plane"] ** 2
+
+    flux *= area_of_sphere
+
+    return flux
+
+
+def get_neutron_flux_error(experiment: dict):
+    """
+    Returns the uncertainty of the neutron flux as a pint.Quantity
+
+    Args:
+        experiment (dict): dictionary containing the experiment data
+        irradiations (list): list of dictionaries with keys "t_on" and "t_off" for irradiations
+
+    Returns:
+        pint.Quantity: uncertainty of the neutron flux
+    """
+    error_counts = experiment["photon_counts_uncertainty"] / experiment["photon_counts"]
+    error_mass = 0.0001 * ureg.g / experiment["foil_mass"]
+    error_geometric_eff = 0.025 / geometric_efficiency
+    error_intrinsic_eff = 0.025 / nal_gamma_efficiency
+
+    error = np.sqrt(
+        error_counts**2
+        + error_mass**2
+        + error_geometric_eff**2
+        + error_intrinsic_eff**2
+    )
+    return error.to(ureg.dimensionless).magnitude
+
+
+if __name__ == "__main__":
+    pass

libra_toolbox/neutron_detection/activation_foils/settings.py

@@ -0,0 +1,17 @@
+import pint
+import numpy as np
+
+ureg = pint.UnitRegistry()
+
+geometric_efficiency = 0.5
+nal_gamma_efficiency = 0.344917296922981
+branching_ratio = 0.999
+
+
+# source: https://scipub.euro-fusion.org/wp-content/uploads/eurofusion/WPJET3PR17_16948_submitted.pdf
+# See Figure 3
+Nb93_n_2n_Nb92m_cross_section_at_14Mev = 0.46 * ureg.barn
+
+# source https://gammaray.inl.gov/SiteAssets/catalogs/ge/pdf/nb92m.pdf
+Nb92m_half_life = 10.25 * ureg.day
+Nb92m_decay_constant = np.log(2) / Nb92m_half_life

libra_toolbox/neutron_detection/diamond/__init__.py

@@ -0,0 +1,2 @@
+from . import process_data
+from . import prt

libra_toolbox/neutron_detection/diamond/process_data.py

@@ -0,0 +1,128 @@
+import numpy as np
+
+
+class DataProcessor:
+    """
+    A class for reading and processing data from diamond detectors as text files
+
+    Attributes:
+        files (list of str): List of text filenames that have been read
+        time_values (np.array): Array of time values from all files
+        energy_values (np.array): Array of energy values from all files
+    """
+
+    def __init__(self) -> None:
+        self.files = []
+
+        self.time_values = np.array([])
+        self.energy_values = np.array([])
+
+    def add_file(
+        self,
+        filename: str,
+        time_column: int,
+        energy_column: int,
+        scale_time: bool = True,
+        **kwargs,
+    ):
+        """
+        Adds a file to the data processor, reading the time and energy values from the file
+        and appending them to the existing data (``time_values`` and ``energy_values`` attributes).
+
+        Args:
+            filename (str): the name of the file to read
+            time_column (int): the column index of the time values in the file
+            energy_column (int): the column index of the energy values in the file
+            scale_time (bool, optional): if True, the time values are scaled from ps to s. Defaults to True.
+        """
+        self.files.append(filename)
+
+        # Should we store the data for each file separately too?
+        data = np.genfromtxt(filename, **kwargs)
+
+        time_values = data[:, time_column]
+        if scale_time:
+            # convert times from ps to s
+            time_values *= 1 / 1e12
+        energy_values = data[:, energy_column]
+
+        # Append time and energy values to the list
+        self.time_values = np.concatenate((self.time_values, time_values))
+        self.energy_values = np.concatenate((self.energy_values, energy_values))
+
+        # sort time and energy values
+        inds = np.argsort(self.time_values)
+        self.time_values = np.array(self.time_values)[inds]
+        self.energy_values = np.array(self.energy_values)[inds]
+
+        print(f"Added file: {filename} containing {len(time_values)} events")
+
+    def get_count_rate(self, bin_time: float, energy_window: tuple = None):
+        """
+        Calculate the count rate in a given time bin for the
+        time values stored in the data processor.
+
+        Args:
+            bin_time (float): the time bin width in seconds
+            energy_window (tuple, optional): If provided, the rate
+                will be computed only on this energy window. Defaults to None.
+
+        Returns:
+            np.array: Array of count rates (counts per second)
+            np.array: Array of time bin edges (in seconds)
+        """
+        time_values = self.time_values.copy()
+        energy_values = self.energy_values.copy()
+
+        time_bins = np.arange(time_values.min(), time_values[-2], bin_time)
+
+        if energy_window is not None:
+            peak_mask = (energy_values > energy_window[0]) & (
+                energy_values < energy_window[1]
+            )
+            time_values = time_values[peak_mask]
+
+        count_rates, count_rate_bins = np.histogram(time_values, bins=time_bins)
+        count_rates = count_rates / bin_time
+
+        return count_rates, count_rate_bins
+
+    def get_avg_rate(self, t_min: float, t_max: float, energy_window: tuple = None):
+        """
+        Calculate the average count rate in a given time window for the
+        time values stored in the data processor.
+        Similar to ``get_count_rate`` but returns a single value for a time window.
+
+        Args:
+            t_min (float): start time of the time window
+            t_max (float): end time of the time window
+            energy_window (tuple, optional): If provided, the rate
+                will be computed only on this energy window. Defaults to None.
+
+        Returns:
+            float: Average count rate (counts per second)
+            float: Error on the average count rate (counts per second)
+        """
+        time_values = self.time_values.copy()
+        energy_values = self.energy_values.copy()
+
+        if energy_window is not None:
+            peak_mask = (energy_values > energy_window[0]) & (
+                energy_values < energy_window[1]
+            )
+            time_values = time_values[peak_mask]
+
+        # Create mask to only count pulses of any energy in section time window
+        idx = np.logical_and(time_values > t_min, time_values < t_max)
+
+        counts = len(time_values[idx])
+        error = np.sqrt(len(time_values[idx]))
+        delta_t = t_max - t_min
+        count_rate = counts / delta_t
+        count_rate_err = error / delta_t
+
+        return count_rate, count_rate_err
+
+
+if __name__ == "__main__":
+    pass