def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("r_WZ[1,0.0,1.0]") # bounded to 1
self.modelBuilder.doVar("r_gZ[1,0.0,2.0]")
self.modelBuilder.doVar("r_tZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_bZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_mZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_topglu[1,0.0,4.0]")
self.modelBuilder.doVar("r_Zglu[1,0.0,4.0]")
self.modelBuilder.doVar("c_gluZ[1,0.0,3.0]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet(
"POI", 'r_WZ,r_gZ,r_tZ,r_bZ,r_mZ,r_topglu,r_Zglu,c_gluZ,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet(
"POI", 'r_WZ,r_gZ,r_tZ,r_bZ,r_mZ,r_topglu,r_Zglu,c_gluZ')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
if self.floatMass: print " --> [WARNING] Floating Higgs mass selected. STXStoEFT model assumes MH=125.0 GeV"
self.doMH()
self.SMH = SMHiggsBuilder(self.modelBuilder)
#Read in parameter list from file using textToPOIList function
self.textToPOIList( os.path.join(self.SMH.datadir,'eft/HEL/pois.txt') )
POIs = ','.join(self.pois.keys())
for poi, poi_range in self.pois.iteritems(): self.modelBuilder.doVar("%s%s"%(poi,poi_range))
# Remove cWW+cB from POI list if freezing other parameters
if self.freezeOtherParameters: POIs = re.sub("cWWPluscB_x02,","",POIs)
self.modelBuilder.doSet("POI",POIs)
#POIs for cWW and cB defined in terms of constraints on cWW+cB and cWW-cB: define expression for individual coefficient
self.modelBuilder.factory_("expr::cWW_x02(\"0.5*(@0+@1)\",cWWPluscB_x02,cWWMinuscB_x02)")
self.modelBuilder.factory_("expr::cB_x02(\"0.5*(@0-@1)\",cWWPluscB_x02,cWWMinuscB_x02)")
self.poi_scaling['cWW'] = "0.01*cWW_x02"
self.poi_scaling['cB'] = "0.01*cB_x02"
# Freeze cWW+cB if freezeOtherParameters
if self.freezeOtherParameters:
for poi in self.pois:
if 'cWWPluscB' in poi: self.modelBuilder.out.var( poi ).setConstant(True)
#set up model
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
#self.modelBuilder.doVar("CV[1,%s,%s]" % (self.cVRange[0], self.cVRange[1]))
self.modelBuilder.doVar("CV[1,0.0,1.0]") # bounded to 1
self.modelBuilder.doVar("CF[1,0,10]")
self.modelBuilder.doVar("BRInvUndet[0,0,1]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", 'CV,CF,BRInvUndet,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI", 'CV,CF,BRInvUndet')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strengths (and MH)"""
pois = []
allProds = []
for regproc in ALL_STXS_PROCS["Stage0"].keys():
P = ALL_STXS_PROCS["Stage0"][regproc]
if P in allProds: continue
allProds.append(P)
for dec in SM_HIGG_DECAYS:
D = CMS_to_LHCHCG_DecSimple[dec]
if (D==self.denominator):
if (not "mu_XS_%s_x_BR_%s"%(P,self.denominator) in pois):
self.modelBuilder.doVar("mu_XS_%s_x_BR_%s[1,0,5]"%(P,self.denominator))
pois.append("mu_XS_%s_x_BR_%s"%(P,self.denominator))
else:
if (not "mu_BR_%s_r_BR_%s"%(D,self.denominator) in pois):
self.modelBuilder.doVar("mu_BR_%s_r_BR_%s[1,0,5]"%(D,self.denominator))
pois.append("mu_BR_%s_r_BR_%s"%(D,self.denominator))
print pois
self.POIs=",".join(pois)
self.doMH()
print "Default parameters of interest: ", self.POIs
self.modelBuilder.doSet("POI",self.POIs)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kV[1,0.0,1.0]") # bounded to 1
self.modelBuilder.doVar("ktau[1,0.0,2.0]")
self.modelBuilder.doVar("ktop[1,0.0,4.0]")
self.modelBuilder.doVar("kbottom[1,0.0,3.0]")
self.modelBuilder.doVar("kgluon[1,0.0,2.0]")
self.modelBuilder.doVar("kgamma[1,0.0,2.5]")
self.modelBuilder.doVar("BRInvUndet[0,0,1]")
pois = 'kV,ktau,ktop,kbottom,kgluon,kgamma,BRInvUndet'
if self.doHZg:
self.modelBuilder.doVar("kZgamma[1,0.0,30.0]")
pois += ",kZgamma"
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", pois + ',MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI", pois)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kV[1,0.0,2.0]")
self.modelBuilder.doVar("ktau[1,0.0,2.0]")
self.modelBuilder.doVar("kquark[1,0.0,2.0]")
self.modelBuilder.doVar("kgluon[1,0.0,2.0]")
self.modelBuilder.doVar("kgamma[1,0.0,2.0]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", 'kV,ktau,kquark,kgluon,kgamma,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI", 'kV,ktau,kquark,kgluon,kgamma')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("r[1,0.0,10.0]")
self.modelBuilder.doVar("kappa_V[1,0.0,2.0]")
self.modelBuilder.doVar("kappa_t[1,-10.0,10.0]")
self.modelBuilder.doVar("kappa_mu[1,0.0,5.0]")
if not self.coupleTopTau:
self.modelBuilder.doVar("kappa_tau[1,0.0,3.0]")
self.modelBuilder.factory_(
"expr::kappa_mu_expr(\"@0*@1+(1-@0)*@2\", CMS_use_kmu[0], kappa_mu, kappa_tau)"
)
else:
self.modelBuilder.factory_(
"expr::kappa_mu_expr(\"@0*@1+(1-@0)*@2\", CMS_use_kmu[0], kappa_mu, kappa_t)"
)
self.modelBuilder.doVar("kappa_b[1,0.0,3.0]")
self.modelBuilder.doVar(
"kappa_c[1,0.0,3.0]") # treat hcc independently from kappa_t
if not self.resolved:
self.modelBuilder.doVar("kappa_g[1,0.0,2.0]")
self.modelBuilder.doVar("kappa_gam[1,0.0,2.5]")
self.modelBuilder.doVar("BRinv[0,0,1]")
if not self.addInvisible:
self.modelBuilder.out.var("BRinv").setConstant(True)
pois = 'kappa_V,kappa_t,kappa_b,kappa_c'
if not self.coupleTopTau:
pois += ',kappa_tau'
if not self.resolved:
pois += ',kappa_g,kappa_gam'
if self.addInvisible: pois += ",BRinv"
self.doMH()
self.modelBuilder.doSet("POI", pois)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("Cg[1,0,10]")
self.modelBuilder.doVar("Cv[1,0,10]")
self.modelBuilder.doVar("Cglu[1,0,10]")
POI = "Cg,Cv,Cglu"
if self.universalCF:
self.modelBuilder.doVar("Cf[1,0,10]")
POI += ",Cf"
else:
self.modelBuilder.doVar("Cu[1,0,10]")
self.modelBuilder.doVar("Cd[1,0,10]")
POI += ",Cu,Cd"
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
POI += ",MH"
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
for F in self.fix:
self.modelBuilder.out.var(F).setConstant(True)
if F+"," in POI: POI = POI.replace(F+",", "")
else: POI = POI.replace(","+F, "")
self.modelBuilder.doSet("POI",POI)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kgluon[1,0,2]")
self.modelBuilder.doVar("kgamma[1,0,3]")
myPOIs = ['kgluon', 'kgamma']
if self.doHZg:
self.modelBuilder.doVar("kZgamma[1,0,10]")
myPOIs.append('kZgamma')
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
myPOIs.append('MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet('POI', ','.join(myPOIs))
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kZ[1,0,2]")
if self.floatKF:
self.modelBuilder.doVar("kf[1,0,2]")
else:
self.modelBuilder.doVar("kf[1]")
self.modelBuilder.doVar("lambdaWZ[1,0,2]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet(
"POI",
"kZ,lambdaWZ,kf,MH" if self.floatKF else "kZ,lambdaWZ,MH")
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet(
"POI", "kZ,lambdaWZ,kf" if self.floatKF else "kZ,lambdaWZ")
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CW[1.0,0.0,5.0]")
self.modelBuilder.doVar("CZ[1.0,0.0,5.0]")
self.modelBuilder.doVar("Ctop[1.0,0.0,5.0]")
self.modelBuilder.doVar("Cb[1.0,0.0,5.0]")
self.modelBuilder.doVar("Ctau[1.0,0.0,5.0]")
self.modelBuilder.doVar("Cmu[1.0,0.0,5.0]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'MH,CW,CZ,Ctop,Cb,Ctau,Cmu')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CW,CZ,Ctop,Cb,Ctau,Cmu')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CV[1,%s,%s]" %
(self.cVRange[0], self.cVRange[1]))
self.modelBuilder.doVar("CF[1,%s,%s]" %
(self.cFRange[0], self.cFRange[1]))
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", "CV,CF,MH")
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI", "CV,CF")
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
class RwzHiggs(SMLikeHiggsModel):
"scale WW by mu and ZZ by cZW^2 * mu"
def __init__(self):
SMLikeHiggsModel.__init__(
self
) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self, physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=", "").split(",")
print("The Higgs mass range:", self.mHRange)
if len(self.mHRange) != 2:
raise RuntimeError(
"Higgs mass range definition requires two extrema.")
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError(
"Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
)
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("Rwz[1,0,10]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", "Rwz,MH")
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI", "Rwz")
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
for d in ["hww", "hzz"]:
self.SMH.makeBR(d)
self.modelBuilder.doVar("Rhzz[1,0,10]")
self.modelBuilder.factory_('expr::Rhww("@0*@1", Rhzz, Rwz)')
def getHiggsSignalYieldScale(self, production, decay, energy):
if decay not in ["hww", "hzz"]:
return 0
else:
return "R%s" % decay
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kappa_V[1,0.0,2.0]")
self.modelBuilder.doVar("kappa_F[1,-2.0,2.0]")
self.modelBuilder.doVar("kappa_lambda[1,-20,20]")
pois = 'kappa_V,kappa_F,kappa_lambda'
self.doMH()
self.modelBuilder.doSet("POI", pois)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("r[1,0,20]")
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),
float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", 'r,MH')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
class RwzHiggs(SMLikeHiggsModel):
"scale WW by mu and ZZ by cZW^2 * mu"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("Rwz[1,0,10]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'Rwz,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'Rwz')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
for d in [ "hww", "hzz" ]:
self.SMH.makeBR(d)
self.modelBuilder.doVar("Rhzz[1,0,10]")
self.modelBuilder.factory_('expr::Rhww("@0*@1", Rhzz, Rwz)')
def getHiggsSignalYieldScale(self,production,decay,energy):
if decay not in ['hww', 'hzz']:
return 0
else:
return 'R%s' % decay
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("r_WZ[1,0.0,1.0]") # bounded to 1
self.modelBuilder.doVar("r_gZ[1,0.0,2.0]")
self.modelBuilder.doVar("r_tZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_bZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_mZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_topglu[1,0.0,4.0]")
self.modelBuilder.doVar("r_Zglu[1,0.0,4.0]")
self.modelBuilder.doVar("c_gluZ[1,0.0,3.0]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'r_WZ,r_gZ,r_tZ,r_bZ,r_mZ,r_topglu,r_Zglu,c_gluZ,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'r_WZ,r_gZ,r_tZ,r_bZ,r_mZ,r_topglu,r_Zglu,c_gluZ')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kV[1,0.0,1.0]") # bounded to 1
self.modelBuilder.doVar("ktau[1,0.0,2.0]")
self.modelBuilder.doVar("ktop[1,0.0,4.0]")
self.modelBuilder.doVar("kbottom[1,0.0,3.0]")
self.modelBuilder.doVar("kgluon[1,0.0,2.0]")
self.modelBuilder.doVar("kgamma[1,0.0,2.5]")
self.modelBuilder.doVar("BRInvUndet[0,0,1]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'kV,ktau,ktop,kbottom,kgluon,kgamma,BRInvUndet,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'kV,ktau,ktop,kbottom,kgluon,kgamma,BRInvUndet')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CW[1.0,0.0,5.0]")
self.modelBuilder.doVar("CZ[1.0,0.0,5.0]")
self.modelBuilder.doVar("Ctop[1.0,0.0,5.0]")
self.modelBuilder.doVar("Cb[1.0,0.0,5.0]")
self.modelBuilder.doVar("Ctau[1.0,0.0,5.0]")
self.modelBuilder.doVar("Cmu[1.0,0.0,5.0]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'MH,CW,CZ,Ctop,Cb,Ctau,Cmu')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CW,CZ,Ctop,Cb,Ctau,Cmu')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kV[1,0.0,2.0]")
self.modelBuilder.doVar("ktau[1,0.0,2.0]")
self.modelBuilder.doVar("ktop[1,0.0,2.0]")
self.modelBuilder.doVar("kbottom[1,0.0,2.0]")
self.modelBuilder.doVar("kgluon[1,0.0,2.0]")
self.modelBuilder.doVar("kgamma[1,0.0,2.0]")
pois = 'kV,ktau,ktop,kbottom,kgluon,kgamma'
if self.doHZg:
self.modelBuilder.doVar("kZgamma[1,0.0,30.0]")
pois += ",kZgamma"
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",pois+',MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",pois)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kgluon[1,0,2]")
self.modelBuilder.doVar("kgamma[1,0,3]")
myPOIs = ['kgluon','kgamma']
if self.doHZg:
self.modelBuilder.doVar("kZgamma[1,0,10]")
myPOIs.append('kZgamma')
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
myPOIs.append('MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet( 'POI', ','.join(myPOIs) )
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def make_splines(self):
print 'Making splines'
# Load spline for HZZ BR (function of MH)
self.SMH = SMHiggsBuilder(self.modelBuilder)
datadir = os.environ[
'CMSSW_BASE'] + '/src/HiggsAnalysis/CombinedLimit/data/lhc-hxswg'
self.SMH.textToSpline('BR_hzz',
os.path.join(datadir, 'sm/br/BR4.txt'),
ycol=11)
self.spline_SMBR_hzz = self.modelBuilder.out.function('BR_hzz')
# Seems to work:
# self.modelBuilder.out.var('MH').setVal(125.09)
# spline_SMBR_hzz.Print()
# Load spling for Hgg BR
self.spline_SMBR_hgg = self.modelBuilder.out.function('fbr_13TeV')
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("Cz[1,0,10]")
self.modelBuilder.doVar("Cwz[1,0,10]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'Cwz,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'Cwz')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("r[1,0,20]")
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'r,MH')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kgluon[1,0,2]")
self.modelBuilder.doVar("kgamma[1,0,3]")
self.modelBuilder.doVar("BRInvUndet[0,0,1]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", "kgluon,kgamma,BRInvUndet,MH")
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI", "kgluon,kgamma,BRInvUndet")
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
## the model is built with:
## r x [GGF + VBF]
## GGF = r_GGF x [sum samples(kl, kt)]
## VBF = r_VBF x [sum samples(kl, CV, C2V)]
POIs = "r,r_gghh,r_qqhh,CV,C2V,kl,kt"
self.modelBuilder.doVar("r[1,0,10]")
self.modelBuilder.doVar("r_gghh[1,0,10]")
self.modelBuilder.doVar("r_qqhh[1,0,10]")
self.modelBuilder.doVar("CV[1,-10,10]")
self.modelBuilder.doVar("C2V[1,-10,10]")
self.modelBuilder.doVar("kl[1,-30,30]")
self.modelBuilder.doVar("kt[1,-10,10]")
self.modelBuilder.doSet("POI", POIs)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.modelBuilder.out.var("r_gghh").setConstant(True)
self.modelBuilder.out.var("r_qqhh").setConstant(True)
self.modelBuilder.out.var("CV").setConstant(True)
self.modelBuilder.out.var("C2V").setConstant(True)
self.modelBuilder.out.var("kl").setConstant(True)
self.modelBuilder.out.var("kt").setConstant(True)
#I need to build MH variables because the BR are tabulated as a function of MH
# the mass setting must be provided as input, i.e. '-m 125'
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.create_scalings()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("Czw[1,0,10]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'Czw,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'Czw')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kgluon[1,0,2]")
self.modelBuilder.doVar("kgamma[1,0,3]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'kgluon,kgamma,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'kgluon,kgamma')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("cosbma[0,-1,1]")
self.modelBuilder.doVar("tanbeta[0,0.0,10]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'cosbma,tanbeta,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'cosbma,tanbeta')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
class FermiophobicHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.mHRange = ['115','135'] # default
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("r[1,0,20]")
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'r,MH')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
## Add FP BRs
datadir = os.environ['CMSSW_BASE']+'/src/HiggsAnalysis/CombinedLimit/data/lhc-hxswg'
self.SMH.textToSpline( 'FP_BR_hww', os.path.join(datadir, 'fp/BR.txt'), ycol=4 );
self.SMH.textToSpline( 'FP_BR_hzz', os.path.join(datadir, 'fp/BR.txt'), ycol=5 );
self.SMH.textToSpline( 'FP_BR_hgg', os.path.join(datadir, 'fp/BR.txt'), ycol=2 );
self.SMH.textToSpline( 'FP_BR_hzg', os.path.join(datadir, 'fp/BR.txt'), ycol=3 );
for decay in ['hww','hzz','hgg','hzg']:
self.SMH.makeBR(decay)
self.modelBuilder.factory_('expr::FP_BRScal_%s("@0*@1/@2",r,FP_BR_%s,SM_BR_%s)'%(decay,decay,decay))
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
if production not in ['VH', 'WH', 'ZH', 'qqH']:
return 0
if decay not in ['hww','hzz','hgg','hzg']:
return 0
return 'FP_BRScal_%s' % decay
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
#self.modelBuilder.doVar("CV[1,%s,%s]" % (self.cVRange[0], self.cVRange[1]))
self.modelBuilder.doVar("CV[1,0.0,1.0]") # bounded to 1
self.modelBuilder.doVar("CF[1,0,10]")
self.modelBuilder.doVar("BRInvUndet[0,0,1]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'CV,CF,BRInvUndet,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CV,CF,BRInvUndet')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kZ[1,0,2]")
if self.floatKF:
self.modelBuilder.doVar("kf[1,0,2]")
else:
self.modelBuilder.doVar("kf[1]")
self.modelBuilder.doVar("lambdaWZ[1,0,2]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'kZ,lambdaWZ,kf,MH' if self.floatKF else 'kZ,lambdaWZ,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'kZ,lambdaWZ,kf' if self.floatKF else 'kZ,lambdaWZ')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
class CfXgHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CV[1]")
self.modelBuilder.doVar("CF[1,-1.5,1.5]")
self.modelBuilder.doVar("XG[0,-4,4]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'CF,XG,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CF,XG')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
## Add some common ingredients
datadir = os.environ['CMSSW_BASE']+'/src/HiggsAnalysis/CombinedLimit/data/lhc-hxswg'
self.SMH.textToSpline( 'mb', os.path.join(datadir, 'running_constants.txt'), ycol=2 );
mb = self.modelBuilder.out.function('mb')
mH = self.modelBuilder.out.var('MH')
CF = self.modelBuilder.out.var('CF')
CV = self.modelBuilder.out.var('CV')
XG = self.modelBuilder.out.var('XG')
RHggCfXg = ROOT.RooScaleHGamGamLOSMPlusX('CfXg_cgammaSq', 'LO SM Hgamgam scaling', mH, CF, CV, mb, CF, XG)
self.modelBuilder.out._import(RHggCfXg)
#Rgluglu = ROOT.RooScaleHGluGluLOSMPlusX('Rgluglu', 'LO SM Hgluglu scaling', mH, CF, mb, CF)
#self.modelBuilder.out._import(Rgluglu)
## partial witdhs, normalized to the SM one, for decays scaling with F, V and total
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::CfXg_Gscal_sumf("@0*@0 * (@1+@2+@3+@4+@5+@6+@7)", CF, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hgluglu, SM_BR_hmm, SM_BR_hss)')
self.modelBuilder.factory_('sum::CfXg_Gscal_sumv(SM_BR_hww, SM_BR_hzz, SM_BR_hzg)')
self.modelBuilder.factory_('expr::CfXg_Gscal_gg("@0 * @1", CfXg_cgammaSq, SM_BR_hgg)')
self.modelBuilder.factory_('sum::CfXg_Gscal_tot(CfXg_Gscal_sumf, CfXg_Gscal_sumv, CfXg_Gscal_gg)')
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::CfXg_BRscal_hgg("@0/@1", CfXg_cgammaSq, CfXg_Gscal_tot)')
self.modelBuilder.factory_('expr::CfXg_BRscal_hf("@0*@0/@1", CF, CfXg_Gscal_tot)')
self.modelBuilder.factory_('expr::CfXg_BRscal_hv("1.0/@0", CfXg_Gscal_tot)')
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "CfXg_XSBRscal_%s_%s" % (production,decay)
if self.modelBuilder.out.function(name) == None:
XSscal = 'CF' if production in ["ggH","ttH"] else 'CV'
BRscal = "hgg"
if decay in ["hww", "hzz"]: BRscal = "hv"
if decay in ["hbb", "htt"]: BRscal = "hf"
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, CfXg_BRscal_%s)' % (name, XSscal, BRscal))
return name
class StageZero(STXSBaseModel):
"Allow different signal strength fits for the stage-0 model"
def __init__(self,denominator="WW"):
STXSBaseModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.denominator=denominator
self.POIs = ""
def doVar(self,x,constant=True):
self.modelBuilder.doVar(x)
vname = re.sub(r"\[.*","",x)
#self.modelBuilder.out.var(vname).setConstant(constant)
print "SignalStrengths:: declaring %s as %s" % (vname,x)
def doParametersOfInterest(self):
"""Create POI out of signal strengths (and MH)"""
pois = []
allProds = []
for regproc in ALL_STXS_PROCS["Stage0"].keys():
P = ALL_STXS_PROCS["Stage0"][regproc]
if P in allProds: continue
allProds.append(P)
for dec in SM_HIGG_DECAYS:
D = CMS_to_LHCHCG_DecSimple[dec]
if (D==self.denominator):
if (not "mu_XS_%s_x_BR_%s"%(P,self.denominator) in pois):
self.modelBuilder.doVar("mu_XS_%s_x_BR_%s[1,0,5]"%(P,self.denominator))
pois.append("mu_XS_%s_x_BR_%s"%(P,self.denominator))
else:
if (not "mu_BR_%s_r_BR_%s"%(D,self.denominator) in pois):
self.modelBuilder.doVar("mu_BR_%s_r_BR_%s[1,0,5]"%(D,self.denominator))
pois.append("mu_BR_%s_r_BR_%s"%(D,self.denominator))
print pois
self.POIs=",".join(pois)
self.doMH()
print "Default parameters of interest: ", self.POIs
self.modelBuilder.doSet("POI",self.POIs)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
for d in SM_HIGG_DECAYS + [ "hss" ]:
self.SMH.makeBR(d)
allProds = []
for regproc in ALL_STXS_PROCS["Stage0"].keys():
P = ALL_STXS_PROCS["Stage0"][regproc]
if P in allProds: continue
allProds.append(P)
allDecs = []
for dec in SM_HIGG_DECAYS:
D = CMS_to_LHCHCG_DecSimple[dec]
if (D in allDecs): continue
allDecs.append(D)
if (D==self.denominator):
muXSBR = "mu_XS_%s_x_BR_%s"%(P,self.denominator)
self.modelBuilder.factory_('expr::scaling_'+P+'_'+D+'_13TeV("@0",'+muXSBR+')')
else:
muXSBR = "mu_XS_%s_x_BR_%s"%(P,self.denominator)
muBR = "mu_BR_%s_r_BR_%s"%(D,self.denominator)
decDen = CMS_to_LHCHCG_DecSimple.keys()[CMS_to_LHCHCG_DecSimple.values().index(self.denominator)]
#self.modelBuilder.factory_('expr::scaling_'+P+'_'+D+'_13TeV("@0*@1*@2/@3",'+muXSBR+','+muBR+',SM_BR_'+dec+',SM_BR_'+decDen+')')
self.modelBuilder.factory_('expr::scaling_'+P+'_'+D+'_13TeV("@0*@1",'+muXSBR+','+muBR+')')
def getHiggsSignalYieldScale(self,production,decay,energy):
for regproc in ALL_STXS_PROCS["Stage0"].keys():
if fnmatch.fnmatch(production, regproc):
return "scaling_%s_%s_%s" % (ALL_STXS_PROCS["Stage0"][regproc],decay,energy)
#raise RuntimeError, "No production process matching %s for Stage0 found !"%production
print "WARNING: No production process matching %s for Stage0 found, will scale by 1 !"%production
return 1
class C6(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.doHZg = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
if po == 'doHZg':
self.doHZg = True
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kV[1,0.0,2.0]")
self.modelBuilder.doVar("ktau[1,0.0,2.0]")
self.modelBuilder.doVar("ktop[1,0.0,2.0]")
self.modelBuilder.doVar("kbottom[1,0.0,2.0]")
self.modelBuilder.doVar("kgluon[1,0.0,2.0]")
self.modelBuilder.doVar("kgamma[1,0.0,2.0]")
pois = 'kV,ktau,ktop,kbottom,kgluon,kgamma'
if self.doHZg:
self.modelBuilder.doVar("kZgamma[1,0.0,30.0]")
pois += ",kZgamma"
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",pois+',MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",pois)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
# SM BR
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]: self.SMH.makeBR(d)
## total witdhs, normalized to the SM one
self.modelBuilder.factory_('expr::c6_Gscal_Vectors("@0*@0 * (@1+@2)", kV, SM_BR_hzz, SM_BR_hww)')
self.modelBuilder.factory_('expr::c6_Gscal_tau("@0*@0 * (@1+@2)", ktau, SM_BR_htt, SM_BR_hmm)')
self.modelBuilder.factory_('expr::c6_Gscal_top("@0*@0 * (@1+@2)", ktop, SM_BR_htoptop, SM_BR_hcc)')
self.modelBuilder.factory_('expr::c6_Gscal_bottom("@0*@0 * (@1+@2)", kbottom, SM_BR_hbb, SM_BR_hss)')
self.modelBuilder.factory_('expr::c6_Gscal_gluon("@0*@0 * @1", kgluon, SM_BR_hgluglu)')
if not self.doHZg:
self.modelBuilder.factory_('expr::c6_Gscal_gamma("@0*@0 * (@1+@2)", kgamma, SM_BR_hgg, SM_BR_hzg)')
else:
self.modelBuilder.factory_('expr::c6_Gscal_gamma("@0*@0 *@1+@2*@2*@3", kgamma, SM_BR_hgg, kZgamma, SM_BR_hzg)')
self.modelBuilder.factory_('sum::c6_Gscal_tot(c6_Gscal_Vectors, c6_Gscal_tau, c6_Gscal_top, c6_Gscal_bottom, c6_Gscal_gluon, c6_Gscal_gamma)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_('expr::c6_BRscal_hvv("@0*@0/@1", kV, c6_Gscal_tot)')
self.modelBuilder.factory_('expr::c6_BRscal_htt("@0*@0/@1", ktau, c6_Gscal_tot)')
self.modelBuilder.factory_('expr::c6_BRscal_hbb("@0*@0/@1", kbottom, c6_Gscal_tot)')
self.modelBuilder.factory_('expr::c6_BRscal_hgg("@0*@0/@1", kgamma, c6_Gscal_tot)')
if self.doHZg:
self.modelBuilder.factory_('expr::c6_BRscal_hzg("@0*@0/@1", kZgamma, c6_Gscal_tot)')
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "c6_XSBRscal_%s_%s" % (production,decay)
print '[LOFullParametrization::C6]'
print name, production, decay, energy
if self.modelBuilder.out.function(name) == None:
XSscal = "kgluon"
if production in ["WH","ZH","VH","qqH"]: XSscal = "kV"
if production == "ttH": XSscal = "ktop"
BRscal = "hgg"
if decay in ["hbb", "htt"]: BRscal = decay
if decay in ["hww", "hzz"]: BRscal = "hvv"
if self.doHZg and decay == "hzg": BRscal = "hzg"
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, c6_BRscal_%s)' % (name, XSscal, BRscal))
return name
class CwzHiggs(SMLikeHiggsModel):
"Scale w and z and touch nothing else"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("Cz[1,0,10]")
self.modelBuilder.doVar("Cwz[1,0,10]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'Cwz,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'Cwz')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
for d in [ "hww", "hzz" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::Cw("@0*@1",Cz, Cwz)')
## total witdhs, normalized to the SM one
self.modelBuilder.factory_('expr::Cwz_Gscal_tot("@0*@1 + @2*@3 + (1.0-@1-@3)", \
Cw, SM_BR_hww, Cz, SM_BR_hzz)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM) / (total/total_SM)
self.modelBuilder.factory_('expr::Cwz_BRscal_hww("@0/@1", Cw, Cwz_Gscal_tot)')
self.modelBuilder.factory_('expr::Cwz_BRscal_hzz("@0/@1", Cz, Cwz_Gscal_tot)')
datadir = os.environ['CMSSW_BASE']+'/src/HiggsAnalysis/CombinedLimit/data/lhc-hxswg'
for e in ['7TeV', '8TeV']:
print 'build for %s'%e
self.SMH.textToSpline( 'RqqH_%s'%e, os.path.join(datadir, 'couplings/R_VBF_%s.txt'%e), ycol=1 );
self.modelBuilder.factory_('expr::Cwz_XSscal_qqH_%s("(@0 + @1*@2) / (1.0 + @2) ", Cw, Cz, RqqH_%s)'%(e,e))
self.modelBuilder.factory_('expr::Cwz_XSscal_WH_%s("@0", Cw)'%e)
self.modelBuilder.factory_('expr::Cwz_XSscal_ZH_%s("@0", Cz)'%e)
self.SMH.makeXS('WH',e)
self.SMH.makeXS('ZH',e)
self.modelBuilder.factory_('expr::Cwz_XSscal_VH_%s("(@0*@1 + @2*@3) / (@1 + @3) ", Cw, SM_XS_WH_%s, Cz, SM_XS_ZH_%s)'%(e,e,e))
def getHiggsSignalYieldScale(self,production,decay,energy):
if decay not in ['hww', 'hzz']:
return 0
name = "Cwz_XSBRscal_%s_%s_%s" % (production,decay,energy)
if self.modelBuilder.out.function(name) == None:
if production in ["ggH","ttH"]:
self.modelBuilder.factory_('expr::%s("@0", Cwz_BRscal_%s)' % (name, decay))
else:
self.modelBuilder.factory_('expr::%s("@0 * @1", Cwz_XSscal_%s_%s, Cwz_BRscal_%s)' % (name, production, energy, decay))
return name
class ResolvedC6(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.MRange = ['150','350']
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
if po.startswith("MRange="):
self.MRange = po.replace("MRange=","").split(":")
if len(self.MRange) != 2:
raise RuntimeError, "M range requires minimal and maximal value"
elif float(self.MRange[0]) >= float(self.MRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CW[1.0,0.0,5.0]")
self.modelBuilder.doVar("CZ[1.0,0.0,5.0]")
self.modelBuilder.doVar("Ctop[1.0,0.0,5.0]")
self.modelBuilder.doVar("Cb[1.0,0.0,5.0]")
self.modelBuilder.doVar("Ctau[1.0,0.0,5.0]")
self.modelBuilder.doVar("Cmu[1.0,0.0,5.0]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'MH,CW,CZ,Ctop,Cb,Ctau,Cmu')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CW,CZ,Ctop,Cb,Ctau,Cmu')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.productionScaling = {
'ttH':'Ctop',
'WH':'CW',
'ZH':'CZ',
}
self.SMH.makeScaling('ggH', Cb='Cb', Ctop='Ctop')
self.SMH.makeScaling('qqH', CW='CW', CZ='CZ')
self.SMH.makeScaling('hgluglu', Cb='Cb', Ctop='Ctop')
self.SMH.makeScaling('hgg', Cb='Cb', Ctop='Ctop', CW='CW', Ctau='Ctau')
self.SMH.makeScaling('hzg', Cb='Cb', Ctop='Ctop', CW='CW', Ctau='Ctau')
## partial widths, normalized to the SM one, for decays scaling with F, V and total
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::wztbtm_Gscal_w("@0*@0 * @1", CW, SM_BR_hww)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_z("@0*@0 * @1", CZ, SM_BR_hzz)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_b("@0*@0 * @1", Cb, SM_BR_hbb)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_tau("@0*@0 * @1", Ctau, SM_BR_htt)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_mu("@0*@0 * @1", Cmu, SM_BR_hmm)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_top("@0*@0 * @1", Ctop, SM_BR_htoptop)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_glu("@0 * @1", Scaling_hgluglu, SM_BR_hgluglu)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_zg("@0 * @1", Scaling_hzg, SM_BR_hzg)')
self.modelBuilder.factory_('sum::wztbtm_Gscal_tot(wztbtm_Gscal_w, wztbtm_Gscal_z, wztbtm_Gscal_b, wztbtm_Gscal_tau, wztbtm_Gscal_mu, wztbtm_Gscal_top, wztbtm_Gscal_glu, wztbtm_Gscal_gg, wztbtm_Gscal_zg, SM_BR_hcc, SM_BR_hss)')
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::wztbtm_BRscal_hww("@0*@0/@1", CW, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hzz("@0*@0/@1", CZ, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hbb("@0*@0/@1", Cb, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hss("@0*@0/@1", Cb, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_htt("@0*@0/@1", Ctau, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hcc("@0*@0/@1", Ctop, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hmm("@0*@0/@1", Cmu, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hgg("@0/@1", Scaling_hgg, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hzg("@0/@1", Scaling_hzg, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hgluglu("@0/@1", Scaling_hgluglu, wztbtm_Gscal_tot)')
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = 'wztbtm_XSBRscal_%(production)s_%(decay)s' % locals()
if production in ('ggH','qqH'):
self.productionScaling[production]='Scaling_'+production+'_'+energy
name += '_%(energy)s' % locals()
if self.modelBuilder.out.function(name):
return name
if production == "VH":
print "WARNING: You are trying to use a VH production mode in a model that needs WH and ZH separately. "\
"The best I can do is to scale [%(production)s, %(decay)s, %(energy)s] with the decay BR only but this is wrong..." % locals()
self.modelBuilder.factory_('expr::%(name)s("1.0*@0", wztbtm_BRscal_%(decay)s)' % locals())
return name
XSscal = self.productionScaling[production]
if production == 'ggH':
self.modelBuilder.factory_('expr::%(name)s("@0 * @1", %(XSscal)s, wztbtm_BRscal_%(decay)s)' % locals())
else:
self.modelBuilder.factory_('expr::%(name)s("@0*@0 * @1", %(XSscal)s, wztbtm_BRscal_%(decay)s)' % locals())
return name
class MepsHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.MRange = ['150','350']
self.epsRange = ['-1','1']
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
if po.startswith("MRange="):
self.MRange = po.replace("MRange=","").split(":")
if len(self.MRange) != 2:
raise RuntimeError, "M range requires minimal and maximal value"
elif float(self.MRange[0]) >= float(self.MRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
if po.startswith("epsRange="):
self.epsRange = po.replace("epsRange=","").split(":")
if len(self.epsRange) != 2:
raise RuntimeError, "epsilon range requires minimal and maximal value"
elif float(self.epsRange[0]) >= float(self.epsRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("M[246.22,%s,%s]" % (self.MRange[0], self.MRange[1]))
self.modelBuilder.doVar("eps[0,%s,%s]" % (self.epsRange[0], self.epsRange[1]))
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'M,eps,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'M,eps')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.modelBuilder.doVar("SM_VEV[246.22]")
self.msbar = {
'top' : (160, (-4.3,+4.8)),
'b' : (4.18, (-0.03,+0.03)),
'tau' : (1.77682, (-0.16,+0.16)),
'mu' : (0.105658, (-0.0000035,+0.0000035)),
'W' : (80.385, (-0.015,+0.015)),
'Z' : (91.1876, (-0.0021,+0.0021)),
}
for name, vals in self.msbar.iteritems():
#self.modelBuilder.doVar("M%s_MSbar[%s,%s,%s]" % (name, vals[0], vals[0]+vals[1][0], vals[0]+vals[1][1]))
self.modelBuilder.doVar("M%s_MSbar[%s]" % (name, vals[0]))
if name in ('W','Z'):
# # Ellis cv == v (mv^(2 e)/M^(1 + 2 e))
# self.modelBuilder.factory_(
# 'expr::C%(name)s("@0 * TMath::Power(@3,2*@2) / TMath::Power(@1,1+2*@2)", SM_VEV, M, eps, M%(name)s_MSbar)' % locals() )
# # AD k = (M/v) eps m^(N(eps-1))
# self.modelBuilder.factory_(
# 'expr::C%(name)s("@1 * @2 * TMath::Power(@3,2*(@2-1)) / @0", SM_VEV, M, eps, M%(name)s_MSbar)' % locals() )
# # GP k = (v/M)^2 (m/M)^(2eps)
self.modelBuilder.factory_(
'expr::C%(name)s("TMath::Power(@0/@1,2) * TMath::Power(@3/@1,2*@2)", SM_VEV, M, eps, M%(name)s_MSbar)' % locals() )
else:
# # Ellis cf == v (mf^e/M^(1 + e))
# self.modelBuilder.factory_(
# 'expr::C%(name)s("@0 * TMath::Power(@3,@2) / TMath::Power(@1,1+@2)", SM_VEV, M, eps, M%(name)s_MSbar)' % locals() )
# AD k = (M/v) eps m^(N(eps-1))
# self.modelBuilder.factory_(
# 'expr::C%(name)s("@1 * @2 * TMath::Power(@3,@2-1) / @0", SM_VEV, M, eps, M%(name)s_MSbar)' % locals() )
# GP k = (v/M) (m/M)^eps
self.modelBuilder.factory_(
'expr::C%(name)s("(@0/@1) * TMath::Power(@3/@1,@2)", SM_VEV, M, eps, M%(name)s_MSbar)' % locals() )
self.productionScaling = {
'ttH':'Ctop',
'WH':'CW',
'ZH':'CZ',
}
self.SMH.makeScaling('ggH', Cb='Cb', Ctop='Ctop')
self.SMH.makeScaling('qqH', CW='CW', CZ='CZ')
self.SMH.makeScaling('hgluglu', Cb='Cb', Ctop='Ctop')
self.SMH.makeScaling('hgg', Cb='Cb', Ctop='Ctop', CW='CW', Ctau='Ctau')
self.SMH.makeScaling('hzg', Cb='Cb', Ctop='Ctop', CW='CW', Ctau='Ctau')
## partial widths, normalized to the SM one, for decays scaling with F, V and total
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::Meps_Gscal_w("@0*@0 * @1", CW, SM_BR_hww)')
self.modelBuilder.factory_('expr::Meps_Gscal_z("@0*@0 * @1", CZ, SM_BR_hzz)')
self.modelBuilder.factory_('expr::Meps_Gscal_b("@0*@0 * @1", Cb, SM_BR_hbb)')
self.modelBuilder.factory_('expr::Meps_Gscal_tau("@0*@0 * @1", Ctau, SM_BR_htt)')
self.modelBuilder.factory_('expr::Meps_Gscal_mu("@0*@0 * @1", Cmu, SM_BR_hmm)')
self.modelBuilder.factory_('expr::Meps_Gscal_top("@0*@0 * @1", Ctop, SM_BR_htoptop)')
self.modelBuilder.factory_('expr::Meps_Gscal_glu("@0 * @1", Scaling_hgluglu, SM_BR_hgluglu)')
self.modelBuilder.factory_('expr::Meps_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::Meps_Gscal_zg("@0 * @1", Scaling_hzg, SM_BR_hzg)')
self.modelBuilder.factory_('sum::Meps_Gscal_tot(Meps_Gscal_w, Meps_Gscal_z, Meps_Gscal_b, Meps_Gscal_tau, Meps_Gscal_mu, Meps_Gscal_top, Meps_Gscal_glu, Meps_Gscal_gg, Meps_Gscal_zg, SM_BR_hcc, SM_BR_hss)')
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::Meps_BRscal_hww("@0*@0/@1", CW, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hzz("@0*@0/@1", CZ, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hbb("@0*@0/@1", Cb, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_htt("@0*@0/@1", Ctau, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hmm("@0*@0/@1", Cmu, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hgg("@0/@1", Scaling_hgg, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hzg("@0/@1", Scaling_hzg, Meps_Gscal_tot)')
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = 'Meps_XSBRscal_%(production)s_%(decay)s' % locals()
if production in ('ggH','qqH'):
self.productionScaling[production]='Scaling_'+production+'_'+energy
name += '_%(energy)s' % locals()
if self.modelBuilder.out.function(name):
return name
if production == "VH":
print "WARNING: You are trying to use a VH production mode in a model that needs WH and ZH separately. "\
"The best I can do is to scale [%(production)s, %(decay)s, %(energy)s] with the decay BR only but this is wrong..." % locals()
self.modelBuilder.factory_('expr::%(name)s("1.0*@0", Meps_BRscal_%(decay)s)' % locals())
return name
XSscal = self.productionScaling[production]
if production == 'ggH':
self.modelBuilder.factory_('expr::%(name)s("@0 * @1", %(XSscal)s, Meps_BRscal_%(decay)s)' % locals())
else:
self.modelBuilder.factory_('expr::%(name)s("@0*@0 * @1", %(XSscal)s, Meps_BRscal_%(decay)s)' % locals())
return name
class LambdaduHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kV[1,0,2]")
self.modelBuilder.doVar("lambdadu[1,-3,3]")
self.modelBuilder.doVar("ku[1,0,2]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'kV,lambdadu,ku,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'kV,lambdadu,ku')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.decayScaling = {
'hgg':'hgg',
'hZg':'hZg',
'hww':'hvv',
'hzz':'hvv',
'hbb':'hdd',
'htt':'hdd',
}
self.productionScaling = {
'ttH':'ku',
'qqH':'kV',
'WH':'kV',
'ZH':'kV',
'VH':'kV',
}
# define kd as lambdadu*ku
self.modelBuilder.factory_('expr::kd("@0*@1",ku, lambdadu)')
# scalings of the loops
self.SMH.makeScaling('ggH', Cb='kd', Ctop='ku')
self.SMH.makeScaling('hgg', Cb='kd', Ctop='ku', CW='kV', Ctau='kd')
self.SMH.makeScaling('hZg', Cb='kd', Ctop='ku', CW='kV', Ctau='kd')
self.SMH.makeScaling('hgluglu', Cb='kd', Ctop='ku')
# SM BR
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hZg", "hmm", "hss" ]:
self.SMH.makeBR(d)
## total witdhs, normalized to the SM one
self.modelBuilder.factory_('expr::lambdadu_Gscal_Vectors("@0*@0 * (@1+@2)", kV, SM_BR_hzz, SM_BR_hww)')
self.modelBuilder.factory_('expr::lambdadu_Gscal_up("@0*@0 * (@1+@2)", ku, SM_BR_hcc, SM_BR_htoptop)')
self.modelBuilder.factory_('expr::lambdadu_Gscal_down("@0*@0 * (@1+@2+@3+@4)", kd, SM_BR_hbb, SM_BR_htt, SM_BR_hmm, SM_BR_hss)')
self.modelBuilder.factory_('expr::lambdadu_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::lambdadu_Gscal_Zg("@0 * @1", Scaling_hZg, SM_BR_hZg)')
self.modelBuilder.factory_('expr::lambdadu_Gscal_gluglu("@0 * @1", Scaling_hgluglu, SM_BR_hgluglu)')
self.modelBuilder.factory_('sum::lambdadu_Gscal_tot(lambdadu_Gscal_Vectors, lambdadu_Gscal_up, lambdadu_Gscal_down, lambdadu_Gscal_gg, lambdadu_Gscal_Zg, lambdadu_Gscal_gluglu)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_('expr::lambdadu_BRscal_hvv("@0*@0/@1", kV, lambdadu_Gscal_tot)')
self.modelBuilder.factory_('expr::lambdadu_BRscal_huu("@0*@0/@1", ku, lambdadu_Gscal_tot)')
self.modelBuilder.factory_('expr::lambdadu_BRscal_hdd("@0*@0/@1", kd, lambdadu_Gscal_tot)')
self.modelBuilder.factory_('expr::lambdadu_BRscal_hgg("@0/@1", Scaling_hgg, lambdadu_Gscal_tot)')
self.modelBuilder.factory_('expr::lambdadu_BRscal_hZg("@0/@1", Scaling_hZg, lambdadu_Gscal_tot)')
# verbosity
#self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = 'lambdadu_XSBRscal_%(production)s_%(decay)s' % locals()
#Special case that depends on Energy
if production == 'ggH':
self.productionScaling[production] = 'Scaling_ggH_' + energy
name += '_%(energy)s' % locals()
if self.modelBuilder.out.function(name):
return name
XSscal = self.productionScaling[production]
BRscal = self.decayScaling[decay]
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, lambdadu_BRscal_%s)' % (name, XSscal, BRscal))
return name
class C5udHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.universalCF = False
self.fix = []
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po == "universalCF": universalCF = True
if po.startswith("fix="): self.fix = po.replace("fix=","").split(",")
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("Cg[1,0,10]")
self.modelBuilder.doVar("Cv[1,0,10]")
self.modelBuilder.doVar("Cglu[1,0,10]")
POI = "Cg,Cv,Cglu"
if self.universalCF:
self.modelBuilder.doVar("Cf[1,0,10]")
POI += ",Cf"
else:
self.modelBuilder.doVar("Cu[1,0,10]")
self.modelBuilder.doVar("Cd[1,0,10]")
POI += ",Cu,Cd"
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
POI += ",MH"
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
for F in self.fix:
self.modelBuilder.out.var(F).setConstant(True)
if F+"," in POI: POI = POI.replace(F+",", "")
else: POI = POI.replace(","+F, "")
self.modelBuilder.doSet("POI",POI)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hZg", "hmm", "hss" ]:
self.SMH.makeBR(d)
## total witdhs, normalized to the SM one
self.modelBuilder.factory_('expr::C5ud_Gscal_sumglu("@0*@0 * @1", Cglu, SM_BR_hgluglu)')
self.modelBuilder.factory_('expr::C5ud_Gscal_sumg("@0*@0 * @1", Cg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::C5ud_Gscal_sumv("@0*@0 * (@1+@2+@3)", Cv, SM_BR_hww, SM_BR_hzz, SM_BR_hZg )')
if self.universalCF:
self.modelBuilder.factory_('expr::C5ud_Gscal_sumf("@0*@0 * (@1+@2+@3+@4+@5+@6)",\
Cf, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hmm, SM_BR_hss)')
else:
self.modelBuilder.factory_('expr::C5ud_Gscal_sumf("@0*@0 * (@1+@2+@3+@4) + @5*@5 * (@6+@7)",\
Cd, SM_BR_hbb, SM_BR_hcc, SM_BR_htt, SM_BR_hmm,\
Cu, SM_BR_htoptop, SM_BR_hss)')
self.modelBuilder.factory_('sum::C5ud_Gscal_tot(C5ud_Gscal_sumglu, C5ud_Gscal_sumg, C5ud_Gscal_sumv, C5ud_Gscal_sumf)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_("expr::C5ud_BRscal_hgg(\"@0*@0/@1\", Cg, C5ud_Gscal_tot)")
self.modelBuilder.factory_("expr::C5ud_BRscal_hvv(\"@0*@0/@1\", Cv, C5ud_Gscal_tot)")
if self.universalCF:
self.modelBuilder.factory_("expr::C5ud_BRscal_hff(\"@0*@0/@1\", Cf, C5ud_Gscal_tot)")
else:
self.modelBuilder.factory_("expr::C5ud_BRscal_hbb(\"@0*@0/@1\", Cd, C5ud_Gscal_tot)")
self.modelBuilder.factory_("expr::C5ud_BRscal_htt(\"@0*@0/@1\", Cd, C5ud_Gscal_tot)")
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "C5ud_XSBRscal_%s_%s" % (production,decay)
if self.modelBuilder.out.function(name) == None:
XSscal = "Cglu" if production in ["ggH"] else "Cv"
if production in ['ttH']:
XSscal = 'Cf' if self.universalCF else 'Cu'
BRscal = "hgg"
if decay in ["hww", "hzz"]: BRscal = "hvv"
if decay in ["hbb", "htt"]: BRscal = ("hff" if self.universalCF else decay)
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, C5ud_BRscal_%s)' % (name, XSscal, BRscal))
return name
class TwoHDM(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.thdmtype = ['1']
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
if po.startswith("thdmtype="):
self.thdmtype= po.replace("thdmtype=","")
if len(self.thdmtype) != 1:
raise RuntimeError, "2HDM type requires one value"
elif int(self.thdmtype[0]) != 1 and int(self.thdmtype[0]) !=2 and int(self.thdmtype[0]) !=3 and int(self.thdmtype[0]) !=4:
raise RuntimeError, "2HDM type must be 1 (default) or 2 or 3 or 4 "
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("cosbma[0,-1,1]")
self.modelBuilder.doVar("tanbeta[0,0.0,10]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'cosbma,tanbeta,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'cosbma,tanbeta')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.modelBuilder.factory_('expr::kV("sqrt(1-@0*@0)",cosbma)')
self.modelBuilder.factory_('expr::tana("(@0*@1-@2)/(@1-@0*@2)", tanbeta, cosbma, kV)')
self.modelBuilder.factory_('expr::cosa("1/sqrt(1+@0*@0)",tana)')
self.modelBuilder.factory_('expr::sinb("tanbeta/sqrt(1+@0*@0)",tanbeta)')
self.modelBuilder.factory_('expr::ku("@0/@1", cosa, sinb)')
if int(self.thdmtype[0]) == 1:
self.modelBuilder.factory_('expr::kd("@0", ku)')
self.modelBuilder.factory_('expr::kl("@0", ku)')
elif int(self.thdmtype[0]) == 2:
self.modelBuilder.factory_('expr::cosb("1/sqrt(1+@0*@0)",tanbeta)')
self.modelBuilder.factory_('expr::sina("tana/sqrt(1+@0*@0)",tana)')
self.modelBuilder.factory_('expr::kd("-@0/@1", sina,cosb)')
self.modelBuilder.factory_('expr::kl("@0", kd)')
elif int(self.thdmtype[0]) == 3:
self.modelBuilder.factory_('expr::cosb("1/sqrt(1+@0*@0)",tanbeta)')
self.modelBuilder.factory_('expr::sina("tana/sqrt(1+@0*@0)",tana)')
self.modelBuilder.factory_('expr::kd("@0", ku)')
self.modelBuilder.factory_('expr::kl("-@0/@1", sina,cosb)')
elif int(self.thdmtype[0]) == 4:
self.modelBuilder.factory_('expr::cosb("1/sqrt(1+@0*@0)",tanbeta)')
self.modelBuilder.factory_('expr::sina("tana/sqrt(1+@0*@0)",tana)')
self.modelBuilder.factory_('expr::kd("-@0/@1", sina,cosb)')
self.modelBuilder.factory_('expr::kl("@0", ku)')
self.decayScaling = {
'hgg':'hgg',
'hzg':'hzg',
'hww':'hvv',
'hzz':'hvv',
'hbb':'hdd',
'htt':'hll',
'hss':'hdd',
'hmm':'hll',
'hcc':'huu',
'hgluglu':'hgluglu',
}
self.productionScaling = {
'ttH':'ku',
'qqH':'kV',
'WH':'kV',
'ZH':'kV',
'VH':'kV',
}
# scalings of the loops
self.SMH.makeScaling('ggH', Cb='kd', Ctop='ku')
self.SMH.makeScaling('hgg', Cb='kd', Ctop='ku', CW='kV', Ctau='kl')
self.SMH.makeScaling('hzg', Cb='kd', Ctop='ku', CW='kV', Ctau='kl')
self.SMH.makeScaling('hgluglu', Cb='kd', Ctop='ku')
# SM BR
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
## total witdhs, normalized to the SM one
self.modelBuilder.factory_('expr::twohdm_Gscal_Vectors("@0*@0 * (@1+@2)", kV, SM_BR_hzz, SM_BR_hww)')
self.modelBuilder.factory_('expr::twohdm_Gscal_up("@0*@0 * (@1+@2)", ku, SM_BR_hcc, SM_BR_htoptop)')
self.modelBuilder.factory_('expr::twohdm_Gscal_down("@0*@0 * (@1+@2)", kd, SM_BR_hbb, SM_BR_hss)')
self.modelBuilder.factory_('expr::twohdm_Gscal_leptons("@0*@0 * (@1+@2)", kl, SM_BR_htt, SM_BR_hmm)')
self.modelBuilder.factory_('expr::twohdm_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::twohdm_Gscal_Zg("@0 * @1", Scaling_hzg, SM_BR_hzg)')
self.modelBuilder.factory_('expr::twohdm_Gscal_gluglu("@0 * @1", Scaling_hgluglu, SM_BR_hgluglu)')
self.modelBuilder.factory_('sum::twohdm_Gscal_tot(twohdm_Gscal_Vectors, twohdm_Gscal_up, twohdm_Gscal_down, twohdm_Gscal_leptons, twohdm_Gscal_gg, twohdm_Gscal_Zg, twohdm_Gscal_gluglu)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_('expr::twohdm_BRscal_hvv("@0*@0/@1", kV, twohdm_Gscal_tot)')
self.modelBuilder.factory_('expr::twohdm_BRscal_huu("@0*@0/@1", ku, twohdm_Gscal_tot)')
self.modelBuilder.factory_('expr::twohdm_BRscal_hdd("@0*@0/@1", kd, twohdm_Gscal_tot)')
self.modelBuilder.factory_('expr::twohdm_BRscal_hll("@0*@0/@1", kl, twohdm_Gscal_tot)')
self.modelBuilder.factory_('expr::twohdm_BRscal_hgg("@0/@1", Scaling_hgg, twohdm_Gscal_tot)')
self.modelBuilder.factory_('expr::twohdm_BRscal_hgluglu("@0/@1", Scaling_hgluglu, twohdm_Gscal_tot)')
self.modelBuilder.factory_('expr::twohdm_BRscal_hzg("@0/@1", Scaling_hzg, twohdm_Gscal_tot)')
# verbosity
#self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = 'twohdm_XSBRscal_%(production)s_%(decay)s' % locals()
#Special case that depends on Energy
if production == 'ggH':
self.productionScaling[production] = 'Scaling_ggH_' + energy
name += '_%(energy)s' % locals()
if self.modelBuilder.out.function(name):
return name
XSscal = self.productionScaling[production]
BRscal = self.decayScaling[decay]
if 'Scaling_' in XSscal: # it's a Scaling, which means it's already squared
self.modelBuilder.factory_('expr::%s("@0 * @1", %s, twohdm_BRscal_%s)' % (name, XSscal, BRscal))
else: # It's a kappa, so it's linear and I must square it
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, twohdm_BRscal_%s)' % (name, XSscal, BRscal))
return name
class CWidth(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.doHZg = False
self.doHInv = False
self.doWidth = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
if po == 'doHZg':
self.doHZg = True
if po == 'doHInv':
self.doHInv = True
if po == 'doWidth':
self.doWidth = True
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kV[1,0.0,1.0]") # bounded to 1
self.modelBuilder.doVar("ktau[1,0.0,2.0]")
self.modelBuilder.doVar("ktop[1,0.0,4.0]")
self.modelBuilder.doVar("kbottom[1,0.0,3.0]")
self.modelBuilder.doVar("kgluon[1,0.0,2.0]")
self.modelBuilder.doVar("kgamma[1,0.0,2.5]")
if self.doWidth:
self.modelBuilder.doVar("Gscale[1,0,10]")
pois = 'kV,ktau,ktop,kbottom,kgluon,kgamma,Gscale'
else:
self.modelBuilder.doVar("BRInvUndet[0,0,1]")
pois = 'kV,ktau,ktop,kbottom,kgluon,kgamma,BRInvUndet'
if self.doHZg:
self.modelBuilder.doVar("kZgamma[1,0.0,30.0]")
pois += ",kZgamma"
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",pois+',MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",pois)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
# SM BR
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]: self.SMH.makeBR(d)
## total witdhs, normalized to the SM one
self.modelBuilder.factory_('expr::c7_Gscal_Vectors("@0*@0 * (@1+@2)", kV, SM_BR_hzz, SM_BR_hww)')
self.modelBuilder.factory_('expr::c7_Gscal_tau("@0*@0 * (@1+@2)", ktau, SM_BR_htt, SM_BR_hmm)')
self.modelBuilder.factory_('expr::c7_Gscal_top("@0*@0 * (@1+@2)", ktop, SM_BR_htoptop, SM_BR_hcc)')
self.modelBuilder.factory_('expr::c7_Gscal_bottom("@0*@0 * (@1+@2)", kbottom, SM_BR_hbb, SM_BR_hss)')
self.modelBuilder.factory_('expr::c7_Gscal_gluon("@0*@0 * @1", kgluon, SM_BR_hgluglu)')
if not self.doHZg:
self.modelBuilder.factory_('expr::c7_Gscal_gamma("@0*@0 * (@1+@2)", kgamma, SM_BR_hgg, SM_BR_hzg)')
else:
self.modelBuilder.factory_('expr::c7_Gscal_gamma("@0*@0 *@1+@2*@2*@3", kgamma, SM_BR_hgg, kZgamma, SM_BR_hzg)')
#
#RooFormulaVar::c7_Gscal_tot[ actualVars=(Gscale,c7_Gscal_Vectors,c7_Gscal_tau,c7_Gscal_top,c7_Gscal_bottom,c7_Gscal_gluon,c7_Gscal_gamma) formula="(@1+@2+@3+@4+@5+@6)<=@0?@0:0.001" ] = 0.001
#root [8] w->function("c7_Gscal_tau")->Print()
#RooFormulaVar::c7_Gscal_tau[ actualVars=(ktau,SM_BR_htt,SM_BR_hmm) formula="@0*@0*(@1+@2)" ] = 0.063419
#root [9] w->function("c7_Gscal_top")->Print()
#RooFormulaVar::c7_Gscal_top[ actualVars=(ktop,SM_BR_htoptop,SM_BR_hcc) formula="@0*@0*(@1+@2)" ] = 0.0291
#root [10] w->function("c7_Gscal_bottom")->Print()
#RooFormulaVar::c7_Gscal_bottom[ actualVars=(kbottom,SM_BR_hbb,SM_BR_hss) formula="@0*@0*(@1+@2)" ] = 0.577246 #### The spline interpolation has small difference w.r.t YR3 number 5.769462E-01
#root [11] w->function("c7_Gscal_gluon")->Print()
#RooFormulaVar::c7_Gscal_gluon[ actualVars=(kgluon,SM_BR_hgluglu) formula="@0*@0*@1" ] = 0.0857
#root [12] w->function("c7_Gscal_gamma")->Print()
#RooFormulaVar::c7_Gscal_gamma[ actualVars=(kgamma,SM_BR_hgg,SM_BR_hzg) formula="@0*@0*(@1+@2)" ] = 0.00382
#root [13] w->function("c7_Gscal_Vectors")->Print()
#RooFormulaVar::c7_Gscal_Vectors[ actualVars=(kV,SM_BR_hzz,SM_BR_hww) formula="@0*@0*(@1+@2)" ] = 0.2414
#############################Then the above sum = 1.000685 , so that the asimov data set will be generated with c7_Gscal_tot = 0.0001, and BRInv = -100
#root [14] w->var("ktau")->Print()
#RooRealVar::ktau = 1 L(0 - 2)
#root [15] w->var("ktop")->Print()
#RooRealVar::ktop = 1 L(0 - 4)
#root [16] w->var("kgluon")->Print()
#RooRealVar::kgluon = 1 L(0 - 2)
#root [17] w->var("kgamma")->Print()
#RooRealVar::kgamma = 1 L(0 - 2.5)
############################either generate asimov dataset with kbottom slightly less 1 i.e. kb=0.999 is fine
if self.doWidth:
self.modelBuilder.factory_('expr::c7_Gscal_tot("(@1+@2+@3+@4+@5+@6)<=@0?@0:0.001",Gscale,c7_Gscal_Vectors, c7_Gscal_tau, c7_Gscal_top, c7_Gscal_bottom, c7_Gscal_gluon, c7_Gscal_gamma)')
self.modelBuilder.factory_('expr::BRInvUndet("1 - (@1+@2+@3+@4+@5+@6)/@0",c7_Gscal_tot,c7_Gscal_Vectors, c7_Gscal_tau, c7_Gscal_top, c7_Gscal_bottom, c7_Gscal_gluon, c7_Gscal_gamma)')
else:
self.modelBuilder.factory_('expr::c7_Gscal_tot("(@1+@2+@3+@4+@5+@6)/(1-@0)",BRInvUndet,c7_Gscal_Vectors, c7_Gscal_tau, c7_Gscal_top, c7_Gscal_bottom, c7_Gscal_gluon, c7_Gscal_gamma)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_('expr::c7_BRscal_hvv("@0*@0/@1", kV, c7_Gscal_tot)')
self.modelBuilder.factory_('expr::c7_BRscal_htt("@0*@0/@1", ktau, c7_Gscal_tot)')
self.modelBuilder.factory_('expr::c7_BRscal_hbb("@0*@0/@1", kbottom, c7_Gscal_tot)')
self.modelBuilder.factory_('expr::c7_BRscal_hgg("@0*@0/@1", kgamma, c7_Gscal_tot)')
if self.doHZg:
self.modelBuilder.factory_('expr::c7_BRscal_hzg("@0*@0/@1", kZgamma, c7_Gscal_tot)')
if self.doHInv:
self.modelBuilder.factory_('expr::c7_BRscal_hinv("@0>=0?@0:-100", BRInvUndet)')
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "c7_XSBRscal_%s_%s" % (production,decay)
print '[LOFullParametrization::C7]'
print name, production, decay, energy
if self.modelBuilder.out.function(name) == None:
XSscal = "kgluon"
if production in ["WH","ZH","VH","qqH"]: XSscal = "kV"
if production == "ttH": XSscal = "ktop"
BRscal = "hgg"
if decay in ["hbb", "htt"]: BRscal = decay
if decay in ["hww", "hzz"]: BRscal = "hvv"
if self.doHZg and decay == "hzg": BRscal = "hzg"
if self.doHInv and decay == "hinv": BRscal = "hinv"
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, c7_BRscal_%s)' % (name, XSscal, BRscal))
return name
class MepsHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.MRange = ['150','350']
self.epsRange = ['-1','1']
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
if po.startswith("MRange="):
self.MRange = po.replace("MRange=","").split(":")
if len(self.MRange) != 2:
raise RuntimeError, "M range requires minimal and maximal value"
elif float(self.MRange[0]) >= float(self.MRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
if po.startswith("epsRange="):
self.epsRange = po.replace("epsRange=","").split(":")
if len(self.epsRange) != 2:
raise RuntimeError, "epsilon range requires minimal and maximal value"
elif float(self.epsRange[0]) >= float(self.epsRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("M[246.22,%s,%s]" % (self.MRange[0], self.MRange[1]))
self.modelBuilder.doVar("eps[0,%s,%s]" % (self.epsRange[0], self.epsRange[1]))
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'M,eps,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'M,eps')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.modelBuilder.doVar("SM_VEV[246.22]")
self.msbar = {
'top' : (160, (-4.3,+4.8)),
'b' : (4.18, (-0.03,+0.03)),
'tau' : (1.77682, (-0.16,+0.16)),
'mu' : (0.105658, (-0.0000035,+0.0000035)),
'W' : (80.385, (-0.015,+0.015)),
'Z' : (91.1876, (-0.0021,+0.0021)),
}
for name, vals in self.msbar.iteritems():
#self.modelBuilder.doVar("M%s_MSbar[%s,%s,%s]" % (name, vals[0], vals[0]+vals[1][0], vals[0]+vals[1][1]))
self.modelBuilder.doVar("M%s_MSbar[%s]" % (name, vals[0]))
if name in ('W','Z'):
# # Ellis cv == v (mv^(2 e)/M^(1 + 2 e))
self.modelBuilder.factory_(
'expr::C%(name)s("@0 * TMath::Power(@3,2*@2) / TMath::Power(@1,1+2*@2)", SM_VEV, M, eps, M%(name)s_MSbar)' % locals() )
else:
# # Ellis cf == v (mf^e/M^(1 + e))
self.modelBuilder.factory_(
'expr::C%(name)s("@0 * TMath::Power(@3,@2) / TMath::Power(@1,1+@2)", SM_VEV, M, eps, M%(name)s_MSbar)' % locals() )
self.productionScaling = {
'ttH':'Ctop',
'WH':'CW',
'ZH':'CZ',
}
self.SMH.makeScaling('ggH', Cb='Cb', Ctop='Ctop')
self.SMH.makeScaling('qqH', CW='CW', CZ='CZ')
self.SMH.makeScaling('hgluglu', Cb='Cb', Ctop='Ctop')
self.SMH.makeScaling('hgg', Cb='Cb', Ctop='Ctop', CW='CW', Ctau='Ctau')
self.SMH.makeScaling('hzg', Cb='Cb', Ctop='Ctop', CW='CW', Ctau='Ctau')
## partial widths, normalized to the SM one, for decays scaling with F, V and total
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::Meps_Gscal_w("@0*@0 * @1", CW, SM_BR_hww)')
self.modelBuilder.factory_('expr::Meps_Gscal_z("@0*@0 * @1", CZ, SM_BR_hzz)')
self.modelBuilder.factory_('expr::Meps_Gscal_b("@0*@0 * @1", Cb, SM_BR_hbb)')
self.modelBuilder.factory_('expr::Meps_Gscal_tau("@0*@0 * @1", Ctau, SM_BR_htt)')
self.modelBuilder.factory_('expr::Meps_Gscal_mu("@0*@0 * @1", Cmu, SM_BR_hmm)')
self.modelBuilder.factory_('expr::Meps_Gscal_top("@0*@0 * @1", Ctop, SM_BR_htoptop)')
self.modelBuilder.factory_('expr::Meps_Gscal_glu("@0 * @1", Scaling_hgluglu, SM_BR_hgluglu)')
self.modelBuilder.factory_('expr::Meps_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::Meps_Gscal_zg("@0 * @1", Scaling_hzg, SM_BR_hzg)')
self.modelBuilder.factory_('sum::Meps_Gscal_tot(Meps_Gscal_w, Meps_Gscal_z, Meps_Gscal_b, Meps_Gscal_tau, Meps_Gscal_mu, Meps_Gscal_top, Meps_Gscal_glu, Meps_Gscal_gg, Meps_Gscal_zg, SM_BR_hcc, SM_BR_hss)')
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::Meps_BRscal_hww("@0*@0/@1", CW, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hzz("@0*@0/@1", CZ, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hbb("@0*@0/@1", Cb, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_htt("@0*@0/@1", Ctau, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hmm("@0*@0/@1", Cmu, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hgg("@0/@1", Scaling_hgg, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hzg("@0/@1", Scaling_hzg, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hcc("@0*@0/@1", Ctau, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hss("@0*@0/@1", Cb, Meps_Gscal_tot)')
self.modelBuilder.factory_('expr::Meps_BRscal_hgluglu("@0/@1", Scaling_hgluglu, Meps_Gscal_tot)')
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = 'Meps_XSBRscal_%(production)s_%(decay)s' % locals()
if production in ('ggH','qqH'):
self.productionScaling[production]='Scaling_'+production+'_'+energy
name += '_%(energy)s' % locals()
if self.modelBuilder.out.function(name):
return name
if production == "VH":
print "WARNING: You are trying to use a VH production mode in a model that needs WH and ZH separately. "\
"The best I can do is to scale [%(production)s, %(decay)s, %(energy)s] with the decay BR only but this is wrong..." % locals()
self.modelBuilder.factory_('expr::%(name)s("1.0*@0", Meps_BRscal_%(decay)s)' % locals())
return name
XSscal = self.productionScaling[production]
if production == 'ggH':
self.modelBuilder.factory_('expr::%(name)s("@0 * @1", %(XSscal)s, Meps_BRscal_%(decay)s)' % locals())
else:
self.modelBuilder.factory_('expr::%(name)s("@0*@0 * @1", %(XSscal)s, Meps_BRscal_%(decay)s)' % locals())
return name
class CfXgHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CV[1]")
self.modelBuilder.doVar("CF[1,-1.5,1.5]")
self.modelBuilder.doVar("XG[0,-4,4]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'CF,XG,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CF,XG')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
## Add some common ingredients
datadir = os.environ['CMSSW_BASE']+'/src/HiggsAnalysis/CombinedLimit/data/lhc-hxswg'
self.SMH.textToSpline( 'mb', os.path.join(datadir, 'running_constants.txt'), ycol=2 );
mb = self.modelBuilder.out.function('mb')
mH = self.modelBuilder.out.var('MH')
CF = self.modelBuilder.out.var('CF')
CV = self.modelBuilder.out.var('CV')
XG = self.modelBuilder.out.var('XG')
RHggCfXg = ROOT.RooScaleHGamGamLOSMPlusX('CfXg_cgammaSq', 'LO SM Hgamgam scaling', mH, CF, CV, mb, CF, XG)
self.modelBuilder.out._import(RHggCfXg)
#Rgluglu = ROOT.RooScaleHGluGluLOSMPlusX('Rgluglu', 'LO SM Hgluglu scaling', mH, CF, mb, CF)
#self.modelBuilder.out._import(Rgluglu)
## partial witdhs, normalized to the SM one, for decays scaling with F, V and total
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::CfXg_Gscal_sumf("@0*@0 * (@1+@2+@3+@4+@5+@6+@7)", CF, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hgluglu, SM_BR_hmm, SM_BR_hss)')
self.modelBuilder.factory_('sum::CfXg_Gscal_sumv(SM_BR_hww, SM_BR_hzz, SM_BR_hzg)')
self.modelBuilder.factory_('expr::CfXg_Gscal_gg("@0 * @1", CfXg_cgammaSq, SM_BR_hgg)')
self.modelBuilder.factory_('sum::CfXg_Gscal_tot(CfXg_Gscal_sumf, CfXg_Gscal_sumv, CfXg_Gscal_gg)')
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::CfXg_BRscal_hgg("@0/@1", CfXg_cgammaSq, CfXg_Gscal_tot)')
self.modelBuilder.factory_('expr::CfXg_BRscal_hf("@0*@0/@1", CF, CfXg_Gscal_tot)')
self.modelBuilder.factory_('expr::CfXg_BRscal_hv("1.0/@0", CfXg_Gscal_tot)')
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "CfXg_XSBRscal_%s_%s" % (production,decay)
if self.modelBuilder.out.function(name) == None:
XSscal = 'CF' if production in ["ggH","ttH"] else 'CV'
BRscal = "hgg"
if decay in ["hww", "hzz"]: BRscal = "hv"
if decay in ["hbb", "htt"]: BRscal = "hf"
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, CfXg_BRscal_%s)' % (name, XSscal, BRscal))
return name
class CvCfHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.cVRange = ['0','2']
self.cFRange = ['-2','2']
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
if po.startswith("cVRange="):
self.cVRange = po.replace("cVRange=","").split(":")
if len(self.cVRange) != 2:
raise RuntimeError, "cV signal strength range requires minimal and maximal value"
elif float(self.cVRange[0]) >= float(self.cVRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
if po.startswith("cFRange="):
self.cFRange = po.replace("cFRange=","").split(":")
if len(self.cFRange) != 2:
raise RuntimeError, "cF signal strength range requires minimal and maximal value"
elif float(self.cFRange[0]) >= float(self.cFRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CV[1,%s,%s]" % (self.cVRange[0], self.cVRange[1]))
self.modelBuilder.doVar("CF[1,%s,%s]" % (self.cFRange[0], self.cFRange[1]))
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'CV,CF,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CV,CF')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.decayScaling = {
'hgg':'hgg',
'hzg':'hzg',
'hww':'hvv',
'hzz':'hvv',
'hbb':'hff',
'htt':'hff',
}
self.productionScaling = {
'ggH':'CF',
'ttH':'CF',
'qqH':'CV',
'WH':'CV',
'ZH':'CV',
'VH':'CV',
}
self.SMH.makeScaling('hgg', Cb='CF', Ctop='CF', CW='CV', Ctau='CF')
self.SMH.makeScaling('hzg', Cb='CF', Ctop='CF', CW='CV', Ctau='CF')
# Ideas for a cleaner future
# self.SMH.makeScaling('hww', 'CV*CV') -> Scaling_hww("@0*@0",CV)
# self.SMH.makeScaling('total', hbb='CF*CF', htoptop='CF*CF', hww='CV*CV', hzz='CV', hgg='Scaling_hgg', hgluglu='Scaling_hgluglu' )
## partial widths, normalized to the SM one, for decays scaling with F, V and total
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::CvCf_Gscal_sumf("@0*@0 * (@1+@2+@3+@4+@5+@6+@7)", CF, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hgluglu, SM_BR_hmm, SM_BR_hss)')
self.modelBuilder.factory_('expr::CvCf_Gscal_sumv("@0*@0 * (@1+@2)", CV, SM_BR_hww, SM_BR_hzz)')
self.modelBuilder.factory_('expr::CvCf_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::CvCf_Gscal_Zg("@0 * @1", Scaling_hzg, SM_BR_hzg)')
self.modelBuilder.factory_('sum::CvCf_Gscal_tot(CvCf_Gscal_sumf, CvCf_Gscal_sumv, CvCf_Gscal_gg, CvCf_Gscal_Zg)')
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::CvCf_BRscal_hgg("@0/@1", Scaling_hgg, CvCf_Gscal_tot)')
self.modelBuilder.factory_('expr::CvCf_BRscal_hzg("@0/@1", Scaling_hzg, CvCf_Gscal_tot)')
self.modelBuilder.factory_('expr::CvCf_BRscal_hff("@0*@0/@1", CF, CvCf_Gscal_tot)')
self.modelBuilder.factory_('expr::CvCf_BRscal_hvv("@0*@0/@1", CV, CvCf_Gscal_tot)')
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "CvCf_XSBRscal_%s_%s" % (production,decay)
if self.modelBuilder.out.function(name):
return name
XSscal = self.productionScaling[production]
BRscal = self.decayScaling[decay]
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, CvCf_BRscal_%s)' % (name, XSscal, BRscal))
return name
class HiggsLoops(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(
self
) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.doHZg = False
def setPhysicsOptions(self, physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=", "").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
if po == 'doHZg':
self.doHZg = True
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kgluon[1,0,2]")
self.modelBuilder.doVar("kgamma[1,0,3]")
myPOIs = ['kgluon', 'kgamma']
if self.doHZg:
self.modelBuilder.doVar("kZgamma[1,0,10]")
myPOIs.append('kZgamma')
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(
float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" %
(self.mHRange[0], self.mHRange[1]))
myPOIs.append('MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet('POI', ','.join(myPOIs))
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.decayScaling = {
'hgg': 'hgg',
'hzg': 'hxx',
'hww': 'hxx',
'hzz': 'hxx',
'hbb': 'hxx',
'htt': 'hxx',
'hmm': 'hxx',
}
if self.doHZg:
self.decayScaling['hzg'] = 'hzg'
# SM BR
for d in [
"htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg",
"hzg", "hmm", "hss"
]:
self.SMH.makeBR(d)
## total witdh, normalized to the SM one
if self.doHZg:
self.modelBuilder.factory_(
'sum::loopGluonGamma_Gscal_OtherDecays(SM_BR_hbb, SM_BR_htt, SM_BR_hmm, SM_BR_hss, SM_BR_hzz, SM_BR_hww, SM_BR_hcc, SM_BR_htoptop)'
)
self.modelBuilder.factory_(
'expr::loopGluonGamma_Gscal_Zg("@0*@0* @1", kZgamma, SM_BR_hzg)'
)
else:
self.modelBuilder.factory_(
'sum::loopGluonGamma_Gscal_OtherDecays(SM_BR_hbb, SM_BR_htt, SM_BR_hmm, SM_BR_hss, SM_BR_hzz, SM_BR_hww, SM_BR_hcc, SM_BR_htoptop, SM_BR_hzg)'
)
self.modelBuilder.factory_(
'expr::loopGluonGamma_Gscal_gg("@0*@0* @1", kgamma, SM_BR_hgg)')
self.modelBuilder.factory_(
'expr::loopGluonGamma_Gscal_gluglu("@0*@0* @1", kgluon, SM_BR_hgluglu)'
)
if self.doHZg:
self.modelBuilder.factory_(
'sum::loopGluonGamma_Gscal_tot(loopGluonGamma_Gscal_OtherDecays, loopGluonGamma_Gscal_gg, loopGluonGamma_Gscal_Zg, loopGluonGamma_Gscal_gluglu)'
)
else:
self.modelBuilder.factory_(
'sum::loopGluonGamma_Gscal_tot(loopGluonGamma_Gscal_OtherDecays, loopGluonGamma_Gscal_gg, loopGluonGamma_Gscal_gluglu)'
)
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_(
'expr::loopGluonGamma_BRscal_hxx("1.0/@0",loopGluonGamma_Gscal_tot)'
)
self.modelBuilder.factory_(
'expr::loopGluonGamma_BRscal_hgg("@0*@0/@1", kgamma, loopGluonGamma_Gscal_tot)'
)
if self.doHZg:
self.modelBuilder.factory_(
'expr::loopGluonGamma_BRscal_hzg("@0*@0/@1", kZgamma, loopGluonGamma_Gscal_tot)'
)
# verbosity
#self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self, production, decay, energy):
name = "loopGluonGamma_XSBRscal_%s_%s" % (production, decay)
if self.modelBuilder.out.function(name):
return name
BRscal = self.decayScaling[decay]
if production == "ggH":
self.modelBuilder.factory_(
'expr::%s("@0*@0 * @1", kgluon, loopGluonGamma_BRscal_%s)' %
(name, BRscal))
else:
self.modelBuilder.factory_(
'expr::%s("1.0 * @0", loopGluonGamma_BRscal_%s)' %
(name, BRscal))
return name
class KappaVKappaT(LHCHCGBaseModel):
"""
Copy of Kappas model with a combined kappa_V (for kappa_W and kappa_Z),
and where hcc is independent of kappa_t.
For tHq multilepton analysis (HIG-17-005)
NOTE - Do not use this model for a generic analysis,
instead use the LHCHCGModels:K3 or K7 models and freeze POIs accordingly
"""
def __init__(self,
resolved=True,
BRU=True,
addInvisible=False,
coupleTopTau=False):
LHCHCGBaseModel.__init__(
self
) # not using 'super(x,self).__init__' since I don't understand it
self.doBRU = BRU
self.resolved = resolved
self.addInvisible = addInvisible
self.coupleTopTau = coupleTopTau
def setPhysicsOptions(self, physOptions):
self.setPhysicsOptionsBase(physOptions)
for po in physOptions:
if po.startswith("BRU="):
self.doBRU = (po.replace("BRU=", "")
in ["yes", "1", "Yes", "True", "true"])
print "BR uncertainties in partial widths: %s " % self.doBRU
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("r[1,0.0,10.0]")
self.modelBuilder.doVar("kappa_V[1,0.0,2.0]")
self.modelBuilder.doVar("kappa_t[1,-10.0,10.0]")
self.modelBuilder.doVar("kappa_mu[1,0.0,5.0]")
if not self.coupleTopTau:
self.modelBuilder.doVar("kappa_tau[1,0.0,3.0]")
self.modelBuilder.factory_(
"expr::kappa_mu_expr(\"@0*@1+(1-@0)*@2\", CMS_use_kmu[0], kappa_mu, kappa_tau)"
)
else:
self.modelBuilder.factory_(
"expr::kappa_mu_expr(\"@0*@1+(1-@0)*@2\", CMS_use_kmu[0], kappa_mu, kappa_t)"
)
self.modelBuilder.doVar("kappa_b[1,0.0,3.0]")
self.modelBuilder.doVar(
"kappa_c[1,0.0,3.0]") # treat hcc independently from kappa_t
if not self.resolved:
self.modelBuilder.doVar("kappa_g[1,0.0,2.0]")
self.modelBuilder.doVar("kappa_gam[1,0.0,2.5]")
self.modelBuilder.doVar("BRinv[0,0,1]")
if not self.addInvisible:
self.modelBuilder.out.var("BRinv").setConstant(True)
pois = 'kappa_V,kappa_t,kappa_b,kappa_c'
if not self.coupleTopTau:
pois += ',kappa_tau'
if not self.resolved:
pois += ',kappa_g,kappa_gam'
if self.addInvisible: pois += ",BRinv"
self.doMH()
self.modelBuilder.doSet("POI", pois)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.dobbH()
# SM BR
for d in SM_HIGG_DECAYS + ["hss"]:
self.SMH.makeBR(d)
# BR uncertainties
if self.doBRU:
self.SMH.makePartialWidthUncertainties()
else:
for d in SM_HIGG_DECAYS:
self.modelBuilder.factory_(
'HiggsDecayWidth_UncertaintyScaling_%s[1.0]' % d)
# get VBF, tHq, tHW, ggZH cross section
self.SMH.makeScaling('qqH', CW='kappa_V', CZ='kappa_V')
self.SMH.makeScaling("tHq", CW='kappa_V', Ctop="kappa_t")
self.SMH.makeScaling("tHW", CW='kappa_V', Ctop="kappa_t")
self.SMH.makeScaling("ggZH",
CZ='kappa_V',
Ctop="kappa_t",
Cb="kappa_b")
# resolve loops
if self.resolved:
self.SMH.makeScaling('ggH',
Cb='kappa_b',
Ctop='kappa_t',
Cc="kappa_t")
self.SMH.makeScaling('hgluglu', Cb='kappa_b', Ctop='kappa_t')
if not self.coupleTopTau:
self.SMH.makeScaling('hgg',
Cb='kappa_b',
Ctop='kappa_t',
CW='kappa_V',
Ctau='kappa_tau')
self.SMH.makeScaling('hzg',
Cb='kappa_b',
Ctop='kappa_t',
CW='kappa_V',
Ctau='kappa_tau')
else:
self.SMH.makeScaling('hgg',
Cb='kappa_b',
Ctop='kappa_t',
CW='kappa_V',
Ctau='kappa_t')
self.SMH.makeScaling('hzg',
Cb='kappa_b',
Ctop='kappa_t',
CW='kappa_V',
Ctau='kappa_t')
else:
self.modelBuilder.factory_(
'expr::Scaling_hgluglu("@0*@0", kappa_g)')
self.modelBuilder.factory_('expr::Scaling_hgg("@0*@0", kappa_gam)')
self.modelBuilder.factory_('expr::Scaling_hzg("@0*@0", kappa_gam)')
self.modelBuilder.factory_(
'expr::Scaling_ggH_7TeV("@0*@0", kappa_g)')
self.modelBuilder.factory_(
'expr::Scaling_ggH_8TeV("@0*@0", kappa_g)')
self.modelBuilder.factory_(
'expr::Scaling_ggH_13TeV("@0*@0", kappa_g)')
self.modelBuilder.factory_(
'expr::Scaling_ggH_14TeV("@0*@0", kappa_g)')
## partial witdhs, normalized to the SM one
self.modelBuilder.factory_(
'expr::c7_Gscal_Z("@0*@0*@1*@2", kappa_V, SM_BR_hzz, HiggsDecayWidth_UncertaintyScaling_hzz)'
)
self.modelBuilder.factory_(
'expr::c7_Gscal_W("@0*@0*@1*@2", kappa_V, SM_BR_hww, HiggsDecayWidth_UncertaintyScaling_hww)'
)
if not self.coupleTopTau:
self.modelBuilder.factory_(
'expr::c7_Gscal_tau("@0*@0*@1*@4+@2*@2*@3*@5", kappa_tau, SM_BR_htt, kappa_mu_expr, SM_BR_hmm, HiggsDecayWidth_UncertaintyScaling_htt, HiggsDecayWidth_UncertaintyScaling_hmm)'
)
else:
self.modelBuilder.factory_(
'expr::c7_Gscal_tau("@0*@0*@1*@4+@2*@2*@3*@5", kappa_t, SM_BR_htt, kappa_mu_expr, SM_BR_hmm, HiggsDecayWidth_UncertaintyScaling_htt, HiggsDecayWidth_UncertaintyScaling_hmm)'
)
self.modelBuilder.factory_(
'expr::c7_Gscal_top("@0*@0 * @1*@2", kappa_c, SM_BR_hcc, HiggsDecayWidth_UncertaintyScaling_hcc)'
)
self.modelBuilder.factory_(
'expr::c7_Gscal_bottom("@0*@0 * (@1*@3+@2)", kappa_b, SM_BR_hbb, SM_BR_hss, HiggsDecayWidth_UncertaintyScaling_hbb)'
)
self.modelBuilder.factory_(
'expr::c7_Gscal_gluon(" @0 * @1 * @2", Scaling_hgluglu, SM_BR_hgluglu, HiggsDecayWidth_UncertaintyScaling_hgluglu)'
)
self.modelBuilder.factory_(
'expr::c7_Gscal_gamma("@0*@1*@4 + @2*@3*@5", Scaling_hgg, SM_BR_hgg, Scaling_hzg, SM_BR_hzg, HiggsDecayWidth_UncertaintyScaling_hgg, HiggsDecayWidth_UncertaintyScaling_hzg)'
)
# fix to have all BRs add up to unity
self.modelBuilder.factory_("sum::c7_SMBRs(%s)" % (",".join(
"SM_BR_" + X
for X in "hzz hww htt hmm hcc hbb hss hgluglu hgg hzg".split())))
self.modelBuilder.out.function("c7_SMBRs").Print("")
## total witdh, normalized to the SM one
self.modelBuilder.factory_(
'expr::c7_Gscal_tot("(@1+@2+@3+@4+@5+@6+@7)/@8/(1-@0)", BRinv, c7_Gscal_Z, c7_Gscal_W, c7_Gscal_tau, c7_Gscal_top, c7_Gscal_bottom, c7_Gscal_gluon, c7_Gscal_gamma, c7_SMBRs)'
)
## BRs, normalized to the SM ones: they scale as (partial/partial_SM) / (total/total_SM)
self.modelBuilder.factory_(
'expr::c7_BRscal_hww("@0*@0*@2/@1", kappa_V, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_hww)'
)
self.modelBuilder.factory_(
'expr::c7_BRscal_hzz("@0*@0*@2/@1", kappa_V, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_hzz)'
)
if not self.coupleTopTau:
self.modelBuilder.factory_(
'expr::c7_BRscal_htt("@0*@0*@2/@1", kappa_tau, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_htt)'
)
else:
self.modelBuilder.factory_(
'expr::c7_BRscal_htt("@0*@0*@2/@1", kappa_t, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_htt)'
)
self.modelBuilder.factory_(
'expr::c7_BRscal_hmm("@0*@0*@2/@1", kappa_mu_expr, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_hmm)'
)
self.modelBuilder.factory_(
'expr::c7_BRscal_hbb("@0*@0*@2/@1", kappa_b, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_hbb)'
)
self.modelBuilder.factory_(
'expr::c7_BRscal_hcc("@0*@0*@2/@1", kappa_c, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_hcc)'
)
self.modelBuilder.factory_(
'expr::c7_BRscal_hgg("@0*@2/@1", Scaling_hgg, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_hgg)'
)
self.modelBuilder.factory_(
'expr::c7_BRscal_hzg("@0*@2/@1", Scaling_hzg, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_hzg)'
)
self.modelBuilder.factory_(
'expr::c7_BRscal_hgluglu("@0*@2/@1", Scaling_hgluglu, c7_Gscal_tot, HiggsDecayWidth_UncertaintyScaling_hgluglu)'
)
self.modelBuilder.factory_('expr::c7_BRscal_hinv("@0", BRinv)')
def getHiggsSignalYieldScale(self, production, decay, energy):
name = "c7_XSBRscal_%s_%s_%s" % (production, decay, energy)
if self.modelBuilder.out.function(name) == None:
if production in ["ggH", "qqH", "ggZH", "tHq", "tHW"]:
XSscal = ("@0", "Scaling_%s_%s" % (production, energy))
elif production == "WH":
XSscal = ("@0*@0", "kappa_V")
elif production == "ZH":
XSscal = ("@0*@0", "kappa_V")
elif production == "ttH":
XSscal = ("@0*@0", "kappa_t")
elif production == "bbH":
XSscal = ("@0*@0", "kappa_b")
else:
raise RuntimeError, "Production %s not supported" % production
BRscal = decay
if not self.modelBuilder.out.function("c7_BRscal_" + BRscal):
raise RuntimeError, "Decay mode %s not supported" % decay
if decay == "hss": BRscal = "hbb"
if production in ['tHq', 'tHW', 'ttH']:
self.modelBuilder.factory_(
'expr::%s("%s*@1*@2", %s, c7_BRscal_%s, r)' %
(name, XSscal[0], XSscal[1], BRscal))
elif production == "ggH" and (decay
in self.add_bbH) and energy in [
"7TeV", "8TeV", "13TeV", "14TeV"
]:
b2g = "CMS_R_bbH_ggH_%s_%s[%g]" % (decay, energy, 0.01)
b2gs = "CMS_bbH_scaler_%s" % energy
self.modelBuilder.factory_(
'expr::%s("(%s + @1*@1*@2*@3)*@4", %s, kappa_b, %s, %s, c7_BRscal_%s)'
% (name, XSscal[0], XSscal[1], b2g, b2gs, BRscal))
else:
self.modelBuilder.factory_(
'expr::%s("%s*@1*@2", %s, c7_BRscal_%s,r)' %
(name, XSscal[0], XSscal[1], BRscal))
print '[LHC-HCG Kappas]', name, production, decay, energy, ": ",
self.modelBuilder.out.function(name).Print("")
return name
class CvCfHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self, physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=", "").split(",")
print("The Higgs mass range:", self.mHRange)
if len(self.mHRange) != 2:
raise RuntimeError("Higgs mass range definition requires two extrema.")
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError(
"Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
)
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CV[1,0.0,1.5]")
self.modelBuilder.doVar("CF[1,-2,2]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", "CV,CF,MH")
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI", "CV,CF")
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
## Coefficient for couplings to photons
# arXiv 1202.3144v2, below eq. 2.6: 2/9*cF - 1.04*cV, and then normalize to SM
# FIXME: this should be replaced with the proper MH dependency
# self.modelBuilder.factory_("expr::CvCf_cgamma(\"-0.271*@0+1.27*@1\",CF,CV)")
#########################################################################
## Coefficient for coupling to di-photons
# Based on Eq 1--4 of Nuclear Physics B 453 (1995)17-82
# ignoring b quark contributions
# Taylor series around MH=125 including terms up to O(MH-125)^2 in Horner polynomial form
CF = self.modelBuilder.out.function("CF")
CF.setVal(1.0)
self.modelBuilder.factory_(
'expr::CvCf_cgammaSq("\
@0*@0*(1.524292518396496 + (0.005166702799572456 - 0.00003355715038472727*@2)*@2) + \
@1*(@1*(0.07244520735564258 + (0.0008318872718720393 - 6.16997610275555e-6*@2)*@2) + \
@0*(-0.5967377257521194 + (-0.005998590071444782 + 0.00003972712648748393*@2)*@2))\
",CV,CF,MH)'
)
## partial witdhs, normalized to the SM one, for decays scaling with F, V and total
for d in ["htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss"]:
self.SMH.makeBR(d)
self.modelBuilder.factory_(
'expr::CvCf_Gscal_sumf("@0*@0 * (@1+@2+@3+@4+@5+@6+@7)", CF, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hgluglu, SM_BR_hmm, SM_BR_hss)'
)
self.modelBuilder.factory_('expr::CvCf_Gscal_sumv("@0*@0 * (@1+@2+@3)", CV, SM_BR_hww, SM_BR_hzz, SM_BR_hzg)')
self.modelBuilder.factory_('expr::CvCf_Gscal_gg("@0 * @1", CvCf_cgammaSq, SM_BR_hgg)')
self.modelBuilder.factory_("sum::CvCf_Gscal_tot(CvCf_Gscal_sumf, CvCf_Gscal_sumv, CvCf_Gscal_gg)")
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::CvCf_BRscal_hgg("@0/@1", CvCf_cgammaSq, CvCf_Gscal_tot)')
self.modelBuilder.factory_('expr::CvCf_BRscal_hf("@0*@0/@1", CF, CvCf_Gscal_tot)')
self.modelBuilder.factory_('expr::CvCf_BRscal_hv("@0*@0/@1", CV, CvCf_Gscal_tot)')
# self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self, production, decay, energy):
name = "CvCf_XSBRscal_%s_%s" % (production, decay)
if self.modelBuilder.out.function(name) == None:
XSscal = "CF" if production in ["ggH", "ttH"] else "CV"
BRscal = "hgg"
if decay in ["hww", "hzz"]:
BRscal = "hv"
if decay in ["hbb", "htt"]:
BRscal = "hf"
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, CvCf_BRscal_%s)' % (name, XSscal, BRscal))
return name
class ResolvedC6(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.MRange = ['150','350']
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
if po.startswith("MRange="):
self.MRange = po.replace("MRange=","").split(":")
if len(self.MRange) != 2:
raise RuntimeError, "M range requires minimal and maximal value"
elif float(self.MRange[0]) >= float(self.MRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CW[1.0,0.0,5.0]")
self.modelBuilder.doVar("CZ[1.0,0.0,5.0]")
self.modelBuilder.doVar("Ctop[1.0,0.0,5.0]")
self.modelBuilder.doVar("Cb[1.0,0.0,5.0]")
self.modelBuilder.doVar("Ctau[1.0,0.0,5.0]")
self.modelBuilder.doVar("Cmu[1.0,0.0,5.0]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'MH,CW,CZ,Ctop,Cb,Ctau,Cmu')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CW,CZ,Ctop,Cb,Ctau,Cmu')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.productionScaling = {
'ttH':'Ctop',
'WH':'CW',
'ZH':'CZ',
}
self.SMH.makeScaling('ggH', Cb='Cb', Ctop='Ctop')
self.SMH.makeScaling('qqH', CW='CW', CZ='CZ')
self.SMH.makeScaling('hgluglu', Cb='Cb', Ctop='Ctop')
self.SMH.makeScaling('hgg', Cb='Cb', Ctop='Ctop', CW='CW', Ctau='Ctau')
self.SMH.makeScaling('hzg', Cb='Cb', Ctop='Ctop', CW='CW', Ctau='Ctau')
## partial widths, normalized to the SM one, for decays scaling with F, V and total
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::wztbtm_Gscal_w("@0*@0 * @1", CW, SM_BR_hww)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_z("@0*@0 * @1", CZ, SM_BR_hzz)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_b("@0*@0 * @1", Cb, SM_BR_hbb)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_tau("@0*@0 * @1", Ctau, SM_BR_htt)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_mu("@0*@0 * @1", Cmu, SM_BR_hmm)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_top("@0*@0 * @1", Ctop, SM_BR_htoptop)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_glu("@0 * @1", Scaling_hgluglu, SM_BR_hgluglu)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::wztbtm_Gscal_zg("@0 * @1", Scaling_hzg, SM_BR_hzg)')
self.modelBuilder.factory_('sum::wztbtm_Gscal_tot(wztbtm_Gscal_w, wztbtm_Gscal_z, wztbtm_Gscal_b, wztbtm_Gscal_tau, wztbtm_Gscal_mu, wztbtm_Gscal_top, wztbtm_Gscal_glu, wztbtm_Gscal_gg, wztbtm_Gscal_zg, SM_BR_hcc, SM_BR_hss)')
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::wztbtm_BRscal_hww("@0*@0/@1", CW, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hzz("@0*@0/@1", CZ, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hbb("@0*@0/@1", Cb, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hss("@0*@0/@1", Cb, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_htt("@0*@0/@1", Ctau, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hcc("@0*@0/@1", Ctop, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hmm("@0*@0/@1", Cmu, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hgg("@0/@1", Scaling_hgg, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hzg("@0/@1", Scaling_hzg, wztbtm_Gscal_tot)')
self.modelBuilder.factory_('expr::wztbtm_BRscal_hgluglu("@0/@1", Scaling_hgluglu, wztbtm_Gscal_tot)')
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = 'wztbtm_XSBRscal_%(production)s_%(decay)s' % locals()
if production in ('ggH','qqH'):
self.productionScaling[production]='Scaling_'+production+'_'+energy
name += '_%(energy)s' % locals()
if self.modelBuilder.out.function(name):
return name
if production == "VH":
print "WARNING: You are trying to use a VH production mode in a model that needs WH and ZH separately. "\
"The best I can do is to scale [%(production)s, %(decay)s, %(energy)s] with the decay BR only but this is wrong..." % locals()
self.modelBuilder.factory_('expr::%(name)s("1.0*@0", wztbtm_BRscal_%(decay)s)' % locals())
return name
XSscal = self.productionScaling[production]
if production == 'ggH':
self.modelBuilder.factory_('expr::%(name)s("@0 * @1", %(XSscal)s, wztbtm_BRscal_%(decay)s)' % locals())
else:
self.modelBuilder.factory_('expr::%(name)s("@0*@0 * @1", %(XSscal)s, wztbtm_BRscal_%(decay)s)' % locals())
return name
def doParametersOfInterest(self):
"""Create POI and other parameters, and define the POI set."""
print "self.MHScaleWW = ",self.MHScaleWW
self.modelBuilder.doVar("Zero[0.,0.,1.]")
self.modelBuilder.out.var("Zero").setVal(0.)
self.modelBuilder.out.var("Zero").setConstant(True)
self.modelBuilder.doVar("xsr_ggH[1.,0.,2.]")
if self.MHScaleWW :
print '!!!!!!! Scaling HWW from mH=125.0 GeV to mH=125.6 GeV !!!!!!!!!'
self.modelBuilder.out.var("xsr_ggH").setVal(1.035)
else:
self.modelBuilder.out.var("xsr_ggH").setVal(1.)
self.modelBuilder.out.var("xsr_ggH").setConstant(True)
self.modelBuilder.doVar("xsr_qqH[1.,0.,2.]")
if self.MHScaleWW :
self.modelBuilder.out.var("xsr_qqH").setVal(1.041)
else:
self.modelBuilder.out.var("xsr_qqH").setVal(1.)
self.modelBuilder.out.var("xsr_qqH").setConstant(True)
#self.SMH = SMHiggsBuilder(self.modelBuilder)
#for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]: self.SMH.makeBR(d)
self.modelBuilder.doVar("lambdaWZ[1.,0.,2.]")
if self.notCustodial :
print "Removing Custodial symmetry"
else:
self.modelBuilder.out.var("lambdaWZ").setVal(1.0)
self.modelBuilder.out.var("lambdaWZ").setConstant(True)
if self.is2l2nu:
#self.modelBuilder.factory_('sum::c7_Gscal_tot(c7_Gscal_Vectors, c7_Gscal_tau, c7_Gscal_top, c7_Gscal_bottom, c7_Gscal_gluon, c7_Gscal_gamma)')
self.modelBuilder.doVar("CMS_widthH_kbkg[1.,0.,2.]")
self.modelBuilder.doVar("CMS_widthH_ww_kbkg[1.,0.,2.]")
self.modelBuilder.doVar("R[1.,0.,4.]")
self.modelBuilder.doVar("R1j[1.,0.,4.]")
self.modelBuilder.doVar("kgluon[1.,0.,4.]")
self.modelBuilder.doVar("kV[1.,0.,8.]")
#self.modelBuilder.doVar("CMS_zz4l_GGsm[1.,0.,30.]")
self.modelBuilder.doVar("CMS_zz4l_GGsm[1.,0.,60.]")
#self.modelBuilder.doVar("kV[0.0,0.0,1.0]")
self.modelBuilder.doVar("ktau[0.0,0.0,2.0]")
self.modelBuilder.doVar("ktop[0.0,0.0,4.0]")
self.modelBuilder.doVar("kbottom[0.0,0.0,3.0]")
#self.modelBuilder.doVar("kgluon[0.0,0.0,2.0]")
self.modelBuilder.doVar("kgamma[0.0,0.0,2.5]")
#self.modelBuilder.doVar("BRInvUndet[0,0,1]")
self.modelBuilder.doVar("CMS_zz4l_scalerK[1.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hww[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hzz[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_htt[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hmm[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_htoptop[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hcc[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hbb[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hss[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hgluglu[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hgg[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hzg[0.0,0.0,1.0]")
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_Vectors("@0*@0 * (@1+@2)*abs(1-@3)", kV, SM_BR_hzz, SM_BR_hww, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_tau("@0*@0 * (@1+@2)*abs(1-@3)", ktau, SM_BR_htt, SM_BR_hmm, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_top("@0*@0 * (@1+@2)*abs(1-@3)", ktop, SM_BR_htoptop, SM_BR_hcc, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_bottom("@0*@0 * (@1+@2)*abs(1-@3)", kbottom, SM_BR_hbb, SM_BR_hss, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_gluon("@0*@0 * @1*abs(1-@2)", kgluon, SM_BR_hgluglu, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_gamma("@0*@0 * (@1+@2)*abs(1-@3)", kgamma, SM_BR_hgg, SM_BR_hzg, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('sum::gammaK(CMS_zz4l_Gscal_Vectors, CMS_zz4l_Gscal_tau, CMS_zz4l_Gscal_top, CMS_zz4l_Gscal_bottom, CMS_zz4l_Gscal_gluon, CMS_zz4l_Gscal_gamma, CMS_zz4l_scalerK)')
self.SMH = SMHiggsBuilder(self.modelBuilder)
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]: self.SMH.makeBR(d)
if self.useKframework:
self.modelBuilder.out.var("CMS_zz4l_scalerK").setVal(0.0)
else:
self.modelBuilder.out.var("CMS_zz4l_scalerK").setVal(1.0)
if not self.is2l2nu:
self.modelBuilder.out.var("SM_BR_hww").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hww").setConstant(True)
self.modelBuilder.out.var("SM_BR_hzz").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hzz").setConstant(True)
self.modelBuilder.out.var("SM_BR_htt").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hmm").setVal(0.0)
self.modelBuilder.out.var("SM_BR_htt").setConstant(True)
self.modelBuilder.out.var("SM_BR_hmm").setConstant(True)
self.modelBuilder.out.var("SM_BR_htoptop").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hcc").setVal(0.0)
self.modelBuilder.out.var("SM_BR_htoptop").setConstant(True)
self.modelBuilder.out.var("SM_BR_hcc").setConstant(True)
self.modelBuilder.out.var("SM_BR_hbb").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hss").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hbb").setConstant(True)
self.modelBuilder.out.var("SM_BR_hss").setConstant(True)
self.modelBuilder.out.var("SM_BR_hgluglu").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hgg").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hgluglu").setConstant(True)
self.modelBuilder.out.var("SM_BR_hgg").setConstant(True)
self.modelBuilder.out.var("SM_BR_hzg").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hzg").setConstant(True)
self.modelBuilder.out.var("CMS_zz4l_scalerK").setConstant(True)
if self.GGsmfixed:
self.modelBuilder.out.var("CMS_zz4l_GGsm")
self.modelBuilder.out.var("CMS_zz4l_GGsm").setVal(1)
self.modelBuilder.out.var("CMS_zz4l_GGsm").setConstant(True)
print "Fixing CMS_zz4l_GGsm"
if self.RVRFfixed:
self.modelBuilder.out.var("kV").setVal(1)
self.modelBuilder.out.var("kV").setConstant(True)
self.modelBuilder.out.var("kgluon").setVal(1)
self.modelBuilder.out.var("kgluon").setConstant(True)
poi = "R"
else:
self.modelBuilder.out.var("R").setVal(1)
self.modelBuilder.out.var("R").setConstant(True)
poi = "kV,kgluon"
else:
#self.modelBuilder.out.var("CMS_zz4l_GGsm").setVal(1)
#self.modelBuilder.out.var("CMS_zz4l_GGsm").setRange(0.0001,30.0001)
self.modelBuilder.out.var("kgluon").setVal(1)
self.modelBuilder.out.var("kV").setVal(1)
self.modelBuilder.out.var("R").setVal(1)
self.modelBuilder.out.var("CMS_widthH_kbkg")
self.modelBuilder.out.var("CMS_widthH_kbkg").setVal(1)
self.modelBuilder.out.var("CMS_widthH_ww_kbkg")
self.modelBuilder.out.var("CMS_widthH_ww_kbkg").setVal(1)
if self.RVRFfixed:
self.modelBuilder.out.var("R").setRange(0.0,4.0)
self.modelBuilder.out.var("kV").setConstant(True)
self.modelBuilder.out.var("kgluon").setConstant(True)
else:
self.modelBuilder.out.var("kV").setRange(0.0,100.0)
self.modelBuilder.out.var("kgluon").setRange(0.0,100.0)
#self.modelBuilder.out.var("kV").setRange(0.0,8.0)
#self.modelBuilder.out.var("kgluon").setRange(0.0,4.0)
self.modelBuilder.out.var("R").setConstant(True)
poi = "CMS_zz4l_GGsm"
self.modelBuilder.factory_("expr::kgluon_WW(\"@0*@1\",kgluon,xsr_ggH)")
self.modelBuilder.factory_("expr::kV_WW(\"@0*@1\",kV,xsr_qqH)")
self.modelBuilder.factory_("expr::kgluon_ZZ(\"@0*@1\",kgluon,lambdaWZ)")
self.modelBuilder.factory_("expr::kV_ZZ(\"@0*@1\",kV,lambdaWZ)")
self.modelBuilder.factory_("expr::ggH_s_func(\"@0*@3*@1*@4-sqrt(@0*@3*@1*@4*@2)\",R,CMS_zz4l_GGsm,CMS_widthH_kbkg,kgluon_ZZ,gammaK)")
self.modelBuilder.factory_("expr::ggH_b_func(\"@2-sqrt(@0*@3*@1*@4*@2)\",R,CMS_zz4l_GGsm,CMS_widthH_kbkg,kgluon_ZZ,gammaK)")
self.modelBuilder.factory_("expr::ggH_sbi_func(\"sqrt(@0*@3*@1*@4*@2)\",R,CMS_zz4l_GGsm,CMS_widthH_kbkg,kgluon_ZZ,gammaK)")
self.modelBuilder.factory_("expr::qqH_s_func(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_ZZ,gammaK)")
self.modelBuilder.factory_("expr::qqH_b_func(\"1-sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_ZZ,gammaK)")
self.modelBuilder.factory_("expr::qqH_sbi_func(\"sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_ZZ,gammaK)")
# CMS_widthH_ww_kbkg uncertainty for WW
self.modelBuilder.factory_("expr::ggH_s_funcWW(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3*@4)\",R,CMS_zz4l_GGsm,kgluon_WW,gammaK,CMS_widthH_ww_kbkg)")
self.modelBuilder.factory_("expr::ggH_b_funcWW(\"@4-sqrt(@0*@2*@1*@3*@4)\",R,CMS_zz4l_GGsm,kgluon_WW,gammaK,CMS_widthH_ww_kbkg)")
self.modelBuilder.factory_("expr::ggH_sbi_funcWW(\"sqrt(@0*@2*@1*@3*@4)\",R,CMS_zz4l_GGsm,kgluon_WW,gammaK,CMS_widthH_ww_kbkg)")
self.modelBuilder.factory_("expr::qqH_s_funcWW(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_b_funcWW(\"1-sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_sbi_funcWW(\"sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::ggH_s_funcWW_1j(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kgluon_WW,gammaK)")
self.modelBuilder.factory_("expr::ggH_b_funcWW_1j(\"1-sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kgluon_WW,gammaK)")
self.modelBuilder.factory_("expr::ggH_sbi_funcWW_1j(\"sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kgluon_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_s_funcWW_1j(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_b_funcWW_1j(\"1-sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_sbi_funcWW_1j(\"sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.doSet("POI",poi)
class Higgswidth(PhysicsModel):
def __init__(self):
self.mHRange = []
self.GGsmfixed = False
self.is2l2nu = False
self.RVRFfixed = False
self.useKframework = False
self.notCustodial = False
self.MHScaleWW = False
self.poiMap = []
self.pois = {}
self.verbose = False
def setModelBuilder(self, modelBuilder):
PhysicsModel.setModelBuilder(self,modelBuilder)
self.modelBuilder.doModelBOnly = False
def getYieldScale(self,bin,process):
if "hww" in bin:
#if "1j" in bin:
#if process == "ggH_s": return "ggH_s_funcWW_1j"
#elif process == "ggH_b": return "ggH_b_funcWW_1j"
#elif process == "ggH_sbi": return "ggH_sbi_funcWW_1j"
#elif process == "qqH_s": return "qqH_s_funcWW_1j"
#elif process == "qqH_b": return "qqH_b_funcWW_1j"
#elif process == "qqH_sbi": return "qqH_sbi_funcWW_1j"
#else :
if process == "ggH_s": return "ggH_s_funcWW"
elif process == "ggH_b": return "ggH_b_funcWW"
elif process == "ggH_sbi": return "ggH_sbi_funcWW"
elif process == "qqH_s": return "qqH_s_funcWW"
elif process == "qqH_b": return "qqH_b_funcWW"
elif process == "qqH_sbi": return "qqH_sbi_funcWW"
else:
if process == "ggH_s": return "ggH_s_func"
elif process == "ggH_b": return "ggH_b_func"
elif process == "ggH_sbi": return "ggH_sbi_func"
elif process == "qqH_s": return "qqH_s_func"
elif process == "qqH_b": return "qqH_b_func"
elif process == "qqH_sbi": return "qqH_sbi_func"
if process in ["ggH_SM","qqH_SM","WH_SM","ZH_SM"]:
return "Zero"
if process in ["ggH","ttH"]:
print " bin= ",bin
if "hww" in bin:
if self.RVRFfixed:
#if "1j" in bin:
#print "1 jet scaling"
#return "R1j"
#else:
return "R"
else:
return "kgluon_WW"
else:
if self.RVRFfixed:
return "R"
else:
return "kgluon_ZZ"
elif process in ["qqH","WH","ZH","VH"]:
if "hww" in bin:
if self.RVRFfixed:
return "R"
else:
return "kV_WW"
else:
if self.RVRFfixed:
return "R"
else:
return "kV_ZZ"
else:
return 1
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po == "GGsmfixed":
print "Will fix CMS_zz4l_GGsm to 1 and float muV and muF"
self.GGsmfixed = True
if po == "RVRFfixed":
print "Will fix muV and muF to 1 and float mu"
self.RVRFfixed = True
if po == "is2l2nu":
print "Will make 2l2nu style cards and float muV and muF"
self.is2l2nu = True
if po == "GGsmRVRFfixed":
print "Will fix CMS_zz4l_GGsm to 1 and float mu"
self.GGsmfixed = True
self.RVRFfixed = True
if po == "is2l2nuRVRFfixed":
print "Will make 2l2nu style cards and float mu"
self.is2l2nu = True
self.RVRFfixed = True
if po == "is2l2nuGGsmfixed":
print "Will make 2l2nu style cards, fix GGsm to 1 and float muV and muF"
self.is2l2nu = True
self.GGsmfixed = True
if po == "is2l2nuGGsmRVRFfixed":
print "Will make 2l2nu style cards, fix GGsm to 1 and float mu"
self.is2l2nu = True
self.RVRFfixed = True
self.GGsmfixed = True
if po == "useKframework":
self.useKframework=True
self.GGsmfixed=True
if po == "notCustodial":
self.notCustodial = True
if po == "MHScaleWW" :
self.MHScaleWW = True
def doParametersOfInterest(self):
"""Create POI and other parameters, and define the POI set."""
print "self.MHScaleWW = ",self.MHScaleWW
self.modelBuilder.doVar("Zero[0.,0.,1.]")
self.modelBuilder.out.var("Zero").setVal(0.)
self.modelBuilder.out.var("Zero").setConstant(True)
self.modelBuilder.doVar("xsr_ggH[1.,0.,2.]")
if self.MHScaleWW :
print '!!!!!!! Scaling HWW from mH=125.0 GeV to mH=125.6 GeV !!!!!!!!!'
self.modelBuilder.out.var("xsr_ggH").setVal(1.035)
else:
self.modelBuilder.out.var("xsr_ggH").setVal(1.)
self.modelBuilder.out.var("xsr_ggH").setConstant(True)
self.modelBuilder.doVar("xsr_qqH[1.,0.,2.]")
if self.MHScaleWW :
self.modelBuilder.out.var("xsr_qqH").setVal(1.041)
else:
self.modelBuilder.out.var("xsr_qqH").setVal(1.)
self.modelBuilder.out.var("xsr_qqH").setConstant(True)
#self.SMH = SMHiggsBuilder(self.modelBuilder)
#for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]: self.SMH.makeBR(d)
self.modelBuilder.doVar("lambdaWZ[1.,0.,2.]")
if self.notCustodial :
print "Removing Custodial symmetry"
else:
self.modelBuilder.out.var("lambdaWZ").setVal(1.0)
self.modelBuilder.out.var("lambdaWZ").setConstant(True)
if self.is2l2nu:
#self.modelBuilder.factory_('sum::c7_Gscal_tot(c7_Gscal_Vectors, c7_Gscal_tau, c7_Gscal_top, c7_Gscal_bottom, c7_Gscal_gluon, c7_Gscal_gamma)')
self.modelBuilder.doVar("CMS_widthH_kbkg[1.,0.,2.]")
self.modelBuilder.doVar("CMS_widthH_ww_kbkg[1.,0.,2.]")
self.modelBuilder.doVar("R[1.,0.,4.]")
self.modelBuilder.doVar("R1j[1.,0.,4.]")
self.modelBuilder.doVar("kgluon[1.,0.,4.]")
self.modelBuilder.doVar("kV[1.,0.,8.]")
#self.modelBuilder.doVar("CMS_zz4l_GGsm[1.,0.,30.]")
self.modelBuilder.doVar("CMS_zz4l_GGsm[1.,0.,60.]")
#self.modelBuilder.doVar("kV[0.0,0.0,1.0]")
self.modelBuilder.doVar("ktau[0.0,0.0,2.0]")
self.modelBuilder.doVar("ktop[0.0,0.0,4.0]")
self.modelBuilder.doVar("kbottom[0.0,0.0,3.0]")
#self.modelBuilder.doVar("kgluon[0.0,0.0,2.0]")
self.modelBuilder.doVar("kgamma[0.0,0.0,2.5]")
#self.modelBuilder.doVar("BRInvUndet[0,0,1]")
self.modelBuilder.doVar("CMS_zz4l_scalerK[1.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hww[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hzz[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_htt[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hmm[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_htoptop[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hcc[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hbb[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hss[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hgluglu[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hgg[0.0,0.0,1.0]")
self.modelBuilder.doVar("SM_BR_hzg[0.0,0.0,1.0]")
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_Vectors("@0*@0 * (@1+@2)*abs(1-@3)", kV, SM_BR_hzz, SM_BR_hww, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_tau("@0*@0 * (@1+@2)*abs(1-@3)", ktau, SM_BR_htt, SM_BR_hmm, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_top("@0*@0 * (@1+@2)*abs(1-@3)", ktop, SM_BR_htoptop, SM_BR_hcc, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_bottom("@0*@0 * (@1+@2)*abs(1-@3)", kbottom, SM_BR_hbb, SM_BR_hss, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_gluon("@0*@0 * @1*abs(1-@2)", kgluon, SM_BR_hgluglu, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('expr::CMS_zz4l_Gscal_gamma("@0*@0 * (@1+@2)*abs(1-@3)", kgamma, SM_BR_hgg, SM_BR_hzg, CMS_zz4l_scalerK)')
self.modelBuilder.factory_('sum::gammaK(CMS_zz4l_Gscal_Vectors, CMS_zz4l_Gscal_tau, CMS_zz4l_Gscal_top, CMS_zz4l_Gscal_bottom, CMS_zz4l_Gscal_gluon, CMS_zz4l_Gscal_gamma, CMS_zz4l_scalerK)')
self.SMH = SMHiggsBuilder(self.modelBuilder)
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]: self.SMH.makeBR(d)
if self.useKframework:
self.modelBuilder.out.var("CMS_zz4l_scalerK").setVal(0.0)
else:
self.modelBuilder.out.var("CMS_zz4l_scalerK").setVal(1.0)
if not self.is2l2nu:
self.modelBuilder.out.var("SM_BR_hww").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hww").setConstant(True)
self.modelBuilder.out.var("SM_BR_hzz").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hzz").setConstant(True)
self.modelBuilder.out.var("SM_BR_htt").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hmm").setVal(0.0)
self.modelBuilder.out.var("SM_BR_htt").setConstant(True)
self.modelBuilder.out.var("SM_BR_hmm").setConstant(True)
self.modelBuilder.out.var("SM_BR_htoptop").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hcc").setVal(0.0)
self.modelBuilder.out.var("SM_BR_htoptop").setConstant(True)
self.modelBuilder.out.var("SM_BR_hcc").setConstant(True)
self.modelBuilder.out.var("SM_BR_hbb").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hss").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hbb").setConstant(True)
self.modelBuilder.out.var("SM_BR_hss").setConstant(True)
self.modelBuilder.out.var("SM_BR_hgluglu").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hgg").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hgluglu").setConstant(True)
self.modelBuilder.out.var("SM_BR_hgg").setConstant(True)
self.modelBuilder.out.var("SM_BR_hzg").setVal(0.0)
self.modelBuilder.out.var("SM_BR_hzg").setConstant(True)
self.modelBuilder.out.var("CMS_zz4l_scalerK").setConstant(True)
if self.GGsmfixed:
self.modelBuilder.out.var("CMS_zz4l_GGsm")
self.modelBuilder.out.var("CMS_zz4l_GGsm").setVal(1)
self.modelBuilder.out.var("CMS_zz4l_GGsm").setConstant(True)
print "Fixing CMS_zz4l_GGsm"
if self.RVRFfixed:
self.modelBuilder.out.var("kV").setVal(1)
self.modelBuilder.out.var("kV").setConstant(True)
self.modelBuilder.out.var("kgluon").setVal(1)
self.modelBuilder.out.var("kgluon").setConstant(True)
poi = "R"
else:
self.modelBuilder.out.var("R").setVal(1)
self.modelBuilder.out.var("R").setConstant(True)
poi = "kV,kgluon"
else:
#self.modelBuilder.out.var("CMS_zz4l_GGsm").setVal(1)
#self.modelBuilder.out.var("CMS_zz4l_GGsm").setRange(0.0001,30.0001)
self.modelBuilder.out.var("kgluon").setVal(1)
self.modelBuilder.out.var("kV").setVal(1)
self.modelBuilder.out.var("R").setVal(1)
self.modelBuilder.out.var("CMS_widthH_kbkg")
self.modelBuilder.out.var("CMS_widthH_kbkg").setVal(1)
self.modelBuilder.out.var("CMS_widthH_ww_kbkg")
self.modelBuilder.out.var("CMS_widthH_ww_kbkg").setVal(1)
if self.RVRFfixed:
self.modelBuilder.out.var("R").setRange(0.0,4.0)
self.modelBuilder.out.var("kV").setConstant(True)
self.modelBuilder.out.var("kgluon").setConstant(True)
else:
self.modelBuilder.out.var("kV").setRange(0.0,100.0)
self.modelBuilder.out.var("kgluon").setRange(0.0,100.0)
#self.modelBuilder.out.var("kV").setRange(0.0,8.0)
#self.modelBuilder.out.var("kgluon").setRange(0.0,4.0)
self.modelBuilder.out.var("R").setConstant(True)
poi = "CMS_zz4l_GGsm"
self.modelBuilder.factory_("expr::kgluon_WW(\"@0*@1\",kgluon,xsr_ggH)")
self.modelBuilder.factory_("expr::kV_WW(\"@0*@1\",kV,xsr_qqH)")
self.modelBuilder.factory_("expr::kgluon_ZZ(\"@0*@1\",kgluon,lambdaWZ)")
self.modelBuilder.factory_("expr::kV_ZZ(\"@0*@1\",kV,lambdaWZ)")
self.modelBuilder.factory_("expr::ggH_s_func(\"@0*@3*@1*@4-sqrt(@0*@3*@1*@4*@2)\",R,CMS_zz4l_GGsm,CMS_widthH_kbkg,kgluon_ZZ,gammaK)")
self.modelBuilder.factory_("expr::ggH_b_func(\"@2-sqrt(@0*@3*@1*@4*@2)\",R,CMS_zz4l_GGsm,CMS_widthH_kbkg,kgluon_ZZ,gammaK)")
self.modelBuilder.factory_("expr::ggH_sbi_func(\"sqrt(@0*@3*@1*@4*@2)\",R,CMS_zz4l_GGsm,CMS_widthH_kbkg,kgluon_ZZ,gammaK)")
self.modelBuilder.factory_("expr::qqH_s_func(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_ZZ,gammaK)")
self.modelBuilder.factory_("expr::qqH_b_func(\"1-sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_ZZ,gammaK)")
self.modelBuilder.factory_("expr::qqH_sbi_func(\"sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_ZZ,gammaK)")
# CMS_widthH_ww_kbkg uncertainty for WW
self.modelBuilder.factory_("expr::ggH_s_funcWW(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3*@4)\",R,CMS_zz4l_GGsm,kgluon_WW,gammaK,CMS_widthH_ww_kbkg)")
self.modelBuilder.factory_("expr::ggH_b_funcWW(\"@4-sqrt(@0*@2*@1*@3*@4)\",R,CMS_zz4l_GGsm,kgluon_WW,gammaK,CMS_widthH_ww_kbkg)")
self.modelBuilder.factory_("expr::ggH_sbi_funcWW(\"sqrt(@0*@2*@1*@3*@4)\",R,CMS_zz4l_GGsm,kgluon_WW,gammaK,CMS_widthH_ww_kbkg)")
self.modelBuilder.factory_("expr::qqH_s_funcWW(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_b_funcWW(\"1-sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_sbi_funcWW(\"sqrt(@0*@2*@1*@3)\",R,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::ggH_s_funcWW_1j(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kgluon_WW,gammaK)")
self.modelBuilder.factory_("expr::ggH_b_funcWW_1j(\"1-sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kgluon_WW,gammaK)")
self.modelBuilder.factory_("expr::ggH_sbi_funcWW_1j(\"sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kgluon_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_s_funcWW_1j(\"@0*@2*@1*@3-sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_b_funcWW_1j(\"1-sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.factory_("expr::qqH_sbi_funcWW_1j(\"sqrt(@0*@2*@1*@3)\",R1j,CMS_zz4l_GGsm,kV_WW,gammaK)")
self.modelBuilder.doSet("POI",poi)
class PartialWidthsModel(SMLikeHiggsModel):
"As in ATL-PHYS-PUB-2012-004"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("r_WZ[1,0.0,1.0]") # bounded to 1
self.modelBuilder.doVar("r_gZ[1,0.0,2.0]")
self.modelBuilder.doVar("r_tZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_bZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_mZ[1,0.0,4.0]")
self.modelBuilder.doVar("r_topglu[1,0.0,4.0]")
self.modelBuilder.doVar("r_Zglu[1,0.0,4.0]")
self.modelBuilder.doVar("c_gluZ[1,0.0,3.0]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'r_WZ,r_gZ,r_tZ,r_bZ,r_mZ,r_topglu,r_Zglu,c_gluZ,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'r_WZ,r_gZ,r_tZ,r_bZ,r_mZ,r_topglu,r_Zglu,c_gluZ')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.modelBuilder.doVar("PW_one[1]")
self.modelBuilder.factory_("prod::sr_WZ(r_WZ,r_WZ)")
self.modelBuilder.factory_("prod::sr_bZ(r_bZ,r_bZ)")
self.modelBuilder.factory_("prod::sr_tZ(r_tZ,r_tZ)")
self.modelBuilder.factory_("prod::sr_mZ(r_mZ,r_mZ)")
self.modelBuilder.factory_("prod::sr_gZ(r_gZ,r_gZ)")
self.modelBuilder.factory_("prod::sr_Zglu(r_Zglu,r_Zglu)")
self.modelBuilder.factory_("prod::sr_topglu(r_topglu,r_topglu)")
self.modelBuilder.factory_("prod::sc_gluZ(c_gluZ,c_gluZ)")
self.modelBuilder.factory_("prod::PW_XSscal_WH(sr_Zglu,sr_WZ)")
#self.modelBuilder.factory_("expr::PW_lambdaWZ(\"sqrt(@0)\",sr_WZ)")
#self.SMH.makeScaling("qqH", CW='PW_lambdaWZ', CZ="PW_one")
self.SMH.makeScaling("qqH", CW='r_WZ', CZ="PW_one")
self.modelBuilder.factory_("prod::PW_XSscal_qqH_7TeV(Scaling_qqH_7TeV,sr_Zglu)")
self.modelBuilder.factory_("prod::PW_XSscal_qqH_8TeV(Scaling_qqH_8TeV,sr_Zglu)")
self.decayScales_ = {
'hzz' : 'PW_one',
'hww' : 'sr_WZ',
'hbb' : 'sr_bZ',
'htt' : 'sr_tZ',
'hmm' : 'sr_mZ',
'hgg' : 'sr_gZ',
'hss' : 'sr_bZ',
'hcc' : 'PW_one', #
'hgluglu' : 'PW_one', #
'hzg' : 'PW_one', #
}
self.prodScales_ = {
'ggH' : 'PW_one',
'qqH' : 'PW_XSscal_qqH',
'WH' : 'PW_XSscal_WH',
'ZH' : 'sr_Zglu',
'ttH' : 'sr_topglu',
}
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "c7_XSBRscal_%s_%s" % (production,decay)
if production == 'qqH': name += "_%s" % energy
if self.modelBuilder.out.function(name):
return name
dscale = self.decayScales_[decay]
pscale = self.prodScales_[production]
if production == "qqH": pscale += "_%s" % energy
print '[LOFullParametrization::PartialWidthModel]: ', name, production, decay, energy, pscale, dscale
self.modelBuilder.factory_("prod::%s(%s,sc_gluZ,%s)" % (name, dscale, pscale))
return name
class CwzHiggs(SMLikeHiggsModel):
"Scale w and z and touch nothing else"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self, physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=", "").split(",")
print("The Higgs mass range:", self.mHRange)
if len(self.mHRange) != 2:
raise RuntimeError("Higgs mass range definition requires two extrema.")
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError(
"Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
)
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("Cwz[1,0,10]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0], self.mHRange[1]))
self.modelBuilder.doSet("POI", "Cwz,MH")
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI", "Cwz")
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
for d in ["hww", "hzz"]:
self.SMH.makeBR(d)
self.modelBuilder.doVar("Cz[1,0,10]")
self.modelBuilder.factory_('expr::Cw("@0*@1",Cz, Cwz)')
## total witdhs, normalized to the SM one
self.modelBuilder.factory_(
'expr::Cwz_Gscal_tot("@0*@1 + @2*@3 + (1.0-@1-@3)", \
Cw, SM_BR_hww, Cz, SM_BR_hzz)'
)
## BRs, normalized to the SM ones: they scale as (partial/partial_SM) / (total/total_SM)
self.modelBuilder.factory_('expr::Cwz_BRscal_hww("@0/@1", Cw, Cwz_Gscal_tot)')
self.modelBuilder.factory_('expr::Cwz_BRscal_hzz("@0/@1", Cz, Cwz_Gscal_tot)')
datadir = os.environ["CMSSW_BASE"] + "/src/combine/data/lhc-hxswg"
for e in ["7TeV", "8TeV"]:
print("build for %s" % e)
self.SMH.textToSpline("RqqH_%s" % e, os.path.join(datadir, "couplings/R_VBF_%s.txt" % e), ycol=1)
self.modelBuilder.factory_(
'expr::Cwz_XSscal_qqH_%s("(@0 + @1*@2) / (1.0 + @2) ", Cw, Cz, RqqH_%s)' % (e, e)
)
self.modelBuilder.factory_('expr::Cwz_XSscal_WH_%s("@0", Cw)' % e)
self.modelBuilder.factory_('expr::Cwz_XSscal_ZH_%s("@0", Cz)' % e)
self.SMH.makeXS("WH", e)
self.SMH.makeXS("ZH", e)
self.modelBuilder.factory_(
'expr::Cwz_XSscal_VH_%s("(@0*@1 + @2*@3) / (@1 + @3) ", Cw, SM_XS_WH_%s, Cz, SM_XS_ZH_%s)' % (e, e, e)
)
def getHiggsSignalYieldScale(self, production, decay, energy):
if decay not in ["hww", "hzz"]:
return 0
name = "Cwz_XSBRscal_%s_%s_%s" % (production, decay, energy)
if self.modelBuilder.out.function(name) == None:
if production in ["ggH", "ttH"]:
self.modelBuilder.factory_('expr::%s("@0", Cwz_BRscal_%s)' % (name, decay))
else:
self.modelBuilder.factory_(
'expr::%s("@0 * @1", Cwz_XSscal_%s_%s, Cwz_BRscal_%s)' % (name, production, energy, decay)
)
return name
class CvCfHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.cVRange = ['0','2']
self.cFRange = ['-2','2']
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
if po.startswith("cVRange="):
self.cVRange = po.replace("cVRange=","").split(":")
if len(self.cVRange) != 2:
raise RuntimeError, "cV signal strength range requires minimal and maximal value"
elif float(self.cVRange[0]) >= float(self.cVRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
if po.startswith("cFRange="):
self.cFRange = po.replace("cFRange=","").split(":")
if len(self.cFRange) != 2:
raise RuntimeError, "cF signal strength range requires minimal and maximal value"
elif float(self.cFRange[0]) >= float(self.cFRange[1]):
raise RuntimeError, "minimal and maximal range swapped. Second value must be larger first one"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("CV[1,%s,%s]" % (self.cVRange[0], self.cVRange[1]))
self.modelBuilder.doVar("CF[1,%s,%s]" % (self.cFRange[0], self.cFRange[1]))
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'CV,CF,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'CV,CF')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.decayScaling = {
'hgg':'hgg',
'hzg':'hzg',
'hww':'hvv',
'hzz':'hvv',
'hbb':'hff',
'hcc':'hff',
'hss':'hff',
'htt':'hff',
'hmm':'hff',
'hgluglu':'hff',
}
self.productionScaling = {
'ggH':'CF',
'ttH':'CF',
'qqH':'CV',
'WH':'CV',
'ZH':'CV',
'VH':'CV',
}
self.SMH.makeScaling('hgg', Cb='CF', Ctop='CF', CW='CV', Ctau='CF')
self.SMH.makeScaling('hzg', Cb='CF', Ctop='CF', CW='CV', Ctau='CF')
# Ideas for a cleaner future
# self.SMH.makeScaling('hww', 'CV*CV') -> Scaling_hww("@0*@0",CV)
# self.SMH.makeScaling('total', hbb='CF*CF', htoptop='CF*CF', hww='CV*CV', hzz='CV', hgg='Scaling_hgg', hgluglu='Scaling_hgluglu' )
## partial widths, normalized to the SM one, for decays scaling with F, V and total
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
self.modelBuilder.factory_('expr::CvCf_Gscal_sumf("@0*@0 * (@1+@2+@3+@4+@5+@6+@7)", CF, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hgluglu, SM_BR_hmm, SM_BR_hss)')
self.modelBuilder.factory_('expr::CvCf_Gscal_sumv("@0*@0 * (@1+@2)", CV, SM_BR_hww, SM_BR_hzz)')
self.modelBuilder.factory_('expr::CvCf_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::CvCf_Gscal_Zg("@0 * @1", Scaling_hzg, SM_BR_hzg)')
self.modelBuilder.factory_('sum::CvCf_Gscal_tot(CvCf_Gscal_sumf, CvCf_Gscal_sumv, CvCf_Gscal_gg, CvCf_Gscal_Zg)')
## BRs, normalized to the SM ones: they scale as (coupling/coupling_SM)^2 / (totWidth/totWidthSM)^2
self.modelBuilder.factory_('expr::CvCf_BRscal_hgg("@0/@1", Scaling_hgg, CvCf_Gscal_tot)')
self.modelBuilder.factory_('expr::CvCf_BRscal_hzg("@0/@1", Scaling_hzg, CvCf_Gscal_tot)')
self.modelBuilder.factory_('expr::CvCf_BRscal_hff("@0*@0/@1", CF, CvCf_Gscal_tot)')
self.modelBuilder.factory_('expr::CvCf_BRscal_hvv("@0*@0/@1", CV, CvCf_Gscal_tot)')
self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "CvCf_XSBRscal_%s_%s" % (production,decay)
if self.modelBuilder.out.function(name):
return name
XSscal = self.productionScaling[production]
BRscal = self.decayScaling[decay]
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, CvCf_BRscal_%s)' % (name, XSscal, BRscal))
return name
class C5qlHiggs(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
self.universalCF = False
self.fix = []
def setPhysicsOptions(self, physOptions):
for po in physOptions:
if po == "universalCF":
universalCF = True
if po.startswith("fix="):
self.fix = po.replace("fix=", "").split(",")
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=", "").split(",")
print("The Higgs mass range:", self.mHRange)
if len(self.mHRange) != 2:
raise RuntimeError("Higgs mass range definition requires two extrema")
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError(
"Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
)
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
# --- Signal Strength as only POI ---
self.modelBuilder.doVar("Cg[1,0,10]")
self.modelBuilder.doVar("Cv[1,0,10]")
self.modelBuilder.doVar("Cglu[1,0,10]")
POI = "Cg,Cv,Cglu"
if self.universalCF:
self.modelBuilder.doVar("Cf[1,0,10]")
POI += ",Cf"
else:
self.modelBuilder.doVar("Cq[1,0,10]")
self.modelBuilder.doVar("Cl[1,0,10]")
POI += ",Cq,Cl"
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]), float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0], self.mHRange[1]))
POI += ",MH"
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
for F in self.fix:
self.modelBuilder.out.var(F).setConstant(True)
if F + "," in POI:
POI = POI.replace(F + ",", "")
else:
POI = POI.replace("," + F, "")
self.modelBuilder.doSet("POI", POI)
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
for d in ["htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss"]:
self.SMH.makeBR(d)
## total witdhs, normalized to the SM one
self.modelBuilder.factory_('expr::C5ql_Gscal_sumglu("@0*@0 * @1", Cglu, SM_BR_hgluglu)')
self.modelBuilder.factory_('expr::C5ql_Gscal_sumg("@0*@0 * @1", Cg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::C5ql_Gscal_sumv("@0*@0 * (@1+@2+@3)", Cv, SM_BR_hww, SM_BR_hzz, SM_BR_hzg )')
if self.universalCF:
self.modelBuilder.factory_(
'expr::C5ql_Gscal_sumf("@0*@0 * (@1+@2+@3+@4+@5+@6)",\
Cf, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hmm, SM_BR_hss)'
)
else:
self.modelBuilder.factory_(
'expr::C5ql_Gscal_sumf("@0*@0 * (@1+@2+@3+@4) + @5*@5 * (@6+@7)",\
Cq, SM_BR_hbb, SM_BR_hcc, SM_BR_htoptop, SM_BR_hss,\
Cl, SM_BR_htt, SM_BR_hmm)'
)
self.modelBuilder.factory_(
"sum::C5ql_Gscal_tot(C5ql_Gscal_sumglu, C5ql_Gscal_sumg, C5ql_Gscal_sumv, C5ql_Gscal_sumf)"
)
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_('expr::C5ql_BRscal_hgg("@0*@0/@1", Cg, C5ql_Gscal_tot)')
self.modelBuilder.factory_('expr::C5ql_BRscal_hvv("@0*@0/@1", Cv, C5ql_Gscal_tot)')
if self.universalCF:
self.modelBuilder.factory_('expr::C5ql_BRscal_hff("@0*@0/@1", Cf, C5ql_Gscal_tot)')
else:
self.modelBuilder.factory_('expr::C5ql_BRscal_hbb("@0*@0/@1", Cq, C5ql_Gscal_tot)')
self.modelBuilder.factory_('expr::C5ql_BRscal_htt("@0*@0/@1", Cl, C5ql_Gscal_tot)')
def getHiggsSignalYieldScale(self, production, decay, energy):
name = "C5ql_XSBRscal_%s_%s" % (production, decay)
if self.modelBuilder.out.function(name) == None:
XSscal = "Cglu" if production in ["ggH"] else "Cv"
if production in ["ttH"]:
XSscal = "Cf" if self.universalCF else "Cq"
BRscal = "hgg"
if decay in ["hww", "hzz"]:
BRscal = "hvv"
if decay in ["hbb", "htt"]:
BRscal = "hff" if self.universalCF else decay
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, C5ql_BRscal_%s)' % (name, XSscal, BRscal))
return name
class LambdaWZHiggs(SMLikeHiggsModel):
def __init__(self):
SMLikeHiggsModel.__init__(self)
self.floatMass = False
self.floatKF = True
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema."
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrema for Higgs mass range defined with inverterd order. Second must be larger the first."
if po == "fixKF":
self.floatKF = False
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kZ[1,0,2]")
if self.floatKF:
self.modelBuilder.doVar("kf[1,0,2]")
else:
self.modelBuilder.doVar("kf[1]")
self.modelBuilder.doVar("lambdaWZ[1,0,2]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'kZ,lambdaWZ,kf,MH' if self.floatKF else 'kZ,lambdaWZ,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'kZ,lambdaWZ,kf' if self.floatKF else 'kZ,lambdaWZ')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.decayScaling = {
'hgg':'hgg',
'hzg':'hzg',
'hww':'hww',
'hzz':'hzz',
'hbb':'hff',
'htt':'hff',
'hmm':'hff',
'hcc':'hff',
'hss':'hff',
'hgluglu':'hff',
}
self.productionScaling = {
'ggH':'kf',
'ttH':'kf',
'WH':'kW',
'ZH':'kZ',
}
# define kW as lambdaWZ*kZ
self.modelBuilder.factory_('expr::kW("@0*@1",kZ, lambdaWZ)')
# scalings of the loops
self.SMH.makeScaling('hgg', Cb='kf', Ctop='kf', CW='kW', Ctau='kf')
self.SMH.makeScaling('hzg', Cb='kf', Ctop='kf', CW='kW', Ctau='kf')
self.SMH.makeScaling('qqH', CW='kW', CZ='kZ')
# SM BR
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hzg", "hmm", "hss" ]:
self.SMH.makeBR(d)
## total witdhs, normalized to the SM one
self.modelBuilder.factory_('expr::lambdaWZ_Gscal_Z("@0*@0 * @1", kZ, SM_BR_hzz)')
self.modelBuilder.factory_('expr::lambdaWZ_Gscal_W("@0*@0 * @1", kW, SM_BR_hww)')
self.modelBuilder.factory_('expr::lambdaWZ_Gscal_fermions("@0*@0 * (@1+@2+@3+@4+@5+@6+@7)", kf, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hgluglu, SM_BR_hmm, SM_BR_hss)')
self.modelBuilder.factory_('expr::lambdaWZ_Gscal_gg("@0 * @1", Scaling_hgg, SM_BR_hgg)')
self.modelBuilder.factory_('expr::lambdaWZ_Gscal_Zg("@0 * @1", Scaling_hzg, SM_BR_hzg)')
self.modelBuilder.factory_('sum::lambdaWZ_Gscal_tot(lambdaWZ_Gscal_Z, lambdaWZ_Gscal_W, lambdaWZ_Gscal_fermions, lambdaWZ_Gscal_gg, lambdaWZ_Gscal_Zg)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM) / (total/total_SM)
self.modelBuilder.factory_('expr::lambdaWZ_BRscal_hzz("@0*@0/@1", kZ, lambdaWZ_Gscal_tot)')
self.modelBuilder.factory_('expr::lambdaWZ_BRscal_hww("@0*@0/@1", kW, lambdaWZ_Gscal_tot)')
self.modelBuilder.factory_('expr::lambdaWZ_BRscal_hff("@0*@0/@1", kf, lambdaWZ_Gscal_tot)')
self.modelBuilder.factory_('expr::lambdaWZ_BRscal_hgg("@0/@1", Scaling_hgg, lambdaWZ_Gscal_tot)')
self.modelBuilder.factory_('expr::lambdaWZ_BRscal_hzg("@0/@1", Scaling_hzg, lambdaWZ_Gscal_tot)')
# verbosity
#self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = 'lambdaWZ_XSBRscal_%(production)s_%(decay)s' % locals()
#Special case that depends on Energy
if production == 'qqH':
self.productionScaling[production]='Scaling_qqH_'+energy
name += '_%(energy)s' % locals()
if self.modelBuilder.out.function(name):
return name
try:
BRscal = self.decayScaling[decay]
XSscal = self.productionScaling[production]
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, lambdaWZ_BRscal_%s)' % (name, XSscal, BRscal))
return name
except KeyError:
if production == "VH":
print "WARNING: You are trying to use a VH production mode in a model that needs WH and ZH separately. "\
"The best I can do is to scale [%(production)s, %(decay)s, %(energy)s] with the decay BR only but this is wrong..." % locals()
self.modelBuilder.factory_('expr::%s("1.0*@0", lambdaWZ_BRscal_%s)' % (name, BRscal))
return name
raise
class HiggsLoopsInvisible(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kgluon[1,0,2]")
self.modelBuilder.doVar("kgamma[1,0,3]")
self.modelBuilder.doVar("BRInvUndet[0,0,1]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'kgluon,kgamma,BRInvUndet,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'kgluon,kgamma,BRInvUndet')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.decayScaling = {
'hgg':'hgg',
'hZg':'hxx',
'hww':'hxx',
'hzz':'hxx',
'hbb':'hxx',
'htt':'hxx',
}
# SM BR
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hZg", "hmm", "hss" ]:
self.SMH.makeBR(d)
## total witdh, normalized to the SM one
self.modelBuilder.factory_('sum::loopGluonGamma_Gscal_OtherDecays(SM_BR_hbb, SM_BR_htt, SM_BR_hmm, SM_BR_hss, SM_BR_hzz, SM_BR_hww, SM_BR_hcc, SM_BR_htoptop, SM_BR_hZg)')
self.modelBuilder.factory_('expr::loopGluonGamma_Gscal_gg("@0*@0* @1", kgamma, SM_BR_hgg)')
self.modelBuilder.factory_('expr::loopGluonGamma_Gscal_gluglu("@0*@0* @1", kgluon, SM_BR_hgluglu)')
self.modelBuilder.factory_('expr::loopGluonGamma_Gscal_tot("(@1+@2+@3)/(1.0-@0)", BRInvUndet, loopGluonGamma_Gscal_OtherDecays, loopGluonGamma_Gscal_gg, loopGluonGamma_Gscal_gluglu)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_('expr::loopGluonGamma_BRscal_hxx("1.0/@0",loopGluonGamma_Gscal_tot)')
self.modelBuilder.factory_('expr::loopGluonGamma_BRscal_hgg("@0*@0/@1", kgamma, loopGluonGamma_Gscal_tot)')
# verbosity
#self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "loopGluonGamma_XSBRscal_%s_%s" % (production,decay)
if self.modelBuilder.out.function(name):
return name
BRscal = self.decayScaling[decay]
if production == "ggH":
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", kgluon, loopGluonGamma_BRscal_%s)' % (name, BRscal))
else:
self.modelBuilder.factory_('expr::%s("1.0 * @0", loopGluonGamma_BRscal_%s)' % (name, BRscal))
return name
class HiggsMinimal(SMLikeHiggsModel):
"assume the SM coupling but let the Higgs mass to float"
def __init__(self):
SMLikeHiggsModel.__init__(self) # not using 'super(x,self).__init__' since I don't understand it
self.floatMass = False
def setPhysicsOptions(self,physOptions):
for po in physOptions:
if po.startswith("higgsMassRange="):
self.floatMass = True
self.mHRange = po.replace("higgsMassRange=","").split(",")
print 'The Higgs mass range:', self.mHRange
if len(self.mHRange) != 2:
raise RuntimeError, "Higgs mass range definition requires two extrema"
elif float(self.mHRange[0]) >= float(self.mHRange[1]):
raise RuntimeError, "Extrama for Higgs mass range defined with inverterd order. Second must be larger the first"
def doParametersOfInterest(self):
"""Create POI out of signal strength and MH"""
self.modelBuilder.doVar("kgluon[1,0,2]")
self.modelBuilder.doVar("kgamma[1,0,3]")
self.modelBuilder.doVar("kV[1,0,3]")
self.modelBuilder.doVar("kf[1,0,3]")
if self.floatMass:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setRange(float(self.mHRange[0]),float(self.mHRange[1]))
self.modelBuilder.out.var("MH").setConstant(False)
else:
self.modelBuilder.doVar("MH[%s,%s]" % (self.mHRange[0],self.mHRange[1]))
self.modelBuilder.doSet("POI",'kgluon,kgamma,kV,kf,MH')
else:
if self.modelBuilder.out.var("MH"):
self.modelBuilder.out.var("MH").setVal(self.options.mass)
self.modelBuilder.out.var("MH").setConstant(True)
else:
self.modelBuilder.doVar("MH[%g]" % self.options.mass)
self.modelBuilder.doSet("POI",'kgluon,kgamma,kV,kf')
self.SMH = SMHiggsBuilder(self.modelBuilder)
self.setup()
def setup(self):
self.decayScaling = {
'hgg':'hgg',
'hZg':'hZg',
'hww':'hvv',
'hzz':'hvv',
'hbb':'hff',
'htt':'hff',
}
self.productionScaling = {
'ggH':'kgluon',
'ttH':'kf',
'qqH':'kV',
'WH':'kV',
'ZH':'kV',
'VH':'kV',
}
self.SMH.makeScaling('hZg', Cb='kf', Ctop='kf', CW='kV', Ctau='kf')
# SM BR
for d in [ "htt", "hbb", "hcc", "hww", "hzz", "hgluglu", "htoptop", "hgg", "hZg", "hmm", "hss" ]:
self.SMH.makeBR(d)
## total witdh, normalized to the SM one
self.modelBuilder.factory_('expr::minimal_Gscal_gg("@0*@0 * @1", kgamma, SM_BR_hgg)')
self.modelBuilder.factory_('expr::minimal_Gscal_gluglu("@0*@0 * @1", kgluon, SM_BR_hgluglu)')
self.modelBuilder.factory_('expr::minimal_Gscal_sumf("@0*@0 * (@1+@2+@3+@4+@5+@6)", kf, SM_BR_hbb, SM_BR_htt, SM_BR_hcc, SM_BR_htoptop, SM_BR_hmm, SM_BR_hss)')
self.modelBuilder.factory_('expr::minimal_Gscal_sumv("@0*@0 * (@1+@2)", kV, SM_BR_hww, SM_BR_hzz)')
self.modelBuilder.factory_('expr::minimal_Gscal_Zg("@0 * @1", Scaling_hZg, SM_BR_hZg)')
self.modelBuilder.factory_('sum::minimal_Gscal_tot(minimal_Gscal_sumf, minimal_Gscal_sumv, minimal_Gscal_Zg, minimal_Gscal_gg, minimal_Gscal_gluglu)')
## BRs, normalized to the SM ones: they scale as (partial/partial_SM)^2 / (total/total_SM)^2
self.modelBuilder.factory_('expr::minimal_BRscal_hgg("@0*@0/@1", kgamma, minimal_Gscal_tot)')
self.modelBuilder.factory_('expr::minimal_BRscal_hZg("@0/@1", Scaling_hZg, minimal_Gscal_tot)')
self.modelBuilder.factory_('expr::minimal_BRscal_hff("@0*@0/@1", kf, minimal_Gscal_tot)')
self.modelBuilder.factory_('expr::minimal_BRscal_hvv("@0*@0/@1", kV, minimal_Gscal_tot)')
# verbosity
#self.modelBuilder.out.Print()
def getHiggsSignalYieldScale(self,production,decay,energy):
name = "minimal_XSBRscal_%s_%s" % (production,decay)
if self.modelBuilder.out.function(name):
return name
XSscal = self.productionScaling[production]
BRscal = self.decayScaling[decay]
self.modelBuilder.factory_('expr::%s("@0*@0 * @1", %s, minimal_BRscal_%s)' % (name, XSscal, BRscal))
return name
