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,
}
