data-manipulation-utilities 0.2.7__py3-none-any.whl → 0.2.8.dev714__py3-none-any.whl

dmu/stats/model_factory.py

@@ -2,6 +2,7 @@
 Module storing ZModel class
 '''
 # pylint: disable=too-many-lines, import-error, too-many-positional-arguments, too-many-arguments
+# pylint: disable=too-many-instance-attributes
 
 from typing import Callable, Union
 
@@ -10,6 +11,7 @@ import zfit
 from zfit.core.interfaces   import ZfitSpace as zobs
 from zfit.core.basepdf      import BasePDF   as zpdf
 from zfit.core.parameter    import Parameter as zpar
+from dmu.stats.parameters   import ParameterLibrary as PL
 from dmu.stats.zfit_models  import HypExp
 from dmu.stats.zfit_models  import ModExp
 from dmu.logging.log_store  import LogStore
@@ -69,7 +71,13 @@ class ModelFactory:
     l_shr = ['mu']
     l_flt = ['mu', 'sg']
     d_rep = {'mu' : 'scale', 'sg' : 'reso'}
-    mod   = ModelFactory(preffix = 'signal', obs = obs, l_pdf = l_pdf, l_shared = l_shr, d_rep = d_rep)
+    mod   = ModelFactory(
+            preffix = 'signal', 
+            obs     = obs, 
+            l_pdf   = l_pdf, 
+            l_shared= l_shr, 
+            d_rep   = d_rep)
+
     pdf   = mod.get_pdf()
     ```
 
@@ -81,23 +89,26 @@ class ModelFactory:
     '''
     #-----------------------------------------
     def __init__(self,
-                 preffix  : str,
-                 obs      : zobs,
-                 l_pdf    : list[str],
-                 l_shared : list[str],
-                 l_float  : list[str],
-                 d_fix    : dict[str:float] = None,
-                 d_rep    : dict[str:str]   = None):
+        preffix  : str,
+        obs      : zobs,
+        l_pdf    : list[str],
+        l_shared : list[str],
+        l_float  : list[str],
+        l_reuse  : None | list[zpar]      = None,
+        d_fix    : None | dict[str,float] = None,
+        d_rep    : None | dict[str,str]   = None):
         '''
         preffix:  used to identify PDF, will be used to name every parameter
         obs:      zfit obserbable
         l_pdf:    List of PDF nicknames which are registered below
         l_shared: List of parameter names that are shared
         l_float:  List of parameter names to allow to float
+        l_reuse:  Optional. List of parameters that if given will be used instead of built by factory
         d_fix:    Dictionary with keys as the beginning of the name of a parameter and value as the number
                   to which it has to be fixed. If not one and only one parameter is found, ValueError is raised
         d_rep:    Dictionary with keys as variables that will be reparametrized
         '''
+        l_reuse = [] if l_reuse is None else l_reuse
 
         self._preffix         = preffix
         self._l_pdf           = l_pdf
@@ -105,6 +116,7 @@ class ModelFactory:
         self._l_flt           = l_float
         self._d_fix           = d_fix
         self._d_rep           = d_rep
+        self._d_reuse         = { par.name : par for par in l_reuse }
         self._obs             = obs
 
         self._d_par : dict[str,zpar] = {}
@@ -112,6 +124,13 @@ class ModelFactory:
         self._check_reparametrization()
     #-----------------------------------------
     def _check_reparametrization(self) -> None:
+        '''
+        This method:
+
+        - Returns if no reparametrization has been requested
+        - Raises if reparametrization is on any fixed parameter
+        - Raises if trying to reparametrize anything that is not scales and resolutions
+        '''
         if self._d_rep is None:
             return
 
@@ -119,6 +138,8 @@ class ModelFactory:
         s_par_2 = set(self._l_flt)
 
         if not s_par_1.isdisjoint(s_par_2):
+            log.info(f'Found  : {s_par_1}')
+            log.info(f'Allowed: {s_par_2}')
             raise ValueError('Non empty intersection between floating and reparametrization parameters')
 
         s_kind  = set(self._d_rep.values())
@@ -133,41 +154,109 @@ class ModelFactory:
         return pname, xname
     #-----------------------------------------
     def _get_parameter_name(self, name : str, suffix : str) -> str:
+        '''
+        Parameters
+        ---------------
+        name  : Name of pdf and physical name, e.g mu_gauss
+        suffix: Identifies this PDF, e.g. index of 3rd gaussian
+
+        Returns
+        ---------------
+        Name of parameter which:
+
+        - mu          if parameter is meant to be reused, e.g. same mu for all PDFs
+        - mu_preffix, if parameter is shared
+        - mu_preffix3 if not shared but not floating
+        - mu_preffix3_flt if not shared and floating
+        '''
+        # pname = physical name, is something like mu or sg
         pname, xname = self._split_name(name)
-
         log.debug(f'Using physical name: {pname}')
 
+        if pname in self._l_flt:
+            # If reused parameter is floating
+            # find it with flt
+            reuse_name = f'{pname}_flt'
+        else:
+            reuse_name = pname
+
+        if reuse_name in self._d_reuse:
+            log.debug(f'Picking name {reuse_name} for reused parameter')
+            return self._add_float(pname=pname, name=pname)
+
         if pname in self._l_shr:
             name = f'{pname}_{self._preffix}'
+            log.debug(f'Using model specific parameter name {name}')
         else:
             name = f'{pname}_{xname}_{self._preffix}{suffix}'
+            log.debug(f'Using component specific parameter name {name}')
 
-        if pname in self._l_flt:
-            return f'{name}_flt'
+        return self._add_float(pname=pname, name=name)
+    #-----------------------------------------
+    def _add_float(self, pname : str, name : str) -> str:
+        '''
+        Parameters
+        -------------
+        pname : Physical name, e.g. mu
+        name  : Actual parameter name, e.g. mu_cbl_3
+
+        Returns
+        -------------
+        Actual parameter name with _flt appended if the physical version is meant to float
+        '''
+        if pname not in self._l_flt:
+            return name
 
-        return name
+        return f'{name}_flt'
     #-----------------------------------------
     def _get_parameter(
             self,
+            kind   : str,
             name   : str,
-            suffix : str,
-            val    : float,
-            low    : float,
-            high   : float) -> zpar:
+            suffix : str) -> zpar:
+        '''
+        Parameters
+        ----------------
+        kind  : Identifies PDF, e.g. gaus
+        name  : Physical name of parameter, e.g. mu
+        suffix: If multiple PDFs of this kind, it will be some sort of index, e.g. gaus(1), gaus(2)
+
+        Returns
+        ----------------
+        Parameter, if it was :
+
+        - Provided as part of l_reuse (e.g. mu), it will pick it up instead of building it
+        - Specified as shared, it will build it once and then reuse that one.
+        - Otherwise, it will make a new one, with a suffix to diferentiate it from whatever was already created 
+        '''
 
-        par_name = self._get_parameter_name(name, suffix)
+        par_name = self._get_parameter_name(f'{name}_{kind}', suffix)
         log.debug(f'Assigning name: {par_name}')
 
+        if par_name in self._d_reuse:
+            log.info(f'Reusing {par_name}')
+            return self._d_reuse[par_name]
+
         if par_name in self._d_par:
+            log.info(f'Picking already made parameter {par_name}')
             return self._d_par[par_name]
 
         is_reparametrized = self._is_reparametrized(name)
 
+        val, low, high = PL.get_values(kind=kind, parameter=name)
+
         if is_reparametrized:
             init_name, _ = self._split_name(par_name)
+            log.info(f'Reparametrizing {par_name}')
             par  = self._get_reparametrization(par_name, init_name, val, low, high)
         else:
-            par  = zfit.param.Parameter(par_name, val, low, high)
+            if val == low == high:
+                log.warning(f'Upper and lower edges agree, fixing parameter to: {low}')
+                par  = zfit.param.Parameter(par_name, val, low - 1 , high + 1)
+                par.floating = False
+            else:
+                log.debug(f'Creating new parameter {par_name}')
+                par  = zfit.param.Parameter(par_name, val, low, high)
 
         self._d_par[par_name] = par
 
@@ -204,16 +293,16 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('exp')
     def _get_exponential(self, suffix : str = '') -> zpdf:
-        c   = self._get_parameter('c_exp', suffix, -0.010, -0.020, -0.0001)
+        c   = self._get_parameter('exp', 'c', suffix)
         pdf = zfit.pdf.Exponential(c, self._obs, name=f'exp{suffix}')
 
         return pdf
     # ---------------------------------------------
     @MethodRegistry.register('hypexp')
     def _get_hypexp(self, suffix : str = '') -> zpdf:
-        mu = zfit.Parameter('mu_hypexp',  5000,   4000,  6000)
-        ap = zfit.Parameter('ap_hypexp', 0.020,      0,  0.10)
-        bt = zfit.Parameter('bt_hypexp', 0.002, 0.0001, 0.003)
+        mu = self._get_parameter('hypexp', 'mu', suffix)
+        ap = self._get_parameter('hypexp', 'ap', suffix)
+        bt = self._get_parameter('hypexp', 'bt', suffix)
 
         pdf= HypExp(obs=self._obs, mu=mu, alpha=ap, beta=bt, name=f'hypexp{suffix}')
 
@@ -221,9 +310,9 @@ class ModelFactory:
     # ---------------------------------------------
     @MethodRegistry.register('modexp')
     def _get_modexp(self, suffix : str = '') -> zpdf:
-        mu = zfit.Parameter('mu_modexp',  4250,  4250,  4500)
-        ap = zfit.Parameter('ap_modexp', 0.002, 0.002, 0.026)
-        bt = zfit.Parameter('bt_modexp', 0.002, 0.002, 0.020)
+        mu = self._get_parameter('modexp', 'mu', suffix)
+        ap = self._get_parameter('modexp', 'ap', suffix)
+        bt = self._get_parameter('modexp', 'bt', suffix)
 
         pdf= ModExp(obs=self._obs, mu=mu, alpha=ap, beta=bt, name=f'modexp{suffix}')
 
@@ -231,34 +320,35 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('pol1')
     def _get_pol1(self, suffix : str = '') -> zpdf:
-        a   = self._get_parameter('a_pol1', suffix, -0.005, -0.95, 0.00)
+        a   = self._get_parameter('pol1', 'a', suffix)
         pdf = zfit.pdf.Chebyshev(obs=self._obs, coeffs=[a], name=f'pol1{suffix}')
 
         return pdf
     #-----------------------------------------
     @MethodRegistry.register('pol2')
     def _get_pol2(self, suffix : str = '') -> zpdf:
-        a   = self._get_parameter('a_pol2', suffix, -0.005, -0.95, 0.00)
-        b   = self._get_parameter('b_pol2', suffix,  0.000, -0.95, 0.95)
+        a   = self._get_parameter('pol2', 'a', suffix)
+        b   = self._get_parameter('pol2', 'b', suffix)
         pdf = zfit.pdf.Chebyshev(obs=self._obs, coeffs=[a, b   ], name=f'pol2{suffix}')
 
         return pdf
     # ---------------------------------------------
     @MethodRegistry.register('pol3')
     def _get_pol3(self, suffix : str = '') -> zpdf:
-        a   = zfit.Parameter('a_pol3', -0.005, -0.95, 0.00)
-        b   = zfit.Parameter('b_pol3',  0.000, -0.95, 0.95)
-        c   = zfit.Parameter('c_pol3',  0.000, -0.95, 0.95)
+        a   = self._get_parameter('pol3', 'a', suffix)
+        b   = self._get_parameter('pol3', 'b', suffix)
+        c   = self._get_parameter('pol3', 'c', suffix)
+
         pdf = zfit.pdf.Chebyshev(obs=self._obs, coeffs=[a, b, c], name=f'pol3{suffix}')
 
         return pdf
     #-----------------------------------------
     @MethodRegistry.register('cbr')
     def _get_cbr(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_cbr', suffix, 5300, 5100, 5500)
-        sg  = self._get_parameter('sg_cbr', suffix,   10,    2,  300)
-        ar  = self._get_parameter('ac_cbr', suffix,   -2, -14., -0.1)
-        nr  = self._get_parameter('nc_cbr', suffix,    1,  0.5,  150)
+        mu  = self._get_parameter('cbr', 'mu', suffix)
+        sg  = self._get_parameter('cbr', 'sg', suffix)
+        ar  = self._get_parameter('cbr', 'ac', suffix)
+        nr  = self._get_parameter('cbr', 'nc', suffix)
 
         pdf = zfit.pdf.CrystalBall(mu, sg, ar, nr, self._obs, name=f'cbr{suffix}')
 
@@ -266,10 +356,10 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('suj')
     def _get_suj(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_suj', suffix, 5300, 5000, 6000)
-        sg  = self._get_parameter('sg_suj', suffix,   10,    2, 5000)
-        gm  = self._get_parameter('gm_suj', suffix,    1,  -10,   10)
-        dl  = self._get_parameter('dl_suj', suffix,    1,  0.1,   40)
+        mu  = self._get_parameter('suj', 'mu', suffix)
+        sg  = self._get_parameter('suj', 'sg', suffix)
+        gm  = self._get_parameter('suj', 'gm', suffix)
+        dl  = self._get_parameter('suj', 'dl', suffix)
 
         pdf = zfit.pdf.JohnsonSU(mu, sg, gm, dl, self._obs, name=f'suj{suffix}')
 
@@ -277,10 +367,10 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('cbl')
     def _get_cbl(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_cbl', suffix, 5300, 5100, 5500)
-        sg  = self._get_parameter('sg_cbl', suffix,   10,    2,  300)
-        al  = self._get_parameter('ac_cbl', suffix,    2,  0.0,  14.)
-        nl  = self._get_parameter('nc_cbl', suffix,    1,  0.5,  150)
+        mu  = self._get_parameter('cbl', 'mu', suffix)
+        sg  = self._get_parameter('cbl', 'sg', suffix)
+        al  = self._get_parameter('cbl', 'ac', suffix)
+        nl  = self._get_parameter('cbl', 'nc', suffix)
 
         pdf = zfit.pdf.CrystalBall(mu, sg, al, nl, self._obs, name=f'cbl{suffix}')
 
@@ -288,8 +378,8 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('gauss')
     def _get_gauss(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_gauss', suffix, 5300, 5100, 5500)
-        sg  = self._get_parameter('sg_gauss', suffix,   10,    2,  300)
+        mu  = self._get_parameter('gauss', 'mu', suffix)
+        sg  = self._get_parameter('gauss', 'sg', suffix)
 
         pdf = zfit.pdf.Gauss(mu, sg, self._obs, name=f'gauss{suffix}')
 
@@ -297,12 +387,12 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('dscb')
     def _get_dscb(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_dscb', suffix, 5300, 5000, 5400)
-        sg  = self._get_parameter('sg_dscb', suffix,   10,    2,  500)
-        ar  = self._get_parameter('ar_dscb', suffix,    1,    0,    5)
-        al  = self._get_parameter('al_dscb', suffix,    1,    0,    5)
-        nr  = self._get_parameter('nr_dscb', suffix,    2,    1,  150)
-        nl  = self._get_parameter('nl_dscb', suffix,    2,    0,  150)
+        mu  = self._get_parameter('dscb', 'mu', suffix)
+        sg  = self._get_parameter('dscb', 'sg', suffix)
+        ar  = self._get_parameter('dscb', 'ar', suffix)
+        al  = self._get_parameter('dscb', 'al', suffix)
+        nr  = self._get_parameter('dscb', 'nr', suffix)
+        nl  = self._get_parameter('dscb', 'nl', suffix)
 
         pdf = zfit.pdf.DoubleCB(mu, sg, al, nl, ar, nr, self._obs, name=f'dscb{suffix}')
 
@@ -310,9 +400,9 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('voigt')
     def _get_voigt(self, suffix : str = '') -> zpdf:
-        mu  = zfit.Parameter('mu_voigt', 5280,  5040, 5500)
-        sg  = zfit.Parameter('sg_voigt',   20,    10,  400)
-        gm  = zfit.Parameter('gm_voigt',    4,   0.1,  100)
+        mu  = self._get_parameter('voigt', 'mu', suffix)
+        sg  = self._get_parameter('voigt', 'sg', suffix)
+        gm  = self._get_parameter('voigt', 'gm', suffix)
 
         pdf = zfit.pdf.Voigt(m=mu, sigma=sg, gamma=gm, obs=self._obs, name=f'voigt{suffix}')
 
@@ -320,9 +410,9 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('qgauss')
     def _get_qgauss(self, suffix : str = '') -> zpdf:
-        mu  = zfit.Parameter('mu_qgauss', 5280,  5040, 5500)
-        sg  = zfit.Parameter('sg_qgauss',   20,    10,  400)
-        q   = zfit.Parameter( 'q_qgauss',    1,     1,    3)
+        mu  = self._get_parameter('qgauss', 'mu', suffix)
+        sg  = self._get_parameter('qgauss', 'sg', suffix)
+        q   = self._get_parameter('qgauss',  'q', suffix)
 
         pdf = zfit.pdf.QGauss(q=q, mu=mu, sigma=sg, obs=self._obs, name =f'qgauss{suffix}')
 
@@ -330,8 +420,8 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('cauchy')
     def _get_cauchy(self, suffix : str = '') -> zpdf:
-        mu  = zfit.Parameter('mu', 5280,  5040, 5500)
-        gm  = zfit.Parameter('gm',  150,    50,  500)
+        mu  = self._get_parameter('cauchy', 'mu', suffix)
+        gm  = self._get_parameter('cauchy', 'gm', suffix)
 
         pdf = zfit.pdf.Cauchy(obs=self._obs, m=mu, gamma=gm, name=f'cauchy{suffix}')
 
@@ -357,7 +447,7 @@ class ModelFactory:
     def _get_pdf(self, kind : str, preffix : str) -> zpdf:
         fun = MethodRegistry.get_method(kind)
         if fun is None:
-            raise NotImplementedError(f'PDF of type {kind} is not implemented')
+            raise NotImplementedError(f'PDF of type \"{kind}\" with preffix \"{preffix}\" is not implemented')
 
         return fun(self, preffix)
     #-----------------------------------------
@@ -375,12 +465,13 @@ class ModelFactory:
     #-----------------------------------------
     def _find_par(self, s_par : set[zpar], name_start : str) -> zpar:
         l_par_match = [ par for par in s_par if par.name.startswith(name_start) ]
+        npar        = len(l_par_match)
 
-        if len(l_par_match) != 1:
+        if npar!= 1:
             for par in s_par:
                 log.info(par.name)
 
-            raise ValueError(f'Not found one and only one parameter starting with: {name_start}')
+            raise ValueError(f'Found {npar} parameters starting with: {name_start}')
 
         return l_par_match[0]
     #-----------------------------------------

dmu/stats/parameters.py

@@ -0,0 +1,100 @@
+'''
+Module with ParameterLibrary class
+'''
+from importlib.resources import files
+
+import yaml
+import pandas as pnd
+
+from dmu.logging.log_store import LogStore
+
+log=LogStore.add_logger('dmu:parameters')
+# --------------------------------
+class ParameterLibrary:
+    '''
+    Class meant to:
+
+    - Connect to database (YAML file) with parameter values and make them available
+    - Allow parameter values to be overriden
+    '''
+    df_parameters : pnd.DataFrame
+    # --------------------------------
+    @staticmethod
+    def _load_data() -> None:
+        if hasattr(ParameterLibrary, 'df_parameters'):
+            return
+
+        data_path = files('dmu_data').joinpath('stats/parameters/data.yaml')
+        data_path = str(data_path)
+
+        d_data = {'parameter' : [], 'kind' : [], 'val' : [], 'low' : [], 'high' : []}
+        with open(data_path, encoding='utf-8') as ifile:
+            data = yaml.safe_load(ifile)
+            for kind, d_par in data.items():
+                for parameter, d_kind in d_par.items():
+                    val = d_kind['val' ]
+                    low = d_kind['low' ]
+                    high= d_kind['high']
+
+                    d_data['parameter'].append(parameter)
+                    d_data['kind'     ].append(kind     )
+                    d_data['val'      ].append(val      )
+                    d_data['low'      ].append(low      )
+                    d_data['high'     ].append(high     )
+
+        df = pnd.DataFrame(d_data)
+
+        ParameterLibrary.df_parameters = df
+    # --------------------------------
+    @staticmethod
+    def print_parameters(kind : str) -> None:
+        '''
+        Method taking the kind of PDF to which the parameters are associated
+        and printing the values.
+        '''
+        df = ParameterLibrary.df_parameters
+        df = df[ df['kind'] == kind ]
+
+        print(df)
+    # --------------------------------
+    @staticmethod
+    def get_values(kind : str, parameter : str) -> tuple[float,float,float]:
+        '''
+        Takes PDF and parameter names and returns default value, low value and high value
+        '''
+        df = ParameterLibrary.df_parameters
+
+        df = df[df['kind']     ==     kind]
+        df = df[df['parameter']==parameter]
+
+        if len(df) != 1:
+            log.info(df)
+            raise ValueError(f'Could not find one and only one row for: {kind}/{parameter}')
+
+        val = df['val'].iloc[0]
+        low = df['low'].iloc[0]
+        high= df['high'].iloc[0]
+
+        return val, low, high
+    # --------------------------------
+    @staticmethod
+    def set_values(
+            parameter : str,
+            kind      : str,
+            val       : float,
+            low       : float,
+            high      : float) -> None:
+        '''
+        This function will override the value and range for the given parameter
+        It should be typically used before using the ModelFactory class
+        '''
+
+        df = ParameterLibrary.df_parameters
+
+        location = (df['parameter'] == parameter) & (df['kind'] == kind)
+
+        df.loc[location, 'val' ] = val
+        df.loc[location, 'low' ] = low
+        df.loc[location, 'high'] = high
+# --------------------------------
+ParameterLibrary._load_data()