示例#1
0
    def __init__(
            self,
            name,  ## the name 
            x,  ## the variable
            k=None,  ## k-parameter
            theta=None):  ## theta-parameter
        #
        PDF.__init__(self, name)
        #
        self.x = x
        self.mass = x  ## ditto
        #
        self.k = makeVar(k, 'k_%s' % name, 'k_{#Gamma}(%s)' % name, k, 1,
                         1.e-3, 100)
        self.theta = makeVar(theta, 'theta_%s' % name,
                             '#theta_{#Gamma}(%s)' % name, theta, 1, 1.e-3,
                             100)

        if self.k.getMin() <= 0:
            self.k.setMin(1.e-3)
            logger.warning('GammaDist(%s): min(k)     is set %s ' %
                           (name, self.k.getMin()))

        if self.theta.getMin() <= 0:
            theta.setMin(1.e-3)
            logger.warning('GammaDist(%s): min(theta) is set %s ' %
                           (name, self.theta.getMin()))

        self.pdf = Ostap.Models.GammaDist('gd_%s' % name,
                                          'GammaDist(%s)' % name, self.x,
                                          self.k, self.theta)
示例#2
0
    def __init__(self, name, xvar, right, x0, nu, sigma):

        PDF.__init__(self, name, xvar=xvar)

        self.__x0 = self.make_var(x0, 'x0_%s' % name, '#x_{0}(%s)' % name, x0,
                                  x0)

        self.__nu = self.make_var(nu, 'nu_%s' % name, '#nu_{CB}(%s)' % name,
                                  nu, nu, 0, 1000)

        self.__sigma = self.make_var(sigma, 'sigma_%s' % name,
                                     '#sigma_{CB}(%s)' % name, sigma, sigma, 0,
                                     1.e+6)

        self.__right = True if right else False

        self.pdf = Ostap.Models.CutOffStudent(
            self.roo_name('cofs_'), "Student's t-like cut-off %s" % self.name,
            self.xvar, self.right, self.x0, self.nu, self.sigma)

        ## save the configuration
        self.config = {
            'name': self.name,
            'xvar': self.xvar,
            'right': self.right,
            'x0': self.x0,
            'nu': self.nu,
            'sigma': self.sigma,
        }
示例#3
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the variable 
            L,  ## L  
            N,  ## N
            left=None,
            right=None):
        ##
        #
        ## initialize the base
        PDF.__init__(self, name)
        #
        self.mass = mass
        #
        mmin = mass.getMin()
        mmax = mass.getMax()
        #
        self.left = makeVar(left, 'left_%s' % name, 'm_{left}(%s)' % name,
                            left, 0.9 * mmin + 0.1 * mmax, mmin, mmax)

        self.right = makeVar(right, 'right_%s' % name, 'm_{right}(%s)' % name,
                             right, 0.1 * mmin + 0.9 * mmax, mmin, mmax)

        if self.left.getMin() >= self.mass.getMax():
            logger.error('PSNL_pdf(%s): invalid setting!' % name)

        if self.right.getMax() <= self.mass.getMax():
            logger.error('PSNL_pdf(%):  invalid setting!' % name)

        self.pdf = Ostap.Models.PhaseSpaceNL('psnl_%s' % name,
                                             'PhaseSpaceNL(%s)' % name,
                                             self.mass, self.left, self.right,
                                             L, N)
示例#4
0
    def __init__(
            self,
            name,  ## the name 
            x,  ## the variable
            shape=None,  ## shape-parameter 
            high=None,  ## high-parameter 
            low=0):  ## low-parameter
        #
        PDF.__init__(self, name)
        #
        self.x = x
        self.mass = x  ## ditto
        #
        self.shape = makeVar(shape, 'shape_%s' % name,
                             '#chi_{Argus}(%s)' % name, shape, 1, 1.e-4, 20)

        self.high = makeVar(high, 'high_%s' % name, 'high_{Argus}(%s)' % name,
                            high,
                            0.1 * self.x.getMin() + 0.9 * self.x.getMax(),
                            self.x.getMin(), self.x.getMax())

        _dm = self.x.getMax() - self.x.getMin()
        lmin = min(0, self.x.getMin() - 10 * _dm)
        lmax = self.x.getMax() + 10 * _dm
        self.low = makeVar(low, 'low_%s' % name, 'low_{Argus}(%s)' % name, low,
                           0.9 * self.x.getMin() + 0.1 * self.x.getMax(), lmin,
                           lmax)

        logger.debug('ARGUS shape  %s' % self.shape)
        logger.debug('ARGUS high   %s' % self.high)
        logger.debug('ARGUS low    %s' % self.low)

        self.pdf = Ostap.Models.Argus('arg_%s' % name, 'Argus(%s)' % name,
                                      self.x, self.shape, self.high, self.low)
示例#5
0
    def __init__(
            self,
            name,  ## the name 
            x,  ## the variable
            theta=None,  ## theta-parameter
            alpha=None,  ## alpha-parameter
            beta=None,  ## beta-parameter
            a=None):  ## s-parameter

        #
        PDF.__init__(self, name)
        #
        self.x = x
        self.mass = x  ## ditto
        #
        self.theta = makeVar(theta, 'theta_%s' % name,
                             '#theta_{Amoroso}(%s)' % name, theta, 1, 1.e-3,
                             100)
        self.alpha = makeVar(alpha, 'alpha_%s' % name,
                             '#alpha_{Amoroso}(%s)' % name, alpha, 1, 1.e-3,
                             100)
        self.beta = makeVar(beta, 'beta_%s' % name,
                            '#beta_{Amoroso}(%s) ' % name, beta, 1, 1.e-3, 10)
        self.a = makeVar(a, 'a_%s' % name, 'a_{Amoroso}(%s)' % name, a, 1, -10,
                         10)

        logger.debug('Amoroso theta  %s' % self.theta)
        logger.debug('Amoroso alpha  %s' % self.alpha)
        logger.debug('Amoroso beta   %s' % self.beta)
        logger.debug('Amoroso a      %s' % self.a)

        self.pdf = Ostap.Models.Amoroso('amo_%s' % name, 'Amoroso(%s)' % name,
                                        self.x, self.theta, self.alpha,
                                        self.beta, self.a)
示例#6
0
    def __init__(
            self,
            name,  ## the name 
            x,  ## the variable
            scale=1,  ## scale-parameter 
            delta=0):  ## shift-parameter
        #
        PDF.__init__(self, name)
        #
        self.x = x
        self.mass = x  ## ditto
        #
        self.scale = makeVar(scale, 'scale_%s' % name,
                             '#theta_{Landau}(%s)' % name, scale, 1, -1000,
                             1000)

        _dm = self.x.getMax() - self.x.getMin()
        self.delta = makeVar(delta, 'delta_%s' % name,
                             '#delta_{Landau}(%s)' % name, delta, 0,
                             self.x.getMin() - 10 * _dm,
                             self.x.getMax() + 10 * _dm)

        logger.debug('Landau scale  %s' % self.scale)
        logger.debug('Landau delta  %s' % self.delta)

        self.pdf = Ostap.Models.Landau('land_%s' % name, 'Landau(%s)' % name,
                                       self.x, self.scale, self.delta)
示例#7
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the variable
            power=2,  ## degree of the polynomial
            alpha=None,  ##
            x0=None):
        #
        PDF.__init__(self, name)
        #
        self.power = power
        self.mass = mass

        xmin = mass.getMin()
        xmax = mass.getMax()
        dx = xmax - xmin
        alpmx = 2000.0 / dx

        self.alpha = makeVar(alpha, 'alpha_%s' % name, 'alpha(%s)' % name,
                             alpha, 0, -alpmx, alpmx)

        self.x0 = makeVar(x0, 'x0_%s' % name, 'x0(%s)' % name, x0,
                          0.5 * (xmax + xmin), xmin - 0.1 * dx,
                          xmax + 0.1 * dx)
        #
        self.makePhis(power)

        self.pdf = Ostap.Models.PolySigmoid('ps_%s' % name,
                                            'PolySigmoid(%s)' % name,
                                            self.mass, self.phi_list,
                                            self.mass.getMin(),
                                            self.mass.getMax(), self.alpha,
                                            self.x0)
示例#8
0
    def __init__(
            self,
            name,  ## the name 
            x,  ## the variable
            alpha=None,  ## shape-parameter 
            delta=None,  ## high-parameter 
            x0=0):  ## low-parameter
        #
        PDF.__init__(self, name)
        #
        self.x = x
        self.mass = x  ## ditto
        #
        self.alpha = makeVar(alpha, 'alpha_%s' % name,
                             '#alpha_{2e}(%s)' % name, alpha, 1, 1.e-4, 50)
        self.delta = makeVar(delta, 'delta_%s' % name,
                             '#delta_{2e}(%s)' % name, delta, 1, 1.e-4, 50)

        xmin = self.x.getMin()
        xmax = self.x.getMin()
        dx = xmax - xmin
        self.x0 = makeVar(x0, 'x0_%s' % name, 'x0_{2e}(%s)' % name, x0, xmin,
                          xmin - 0.1 * dx, xmax + 0.1 * dx)

        logger.debug('2expos alpha  %s' % self.alpha)
        logger.debug('2expos delta  %s' % self.delta)
        logger.debug('2expos x0     %s' % self.x0)

        self.pdf = Ostap.Models.TwoExpos('exp2_%s' % name, '2Expos(%s)' % name,
                                         self.x, self.alpha, self.delta,
                                         self.x0)
示例#9
0
    def __init__(
            self,
            pt,  ## pT-variable (for fitting) 
            mass=0,  ## particle mass (may be fixed)
            n=None,  ## shape parameter
            T=None,  ## temperature parameter                   
            name=''):

        ## initialize the base
        PDF.__init__(self, name)
        if not isinstance(pt, ROOT.RooAbsReal):
            raise AttributeError("Tsallis(%s): invalid 'pt'-parameter %s" %
                                 (name, pt))

        self.pt = pt

        self.m = self.pt
        self.mass = self.pt

        self.m0 = makeVar(mass, 'm0_%s' % name, 'm0(%s)' % name, mass, 0, 1e+6)

        self.n = makeVar(n, 'n_%s' % name, 'n(%s) ' % name, n, 0.01, 1000)

        self.n = makeVar(T, 'n_%s' % name, 'n(%s) ' % name, n, 1.e-3, 1e+6)

        self.pdf = Ostap.Models.Tsallis('tsallis_' + name,
                                        'Tsallis(%s)' % name, self.pt, self.n,
                                        self.T, self.m0)
示例#10
0
    def __init__(self, name, xvar, right, x0, sigma):

        PDF.__init__(self, name, xvar=xvar)

        self.__x0 = self.make_var(x0, 'x0_%s' % name, '#x_{0}(%s)' % name, x0,
                                  x0)

        self.__sigma = self.make_var(sigma, 'csigma_%s' % name,
                                     '#sigma_{CB}(%s)' % name, sigma, sigma, 0,
                                     1.e+6)

        self.__right = True if right else False

        self.pdf = Ostap.Models.CutOffGauss(self.roo_name('cofg_'),
                                            'Gaussian cut-off %s' % self.name,
                                            self.xvar, self.right, self.x0,
                                            self.sigma)

        ## save the configuration
        self.config = {
            'name': self.name,
            'xvar': self.xvar,
            'x0': self.x0,
            'right': self.right,
            'sigma': self.sigma,
        }
示例#11
0
    def __init__(
            self,
            pdf,  ## the PDF to be convoluted 
            resolution,  ## the convolution/resolution
            xvar=None,  ## the axis varable
            useFFT=True,  ## use  FastFourierTransform?
            nbins=1000000,  ## #bins for FFT
            buffer=0.25,  ## buffer fraction ## setBufferFraction
            nsigmas=6,  ## number of sigmas for setConvolutionWindow
            name=''):  ## the name

        self.__arg_pdf = pdf
        self.__arg_resolution = resolution
        self.__arg_xvar = xvar

        if isinstance(pdf, PDF):
            self.__old_pdf = pdf
            xvar = pdf.xvar
        elif isinstance(pdf, ROOT.RooAbsPdf) and xvar:
            self.__old_pdf = Generic1D_pdf(pdf, xvar)
        else:
            raise AttributeError("Convolution_pdf: invalid pdf/xvar %s/%s" %
                                 (pdf, xvar))

        name = name if name else 'Cnv_%s' % pdf.name

        ## initialize the base
        PDF.__init__(self, name, xvar)

        em = pdf.pdf.extendMode()
        if 1 == em: self.warning("PDF  ``canBeExtended''")
        elif 2 == em: self.error("PDF ``mustBeExtended''")

        ## make the actual convolution
        self.__cnv = Convolution(name=name,
                                 pdf=self.old_pdf.pdf,
                                 xvar=xvar,
                                 resolution=resolution,
                                 useFFT=useFFT,
                                 nbins=nbins,
                                 buffer=buffer,
                                 nsigmas=nsigmas)

        self.pdf = self.__cnv.pdf

        ## save configuration
        self.config = {
            'name': self.name,
            'xvar': self.xvar,
            'pdf': self.old_pdf,
            'resolution': self.cnv.resolution,
            'useFFT': self.cnv.useFFT,
            'nbins': self.cnv.nbinsFFT,
            'buffer': self.cnv.buffer,
            'nsigmas': self.cnv.nsigmas,
        }
示例#12
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the variable
            alpha=None,  ## the slope of the first exponent 
            delta=None,  ## (alpha+delta) is the slope of the first exponent
            x0=0,  ## f(x)=0 for x<x0 
            power=0,  ## degree of polynomial
            tau=None):  ##
        #
        PDF.__init__(self, name)
        #
        self.mass = mass
        self.power = power
        #
        mn, mx = mass.minmax()
        mc = 0.5 * (mn + mx)
        taumax = 100
        #
        if not iszero(mn): taumax = 100.0 / abs(mn)
        if not iszero(mc): taumax = min(taumax, 100.0 / abs(mc))
        if not iszero(mx): taumax = min(taumax, 100.0 / abs(mx))
        #
        ## the exponential slope
        #
        self.alpha = makeVar(alpha, "alpha_%s" % name, "#alpha(%s)" % name,
                             alpha, 1, 0, taumax)

        self.delta = makeVar(delta, "delta_%s" % name, "#delta(%s)" % name,
                             delta, 1, 0, taumax)

        self.x0 = makeVar(x0, "x0_%s" % name, "x_{0}(%s)" % name, x0, mn,
                          mn - 0.5 * (mx - mn), mx + 0.5 * (mx - mn))
        #
        #
        if 0 >= self.power:

            self.phis = []
            self.phi_list = ROOT.RooArgList()
            self.pdf = ROOT.RooExponential('exp_%s' % name, 'exp(%s)' % name,
                                           mass, self.tau)

        else:

            #
            self.makePhis(power)
            #

            self.pdf = Ostap.Models.TwoExpoPositive(
                '2expopos_%s' % name, '2expopos(%s)' % name, mass,
                self.alpha, self.delta, self.x0, self.phi_list, mass.getMin(),
                mass.getMax())
示例#13
0
    def __init__(
            self,
            name,  ## the name 
            x,  ## the variable
            alpha=None,  ## alpha-parameter
            beta=None,  ## beta-parameter
            scale=1,  ## scale-parameter 
            delta=0):  ## shift-parameter
        #
        PDF.__init__(self, name)
        #
        self.x = x
        self.mass = x  ## ditto
        #
        self.alpha = makeVar(alpha, 'alpha_%s' % name,
                             '#alpha_{#beta#prime}(%s)' % name, alpha, 1,
                             1.e-3, 1000)
        self.beta = makeVar(beta, 'beta_%s' % name,
                            '#beta_{#beta#prime}(%s)' % name, beta, 1, 1.e-3,
                            1000)

        if self.alpha.getMin() <= 0:
            self.alpha.setMin(1.e-3)
            logger.warning('BetaPrime(%s): min(alpha) is set %s ' %
                           (name, self.alpha.getMin()))

        if self.beta.getMin() <= 0:
            self.beta.setMin(1.e-3)
            logger.warning('BetaPrime(%s): min(beta) is set %s ' %
                           (name, self.beta.getMin()))

        self.scale = makeVar(scale, 'scale_%s' % name,
                             '#theta_{#beta#prime}(%s)' % name, scale, 1,
                             -1000, 1000)

        _dm = self.x.getMax() - self.x.getMin()
        self.delta = makeVar(delta, 'delta_%s' % name,
                             '#delta_{#beta#prime}(%s)' % name, delta, 0,
                             self.x.getMin() - 10 * _dm,
                             self.x.getMax() + 10 * _dm)

        logger.debug("Beta' alpha     %s" % self.alpha)
        logger.debug("Beta' beta      %s" % self.beta)
        logger.debug("Beta' scale     %s" % self.scale)
        logger.debug("Beta' sdelta    %s" % self.delta)

        self.pdf = Ostap.Models.BetaPrime('bp_%s' % name,
                                          'BetaPrime(%s)' % name, self.x,
                                          self.alpha, self.beta, self.scale,
                                          self.delta)
示例#14
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the variable
            power=0,  ## degree of polynomial
            tau=None,  ## exponential slope 
            the_phis=None):  ## the phis...
        #
        PDF.__init__(self, name)
        #
        self.mass = mass
        self.power = power
        #
        mn, mx = mass.minmax()
        mc = 0.5 * (mn + mx)
        taumax = 100
        #
        if not iszero(mn): taumax = 100.0 / abs(mn)
        if not iszero(mc): taumax = min(taumax, 100.0 / abs(mc))
        if not iszero(mx): taumax = min(taumax, 100.0 / abs(mx))
        #
        ## the exponential slope
        #
        self.tau = makeVar(tau, "tau_%s" % name, "tau(%s)" % name, tau, 0,
                           -taumax, taumax)
        #
        if the_phis:
            ## copy phis
            self.makePhis(power, the_phis=the_phis)  ## copy phis

        elif 0 >= self.power:

            self.phis = []
            self.phi_list = ROOT.RooArgList()
            self.pdf = ROOT.RooExponential('exp_%s' % name, 'exp(%s)' % name,
                                           mass, self.tau)

        else:

            #
            self.makePhis(power)
            #

        self.pdf = Ostap.Models.ExpoPositive('expopos_%s' % name,
                                             'expopos(%s)' % name, mass,
                                             self.tau, self.phi_list,
                                             mass.getMin(), mass.getMax())
示例#15
0
    def __init__(
        self,
        pdf,  ## template PDF of "old" variabe  
        new_var,  ## old variable as function of a new variable
        jacob=None,  ## absolute value of the Jacobian: |d(old)/d(new)|
        name=''):  ## proposed name

        assert pdf and isinstance(pdf, PDF), 'Invalid PDF type %s' % type(pdf)
        assert new_var and isinstance(
            new_var, FUNC), 'Invalid new_var type %s' % type(new_var)

        xvar = new_var.xvar

        name = name if name else "Transform_%s" % pdf.name
        PDF.__init__(self, name, xvar=xvar)

        if not jacob: jacob = abs(new_var.dFdX())

        assert isinstance(jacob, FUNC), 'Invalid Jacobian %s' % type(jacob)
        if not xvar in jacob:
            self.warning('Jacobian has does not depend on xvar!')

        self.__jacob = jacob
        self.__new_var = new_var
        self.__ori_pdf = pdf

        self.__clo_pdf = pdf.clone(xvar=new_var.fun)

        ## new PDF as a function
        self.__new_fun = var_mul(jacob.fun, self.__clo_pdf.pdf)

        from ostap.fitting.basic import make_pdf
        self.__new_pdf = make_pdf(self.__new_fun, [xvar], self.name + '_')

        ## finally the new PDF:
        self.pdf = self.__new_pdf.pdf

        self.config = {
            'name': self.name,
            'pdf': self.orig_pdf,
            'new_var': self.new_var,
            'jacob': self.jacob,
        }

        self.checked_keys.add('pdf')
        self.checked_keys.add('new_var')
        self.checked_keys.add('jacob')
示例#16
0
    def __init__(
        self,
        name,  ## the name 
        pdf,  ## the PDF to be convoluted 
        resolution,  ## the resolution
        xvar=None,  ## the axis varable
        useFFT=True,  ## use  FastFourierTransform?
        nbins=1000000,  ## #bins for FFT
        buffer=0.25,  ## buffer fraction ## setBufferFraction
        nsigmas=6):  ## number of sigmas for setConvolutionWindow

        if isinstance(pdf, PDF):
            xvar = pdf.xvar
        elif isinstance(pdf, ROOT.RooAbsPdf) and isinstance(
                xvar, ROOT.RooAbsReal):
            pdf = Generic1D_pdf(pdf, xvar)
        else:
            raise AttributeError("Convolution_pdf: invalid pdf/xvar    %s/%s" %
                                 (pdf, xvar))

        ## initialize the base
        PDF.__init__(self, name, xvar)

        ## make the actual convolution
        self.__cnv = Convolution(name=name,
                                 pdf=pdf,
                                 xvar=xvar,
                                 resolution=resolution,
                                 useFFT=useFFT,
                                 nbins=nbins,
                                 buffer=buffer,
                                 nsigmas=nsigmas)

        self.pdf = self.__cnv.pdf

        ## save configuration
        self.config = {
            'name': self.name,
            'xvar': self.xvar,
            'pdf': self.cnv.old_pdf,
            'resolution': self.cnv.resolution,
            'useFFT': self.cnv.useFFT,
            'nbins': self.cnv.nbinsFFT,
            'buffer': self.cnv.buffer,
            'nsigmas': self.cnv.nsigmas,
        }
示例#17
0
 def __init__(
     self,
     name,  ## the name 
     mass,  ## the variable
     m1,  ## mass the first particle  (const)
     m2,  ## mass the second particle (const)
     m3,  ## mass the third particle  (const)
     m,  ## mass of the whole system (const)
     L,  ## orbital momenutm between (1,2) and 3
     l=0):  ## orbital momentum between 1 and 2
     #
     ## initialize the base
     PDF.__init__(self, name)
     #
     self.mass = mass
     self.pdf = Ostap.Models.PhaseSpace23L('ps23l_%s' % name,
                                           'PhaseSpace23L(%s)' % name,
                                           self.mass, m1, m2, m3, m, L, l)
示例#18
0
    def __init__(
        self,
        name,  ## the name 
        mass,  ## the variable
        spline):  ## the spline object Ostap::Math::ConvexOnlySpline
        #
        PDF.__init__(self, name)
        #
        self.spline = spline
        self.mass = mass

        #
        self.makePhis(spline.npars())
        #
        self.pdf = Ostap.Models.ConvexOnlySpline('is_%s' % name,
                                                 'ConvexOnlySpline(%s)' % name,
                                                 self.mass, self.spline,
                                                 self.phi_list)
示例#19
0
    def __init__(
            self,
            name,  ## the name 
            x,  ## the variable
            k=None,  ## k-parameter
            theta=None,  ## theta-parameter
            p=None,  ## p-parameter
            low=None):  ## low-parameter
        #
        PDF.__init__(self, name)
        #
        self.x = x
        self.mass = x  ## ditto
        #
        self.k = makeVar(k, 'k_%s' % name, 'k_{#Gamma}(%s)' % name, k, 1,
                         1.e-3, 100)
        self.theta = makeVar(theta, 'theta_%s' % name,
                             '#theta_{#Gamma}(%s)' % name, theta, 1, 1.e-3,
                             100)
        self.p = makeVar(p, 'p_%s' % name, 'p_{#Gamma}(%s)' % name, p, 1,
                         1.e-3, 6)

        self.low = makeVar(low, 'low_%s' % name, 'l_{#Gamma}(%s)' % name, low,
                           min(0, x.getMin()), x.getMax())

        if self.k.getMin() <= 0:
            self.k.setMin(1.e-3)
            logger.warning('GenGammaDist(%s): min(k)     is set %s ' %
                           (name, self.k.getMin()))

        if self.theta.getMin() <= 0:
            self.theta.setMin(1.e-3)
            logger.warning('GenGammaDist(%s): min(theta) is set %s ' %
                           (name, self.theta.getMin()))

        if self.p.getMin() <= 0:
            self.p.setMin(1.e-3)
            logger.warning('GenGammaDist(%s): min(p)     is set %s ' %
                           (name, self.p.getMin()))

        self.pdf = Ostap.Models.GenGammaDist('ggd_%s' % name,
                                             'GenGammaDist(%s)' % name, self.x,
                                             self.k, self.theta, self.p,
                                             self.low)
示例#20
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the varibale 
            power=1):  ## (half)degree of the polynomial
        #
        PDF.__init__(self, name)
        #
        self.power = power
        self.mass = mass

        #
        self.makePhis(power)

        self.pdf = Ostap.Models.PolyPositiveEven('ppe_%s' % name,
                                                 'PolyPositiveEven(%s)' % name,
                                                 self.mass, self.phi_list,
                                                 self.mass.getMin(),
                                                 self.mass.getMax())
示例#21
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the varibale
            m1,  ## the first  mass (constant)
            m2):  ## the second mass (constant)
        #
        ## initialize the base
        PDF.__init__(self, name)
        #
        if hasattr(mass, 'getMax') and mass.getMax() < abs(m1) + abs(m2):
            logger.error('PS2_pdf(%s): senseless setting of edges/threshold' %
                         self.name)

        self.mass = mass

        self.pdf = Ostap.Models.PhaseSpace2('ps2_%s' % name,
                                            'PhaseSpace2(%s)' % name,
                                            self.mass, m1, m2)
示例#22
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the variable
            power=2,  ## degree of the polynomial
            convex=True):  ## convex or concave ?
        #
        PDF.__init__(self, name)
        #
        self.power = power
        self.mass = mass
        self.convex = convex
        #
        self.makePhis(power)

        self.pdf = Ostap.Models.PolyConvexOnly('pp_%s' % name,
                                               'PolyConvex(%s)' % name,
                                               self.mass, self.phi_list,
                                               self.mass.getMin(),
                                               self.mass.getMax(), self.convex)
示例#23
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the variable
            N,  ## N 
            left=None):
        #
        ## initialize the base
        PDF.__init__(self, name)
        #
        self.mass = mass
        self.left = makeVar(left, 'left_%s' % name, 'm_left(%s)' % name, None,
                            mass.getMin(), mass.getMax())

        if self.left.getMin() >= self.mass.getMax():
            logger.error('PSLeft_pdf(%s): invalid setting!' % name)

        self.pdf = Ostap.Models.PhaseSpaceLeft('psl_%s' % name,
                                               'PhaseSpaceLeft(%s)' % name,
                                               self.mass, self.left, N)
示例#24
0
    def __init__(
        self,
        name,  ## the name 
        mass,  ## the variable
        power=2,  ## degree of the polynomial
        increasing=True):  ## increasing or decreasing ?
        #
        PDF.__init__(self, name)
        #
        self.power = power
        self.mass = mass
        self.increasing = increasing
        #
        self.makePhis(power)

        self.pdf = Ostap.Models.PolyMonothonic('pp_%s' % name,
                                               'PolyMonothonic(%s)' % name,
                                               self.mass, self.phi_list,
                                               self.mass.getMin(),
                                               self.mass.getMax(),
                                               self.increasing)
示例#25
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the variable
            L,  ## L  
            N,  ## N
            right=None):
        #
        ## initialize the base
        PDF.__init__(self, name)
        #
        self.mass = mass
        self.right = makeVar(right, 'right_%s' % name, 'm_{right}(%s)' % name,
                             None, mass.getMin(), mass.getMax())

        if self.right.getMax() <= self.mass.getMax():
            logger.error('PSRight_pdf(%s): invalid setting!' % name)

        self.pdf = Ostap.Models.PhaseSpaceRight('psr_%s' % name,
                                                'PhaseSpaceRight(%s)' % name,
                                                self.mass, self.right, L, N)
示例#26
0
    def __init__(
            self,
            name,  ## the name 
            x,  ## the variable
            nu=None,  ## nu-parameter
            lam=None,  ## lambda-parameter
            alpha=None):  ## nu-parameter
        #
        PDF.__init__(self, name)
        #
        self.x = x
        self.mass = x  ## ditto
        #
        xmin = self.x.getMin()
        xmax = self.x.getMax()
        dx = xmax - xmin
        #
        self.nu = makeVar(nu, 'nu_%s' % name, '#nu_{#log#Gamma}(%s)' % name,
                          nu, 0.5 * (xmin + xmax), xmin - 10 * dx,
                          xmax + 10 * dx)

        self.lam = makeVar(lam, 'lambda_%s' % name,
                           '#lambda_{#log#Gamma}(%s)' % name, lam, 2, -1000,
                           1000)

        self.alpha = makeVar(alpha, 'alpha_%s' % name,
                             '#alpha_{#log#Gamma}(%s)' % name, alpha, 1, 1.e-3,
                             1000)

        if self.alpha.getMin() <= 0:
            self.alpha.setMin(1.e-3)
            logger.warning('LogGamma(%s): min(alpha) is set %s ' %
                           (name, self.alpha.getMin()))

        logger.debug('LogGamma nu     %s' % self.nu)
        logger.debug('LogGamma lambda %s' % self.lam)
        logger.debug('LogGamma alpha  %s' % self.alpha)

        self.pdf = Ostap.Models.LogGamma('lg_%s' % name, 'LogGamma(%s)' % name,
                                         self.x, self.nu, self.lam, self.alpha)
示例#27
0
    def __init__(self, pdf, xvar=None, fraction=1.e-5, name=''):

        if isinstance(pdf, PDF):
            self.__old_pdf = pdf
            if xvar and not xvar is pdf.xvar: self.warning("mismatch in xvar?")
            xvar = pdf.xvar
        elif insinstance(pdf, ROOT.RooAbsPdf) and xvar:
            self.__old_pdf = Generic1D_pdf(pdf, xvar=xvar)
        else:
            raise TypeError("Unknown type of pdf %s/%s" % (pdf, type(pdf)))

        assert isinstance(xvar,
                          ROOT.RooAbsReal), "``xvar'' must be ROOT.RooAbsReal"

        name = name if name else self.generate_name('Adjust1D_' +
                                                    self.old_pdf.name)

        ## initialize the base
        PDF.__init__(self, name=name, xvar=xvar)

        em = self.old_pdf.pdf.extendMode()
        if 1 == em: self.warning("PDF  ``canBeExtended''")
        elif 2 == em: self.warning("PDF ``mustBeExtended''")

        ## make the real adjustment
        self.__adjustment = Adjust1D(name,
                                     pdf=self.old_pdf.pdf,
                                     xvar=xvar,
                                     fraction=fraction)

        self.pdf = self.adjustment.pdf

        self.config = {
            'xvar': self.xvar,
            'name': self.name,
            'pdf': self.old_pdf,
            'fraction': self.fraction
        }
示例#28
0
    def __init__(
            self,
            name,  ## the name 
            mass,  ## the varibale 
            phasespace,  ## Ostap::Math::PhaseSpaceNL 
            power=1):  ## degree of the polynomial

        #
        PDF.__init__(self, name)
        #
        self.mass = mass
        self.ps = phasespace  ## Ostap::Math::PhaseSpaceNL
        self.power = power

        #
        self.makePhis(power)
        #

        self.pdf = Ostap.Models.PhaseSpacePol(
            'pspol_%s' % name,
            'PhaseSpacePol(%s)' % name,
            self.mass,
            self.ps,  ## Ostap::Math::PhaseSpaceNL 
            self.phi_list)
示例#29
0
    def __init__(
            self,
            pt,  ## pT-variable (for fitting) 
            mass=0,  ## particle mass (may be fixed)
            b=None,  ## slope parameter
            name=''):

        ## initialize the base
        PDF.__init__(self, name)
        if not isinstance(pt, ROOT.RooAbsReal):
            raise AttributeError("QGSM(%s): invalid 'pt'-parameter %s" %
                                 (name, pt))

        self.pt = pt

        self.m = self.pt
        self.mass = self.pt

        self.m0 = makeVar(mass, 'm0_%s' % name, 'm0(%s)' % name, mass, 0, 1e+6)

        self.b = makeVar(b, 'b_%s' % name, 'b(%s) ' % name, b, 0., 1e+6)

        self.pdf = Ostap.Models.QGSM('qgsm_' + name, 'QGSM(%s)' % name,
                                     self.pt, self.b, self.m0)
示例#30
0
    def __init__ ( self             ,
                   pdf              ,   ## the PDF to be convoluted 
                   resolution       ,   ## the convolution/resolution
                   xvar     = None  ,   ## the axis varable
                   useFFT   = True  ,   ## use  FastFourierTransform?
                   nbins    = 2**14 ,   ## #bins for FFT
                   buffer   = 0.25  ,   ## buffer fraction ## setBufferFraction
                   bufstrat = None  ,   ## "Buffer strategy" : (0,1,2)
                   nsigmas  = 6     ,   ## number of sigmas for setConvolutionWindow
                   name     = ''    ) : ## the name 

        self.__arg_pdf        = pdf
        self.__arg_resolution = resolution 
        self.__arg_xvar       = xvar
        
        if   isinstance ( pdf , PDF ) :
            self.__old_pdf = pdf 
            xvar           = pdf.xvar
        elif isinstance ( pdf , ROOT.RooAbsPdf ) and xvar :
            self.__old_pdf = Generic1D_pdf  ( pdf , xvar )
        else :
            raise AttributeError ("Convolution_pdf: invalid pdf/xvar %s/%s"  % ( pdf , xvar ) ) 

        em = self.old_pdf.pdf.extendMode ()
        if   1 == em : self.warning ( "PDF  ``canBeExtended''" )
        elif 2 == em : self.error   ( "PDF ``mustBeExtended''" )

        ## make the actual convolution
        if isinstance ( resolution , Convolution ) :
            assert resolution.xvar is xvar, "Mismatch in ``xvar'': %s vs %s" % ( xvar , resolution.xvar )
            self.__cnv = resolution
        else :
            self.__cnv = Convolution ( name       = ''               ,
                                       pdf        = self.old_pdf.pdf ,
                                       xvar       = xvar             ,
                                       resolution = resolution       ,
                                       useFFT     = useFFT           ,
                                       nbins      = nbins            ,
                                       buffer     = buffer           ,
                                       bufstrat   = bufstrat         ,
                                       nsigmas    = nsigmas          )

        name = name if name else self.generate_name ( prefix = 'Cnv_%s@%s_' %  ( pdf.name , self.resolution.name ) ) 
                            
        ## initialize the base 
        PDF.__init__ ( self , name , xvar )


        ## the  actual convoluted PDF 
        self.pdf = self.__cnv.pdf 

        ## save configuration 
        self.config = {
            'name'       : self.name           ,
            'xvar'       : self.xvar           ,
            'pdf'        : self.old_pdf        ,
            'resolution' : self.cnv.resolution ,
            'useFFT'     : self.cnv.useFFT     ,
            'nbins'      : self.cnv.nbinsFFT   ,
            'buffer'     : self.cnv.buffer     ,
            'bufstrat'   : self.cnv.bufstrat   ,
            'nsigmas'    : self.cnv.nsigmas    ,
            }