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

dmu/stats/model_factory.py

@@ -2,13 +2,18 @@
 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
 
 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
 
 log=LogStore.add_logger('dmu:stats:model_factory')
@@ -47,6 +52,13 @@ class MethodRegistry:
             log.info(f'    {value}')
 
         return method
+
+    @classmethod
+    def get_pdf_names(cls) -> list[str]:
+        '''
+        Returns list of PDFs that are registered/supported
+        '''
+        return list(cls._d_method)
 #-----------------------------------------
 class ModelFactory:
     '''
@@ -57,34 +69,82 @@ class ModelFactory:
 
     l_pdf = ['dscb', 'gauss']
     l_shr = ['mu']
-    mod   = ModelFactory(preffix = 'signal', obs = obs, l_pdf = l_pdf, l_shared=l_shr)
+    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)
+
     pdf   = mod.get_pdf()
     ```
 
-    where one can specify which parameters can be shared among the PDFs
+    where one can specify which parameters
+
+    - Can be shared among the PDFs
+    - Are meant to float if this fit is done to MC, in order to fix parameters in data.
+    - Are scales or resolutions that need reparametrizations
     '''
     #-----------------------------------------
     def __init__(self,
-                 preffix  : str,
-                 obs      : zobs,
-                 l_pdf    : list[str],
-                 l_shared : list[str],
-                 l_float  : list[str]):
+        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
         self._l_shr           = l_shared
         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] = {}
+
+        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
+
+        s_par_1 = set(self._d_rep)
+        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())
+        if not s_kind.issubset({'scale', 'reso'}):
+            raise ValueError(f'Only scales and resolution reparametrizations allowed, found: {s_kind}')
     #-----------------------------------------
     def _split_name(self, name : str) -> tuple[str,str]:
         l_part = name.split('_')
@@ -94,67 +154,201 @@ 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,
-                       name   : str,
-                       suffix : str,
-                       val    : float,
-                       low    : float,
-                       high   : float) -> zpar:
+    def _get_parameter(
+            self,
+            kind   : str,
+            name   : str,
+            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 
+        '''
 
-        name = self._get_parameter_name(name, suffix)
-        log.debug(f'Assigning name: {name}')
+        par_name = self._get_parameter_name(f'{name}_{kind}', suffix)
+        log.debug(f'Assigning name: {par_name}')
 
-        if name in self._d_par:
-            return self._d_par[name]
+        if par_name in self._d_reuse:
+            log.info(f'Reusing {par_name}')
+            return self._d_reuse[par_name]
 
-        par  = zfit.param.Parameter(name, val, low, high)
+        if par_name in self._d_par:
+            log.info(f'Picking already made parameter {par_name}')
+            return self._d_par[par_name]
 
-        self._d_par[name] = par
+        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:
+            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
+
+        return par
+    #-----------------------------------------
+    def _is_reparametrized(self, name : str) -> bool:
+        if self._d_rep is None:
+            return False
+
+        root_name, _ = self._split_name(name)
+
+        is_rep = root_name in self._d_rep
+
+        log.debug(f'Reparametrizing {name}: {is_rep}')
+
+        return is_rep
+    #-----------------------------------------
+    def _get_reparametrization(self, par_name : str, init_name : str, value : float, low : float, high : float) -> zpar:
+        log.debug(f'Reparametrizing {par_name}')
+        par_const = zfit.Parameter(par_name, value, low, high)
+        par_const.floating = False
+
+        kind = self._d_rep[init_name]
+        if   kind == 'reso':
+            par_reso  = zfit.Parameter(f'{par_name}_reso_flt' , 1.0, 0.20, 5.0)
+            par       = zfit.ComposedParameter(f'{par_name}_cmp', lambda d_par : d_par['par_const'] * d_par['reso' ], params={'par_const' : par_const, 'reso'  : par_reso } )
+        elif kind == 'scale':
+            par_scale = zfit.Parameter(f'{par_name}_scale_flt', 0.0, -100, 100)
+            par       = zfit.ComposedParameter(f'{par_name}_cmp', lambda d_par : d_par['par_const'] + d_par['scale'], params={'par_const' : par_const, 'scale' : par_scale} )
+        else:
+            raise ValueError(f'Invalid kind: {kind}')
 
         return par
     #-----------------------------------------
     @MethodRegistry.register('exp')
     def _get_exponential(self, suffix : str = '') -> zpdf:
-        c   = self._get_parameter('c_exp', suffix, -0.005, -0.20, 0.00)
+        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 = 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}')
+
+        return pdf
+    # ---------------------------------------------
+    @MethodRegistry.register('modexp')
+    def _get_modexp(self, suffix : str = '') -> zpdf:
+        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}')
+
         return pdf
     #-----------------------------------------
     @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)
-        pdf = zfit.pdf.Chebyshev(obs=self._obs, coeffs=[a, b], name=f'pol2{suffix}')
+        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   = 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, 5350)
-        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}')
 
@@ -162,10 +356,10 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('suj')
     def _get_suj(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_suj', suffix, 5300, 4000, 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,   10)
+        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}')
 
@@ -173,10 +367,10 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('cbl')
     def _get_cbl(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_cbl', suffix, 5300, 5100, 5350)
-        sg  = self._get_parameter('sg_cbl', suffix,   10,    2,  300)
-        al  = self._get_parameter('ac_cbl', suffix,    2,  0.1,  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}')
 
@@ -184,8 +378,8 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('gauss')
     def _get_gauss(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_gauss', suffix, 5300, 5100, 5350)
-        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}')
 
@@ -193,17 +387,46 @@ class ModelFactory:
     #-----------------------------------------
     @MethodRegistry.register('dscb')
     def _get_dscb(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_dscb', suffix, 4000, 4000, 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}')
 
         return pdf
     #-----------------------------------------
+    @MethodRegistry.register('voigt')
+    def _get_voigt(self, suffix : str = '') -> zpdf:
+        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}')
+
+        return pdf
+    #-----------------------------------------
+    @MethodRegistry.register('qgauss')
+    def _get_qgauss(self, suffix : str = '') -> zpdf:
+        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}')
+
+        return pdf
+    #-----------------------------------------
+    @MethodRegistry.register('cauchy')
+    def _get_cauchy(self, suffix : str = '') -> zpdf:
+        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}')
+
+        return pdf
+    #-----------------------------------------
     def _get_pdf_types(self) -> list[tuple[str,str]]:
         d_name_freq = {}
 
@@ -224,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)
     #-----------------------------------------
@@ -234,12 +457,43 @@ class ModelFactory:
             log.debug('Requested only one PDF, skipping sum')
             return l_pdf[0]
 
-        l_frc= [ zfit.param.Parameter(f'frc_{ifrc + 1}', 0.5, 0, 1) for ifrc in range(nfrc - 1) ]
+        l_frc= [ zfit.param.Parameter(f'frc_{self._preffix}_{ifrc + 1}', 0.5, 0, 1) for ifrc in range(nfrc - 1) ]
 
         pdf = zfit.pdf.SumPDF(l_pdf, name=self._preffix, fracs=l_frc)
 
         return pdf
     #-----------------------------------------
+    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 npar!= 1:
+            for par in s_par:
+                log.info(par.name)
+
+            raise ValueError(f'Found {npar} parameters starting with: {name_start}')
+
+        return l_par_match[0]
+    #-----------------------------------------
+    def _fix_parameters(self, pdf : zpdf) -> zpdf:
+        if self._d_fix is None:
+            log.debug('Not fixing any parameter')
+            return pdf
+
+        s_par = pdf.get_params()
+
+        log.info('-' * 30)
+        log.info('Fixing parameters')
+        log.info('-' * 30)
+        for name_start, value in self._d_fix.items():
+            par = self._find_par(s_par, name_start)
+            par.set_value(value)
+
+            log.info(f'{name_start:<20}{value:<20.3f}')
+            par.floating = False
+
+        return pdf
+    #-----------------------------------------
     def get_pdf(self) -> zpdf:
         '''
         Given a list of strings representing PDFs returns the a zfit PDF which is
@@ -248,6 +502,7 @@ class ModelFactory:
         l_type=   self._get_pdf_types()
         l_pdf = [ self._get_pdf(kind, preffix) for kind, preffix in l_type ]
         pdf   =   self._add_pdf(l_pdf)
+        pdf   =   self._fix_parameters(pdf)
 
         return pdf
 #-----------------------------------------

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()