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)
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)
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)
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)
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)
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)
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)
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)
def __init__( self, name, x, ## the first dimension y, ## the second dimension nx=2, ## polynomial degree in X ny=2, ## polynomial degree in Y taux=None, ## the exponent in X tauy=None): ## the exponent in Y PDF2.__init__(self, name, x, y) # ## get tau_x # xtaumax = 100 mn, mx = x.minmax() mc = 0.5 * (mn + mx) # if not iszero(mn): xtaumax = 100.0 / abs(mn) if not iszero(mc): xtaumax = min(xtaumax, 100.0 / abs(mc)) if not iszero(mx): xtaumax = min(xtaumax, 100.0 / abs(mx)) ytaumax = 100 mn, mx = y.minmax() mc = 0.5 * (mn + mx) # if not iszero(mn): ytaumax = 100.0 / abs(mn) if not iszero(mc): ytaumax = min(ytaumax, 100.0 / abs(mc)) if not iszero(mx): ytaumax = min(ytaumax, 100.0 / abs(mx)) # ## the exponential slopes # self.taux = makeVar(taux, "taux_%s" % name, "taux(%s)" % name, taux, 0, -xtaumax, xtaumax) # self.tauy = makeVar(tauy, "tauy_%s" % name, "tauy(%s)" % name, tauy, 0, -ytaumax, ytaumax) # self.m1 = x ## ditto self.m2 = y ## ditto # num = (nx + 1) * (ny + 1) - 1 self.makePhis(num) # # ## finally build PDF # self.pdf = Ostap.Models.Expo2DPol('exp2D_%s' % name, 'Expo2DPol(%s)' % name, self.x, self.y, self.taux, self.tauy, nx, ny, self.phi_list)
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())
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)
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)
def __init__( self, name, ## the name xvar, ## the variable sigma, ## core r esolution alpha=1.5, ## alpha n=5, ## power-law exponent mean=None): ## the mean value if mean is None: mean = ROOT.RooConstVar('mean_ResoCB2' + name, 'mean_ResoCB2(%s)' % name, 0) ## initialize the base super(ResoCB2, self).__init__(name=name, xvar=xvar, sigma=sigma, mean=mean) self.__alpha = makeVar(alpha, 'ResoAlpha_' + name, 'ResoAlpha(%s)' % name, alpha, 0.1, 10) self.__n = makeVar(n, 'ResoN_' + name, 'ResoN(%s)' % name, n, 1.e-6, 50) ## gaussian self.cb2 = Ostap.Models.CrystalBallDS('ResoCB2_' + name, 'ResoCB2(%s' % name, self.xvar, self.mean, self.sigma, self.alpha, self.n, self.alpha, self.n) ## the final PDF self.pdf = self.cb2 ## save the configuration self.config = { 'name': self.name, 'xvar': self.xvar, 'mean': self.mean, 'sigma': self.sigma, 'alpha': self.alpha, 'n': self.n, }
def __init__( self, name, xvar, ## the first dimension yvar, ## the second dimension psy=None, ## phase space in Y, Ostap::Math::PhaseSpaceNL nx=2, ## polynomial degree in X ny=2, ## polynomial degree in Y tau=None): ## the exponent ## check arguments assert isinstance( nx, int) and 0 <= nx < 100, "``nx''-parameter is illegal: %s" % nx assert isinstance( ny, int) and 0 <= ny < 100, "``ny''-parameter is illegal: %s" % ny ## the base PolyBase2.__init__(self, name, xvar, yvar, (nx + 1) * (ny + 1) - 1) limits_tau = () if self.xminmax(): mn, mx = self.xminmax() mmax = max(abs(mn), abs(mx)) limits_tau = -500. / mmax, 500. / mmax ## the exponential slope self.__tau = makeVar(tau, "tau_%s" % name, "tau(%s)" % name, tau, 0, *limits_tau) # self.__phasespace = psy self.__nx = nx self.__ny = ny # ## finally build PDF # self.pdf = Ostap.Models.ExpoPS2DPol('ps2D_%s' % name, 'PS2DPol(%s)' % name, self.x, self.y, self.tau, self.phasespacey, self.nx, self.ny, self.phi_list) ## save configuration self.config = { 'name': self.name, 'xvar': self.xvar, 'yvar': self.yvar, 'psy': self.phasespacey, 'nx': self.nx, 'ny': self.ny, 'tau': self.tau, 'the_phis': self.phis, }
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)
def __init__( self, name, x, ## the first dimension y, ## the second dimension n=2, ## polynomial degree in X and Y tau=None): ## the exponent if x.getMin() != y.getMin(): logger.warning( 'PSPos2Dsym: x&y have different low edges %s vs %s' % (x.getMin(), y.getMin())) if x.getMax() != y.getMax(): logger.warning( 'PSPos2Dsym: x&y have different high edges %s vs %s' % (x.getMax(), y.getMax())) PDF2.__init__(self, name, x, y) # ## get tau # taumax = 100 mn, mx = x.minmax() mc = 0.5 * (mn + mx) # 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 slopes # self.tau = makeVar(tau, "tau_%s" % name, "tau(%s)" % name, tau, 0, -taumax, taumax) # self.m1 = x ## ditto self.m2 = y ## ditto # num = (n + 1) * (n + 2) / 2 - 1 self.makePhis(num) # # ## finally build PDF # self.pdf = Ostap.Models.Expo2DPolSym('exp2Ds_%s' % name, 'Expo2DPolSym(%s)' % name, self.x, self.y, self.tau, n, self.phi_list)
def __init__( self, name, ## the name xvar, ## the variable sigma, ## the core sigma scale=1.2, ## sigma2/sigma1 ratio fraction=0.5, ## fraction of mean=None): ## the mean value if mean is None: mean = ROOT.RooConstVar('mean_ResoGauss2' + name, 'mean_ResoGauss2(%s)' % name, 0) ## initialize the base super(ResoGauss2, self).__init__(name=name, xvar=xvar, sigma=sigma, mean=mean) ## fraction of sigma1-component self.__fraction = makeVar(fraction, 'CoreFraction_' + name, 'CoreFraction(%s)' % name, fraction, 0, 1) ## sigma2/sigma1 width ratio; self.__scale = makeVar(scale, 'SigmaScale_' + name, 'SigmaScale(%s)' % name, scale, 1, 10) self.pdf = Ostap.Models.DoubleGauss("Reso2Gauss_" + name, "Reso2Gauss(%s)" % name, self.xvar, self.sigma, self.fraction, self.scale, self.mean) ## save the configuration self.config = { 'name': self.name, 'xvar': self.xvar, 'mean': self.mean, 'sigma': self.sigma, 'scale': self.scale, 'fraction': self.fraction, }
def __init__( self, name, xvar, ## the first dimension yvar, ## the second dimension n=2, ## polynomial degree in X and Y tau=None, ## the exponent the_phis=None): ## check arguments assert isinstance( n, int) and 0 <= n < 100, "``n''-parameter is illegal: %s" % n ## PolyBase2.__init__(self, name, xvar, yvar, (n + 1) * (n + 2) / 2 - 1, the_phis) if self.xminmax() != self.yminmax(): logger.warning( 'PSPol2Dsym_pdf: x&y have different edges %s vs %s' % (self.xminmax(), self.yminmax())) limits_tau = () if self.xminmax(): mn, mx = self.xminmax() mmax = max(abs(mn), abs(mx)) limits_tau = -500. / mmax, 500. / mmax self.__n = n # ## the exponential slopes # self.__tau = makeVar(tau, "tau_%s" % name, "tau(%s)" % name, tau, 0, *limits_tau) # ## finally build PDF # self.pdf = Ostap.Models.Expo2DPolSym('exp2Ds_%s' % name, 'Expo2DPolSym(%s)' % name, self.x, self.y, self.tau, self.n, self.phi_list) ## save configuration self.config = { 'name': self.name, 'xvar': self.xvar, 'yvar': self.yvar, 'n': self.n, 'tau': self.tau, 'the_phis': self.phis }
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)
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())
def __init__( self, name, x, ## the first dimension y, ## the second dimension psy=None, ## phase space in Y, Ostap::Math::PhaseSpaceNL nx=2, ## polynomial degree in X ny=2, ## polynomial degree in Y tau=None): ## the exponent PDF2.__init__(self, name, x, y) # ## get tau taumax = 100 mn, mx = x.minmax() mc = 0.5 * (mn + mx) # 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) # self.psy = psy # num = (nx + 1) * (ny + 1) - 1 self.makePhis(num) # # ## finally build PDF # self.pdf = Ostap.Models.ExpoPS2DPol('ps2D_%s' % name, 'PS2DPol(%s)' % name, self.x, self.y, self.tau, self.psy, nx, ny, self.phi_list)
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)
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)
def __init__( self, name, ## the name xvar, ## the variable sigma, ## the sigma beta=1, ## beta parameter mean=None): ## the mean value if mean is None: mean = ROOT.RooConstVar('mean_ResoApo2' + name, 'mean_ResoApo2(%s)' % name, 0) ## initlialize the base super(ResoApo2, self).__init__(name=name, xvar=xvar, sigma=sigma, mean=mean) self.__beta = makeVar(beta, 'ResoBeta_%s' % name, 'ResoBeta(%s)' % name, beta, 0.0001, 10000) ## build resolution model self.apo2 = Ostap.Models.Apolonios2("ResoApolonious_" + name, "ResoApolonios(%s)" % name, self.xvar, self.mean, self.sigma, self.sigma, self.beta) self.pdf = self.apo2 ## save the configuration self.config = { 'name': self.name, 'xvar': self.xvar, 'mean': self.mean, 'sigma': self.sigma, 'beta': self.beta, }
def __init__(self, mass, name='Y', power=0, m1s=None, sigma=None, a0=1.91, a1=None, a2=None): # PDF.__init__(self, name, mass) # if 9460. in self.mass and 10023. in self.mass and 10355. in self.mass: gev_ = 1000 elif 9.460 in self.mass and 10.023 in self.mass and 10.355 in self.mass: gev_ = 1 else: raise AttributeError("Illegal mass range %s<m<%s" % self.xminmax()) m_y1s = 9.46030 * gev_ s_y1s = 4.3679e-02 * gev_ dm_y2s = 10.02326 * gev_ - m_y1s dm_y3s = 10.3552 * gev_ - m_y1s # ===================================================================== ## Y(1S) # ===================================================================== self.__a0 = makeVar(a0, 'a0m_%s' % name, "a0 for Needham's function", a0, 1.91, 0.1, 3.0) self.__a1 = makeVar(a1, 'a1m_%s' % name, "a1 for Needham's function", a1, 1.1174 / gev_, -10.0 / gev_, 10.0 / gev_) self.__a2 = makeVar(a2, 'a2m_%s' % name, "a2 for Needham's function", a2, -5.299 / gev_**2, -100.0 / gev_**2, 100.0 / gev_**2) ## default logic does not work nicely here, therefore we need to be explicit: if a0 is None and not self.a0.isConstant(): self.a0.fix(1.91) if a1 is None and not self.a1.isConstant(): self.a1.fix(1.1174 / gev_) if a2 is None and not self.a2.isConstant(): self.a2.fix(-5.299 / gev_**2) self.__m1s = makeVar(m1s, "m1S_%s" % name, "mass Y1S(%s)" % name, m1s, m_y1s, m_y1s - 0.15 * s_y1s, m_y1s + 0.15 * s_y1s) self.__s1s = makeVar(sigma, "s1S_%s" % name, "sigma Y1S(%s)" % name, sigma, s_y1s, 0.3 * s_y1s, 4 * s_y1s) self.__sigma = self.s1s self.__Y1S = Needham_pdf(name + '1S', xvar=self.mass, mean=self.m1s, sigma=self.s1s, a0=self.a0, a1=self.a1, a2=self.a2) # ===================================================================== ## Y(2S) # ===================================================================== self.__dm2s = makeVar(None, "dm2s" + name, "dm2s(%s)" % name, dm_y2s, dm_y2s - 0.20 * s_y1s, dm_y2s + 0.20 * s_y1s) self.__aset11 = ROOT.RooArgList(self.__m1s, self.__dm2s) self.__m2s = ROOT.RooFormulaVar( "m_" + name + '2S', "m2s(%s)" % name, "%s+%s" % (self.__m1s.GetName(), self.__dm2s.GetName()), self.__aset11) self.__aset12 = ROOT.RooArgList(self.__sigma, self.__m1s, self.__m2s) self.__s2s = ROOT.RooFormulaVar( "sigma_" + name + '2S', "#sigma_{Y2S}(%s)" % name, "%s*(%s/%s)" % (self.__sigma.GetName(), self.__m2s.GetName(), self.__m1s.GetName()), self.__aset12) self.__Y2S = Needham_pdf(name + '2S', xvar=self.mass, mean=self.m2s, sigma=self.s2s, a0=self.a0, a1=self.a1, a2=self.a2) # ===================================================================== ## Y(3S) # ===================================================================== self.__dm3s = makeVar(None, "dm3s" + name, "dm3s(%s)" % name, dm_y3s, dm_y3s - 0.20 * s_y1s, dm_y3s + 0.20 * s_y1s) self.__aset21 = ROOT.RooArgList(self.__m1s, self.__dm3s) self.__m3s = ROOT.RooFormulaVar( "m_" + name + '(3S)', "m3s(%s)" % name, "%s+%s" % (self.__m1s.GetName(), self.__dm3s.GetName()), self.__aset21) self.__aset22 = ROOT.RooArgList(self.__sigma, self.__m1s, self.__m3s) self.__s3s = ROOT.RooFormulaVar( "sigma_" + name + '3S', "#sigma_{Y3S}(%s)" % name, "%s*(%s/%s)" % (self.__sigma.GetName(), self.__m3s.GetName(), self.__m1s.GetName()), self.__aset22) self.Y3S = Needham_pdf(name + '3S', xvar=self.mass, mean=self.m3s, sigma=self.s3s, a0=self.a0, a1=self.a1, a2=self.a2) # ## the actual signal PDFs # self.__y1s = self.Y1S.pdf self.__y2s = self.Y2S.pdf self.__y3s = self.Y3S.pdf self.__power = power ## use helper function to create background self.background = makeBkg(power, 'Bkg%s' % name, self.mass) self.__n1s = makeVar(None, "N1S" + name, "Signal(Y1S)", None, 1000, 0, 1.e+8) self.__n2s = makeVar(None, "N2S" + name, "Signal(Y2S)", None, 300, 0, 1.e+7) self.__n3s = makeVar(None, "N3S" + name, "Signal(Y3S)", None, 100, 0, 1.e+6) self.__b = makeVar(None, "B" + name, "Background", None, 100, 0, 1.e+8) self.alist1 = ROOT.RooArgList(self.__y1s, self.__y2s, self.__y3s) self.alist2 = ROOT.RooArgList(self.__n1s, self.__n2s, self.__n3s) self.alist1.add(self.background.pdf) self.alist2.add(self.__b) self.pdf = ROOT.RooAddPdf("manca_%s" % name, "manca(%s)" % name, self.alist1, self.alist2) self.__dm2s.setConstant(True) self.__dm3s.setConstant(True) self._splots = [] self.s1_name = self.__n1s.GetName() self.s2_name = self.__n2s.GetName() self.s3_name = self.__n3s.GetName() # ## finally declare components # self.signals().add(self.__y1s) self.signals().add(self.__y2s) self.signals().add(self.__y3s) self.backgrounds().add(self.background.pdf) ## save configurtaion self.config = { 'mass': self.mass, 'name': self.name, 'power': self.power, 'm1s': self.m1s, 'sigma': self.sigma, 'a0': self.a0, 'a1': self.a1, 'a2': self.a2, }
def __init__( self, name, xvar, ## the first dimension yvar, ## the second dimension nx=2, ## polynomial degree in X ny=2, ## polynomial degree in Y taux=None, ## the exponent in X tauy=None, ## the exponent in Y the_phis=None): ## check arguments assert isinstance( nx, int) and 0 <= nx < 100, "``nx''-parameter is illegal: %s" % nx assert isinstance( ny, int) and 0 <= ny < 100, "``ny''-parameter is illegal: %s" % ny PolyBase2.__init__(self, name, xvar, yvar, (nx + 1) * (ny + 1) - 1, the_phis) limits_taux = () if self.xminmax(): mn, mx = self.xminmax() mmax = max(abs(mn), abs(mx)) limits_taux = -500. / mmax, 500. / mmax limits_tauy = () if self.yminmax(): mn, mx = self.yminmax() mmax = max(abs(mn), abs(mx)) limits_tauy = -500. / mmax, 500. / mmax self.__nx = nx self.__ny = ny # ## the exponential slopes # self.__taux = makeVar(taux, "taux_%s" % name, "taux(%s)" % name, taux, 0, *limits_taux) # self.__tauy = makeVar(tauy, "tauy_%s" % name, "tauy(%s)" % name, tauy, 0, *limits_tauy) # ## finally build PDF # self.pdf = Ostap.Models.Expo2DPol('exp2D_%s' % name, 'Expo2DPol(%s)' % name, self.x, self.y, self.taux, self.tauy, nx, ny, self.phi_list) ## save configuration self.config = { 'name': self.name, 'xvar': self.xvar, 'yvar': self.yvar, 'nx': self.nx, 'ny': self.ny, 'taux': self.taux, 'tauy': self.tauy, 'the_phis': self.phis, }
def __init__(self, mass, name='Y', power=0, m1s=None, sigma=None, a0=1.91, a1=None, a2=None): # PDF.__init__(self, name) # if mass.getMin() < 9.460 and 9.60 <= mass.getMax(): gev_ = 1 elif mass.getMin() < 10. and 10.500 <= mass.getMax(): gev_ = 1 elif mass.getMin() < 10.0 and 10.200 <= mass.getMax(): gev_ = 1 elif mass.getMin() < 9460 and 10355 <= mass.getMax(): gev_ = 1000 elif mass.getMin() < 10000 and 10500 <= mass.getMax(): gev_ = 1000 elif mass.getMin() < 10000 and 10200 <= mass.getMax(): gev_ = 1000 else: raise TypeError("Illegal mass range %s<m<%s" % (mass.getMin(), mass.getMax())) m_y1s = 9.46030 * gev_ s_y1s = 4.3679e-02 * gev_ dm_y2s = 10.02326 * gev_ - m_y1s dm_y3s = 10.3552 * gev_ - m_y1s # self.mass = mass # ===================================================================== from ostap.fitting.basic import makeVar from ostap.fitting.signals import Needham_pdf # ===================================================================== ## Y(1S) # ===================================================================== self.a0 = makeVar(a0, 'a0m_%s' % name, "a0 for Needham's function", a0, 1.91, 0.1, 3.0) self.a1 = makeVar(a1, 'a1m_%s' % name, "a1 for Needham's function", a1, 1.1174 / gev_, -10.0 / gev_, 10.0 / gev_) self.a2 = makeVar(a2, 'a2m_%s' % name, "a2 for Needham's function", a2, -5.299 / gev_**2, -100.0 / gev_**2, 100.0 / gev_**2) ## default logic does not work nicely here, therefore we need to be explicit: if a0 is None and not self.a0.isConstant(): self.a0.fix(1.91) if a1 is None and not self.a1.isConstant(): self.a1.fix(1.1174 / gev_) if a2 is None and not self.a2.isConstant(): self.a2.fix(-5.299 / gev_**2) self.m1s = makeVar(m1s, "m1S_%s" % name, "mass Y1S(%s)" % name, m1s, m_y1s, m_y1s - 0.15 * s_y1s, m_y1s + 0.15 * s_y1s) self.s1s = makeVar(sigma, "s1S_%s" % name, "sigma Y1S(%s)" % name, sigma, s_y1s, 0.3 * s_y1s, 4 * s_y1s) self.sigma = self.s1s self.Y1S = Needham_pdf(name + '1S', mass.getMin(), mass.getMax(), mass=self.mass, mean=self.m1s, sigma=self.s1s, a0=self.a0, a1=self.a1, a2=self.a2) # ===================================================================== ## Y(2S) # ===================================================================== self.dm2s = makeVar(None, "dm2s" + name, "dm2s(%s)" % name, dm_y2s, dm_y2s - 0.20 * s_y1s, dm_y2s + 0.20 * s_y1s) self.aset11 = ROOT.RooArgList(self.m1s, self.dm2s) self.m2s = ROOT.RooFormulaVar( "m_" + name + '2S', "m2s(%s)" % name, "%s+%s" % (self.m1s.GetName(), self.dm2s.GetName()), self.aset11) self.aset12 = ROOT.RooArgList(self.sigma, self.m1s, self.m2s) self.s2s = ROOT.RooFormulaVar( "sigma_" + name + '2S', "#sigma_{Y2S}(%s)" % name, "%s*(%s/%s)" % (self.sigma.GetName(), self.m2s.GetName(), self.m1s.GetName()), self.aset12) self.Y2S = Needham_pdf(name + '2S', mass.getMin(), mass.getMax(), mass=self.mass, mean=self.m2s, sigma=self.s2s, a0=self.a0, a1=self.a1, a2=self.a2) # ===================================================================== ## Y(3S) # ===================================================================== self.dm3s = makeVar(None, "dm3s" + name, "dm3s(%s)" % name, dm_y3s, dm_y3s - 0.20 * s_y1s, dm_y3s + 0.20 * s_y1s) self.aset21 = ROOT.RooArgList(self.m1s, self.dm3s) self.m3s = ROOT.RooFormulaVar( "m_" + name + '(3S)', "m3s(%s)" % name, "%s+%s" % (self.m1s.GetName(), self.dm3s.GetName()), self.aset21) self.aset22 = ROOT.RooArgList(self.sigma, self.m1s, self.m3s) self.s3s = ROOT.RooFormulaVar( "sigma_" + name + '3S', "#sigma_{Y3S}(%s)" % name, "%s*(%s/%s)" % (self.sigma.GetName(), self.m3s.GetName(), self.m1s.GetName()), self.aset22) self.Y3S = Needham_pdf(name + '3S', mass.getMin(), mass.getMax(), mass=self.mass, mean=self.m3s, sigma=self.s3s, a0=self.a0, a1=self.a1, a2=self.a2) # ## the actual signal PDFs # self.y1s = self.Y1S.pdf self.y2s = self.Y2S.pdf self.y3s = self.Y3S.pdf ## use helper function to create background from ostap.fitting.models_bkg import makeBkg self.background = makeBkg(power, 'Bkg%s' % name, self.mass) self.n1s = makeVar(None, "N1S" + name, "Signal(Y1S)", None, 1000, 0, 1.e+7) self.n2s = makeVar(None, "N2S" + name, "Signal(Y2S)", None, 300, 0, 1.e+6) self.n3s = makeVar(None, "N3S" + name, "Signal(Y3S)", None, 100, 0, 1.e+5) self.b = makeVar(None, "B" + name, "Background", None, 100, 0, 1.e+8) self.alist1 = ROOT.RooArgList(self.y1s, self.y2s, self.y3s) self.alist2 = ROOT.RooArgList(self.n1s, self.n2s, self.n3s) self.alist1.add(self.background.pdf) self.alist2.add(self.b) self.pdf = ROOT.RooAddPdf("manca_%s" % name, "manca(%s)" % name, self.alist1, self.alist2) self.dm2s.setConstant(True) self.dm3s.setConstant(True) self._splots = [] self.s1_name = self.n1s.GetName() self.s2_name = self.n2s.GetName() self.s3_name = self.n3s.GetName() # ## finally declare components # self.signals().add(self.y1s) self.signals().add(self.y2s) self.signals().add(self.y3s) self.backgrounds().add(self.background.pdf)
def __init__(self, mass, name='Y', power=0, m1s=None, sigma=None, alphaL=1.5462, alphaR=1.6952, nL=1.3110, nR=1.5751e+01): # PDF.__init__(self, name) # if mass.getMin() < 9.460 and 9.60 <= mass.getMax(): gev_ = 1 elif mass.getMin() < 10. and 10.500 <= mass.getMax(): gev_ = 1 elif mass.getMin() < 10.0 and 10.200 <= mass.getMax(): gev_ = 1 elif mass.getMin() < 9460 and 10355 <= mass.getMax(): gev_ = 1000 elif mass.getMin() < 10000 and 10500 <= mass.getMax(): gev_ = 1000 elif mass.getMin() < 10000 and 10200 <= mass.getMax(): gev_ = 1000 else: raise TypeError("Illegal mass range %s<m<%s" % (mass.getMin(), mass.getMax())) m_y1s = 9.46030 * gev_ s_y1s = 4.03195e-02 * gev_ dm_y2s = 10.02326 * gev_ - m_y1s dm_y3s = 10.3552 * gev_ - m_y1s # self.mass = mass # ===================================================================== from ostap.fitting.basic import makeVar from ostap.fitting.signals import CB2_pdf # ===================================================================== ## Y(1S) # ===================================================================== self.aL = makeVar(alphaL, "aL_%s" % name, "#alpha_{L}(%s)" % name, alphaL, 1.5462, 0, 10) self.nL = makeVar(nL, "nL_%s" % name, "n_{L}(%s)" % name, nL, 1.3119, 0, 10) self.aR = makeVar(alphaR, "aR_%s" % name, "#alpha_{R}(%s)" % name, alphaR, 1.6952e+00, 0, 10) self.nR = makeVar(nR, "nR_%s" % name, "n_{R}(%s)" % name, nR, 1.5751e+01, 0, 25) self.m1s = makeVar(m1s, "m1S_%s" % name, "mass Y1S(%s)" % name, m1s, m_y1s, m_y1s - 0.15 * s_y1s, m_y1s + 0.15 * s_y1s) self.s1s = makeVar(sigma, "s1S_%s" % name, "sigma Y1S(%s)" % name, sigma, s_y1s, 0.3 * s_y1s, 4 * s_y1s) self.sigma = self.s1s self.Y1S = CB2_pdf(name + '1S', mass.getMin(), mass.getMax(), mass=self.mass, mean=self.m1s, sigma=self.s1s, alphaL=self.aL, alphaR=self.aR, nL=self.nL, nR=self.nR) # ===================================================================== ## Y(2S) # ===================================================================== self.dm2s = makeVar(None, "dm2s" + name, "dm2s(%s)" % name, dm_y2s, dm_y2s - 0.20 * s_y1s, dm_y2s + 0.20 * s_y1s) self.aset11 = ROOT.RooArgList(self.m1s, self.dm2s) self.m2s = ROOT.RooFormulaVar( "m_" + name + '2S', "m2s(%s)" % name, "%s+%s" % (self.m1s.GetName(), self.dm2s.GetName()), self.aset11) self.aset12 = ROOT.RooArgList(self.sigma, self.m1s, self.m2s) self.s2s = ROOT.RooFormulaVar( "sigma_" + name + '2S', "#sigma_{Y2S}(%s)" % name, "%s*(%s/%s)" % (self.sigma.GetName(), self.m2s.GetName(), self.m1s.GetName()), self.aset12) self.Y2S = CB2_pdf(name + '2S', mass.getMin(), mass.getMax(), mass=self.mass, mean=self.m2s, sigma=self.s2s, alphaL=self.aL, alphaR=self.aR, nL=self.nL, nR=self.nR) # ===================================================================== ## Y(3S) # ===================================================================== self.dm3s = makeVar(None, "dm3s" + name, "dm3s(%s)" % name, dm_y3s, dm_y3s - 0.20 * s_y1s, dm_y3s + 0.20 * s_y1s) self.aset21 = ROOT.RooArgList(self.m1s, self.dm3s) self.m3s = ROOT.RooFormulaVar( "m_" + name + '(3S)', "m3s(%s)" % name, "%s+%s" % (self.m1s.GetName(), self.dm3s.GetName()), self.aset21) self.aset22 = ROOT.RooArgList(self.sigma, self.m1s, self.m3s) self.s3s = ROOT.RooFormulaVar( "sigma_" + name + '3S', "#sigma_{Y3S}(%s)" % name, "%s*(%s/%s)" % (self.sigma.GetName(), self.m3s.GetName(), self.m1s.GetName()), self.aset22) self.Y3S = CB2_pdf(name + '3S', mass.getMin(), mass.getMax(), mass=self.mass, mean=self.m3s, sigma=self.s3s, alphaL=self.aL, alphaR=self.aR, nL=self.nL, nR=self.nR) # ## the actual signal PDFs # self.y1s = self.Y1S.pdf self.y2s = self.Y2S.pdf self.y3s = self.Y3S.pdf ## use helper function to create background from ostap.fitting.models_bkg import makeBkg self.background = makeBkg(power, 'Bkg%s' % name, self.mass) self.n1s = makeVar(None, "N1S" + name, "Signal(Y1S)", None, 1000, 0, 1.e+7) self.n2s = makeVar(None, "N2S" + name, "Signal(Y2S)", None, 300, 0, 1.e+6) self.n3s = makeVar(None, "N3S" + name, "Signal(Y3S)", None, 100, 0, 1.e+6) self.b = makeVar(None, "B" + name, "Background", None, 100, 0, 1.e+8) self.alist1 = ROOT.RooArgList(self.y1s, self.y2s, self.y3s) self.alist2 = ROOT.RooArgList(self.n1s, self.n2s, self.n3s) self.alist1.add(self.background.pdf) self.alist2.add(self.b) self.pdf = ROOT.RooAddPdf("manca_%s" % name, "manca(%s)" % name, self.alist1, self.alist2) self.dm2s.setConstant(True) self.dm3s.setConstant(True) self._splots = [] self.s1_name = self.n1s.GetName() self.s2_name = self.n2s.GetName() self.s3_name = self.n3s.GetName() # ## finally declare components # self.signals().add(self.y1s) self.signals().add(self.y2s) self.signals().add(self.y3s) self.backgrounds().add(self.background.pdf)
def __init__( self, manca, ## manca pdf, that defined 3 upsolon peaks charm, ## charm pdf bkg1=0, bkg2=0, bkgA=0, bkgB=0, suffix=''): PDF2.__init__(self, 'MancaX' + suffix, manca.mass, charm.mass) self._crossterms1 = ROOT.RooArgSet() self._crossterms2 = ROOT.RooArgSet() self.suffix = suffix self.signal1 = manca self.signal2 = charm ## use helper function to create background from ostap.fitting.models_bkg import makeBkg # ## background components # self.b_Y = makeBkg(bkg1, 'BkgY' + suffix, self.m1) self.b_C = makeBkg(bkg2, 'BkgC' + suffix, self.m2) self.b_A = makeBkg(bkgA, 'BkgA' + suffix, self.m1) self.b_B = makeBkg(bkgB, 'BkgB' + suffix, self.m2) # ## pure signal components: 3 # RPP = ROOT.RooProdPdf self.y1s_c = RPP('Y1SC' + suffix, 'Y(1S)(x)Charm', manca.y1s, charm.pdf) self.y2s_c = RPP('Y2SC' + suffix, 'Y(2S)(x)Charm', manca.y2s, charm.pdf) self.y3s_c = RPP('Y3SC' + suffix, 'Y(3S)(x)Charm', manca.y3s, charm.pdf) ## charm + background self.bs_pdf = RPP('BC' + suffix, 'B(2mu)(x)Charm', self.b_Y.pdf, charm.pdf) ## Y + background self.y1s_b = RPP('Y1SB' + suffix, 'Y(1S)(x)Bkg', manca.y1s, self.b_C.pdf) self.y2s_b = RPP('Y2SB' + suffix, 'Y(2S)(x)Bkg', manca.y2s, self.b_C.pdf) self.y3s_b = RPP('Y3SB' + suffix, 'Y(3S)(x)Bkg', manca.y3s, self.b_C.pdf) ## background + background self.bb_pdf = RPP('BB' + suffix, 'Bkg(x)Bkg', self.b_A.pdf, self.b_B.pdf) ## coefficients from Ostap.FitBasic import makeVar self.s1s = makeVar(None, 'NY1C' + suffix, 'N(Y1S+C)' + suffix, None, 200, 0, 1.e+5) self.s2s = makeVar(None, 'NY2C' + suffix, 'N(Y2S+C)' + suffix, None, 100, 0, 1.e+4) self.s3s = makeVar(None, 'NY3C' + suffix, 'N(Y3S+C)' + suffix, None, 20, 0, 1.e+4) self.bs = makeVar(None, 'NBC' + suffix, 'N(Bkg+C)' + suffix, None, 500, 0, 1.e+5) self.s1b = makeVar(None, 'NY1B' + suffix, 'N(Y1S+B)' + suffix, None, 500, 0, 1.e+5) self.s2b = makeVar(None, 'NY2B' + suffix, 'N(Y2S+B)' + suffix, None, 200, 0, 1.e+4) self.s3b = makeVar(None, 'NY3B' + suffix, 'N(Y3S+B)' + suffix, None, 200, 0, 1.e+4) self.bb = makeVar(None, 'NBB' + suffix, 'N(Bkg+B)' + suffix, None, 500, 0, 1.e+5) self.S1S_name = self.s1s.GetName() self.S2S_name = self.s2s.GetName() self.S3S_name = self.s3s.GetName() self.S1B_name = self.s1b.GetName() self.S2B_name = self.s2b.GetName() self.S3B_name = self.s3b.GetName() self.BS_name = self.bs.GetName() self.BB_name = self.bb.GetName() self.alist1 = ROOT.RooArgList(self.y1s_c, self.y2s_c, self.y3s_c, self.bs_pdf, self.y1s_b, self.y2s_b, self.y3s_b, self.bb_pdf) self.alist2 = ROOT.RooArgList(self.s1s, self.s2s, self.s3s, self.bs, self.s1b, self.s2b, self.s3b, self.bb) # ## build final PDF # self.pdf = ROOT.RooAddPdf("model2D" + suffix, "Model2D(%s)" % suffix, self.alist1, self.alist2) self.name = self.pdf.GetName() ## self.signals().add(self.y1s_c) self.signals().add(self.y2s_c) self.signals().add(self.y3s_c) ## self.backgrounds().add(self.bb_pdf) ## self.crossterms1().add(self.y1s_b) self.crossterms1().add(self.y2s_b) self.crossterms1().add(self.y3s_b) ## self.crossterms2().add(self.bs_pdf)
def __init__(self, mass, name='Y', power=0, m1s=None, sigma=None, alphaL=1.5462, alphaR=1.6952, nL=1.3110, nR=1.5751e+01): # PDF.__init__(self, name, mass) # if 9460. in self.mass and 10023. in self.mass and 10355. in self.mass: gev_ = 1000 elif 9.460 in self.mass and 10.023 in self.mass and 10.355 in self.mass: gev_ = 1 else: raise AttributeError("Illegal mass range %s<m<%s" % self.xminmax()) m_y1s = 9.46030 * gev_ s_y1s = 4.03195e-02 * gev_ dm_y2s = 10.02326 * gev_ - m_y1s dm_y3s = 10.3552 * gev_ - m_y1s # ===================================================================== # ===================================================================== ## Y(1S) # ===================================================================== self.__aL = makeVar(alphaL, "aL_%s" % name, "#alpha_{L}(%s)" % name, alphaL, 1.5462, 0.1, 10) self.__nL = makeVar(nL, "nL_%s" % name, "n_{L}(%s)" % name, nL, 1.3119, 1.e-5, 25) self.__aR = makeVar(alphaR, "aR_%s" % name, "#alpha_{R}(%s)" % name, alphaR, 1.6952e+00, 0.1, 10) self.__nR = makeVar(nR, "nR_%s" % name, "n_{R}(%s)" % name, nR, 1.5751e+01, 1.e-5, 25) self.__m1s = makeVar(m1s, "m1S_%s" % name, "mass Y1S(%s)" % name, m1s, m_y1s, m_y1s - 0.15 * s_y1s, m_y1s + 0.15 * s_y1s) self.__s1s = makeVar(sigma, "s1S_%s" % name, "sigma Y1S(%s)" % name, sigma, s_y1s, 0.3 * s_y1s, 4 * s_y1s) self.__sigma = self.__s1s self.__Y1S = CB2_pdf(name + '1S', xvar=self.mass, mean=self.__m1s, sigma=self.__s1s, alphaL=self.__aL, alphaR=self.__aR, nL=self.__nL, nR=self.__nR) # ===================================================================== ## Y(2S) # ===================================================================== self.__dm2s = makeVar(None, "dm2s" + name, "dm2s(%s)" % name, dm_y2s, dm_y2s - 0.20 * s_y1s, dm_y2s + 0.20 * s_y1s) self.__aset11 = ROOT.RooArgList(self.__m1s, self.__dm2s) self.__m2s = ROOT.RooFormulaVar( "m_" + name + '2S', "m2s(%s)" % name, "%s+%s" % (self.__m1s.GetName(), self.__dm2s.GetName()), self.__aset11) self.__aset12 = ROOT.RooArgList(self.__sigma, self.__m1s, self.__m2s) self.s2s = ROOT.RooFormulaVar( "sigma_" + name + '2S', "#sigma_{Y2S}(%s)" % name, "%s*(%s/%s)" % (self.__sigma.GetName(), self.__m2s.GetName(), self.__m1s.GetName()), self.__aset12) self.__Y2S = CB2_pdf(name + '2S', xvar=self.mass, mean=self.__m2s, sigma=self.__s2s, alphaL=self.__aL, alphaR=self.__aR, nL=self.__nL, nR=self.__nR) # ===================================================================== ## Y(3S) # ===================================================================== self.__dm3s = makeVar(None, "dm3s" + name, "dm3s(%s)" % name, dm_y3s, dm_y3s - 0.20 * s_y1s, dm_y3s + 0.20 * s_y1s) self.__aset21 = ROOT.RooArgList(self.__m1s, self.__dm3s) self.__m3s = ROOT.RooFormulaVar( "m_" + name + '(3S)', "m3s(%s)" % name, "%s+%s" % (self.__m1s.GetName(), self.__dm3s.GetName()), self.__aset21) self.__aset22 = ROOT.RooArgList(self.__sigma, self.__m1s, self.__m3s) self.__s3s = ROOT.RooFormulaVar( "sigma_" + name + '3S', "#sigma_{Y3S}(%s)" % name, "%s*(%s/%s)" % (self.__sigma.GetName(), self.__m3s.GetName(), self.__m1s.GetName()), self.__aset22) self.__Y3S = CB2_pdf(name + '3S', xvar=self.mass, mean=self.__m3s, sigma=self.__s3s, alphaL=self.__aL, alphaR=self.__aR, nL=self.__nL, nR=self.__nR) # ## the actual signal PDFs # self.__y1s = self.__Y1S.pdf self.__y2s = self.__Y2S.pdf self.__y3s = self.__Y3S.pdf ## use helper function to create background self.background = makeBkg(power, 'Bkg%s' % name, self.mass) self.__n1s = makeVar(None, "N1S" + name, "Signal(Y1S)", None, 1000, 0, 1.e+7) self.__n2s = makeVar(None, "N2S" + name, "Signal(Y2S)", None, 300, 0, 1.e+6) self.__n3s = makeVar(None, "N3S" + name, "Signal(Y3S)", None, 100, 0, 1.e+6) self.__b = makeVar(None, "B" + name, "Background", None, 100, 0, 1.e+8) self.alist1 = ROOT.RooArgList(self.__y1s, self.__y2s, self.__y3s) self.alist2 = ROOT.RooArgList(self.__n1s, self.__n2s, self.__n3s) self.alist1.add(self.background.pdf) self.alist2.add(self.__b) self.pdf = ROOT.RooAddPdf("manca_%s" % name, "manca(%s)" % name, self.alist1, self.alist2) self.__dm2s.setConstant(True) self.__dm3s.setConstant(True) self._splots = [] self.s1_name = self.N1S.GetName() self.s2_name = self.N2S.GetName() self.s3_name = self.N3S.GetName() self.b_name = self.B.GetName() # ## finally declare components # self.signals().add(self.__y1s) self.signals().add(self.__y2s) self.signals().add(self.__y3s) self.backgrounds().add(self.background.pdf) ## save configurtaion self.config = { 'mass': self.mass, 'name': self.name, 'power': self.power, 'm1s': self.m1s, 'sigma': self.sigma, 'alphaL': self.aL, 'alphaR': self.aR, 'nL': self.nL, 'nR': self.nR, }