dgm-dayabay-dev 0.2__py3-none-any.whl

dgm_dayabay_dev/bundles/cross_check_refine_lsnl_data.py

@@ -0,0 +1,77 @@
+from numpy import arange
+from numpy.typing import NDArray
+from scipy.interpolate import interp1d
+
+from nested_mapping.nested_mapping import NestedMapping
+
+
+def cross_check_refine_lsnl_data(
+    storage: NestedMapping, *, xname: str, nominalname: str, **kwargs
+) -> None:
+    xcoarse = storage[xname]
+
+    refiner = RefineGraph(xcoarse, **kwargs)
+
+    for key, ycoarse in storage.walkitems():
+        if ycoarse is xcoarse:
+            continue
+
+        nominal = storage[nominalname]
+        storage[key] = refiner.process(ycoarse, nominal)
+
+    storage[xname] = refiner.xfine
+
+
+class RefineGraph:
+    __slots__ = (
+        "xcoarse",
+        "xfine",
+        "newmin",
+        "newmax",
+    )
+    xcoarse: NDArray
+    xfine: NDArray
+    newmin: float
+    newmax: float
+
+    def __init__(
+        self,
+        xcoarse: NDArray,
+        *,
+        newmin: float,
+        newmax: float,
+    ):
+        self.xcoarse = xcoarse
+        self.newmin = newmin
+        self.newmax = newmax
+
+        self._process_x()
+
+    def make_x(self) -> None:
+        self.xfine = arange(0.0, 12.0000001, 0.05)
+
+    def _process_x(self) -> None:
+        self.make_x()
+
+    def process(self, y: NDArray, nominal: NDArray) -> NDArray:
+        skip_diff = y is nominal
+        yfine = self._method_interpolate(y)
+        yabs = self._method_reltoabs(yfine)
+
+        return yabs if skip_diff else self._method_diff(nominal, yabs)
+
+    def _method_reltoabs(self, yrel: NDArray) -> NDArray:
+        return yrel * self.xfine
+
+    def _method_interpolate(self, ycoarse) -> NDArray:
+        fcn = interp1d(
+            self.xcoarse,
+            ycoarse,
+            kind="linear",
+            bounds_error=False,
+            fill_value="extrapolate",
+        )
+        return fcn(self.xfine)
+
+    def _method_diff(self, nominal: NDArray, y: NDArray) -> NDArray:
+        return nominal if nominal is y else y - nominal

dgm_dayabay_dev/bundles/refine_detector_data.py

@@ -0,0 +1,46 @@
+from collections.abc import Sequence
+
+from nested_mapping import NestedMapping
+
+
+def refine_detector_data(
+    source: NestedMapping,
+    target: NestedMapping,
+    *,
+    detectors: Sequence[str],
+    periods: Sequence[str] = ("6AD", "8AD", "7AD"),
+    clean_source: bool = True,
+    columns=("livetime", "eff", "efflivetime"),
+    skip: Sequence[set[str]] | None = None,
+) -> None:
+    """Read arrays with detector data for the whole data taking period, write detector
+    data for each period in separate array.
+    """
+    target["days"] = (days_storage := {})
+    for det in detectors:
+        day = source["day", det]
+        step = day[1:] - day[:-1]
+        assert (step == 1).all(), "Expect detector data for each day"
+
+        ndet = source["ndet", det]
+        for periodname in periods:
+            period_ndet = int(periodname[0])
+            mask_period = ndet == period_ndet
+
+            for field in columns:
+                data = source[field, det]
+
+                key = (field, periodname, det)
+                if skip is not None and any(skipkey.issubset(key) for skipkey in skip):
+                    continue
+
+                target[key] = data[mask_period]
+
+            days = source["day", det][mask_period]
+            days_stored = days_storage.setdefault(periodname, days)
+            if days is not days_stored:
+                assert all(days == days_stored)
+
+    if clean_source:
+        for key in tuple(source.walkkeys()):
+            source.delete_with_parents(key)

dgm_dayabay_dev/bundles/refine_lsnl_data.py

@@ -0,0 +1,161 @@
+from numpy import arange, concatenate, linspace
+from numpy.typing import NDArray
+from scipy.interpolate import interp1d
+
+from nested_mapping.nested_mapping import NestedMapping
+
+
+def refine_lsnl_data(
+    storage: NestedMapping, *, xname: str, nominalname: str, **kwargs
+) -> None:
+    xcoarse = storage[xname]
+
+    refiner = RefineGraph(xcoarse, **kwargs)
+
+    for key, ycoarse in storage.walkitems():
+        if ycoarse is xcoarse:
+            continue
+
+        nominal = storage[nominalname]
+        storage[key] = refiner.process(ycoarse, nominal)
+
+    storage[xname] = refiner.xfine_extended
+
+
+class RefineGraph:
+    __slots__ = (
+        "xcoarse",
+        "xfine_bound",
+        "xfine_extended",
+        "xfine_extended_stack",
+        "refine_times",
+        "newmin",
+        "newmax",
+        "savgol_filter_smoothen",
+    )
+    xcoarse: NDArray
+    xfine_bound: NDArray
+    xfine_extended: NDArray
+    xfine_extended_stack: tuple[NDArray | None, NDArray | None, NDArray | None]
+    refine_times: int
+    newmin: float
+    newmax: float
+    savgol_filter_smoothen: tuple[int, int] | None
+
+    def __init__(
+        self,
+        xcoarse: NDArray,
+        *,
+        refine_times: int,
+        newmin: float,
+        newmax: float,
+        savgol_filter_smoothen: tuple[int, int] | None = None,
+    ):
+        self.xcoarse = xcoarse
+        self.refine_times = refine_times
+        self.newmin = newmin
+        self.newmax = newmax
+        self.savgol_filter_smoothen = savgol_filter_smoothen
+
+        self._process_x()
+
+    def make_finer_x(self) -> None:
+        assert self.refine_times % 1 == 0 and self.refine_times > 0
+
+        if self.refine_times == 1:
+            self.xfine_bound = self.xcoarse.copy()
+            return
+
+        shape_fine = (self.xcoarse.size - 1) * self.refine_times + 1
+        self.xfine_bound = linspace(self.xcoarse[0], self.xcoarse[-1], shape_fine)
+
+    def make_extended_x(self):
+        if self.newmin is None and self.newmax is None:
+            return
+
+        xstack = [None, self.xfine_bound, None]
+        if self.newmin is not None:
+            xstack[0] = arange(
+                self.newmin,
+                self.xfine_bound[0],
+                self.xfine_bound[1] - self.xfine_bound[0],
+            )
+
+        if self.newmax is not None:
+            stepright = self.xfine_bound[-1] - self.xfine_bound[-2]
+            xstack[-1] = arange(
+                self.xfine_bound[-1], self.newmax + stepright * 1.0e-6, stepright
+            )[1:]
+
+        self.xfine_extended = concatenate(xstack)
+        self.xfine_extended_stack = tuple(xstack)
+
+    def _process_x(self):
+        self.make_finer_x()
+        self.make_extended_x()
+
+    def process(
+        self,
+        y: NDArray,
+        nominal: NDArray,
+    ) -> NDArray:
+        skip_diff = y is nominal
+        yabs = self._method_reltoabs(y)
+        yfine = self._method_interpolate(yabs)
+        yunbound = self._method_extrapolate(yfine)
+
+        if skip_diff:
+            return yunbound
+
+        ydiff = self._method_diff(nominal, yunbound)
+        if self.savgol_filter_smoothen is None:
+            return ydiff
+
+        ydiff_smooth = self._method_filter(ydiff)
+        return ydiff_smooth
+
+    def _method_reltoabs(self, yrel: NDArray) -> NDArray:
+        return yrel * self.xcoarse
+
+    def _method_interpolate(self, ycoarse) -> NDArray:
+        if self.refine_times == 1:
+            return ycoarse.copy()
+
+        fcn = interp1d(
+            self.xcoarse,
+            ycoarse,
+            kind="cubic",
+            bounds_error=False,
+            fill_value="extrapolate",
+        )
+        return fcn(self.xfine_bound)
+
+    def _method_extrapolate(self, ybound: NDArray) -> NDArray:
+        fcn = interp1d(
+            self.xfine_bound,
+            ybound,
+            kind="linear",
+            bounds_error=False,
+            fill_value="extrapolate",
+        )
+
+        xleft, _, xright = self.xfine_extended_stack
+        ystack = [None, ybound, None]
+        if xleft is not None:
+            ystack[0] = fcn(xleft)
+        if xright is not None:
+            ystack[-1] = fcn(xright)
+
+        return concatenate(ystack)
+
+    def _method_diff(self, nominal: NDArray, y: NDArray) -> NDArray:
+        return nominal if nominal is y else y - nominal
+
+    def _method_filter(self, y: NDArray) -> NDArray:
+        if self.savgol_filter_smoothen is None:
+            return y.copy()
+
+        from scipy.signal import savgol_filter
+
+        npoints_coarse, deg = self.savgol_filter_smoothen
+        return savgol_filter(y, npoints_coarse * self.refine_times, deg)

dgm_dayabay_dev/bundles/refine_reactor_data.py

@@ -0,0 +1,304 @@
+from collections.abc import Sequence
+
+from numba import njit
+from numpy import empty, isnan
+from numpy.typing import NDArray
+
+from nested_mapping import NestedMapping
+
+
+@njit
+def weekly_to_daily(array: NDArray) -> NDArray:
+    ret = empty(array.shape[0] * 7)
+
+    for i in range(7):
+        ret[i::7] = array
+
+    return ret
+
+
+@njit
+def inperiod_to_daily(array: NDArray, ndays: int) -> NDArray:
+    ret = empty(array.shape[0] * ndays)
+
+    for i in range(ndays):
+        ret[i::ndays] = array
+
+    return ret
+
+
+@njit
+def periods_to_days(array: NDArray, ndays: int) -> NDArray:
+    ret = empty(array.shape[0] * ndays)
+
+    for i in range(ndays):
+        ret[i::ndays] = array
+        ret[i::ndays] += i
+
+    return ret
+
+
+@njit
+def weeks_to_days(array: NDArray) -> NDArray:
+    ret = empty(array.shape[0] * 7)
+
+    for i in range(7):
+        ret[i::7] = array
+        ret[i::7] += i
+
+    return ret
+
+
+def refine_reactor_data(
+    source: NestedMapping,
+    target: NestedMapping,
+    *,
+    reactors: Sequence[str],
+    isotopes: Sequence[str],
+    periods: Sequence[int] = (6, 8, 7),
+    clean_source: bool = True,
+) -> None:
+    """Refine reactor reactor data.
+
+    Does the following items:
+        - checks input consistency
+        - split arrays based on isotope number and period name
+        - provides similar data on a daily basis
+        - splits into multiple arrays based on the reactor index
+
+    Source should contain the following fields:
+        - period : int
+              period number
+        - day : int
+              number of the first day of the period, relative to some common day.
+        - ndays : int
+              length of the period in days. This function can deal only with periods of
+              equal length and with no gaps.
+        - core : int
+              number of the current reactor (1 to 6).
+        - ndet : int
+              number of active detectors during the period (6, 8 or 7).
+        - power : dict[str, NDArray]
+              thermal power as a fraction to nominal value (0 to 1) for each reactor
+              core.
+        - u235 : dict[str, NDArray]
+              fission fraction for the ²³⁵U ("U235" should be contained in isotopes) for
+              each reactor core.
+        - <isotope> : dict[str, NDArray]
+              fission fraction for the <isotope> according to isotopes for each reactor
+              core.
+
+    The target dictionary will be populated as follows:
+    ```python
+    target = {
+        "days": array(),
+        "power": {
+            "period_name": {
+                "reactor_name": array(),
+                ...
+            },
+            ...
+        },
+        "fission_fraction": {
+            "isotope_name": {
+                "period_name": {
+                    "reactor_name": array(),
+                    ...
+                },
+                ...
+            },
+        }
+    }
+    ```
+    with all the arrays of same lengths.
+
+    Parameters
+    ----------
+    source : NestedMapping
+        storage/record/mapping with source data.
+    target : NestedMapping
+        storage to write target arrays to.
+    reactors : Sequence[str]
+        reactor names to use when writing data.
+    isotopes : Sequence[str]
+        names of the isotopes to read and write fission fractions.
+    periods : Sequence[int], default=(6, 8, 7)
+        periods (number of active detectors) to select.
+    clean_source : bool, default=True
+        if True, remove used data from source.
+    """
+    for corename in reactors:
+        period = source["period", corename]
+        day = source["day", corename]
+        ndays = source["ndays", corename]
+        ndet = source["ndet", corename]
+
+        ndays0 = ndays[0]
+        if not (ndays[:-1] == ndays0).all():
+            raise ValueError(
+                "refine_reactor_data expects information with constant periodicity"
+            )
+
+        power = source["power"][corename]
+        fission_fractions = {key: source[key.lower(), corename] for key in isotopes}
+
+        step = period[1:] - period[:-1]
+        assert (
+            step == 1
+        ).all(), "Expect reactor data for with distinct period, no gaps"
+
+        target["days"] = (days_storage := {})
+        for period in periods:
+            mask_period = ndet == period
+            periodname = f"{period}AD"
+
+            mask = mask_period
+            key = (
+                periodname,
+                corename,
+            )
+            target[("power",) + key] = inperiod_to_daily(power[mask], ndays0)
+            for isotope in isotopes:
+                target[("fission_fraction",) + key + (isotope,)] = inperiod_to_daily(
+                    fission_fractions[isotope][mask], ndays0
+                )
+
+            days = periods_to_days(day[mask], ndays0)
+            days_stored = days_storage.setdefault(periodname, days)
+            if days is not days_stored:
+                assert all(days == days_stored)
+
+    for key, array in target.walkjoineditems():
+        if isnan(array).any():
+            raise ValueError(f"Invalid refined reactor data for {key}")
+
+    if clean_source:
+        for key in tuple(source.walkkeys()):
+            source.delete_with_parents(key)
+
+
+def split_refine_reactor_data(
+    source: NestedMapping,
+    target: NestedMapping,
+    *,
+    reactors: Sequence[str],
+    isotopes: Sequence[str],
+    periods: Sequence[int] = (6, 8, 7),
+    reactor_number_start: int = 1,
+    clean_source: bool = True,
+) -> None:
+    """Filter/split and refine reactor reactor data.
+
+    Does the following items:
+        - checks input consistency
+        - split arrays based on reactor number, isotope number and period name
+        - provides similar data on a daily basis
+        - splits into multiple arrays based on the reactor index
+
+    Source should contain the following fields:
+        - week : int
+              week/period number
+        - day : int
+              number of the first day of the period, relative to some common day.
+        - ndays : int
+              length of the period in days. This function can deal only with periods of
+              equal length and with no gaps.
+        - core : int
+              number of the current reactor (1 to 6).
+        - ndet : int
+              number of active detectors during the period (6, 8 or 7).
+        - power : float
+              thermal power as a fraction to nominal value (0 to 1).
+        - u235 : float
+              fission fraction for the ²³⁵U ("U235" should be contained in isotopes).
+        - <isotope> : float
+              fission fraction for the <isotope> according to isotopes.
+
+    The target dictionary will be populated as follows:
+    ```python
+    target = {
+        "days": array(),
+        "power": {
+            "period_name": {
+                "reactor_name": array(),
+                ...
+            },
+            ...
+        },
+        "fission_fraction": {
+            "isotope_name": {
+                "period_name": {
+                    "reactor_name": array(),
+                    ...
+                },
+                ...
+            },
+        }
+    }
+    ```
+    with all the arrays of same lengths.
+
+    Parameters
+    ----------
+    source : NestedMapping
+        storage/record/mapping with source data.
+    target : NestedMapping
+        storage to write target arrays to.
+    reactors : Sequence[str]
+        reactor names to use when writing data.
+    isotopes : Sequence[str]
+        names of the isotopes to read and write fission fractions.
+    periods : Sequence[int], default=(6, 8, 7)
+        periods (number of active detectors) to select.
+    reactor_number_start : int, default=1
+        number of the first reactor in the input data.
+    clean_source : bool, default=True
+        if True, remove used data from source.
+    """
+    week = source["week"]
+    day = source["day"]
+    ndays = source["ndays"]
+    core = source["core"]
+    ndet = source["ndet"]
+
+    if not (ndays == 7).all():
+        raise ValueError("refine_reactor_data expects weekly information")
+
+    power = source["power"]
+    fission_fractions = {key: source[key.lower()] for key in isotopes}
+
+    ncores = 6
+    for i in range(ncores):
+        rweek = week[i::ncores]
+        step = rweek[1:] - rweek[:-1]
+        assert (step == 1).all(), "Expect reactor data for each week, no gaps"
+
+    target["days"] = (days_storage := {})
+    for period in periods:
+        mask_period = ndet == period
+        periodname = f"{period}AD"
+
+        for icore, corename in enumerate(reactors, reactor_number_start):
+            mask = mask_period * (core == icore)
+            key = (
+                periodname,
+                corename,
+            )
+            target[("power",) + key] = weekly_to_daily(power[mask])
+            for isotope in isotopes:
+                target[("fission_fraction",) + key + (isotope,)] = weekly_to_daily(
+                    fission_fractions[isotope][mask]
+                )
+
+            days = weeks_to_days(day[mask])
+            days_stored = days_storage.setdefault(periodname, days)
+            if days is not days_stored:
+                assert all(days == days_stored)
+
+    for key, array in target.walkjoineditems():
+        if isnan(array).any():
+            raise ValueError(f"Invalid refined reactor data for {key}")
+
+    if clean_source:
+        for key in tuple(source.walkkeys()):
+            source.delete_with_parents(key)

dgm_dayabay_dev/bundles/sync_reactor_detector_data.py

@@ -0,0 +1,39 @@
+from nested_mapping import NestedMapping
+
+
+def sync_reactor_detector_data(
+    reactor_data: NestedMapping,
+    detector_data: NestedMapping,
+) -> None:
+    reactor_day = reactor_data("days")
+    detector_day = detector_data("days")
+
+    for period, detector_day_p in detector_day.items():
+        reactor_day_p = reactor_day[period]
+
+        offset1 = int(detector_day_p[0] - reactor_day_p[0])
+        offset2 = int(detector_day_p[-1] - reactor_day_p[-1])
+        if offset1 < 0 or offset2 > 0:
+            raise RuntimeError(
+                "Reactor data is expected to start not later and end later then detector data. "
+                f"{period} got start/end for reactor ({reactor_day_p[0]:.0f}, {reactor_day_p[-1]:.0f})"
+                f" and detector ({detector_day_p[0]:.0f}, {detector_day_p[-1]:.0f})"
+            )
+        if offset2 == 0:
+            offset2 = None
+
+        slc = slice(offset1, offset2)
+        reactor_day_p_new = reactor_day_p[slc]
+        assert (
+            reactor_day_p_new == detector_day_p
+        ).all(), f"Unable to synchronize reactor and detector data for {period}"
+
+        reactor_day[period] = reactor_day_p_new
+
+        for key, data in reactor_data.walkitems():
+            if key[0] == "days":
+                continue
+            if not period in key:
+                continue
+
+            reactor_data[key] = data[slc]

dgm_dayabay_dev/models/__init__.py

@@ -0,0 +1,64 @@
+from typing import Mapping
+
+from dag_modelling.tools.logger import logger
+
+from .dayabay_v0 import model_dayabay_v0
+from .dayabay_v0b import model_dayabay_v0b
+from .dayabay_v0c import model_dayabay_v0c
+from .dayabay_v0d import model_dayabay_v0d
+from .dayabay_v0e import model_dayabay_v0e
+
+from .dayabay_labels import LATEX_SYMBOLS
+
+
+AD_TO_EH = {
+    "AD11": "EH1",
+    "AD12": "EH1",
+    "AD21": "EH2",
+    "AD22": "EH2",
+    "AD31": "EH3",
+    "AD32": "EH3",
+    "AD33": "EH3",
+    "AD34": "EH3",
+}
+
+_dayabay_models = {
+    "v0": model_dayabay_v0,
+    "v0b": model_dayabay_v0b,
+    "v0c": model_dayabay_v0c,
+    "v0d": model_dayabay_v0d,
+    "v0e": model_dayabay_v0e,
+}
+_dayabay_models["latest"] = _dayabay_models["v0e"]
+
+_available_sources = ("tsv", "hdf5", "root", "npz")
+
+
+def available_models() -> tuple[str, ...]:
+    return tuple(_dayabay_models.keys())
+
+def available_sources() -> tuple[str, ...]:
+    return _available_sources
+
+def load_model(version, model_options: Mapping | str = {}, **kwargs):
+    if isinstance(model_options, str):
+        from yaml import Loader, load
+
+        model_options = load(model_options, Loader)
+
+    if not isinstance(model_options, dict):
+        raise RuntimeError(
+            "model_options expects a python dictionary or yaml dictionary"
+        )
+
+    model_options = dict(model_options, **kwargs)
+
+    logger.info(f"Execute Daya Bay model {version}")
+    try:
+        cls = _dayabay_models[version]
+    except KeyError:
+        raise RuntimeError(
+            f"Invalid model version {version}. Available models: {', '.join(sorted(_dayabay_models.keys()))}"
+        )
+
+    return cls(**model_options)