data-manipulation-utilities 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

dmu/stats/minimizers.py

@@ -1,12 +1,16 @@
 '''
 Module containing derived classes from ZFit minimizer
 '''
+from typing import Union
 import numpy
 
 import zfit
+import matplotlib.pyplot as plt
+
 from zfit.result                   import FitResult
 from zfit.core.basepdf             import BasePDF           as zpdf
 from zfit.minimizers.baseminimizer import FailMinimizeNaN
+from dmu.stats.utilities           import print_pdf
 from dmu.stats.gof_calculator      import GofCalculator
 from dmu.logging.log_store         import LogStore
 
@@ -29,6 +33,7 @@ class AnealingMinimizer(zfit.minimize.Minuit):
         self._chi2ndof = chi2ndof
 
         self._check_thresholds()
+        self._l_bad_fit_res : list[FitResult] = []
 
         super().__init__()
     # ------------------------
@@ -66,19 +71,24 @@ class AnealingMinimizer(zfit.minimize.Minuit):
         return is_good
     # ------------------------
     def _is_good_fit(self, res : FitResult) -> bool:
+        good_fit = True
+
         if not res.valid:
-            log.warning('Skipping invalid fit')
-            return False
+            log.debug('Skipping invalid fit')
+            good_fit = False
 
         if res.status != 0:
-            log.warning('Skipping fit with bad status')
-            return False
+            log.debug('Skipping fit with bad status')
+            good_fit = False
 
         if not res.converged:
-            log.warning('Skipping non-converging fit')
-            return False
+            log.debug('Skipping non-converging fit')
+            good_fit = False
 
-        return True
+        if not good_fit:
+            self._l_bad_fit_res.append(res)
+
+        return good_fit
     # ------------------------
     def _get_gof(self, nll) -> tuple[float, float]:
         log.debug('Checking GOF')
@@ -108,10 +118,11 @@ class AnealingMinimizer(zfit.minimize.Minuit):
             par.set_value(fval)
             log.debug(f'{par.name:<20}{ival:<15.3f}{"->":<10}{fval:<15.3f}{"in":<5}{par.lower:<15.3e}{par.upper:<15.3e}')
     # ------------------------
-    def _pick_best_fit(self, d_chi2_res : dict) -> FitResult:
+    def _pick_best_fit(self, d_chi2_res : dict) -> Union[FitResult,None]:
         nres = len(d_chi2_res)
         if nres == 0:
-            raise ValueError('No fits found')
+            log.error('No fits found')
+            return None
 
         l_chi2_res= list(d_chi2_res.items())
         l_chi2_res.sort()
@@ -149,6 +160,15 @@ class AnealingMinimizer(zfit.minimize.Minuit):
 
         return l_model[0]
     # ------------------------
+    def _print_failed_fit_diagnostics(self, nll) -> None:
+        for res in self._l_bad_fit_res:
+            print(res)
+
+        arr_mass = nll.data[0].numpy()
+
+        plt.hist(arr_mass, bins=60)
+        plt.show()
+    # ------------------------
     def minimize(self, nll, **kwargs) -> FitResult:
         '''
         Will run minimization and return FitResult object
@@ -156,18 +176,20 @@ class AnealingMinimizer(zfit.minimize.Minuit):
 
         d_chi2_res : dict[float,FitResult] = {}
         for i_try in range(self._ntries):
-            log.info(f'try {i_try:02}/{self._ntries:02}')
             try:
                 res = super().minimize(nll, **kwargs)
             except (FailMinimizeNaN, ValueError, RuntimeError) as exc:
-                log.warning(exc)
+                log.error(f'{i_try:02}/{self._ntries:02}{"Failed":>20}')
+                log.debug(exc)
                 self._randomize_parameters(nll)
                 continue
 
             if not self._is_good_fit(res):
+                log.warning(f'{i_try:02}/{self._ntries:02}{"Bad fit":>20}')
                 continue
 
             chi2, pvl = self._get_gof(nll)
+            log.info(f'{i_try:02}/{self._ntries:02}{chi2:>20.3f}')
             d_chi2_res[chi2] = res
 
             if self._is_good_gof(chi2, pvl):
@@ -176,6 +198,13 @@ class AnealingMinimizer(zfit.minimize.Minuit):
             self._randomize_parameters(nll)
 
         res = self._pick_best_fit(d_chi2_res)
+        if res is None:
+            self._print_failed_fit_diagnostics(nll)
+            pdf = nll.model[0]
+            print_pdf(pdf)
+
+            raise ValueError('Fit failed')
+
         pdf = self._pdf_from_nll(nll)
         self._set_pdf_pars(res, pdf)
 

dmu/stats/model_factory.py

@@ -6,9 +6,12 @@ Module storing ZModel class
 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.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')
@@ -37,7 +40,23 @@ class MethodRegistry:
         '''
         Will return method in charge of building PDF, for an input nickname
         '''
-        return cls._d_method.get(nickname, None)
+        method = cls._d_method.get(nickname, None)
+
+        if method is not None:
+            return method
+
+        log.warning('Available PDFs:')
+        for value in cls._d_method:
+            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:
     '''
@@ -48,67 +67,172 @@ class ModelFactory:
 
     l_pdf = ['dscb', 'gauss']
     l_shr = ['mu']
-    mod   = ModelFactory(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, obs : zobs, l_pdf : list[str], l_shared : list[str]):
+    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:  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
+        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
         '''
 
+        self._preffix         = preffix
         self._l_pdf           = l_pdf
         self._l_shr           = l_shared
-        self._l_can_be_shared = ['mu', 'sg']
+        self._l_flt           = l_float
+        self._d_fix           = d_fix
+        self._d_rep           = d_rep
         self._obs             = obs
 
         self._d_par : dict[str,zpar] = {}
+
+        self._check_reparametrization()
+    #-----------------------------------------
+    def _check_reparametrization(self) -> None:
+        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):
+            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('_')
+        pname  = l_part[0]
+        xname  = '_'.join(l_part[1:])
+
+        return pname, xname
     #-----------------------------------------
-    def _fltname_from_name(self, name : str) -> str:
-        if name in ['mu', 'sg']:
+    def _get_parameter_name(self, name : str, suffix : str) -> str:
+        pname, xname = self._split_name(name)
+
+        log.debug(f'Using physical name: {pname}')
+
+        if pname in self._l_shr:
+            name = f'{pname}_{self._preffix}'
+        else:
+            name = f'{pname}_{xname}_{self._preffix}{suffix}'
+
+        if pname in self._l_flt:
             return f'{name}_flt'
 
         return name
     #-----------------------------------------
-    def _get_name(self, name : str, suffix : str) -> str:
-        for can_be_shared in self._l_can_be_shared:
-            if name.startswith(f'{can_be_shared}_') and can_be_shared in self._l_shr:
-                return self._fltname_from_name(can_be_shared)
+    def _get_parameter(
+            self,
+            name   : str,
+            suffix : str,
+            val    : float,
+            low    : float,
+            high   : float) -> zpar:
+
+        par_name = self._get_parameter_name(name, suffix)
+        log.debug(f'Assigning name: {par_name}')
+
+        if par_name in self._d_par:
+            return self._d_par[par_name]
+
+        is_reparametrized = self._is_reparametrized(name)
+
+        if is_reparametrized:
+            init_name, _ = self._split_name(par_name)
+            par  = self._get_reparametrization(par_name, init_name, val, low, high)
+        else:
+            par  = zfit.param.Parameter(par_name, val, low, high)
 
-        return self._fltname_from_name(f'{name}{suffix}')
+        self._d_par[par_name] = par
+
+        return par
     #-----------------------------------------
-    def _get_parameter(self,
-                       name   : str,
-                       suffix : str,
-                       val    : float,
-                       low    : float,
-                       high   : float) -> zpar:
-        name = self._get_name(name, suffix)
-        if name in self._d_par:
-            return self._d_par[name]
+    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
 
-        par  = zfit.param.Parameter(name, val, low, high)
+        log.debug(f'Reparametrizing {name}: {is_rep}')
 
-        self._d_par[name] = par
+        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.05, 0.00)
-        pdf = zfit.pdf.Exponential(c, self._obs)
+        c   = self._get_parameter('c_exp', suffix, -0.010, -0.020, -0.0001)
+        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)
+
+        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 = 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)
+
+        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)
-        pdf = zfit.pdf.Chebyshev(obs=self._obs, coeffs=[a])
+        pdf = zfit.pdf.Chebyshev(obs=self._obs, coeffs=[a], name=f'pol1{suffix}')
 
         return pdf
     #-----------------------------------------
@@ -116,51 +240,100 @@ class ModelFactory:
     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])
+        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)
+        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, 5250, 5350)
+        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,  -4.,  -1.)
-        nr  = self._get_parameter('nc_cbr', suffix,    1,  0.5,  5.0)
+        ar  = self._get_parameter('ac_cbr', suffix,   -2, -14., -0.1)
+        nr  = self._get_parameter('nc_cbr', suffix,    1,  0.5,  150)
+
+        pdf = zfit.pdf.CrystalBall(mu, sg, ar, nr, self._obs, name=f'cbr{suffix}')
+
+        return pdf
+    #-----------------------------------------
+    @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)
 
-        pdf = zfit.pdf.CrystalBall(mu, sg, ar, nr, self._obs)
+        pdf = zfit.pdf.JohnsonSU(mu, sg, gm, dl, self._obs, name=f'suj{suffix}')
 
         return pdf
     #-----------------------------------------
     @MethodRegistry.register('cbl')
     def _get_cbl(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_cbl', suffix, 5300, 5250, 5350)
+        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,   1.,  14.)
-        nl  = self._get_parameter('nc_cbl', suffix,    1,  0.5,  15.)
+        al  = self._get_parameter('ac_cbl', suffix,    2,  0.0,  14.)
+        nl  = self._get_parameter('nc_cbl', suffix,    1,  0.5,  150)
 
-        pdf = zfit.pdf.CrystalBall(mu, sg, al, nl, self._obs)
+        pdf = zfit.pdf.CrystalBall(mu, sg, al, nl, self._obs, name=f'cbl{suffix}')
 
         return pdf
     #-----------------------------------------
     @MethodRegistry.register('gauss')
     def _get_gauss(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_gauss', suffix, 5300, 5250, 5350)
+        mu  = self._get_parameter('mu_gauss', suffix, 5300, 5100, 5500)
         sg  = self._get_parameter('sg_gauss', suffix,   10,    2,  300)
 
-        pdf = zfit.pdf.Gauss(mu, sg, self._obs)
+        pdf = zfit.pdf.Gauss(mu, sg, self._obs, name=f'gauss{suffix}')
 
         return pdf
     #-----------------------------------------
     @MethodRegistry.register('dscb')
     def _get_dscb(self, suffix : str = '') -> zpdf:
-        mu  = self._get_parameter('mu_dscb', suffix, 5300, 5250, 5400)
-        sg  = self._get_parameter('sg_dscb', suffix,   10,    2,   30)
+        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,   15)
-        nl  = self._get_parameter('nl_dscb', suffix,    2,    0,   15)
+        nr  = self._get_parameter('nr_dscb', suffix,    2,    1,  150)
+        nl  = self._get_parameter('nl_dscb', suffix,    2,    0,  150)
+
+        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  = zfit.Parameter('mu_voigt', 5280,  5040, 5500)
+        sg  = zfit.Parameter('sg_voigt',   20,    10,  400)
+        gm  = zfit.Parameter('gm_voigt',    4,   0.1,  100)
 
-        pdf = zfit.pdf.DoubleCB(mu, sg, al, nl, ar, nr, self._obs)
+        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  = zfit.Parameter('mu_qgauss', 5280,  5040, 5500)
+        sg  = zfit.Parameter('sg_qgauss',   20,    10,  400)
+        q   = zfit.Parameter( 'q_qgauss',    1,     1,    3)
+
+        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  = zfit.Parameter('mu', 5280,  5040, 5500)
+        gm  = zfit.Parameter('gm',  150,    50,  500)
+
+        pdf = zfit.pdf.Cauchy(obs=self._obs, m=mu, gamma=gm, name=f'cauchy{suffix}')
 
         return pdf
     #-----------------------------------------
@@ -194,9 +367,39 @@ 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) ]
+
+        if len(l_par_match) != 1:
+            for par in s_par:
+                log.info(par.name)
+
+            raise ValueError(f'Not found one and only one parameter 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)
 
-        pdf = zfit.pdf.SumPDF(l_pdf, fracs=l_frc)
+            log.info(f'{name_start:<20}{value:<20.3f}')
+            par.floating = False
 
         return pdf
     #-----------------------------------------
@@ -208,6 +411,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/zfit_models.py

@@ -0,0 +1,68 @@
+'''
+Module meant to hold classes defining PDFs that can be used by ZFIT
+'''
+
+import zfit
+from zfit   import z
+
+#-------------------------------------------------------------------
+class HypExp(zfit.pdf.ZPDF):
+    _N_OBS  = 1
+    _PARAMS = ['mu', 'alpha', 'beta']
+
+    def _unnormalized_pdf(self, x):
+        x    = z.unstack_x(x)
+        mu   = self.params['mu']
+        ap   = self.params['alpha']
+        bt   = self.params['beta']
+
+        u   = (x - mu)
+        val = z.exp(-bt * x) / (1 + z.exp(-ap * u))
+
+        return val
+#-------------------------------------------------------------------
+class ModExp(zfit.pdf.ZPDF):
+    _N_OBS  = 1
+    _PARAMS = ['mu', 'alpha', 'beta']
+
+    def _unnormalized_pdf(self, x):
+        x    = z.unstack_x(x)
+        mu   = self.params['mu']
+        ap   = self.params['alpha']
+        bt   = self.params['beta']
+
+        u   = x - mu
+        val = (1 - z.exp(-ap * u)) * z.exp(-bt * u)
+
+        return val
+#-------------------------------------------------------------------
+class GenExp(zfit.pdf.ZPDF):
+    _N_OBS  = 1
+    _PARAMS = ['mu', 'sg', 'alpha', 'beta']
+
+    def _unnormalized_pdf(self, x):
+        x    = z.unstack_x(x)
+        mu   = self.params['mu']
+        sg   = self.params['sg']
+        ap   = self.params['alpha']
+        bt   = self.params['beta']
+
+        u   = (x - mu) / sg
+        val = (1 - z.exp(-ap * u)) * z.exp(-bt * u)
+
+        return val
+#-------------------------------------------------------------------
+class FermiDirac(zfit.pdf.ZPDF):
+    _N_OBS  = 1
+    _PARAMS = ['mu', 'ap']
+
+    def _unnormalized_pdf(self, x):
+        x    = z.unstack_x(x)
+        mu   = self.params['mu']
+        ap   = self.params['ap']
+
+        exp  = (x - mu) / ap
+        den  = 1 + z.exp(exp)
+
+        return 1. / den
+#-------------------------------------------------------------------