dgm-dayabay-dev 0.2__tar.gz

dgm_dayabay_dev-0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Gonchar Maxim, Tsegelnik Nikita
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dgm_dayabay_dev-0.2/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: dgm-dayabay-dev
+Version: 0.2
+Summary: Implementation of the Daya Bay modelfor dag-modelling framework. Development version.
+Author-email: DAGModelling Team <dagflow@jinr.ru>
+Maintainer-email: DAGModelling Team <dagflow@jinr.ru>
+License-Expression: MIT
+Project-URL: Bug Tracker, https://github.com/dagflow-team/dgm-dayabay-dev/issues
+Project-URL: DAGModelling Team, https://github.com/dagflow-team
+Project-URL: documentation, https://github.com/dagflow-team/dgm-dayabay-dev/wiki
+Project-URL: homepage, https://github.com/dagflow-team/dgm-dayabay-dev
+Project-URL: repository, https://github.com/dagflow-team/dgm-dayabay-dev
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dag-modelling
+Requires-Dist: dgm-fit
+Requires-Dist: dgm-reactor-neutrino
+Requires-Dist: more-itertools
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: nbconvert; extra == "test"
+Requires-Dist: parameterized; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# dgm-dayabay-dev
+
+[![python](https://img.shields.io/badge/python-3.11-purple.svg)](https://www.python.org/)
+[![pipeline](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/badges/main/pipeline.svg)](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/commits/main)
+[![coverage report](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/badges/main/coverage.svg)](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/-/commits/main)
+
+<!--- Uncomment here after adding docs!
+[![pages](https://img.shields.io/badge/pages-link-white.svg)](http://dagflow-team.pages.jinr.ru/dgm-dayabay-dev)
+-->
+
+Implementation of the Daya Bay modelfor `dag-modelling` framework. Development version.
+
+## Repositories
+
+- Main repo:
+  - Development/CI: https://git.jinr.ru/dagflow-team/dgm-dayabay-dev
+  - Contact/pypi/mirror: https://github.com/dagflow-team/dgm-dayabay-dev
+  - PYPI: https://pypi.org/project/dgm-dayabay-dev

dgm_dayabay_dev-0.2/README.md

@@ -0,0 +1,18 @@
+# dgm-dayabay-dev
+
+[![python](https://img.shields.io/badge/python-3.11-purple.svg)](https://www.python.org/)
+[![pipeline](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/badges/main/pipeline.svg)](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/commits/main)
+[![coverage report](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/badges/main/coverage.svg)](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/-/commits/main)
+
+<!--- Uncomment here after adding docs!
+[![pages](https://img.shields.io/badge/pages-link-white.svg)](http://dagflow-team.pages.jinr.ru/dgm-dayabay-dev)
+-->
+
+Implementation of the Daya Bay modelfor `dag-modelling` framework. Development version.
+
+## Repositories
+
+- Main repo:
+  - Development/CI: https://git.jinr.ru/dagflow-team/dgm-dayabay-dev
+  - Contact/pypi/mirror: https://github.com/dagflow-team/dgm-dayabay-dev
+  - PYPI: https://pypi.org/project/dgm-dayabay-dev

dgm_dayabay_dev-0.2/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+
+requires = [ "packaging", "setuptools", "wheel" ]
+
+[project]
+name = "dgm-dayabay-dev"
+version = "0.2"
+description = "Implementation of the Daya Bay modelfor dag-modelling framework. Development version."
+readme = "README.md"
+license = "MIT"
+maintainers = [ { name = "DAGModelling Team", email = "dagflow@jinr.ru" } ]
+authors = [ { name = "DAGModelling Team", email = "dagflow@jinr.ru" } ]
+requires-python = ">=3.11"
+classifiers = [
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+  "dag-modelling",
+  "dgm-fit",
+  "dgm-reactor-neutrino",
+  "more-itertools",
+]
+
+optional-dependencies.test = [ "coverage", "nbconvert", "parameterized", "pytest", "pytest-cov" ]
+
+urls."Bug Tracker" = "https://github.com/dagflow-team/dgm-dayabay-dev/issues"
+urls."DAGModelling Team" = "https://github.com/dagflow-team"
+urls.documentation = "https://github.com/dagflow-team/dgm-dayabay-dev/wiki"
+urls.homepage = "https://github.com/dagflow-team/dgm-dayabay-dev"
+urls.repository = "https://github.com/dagflow-team/dgm-dayabay-dev"
+
+[tool.setuptools.package-data]
+"*" = [ "*.yaml" ]
+
+[tool.setuptools.packages.find]
+where = [ "src" ]
+exclude = [
+  "tests*",
+]
+
+[tool.black]
+line-length = 100
+
+[tool.isort]
+profile = "black"
+line_length = 100
+multi_line_output = 5

dgm_dayabay_dev-0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dgm_dayabay_dev-0.2/src/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-0.2/src/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-0.2/src/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)