def testRuntimeImport(self):
filename = "./testFiles/slha/gluino_squarks.slha"
runtime.modelFile = 'mssm'
reload(particlesLoader)
from smodels.particlesLoader import BSMList
model = Model(BSMparticles=BSMList, SMparticles=SMList)
model.updateParticles(filename)
runtime.modelFile = 'mssmQNumbers.slha'
reload(particlesLoader)
from smodels.particlesLoader import BSMList
modelB = Model(BSMparticles=BSMList, SMparticles=SMList)
modelB.updateParticles(filename)
for ptc in model.BSMparticles:
ptcB = modelB.getParticlesWith(pdg = ptc.pdg)
if not ptcB: #If particule is its own anti-particle, it should not appear in modelB
ptcB = modelB.getParticlesWith(pdg = -ptc.pdg)
self.assertEqual(len(ptcB),1)
ptcB = ptcB[0]
for attr,val in ptc.__dict__.items():
if attr in ['_id','label','_comp','pdg','_isInvisible']:
continue
valB = getattr(ptcB,attr)
if attr == 'decays':
self.assertEqual(len(val),len(valB))
continue
self.assertEqual(val,valB)
def checkPrediction(self, slhafile, expID, expectedValues, datasetID):
reducedModel = [
ptc for ptc in BSMList if abs(ptc.pdg) in [1000011, 1000012]
]
model = Model(reducedModel, SMList)
model.updateParticles(slhafile)
self.configureLogger()
smstoplist = decomposer.decompose(model,
0. * fb,
doCompress=True,
doInvisible=True,
minmassgap=5. * GeV)
expresults = database.getExpResults(analysisIDs=expID,
datasetIDs=datasetID)
for expresult in expresults:
theorypredictions = theoryPredictionsFor(expresult, smstoplist)
for pred in theorypredictions:
predval = pred.xsection.value
expval = expectedValues.pop()
delta = expval * 0.01
self.assertAlmostEqual(predval.asNumber(fb),
expval,
delta=delta)
self.assertTrue(len(expectedValues) == 0)
def __init__(self,
filename,
findMissingDecayBlocks=True,
findIllegalDecays=False,
checkXsec=True):
"""
:parameter filename: path to input SLHA file
:parameter findMissingDecayBlocks: if True add a warning for missing decay blocks
:parameter findIllegalDecays: if True check if all decays are kinematically allowed
:parameter checkXsec: if True check if SLHA file contains cross sections
:parameter findLonglived: if True find stable charged particles and displaced vertices
"""
self.filename = filename
self.slha = self.read()
from smodels.particlesLoader import BSMList
if not self.slha:
self.status = -3, "Could not read input SLHA file"
return
try:
model = Model(BSMList, SMList)
model.updateParticles(filename)
self.model = model
self.illegalDecays = self.findIllegalDecay(findIllegalDecays)
self.xsec = self.hasXsec(checkXsec)
self.decayBlocksStatus = self.findMissingDecayBlocks(
findMissingDecayBlocks)
self.status = self.evaluateStatus()
except (SModelSError, TypeError, IOError, ValueError,
AttributeError) as e:
self.status = -4, "Error checking SLHA file: " + str(e)
def runPrinterMain(self, slhafile, mprinter, addTopList=False):
"""
Main program. Displays basic use case.
"""
runtime.modelFile = 'mssm'
reload(particlesLoader)
#Set main options for decomposition:
sigmacut = 0.03 * fb
mingap = 5. * GeV
""" Decompose model """
model = Model(BSMList, SMList)
model.updateParticles(slhafile)
smstoplist = decomposer.decompose(model,
sigmacut,
doCompress=True,
doInvisible=True,
minmassgap=mingap)
#Add the decomposition result to the printers
if addTopList:
mprinter.addObj(smstoplist)
listOfExpRes = database.getExpResults(analysisIDs=[
'*:8*TeV', 'CMS-PAS-SUS-15-002', 'CMS-PAS-SUS-16-024'
])
# Compute the theory predictions for each analysis
allPredictions = []
for expResult in listOfExpRes:
predictions = theoryPredictionsFor(expResult, smstoplist)
if not predictions:
continue
allPredictions += predictions._theoryPredictions
for theoPred in allPredictions:
if theoPred.dataType() == 'efficiencyMap' and hasattr(
theoPred,
'expectedUL') and not theoPred.expectedUL is None:
theoPred.computeStatistics()
maxcond = 0.2
theoryPredictions = TheoryPredictionList(allPredictions, maxcond)
mprinter.addObj(theoryPredictions)
#Add coverage information:
coverageInfo = coverage.Uncovered(smstoplist)
mprinter.addObj(coverageInfo)
#Add additional information:
databaseVersion = database.databaseVersion
outputStatus = ioObjects.OutputStatus(
[1, 'Input file ok'], slhafile, {
'sigmacut': sigmacut.asNumber(fb),
'minmassgap': mingap.asNumber(GeV),
'maxcond': maxcond
}, databaseVersion)
outputStatus.status = 1
mprinter.addObj(outputStatus)
mprinter.flush()
def testGraph(self):
""" draw ascii graph """
filename = "./testFiles/lhe/simplyGluino.lhe"
model = Model(BSMparticles = BSMList, SMparticles = SMList)
model.updateParticles(filename)
topList = decomposer.decompose(model, sigmacut=0)
element = topList.getElements()[0]
d1=self.orig().split("\n")
d2=asciiGraph.asciidraw(element, border=True ).split("\n")
self.assertEqual(d1,d2)
def testT1(self):
""" test with the T1 slha input file """
slhafile = "./testFiles/slha/simplyGluino.slha"
model = Model(BSMList, SMList)
model.updateParticles(inputFile=slhafile)
topos = decomposer.decompose(model, .1 * fb, False, False, 5. * GeV)
for topo in topos:
for element in topo.elementList:
masses = element.mass
# print "e=",element,"masses=",masses
mgluino = masses[0][0]
mLSP = masses[0][1]
self.assertEqual(str(element), "[[[q,q]],[[q,q]]]")
self.assertEqual(int(mgluino / GeV), 675)
self.assertEqual(int(mLSP / GeV), 200)
def testGoodFile(self):
filename = "./testFiles/slha/lightEWinos.slha"
model = Model(BSMList, SMList)
model.updateParticles(filename)
topolist = decomposer.decompose(model,
sigmacut=0.1 * fb,
doCompress=True,
doInvisible=True,
minmassgap=5 * GeV)
analyses = database.getExpResults(txnames=["TChiWZoff"],
analysisIDs='ATLAS-SUSY-2013-12')
theoryPrediction = theoryPredictionsFor(analyses[0], topolist)[0]
conditionViolation = theoryPrediction.conditions
self.assertEqual(
conditionViolation[
'Cgtr([[[mu+,mu-]],[[l,nu]]],[[[e+,e-]],[[l,nu]]])'], 0.)
def testIntegration(self):
slhafile = '../inputFiles/slha/simplyGluino.slha'
model = Model(BSMList, SMList)
model.updateParticles(slhafile)
self.configureLogger()
smstoplist = decomposer.decompose(model,
.1 * fb,
doCompress=True,
doInvisible=True,
minmassgap=5. * GeV)
listofanalyses = database.getExpResults(
analysisIDs=["ATLAS-SUSY-2013-02", "CMS-SUS-13-012"],
txnames=["T1"])
if type(listofanalyses) != list:
listofanalyses = [listofanalyses]
for analysis in listofanalyses:
self.checkAnalysis(analysis, smstoplist)
def testInvisibleNegative(self):
""" test the invisible compression, a negative example """
slhafile = "./testFiles/slha/higgsinoStop.slha"
model = Model(BSMList, SMList)
model.updateParticles(slhafile)
topos = decomposer.decompose(model, .1 * fb, False, True, 5. * GeV)
tested = False
for topo in topos:
if str(topo) != "[1,1][1,1]":
continue
for element in topo.elementList:
if str(element) != "[[[t+],[t-]],[[q],[W+]]]":
continue
tested = True
trueMothers = [
mother for mother in element.motherElements
if not mother is element
]
self.assertEqual(len(trueMothers), 0)
self.assertTrue(tested)
def testMass(self):
""" test the mass compression, a positive example """
tested = False
slhafile = "./testFiles/slha/higgsinoStop.slha"
model = Model(BSMList, SMList)
model.updateParticles(slhafile, promptWidth=1e-12 * GeV)
topos = decomposer.decompose(model, .1 * fb, True, False, 5. * GeV)
for topo in topos:
if str(topo) != "[1][1]":
continue
for element in topo.elementList:
if str(element) != "[[[b]],[[b]]]":
continue
masses = element.motherElements[0].mass
tested = True
dm = abs(masses[0][1] - masses[0][2]) / GeV
#If intermediate BSM states are compared there are two elements ([[[b],[c,q]],[[b],[q,q]]])
# which do not get combined because their branches differ by the charges of the intermediate states
self.assertEqual(len(element.motherElements), 24)
self.assertTrue(dm < 5.0)
self.assertTrue(tested)
def testApproxGaussian(self):
## turn experimental features on
from smodels.tools import runtime
runtime._experimental = True
expRes = database.getExpResults(analysisIDs=["CMS-PAS-SUS-12-026"])
self.assertTrue(len(expRes), 1)
filename = "./testFiles/slha/T1tttt.slha"
model = Model(BSMList, SMList)
model.updateParticles(filename)
smstoplist = decomposer.decompose(model, sigmacut=0)
prediction = theoryPredictionsFor(expRes[0], smstoplist)[0]
prediction.computeStatistics()
import numpy
tot = 0.
for i in numpy.arange(0., .2, .02):
tot += prediction.getLikelihood(i)
c = 0.
for i in numpy.arange(0., .2, .02):
l = prediction.getLikelihood(i)
c += l
self.assertAlmostEqual(prediction.likelihood, 1.563288e-35, 3)
def testClusteringEM(self):
slhafile = 'testFiles/slha/lightEWinos.slha'
model = Model(BSMparticles=BSMList, SMparticles=SMList)
model.updateParticles(slhafile)
sigmacut = 5. * fb
mingap = 5. * GeV
toplist = decomposer.decompose(model,
sigmacut,
doCompress=True,
doInvisible=True,
minmassgap=mingap)
#Test clustering for EM results
dataset = database.getExpResults(
analysisIDs='CMS-SUS-13-012',
datasetIDs='3NJet6_800HT1000_300MHT450')[0].getDataset(
'3NJet6_800HT1000_300MHT450')
el1 = toplist[0].elementList[0].copy()
el2 = toplist[0].elementList[1].copy()
el3 = toplist[2].elementList[1].copy()
el1.eff = 1. #(Used in clustering)
el2.eff = 1. #(Used in clustering)
el3.eff = 1. #(Used in clustering)
#All elements have the same UL (for EM results)
el1._upperLimit = el2._upperLimit = el3._upperLimit = 1. * fb
#Clustering should not depend on the mass, width or txname:
el1.txname = el2.txname = el3.txname = None
el1.mass = [[1000. * GeV, 10 * GeV]] * 2
el2.mass = [[1500. * GeV, 10 * GeV]] * 2
el3.mass = [[200. * GeV, 100 * GeV, 90. * GeV]] * 2
el3.totalwidth = [[1e-10 * GeV, 1e-15 * GeV, 0. * GeV]] * 2
clusters = clusterElements([el1, el2, el3],
maxDist=0.2,
dataset=dataset)
self.assertEqual(len(clusters), 1)
self.assertEqual(sorted(clusters[0].elements), sorted([el1, el2, el3]))
self.assertEqual(clusters[0].averageElement().mass, None)
self.assertEqual(clusters[0].averageElement().totalwidth, None)
def testInvisiblePositive(self):
""" test the invisible compression, a positive example """
slhafile = "./testFiles/slha/higgsinoStop.slha"
model = Model(BSMList, SMList)
model.updateParticles(slhafile)
topos = decomposer.decompose(model, .1 * fb, False, True, 5. * GeV)
tested = False
for topo in topos:
if str(topo) != "[][]":
continue
for element in topo.elementList:
if str(element) != "[[],[]]":
continue
tested = True
trueMothers = [
mother for mother in element.motherElements
if not mother is element
]
if not trueMothers: continue
self.assertEqual(str(trueMothers[0]), "[[],[[nu,nu]]]")
self.assertEqual(len(trueMothers), 1)
self.assertTrue(tested)
def testPredictionInterface(self):
""" A simple test to see that the interface in datasetObj
and TheoryPrediction to the statistics tools is working correctly
"""
expRes = database.getExpResults(analysisIDs=['CMS-SUS-13-012'])[0]
filename = "./testFiles/slha/simplyGluino.slha"
model = Model(BSMList, SMList)
model.updateParticles(filename)
smstoplist = decomposer.decompose(model, sigmacut=0)
prediction = theoryPredictionsFor(expRes, smstoplist)[0]
pred_signal_strength = prediction.xsection.value
prediction.computeStatistics()
ill = math.log(prediction.likelihood)
ichi2 = prediction.chi2
nsig = (pred_signal_strength * expRes.globalInfo.lumi).asNumber()
m = Data(4, 2.2, 1.1**2, None, nsignal=nsig, deltas_rel=0.2)
computer = LikelihoodComputer(m)
dll = math.log(computer.likelihood(nsig, marginalize=False))
self.assertAlmostEqual(ill, dll, places=2)
dchi2 = computer.chi2(nsig, marginalize=False)
# print ( "dchi2,ichi2",dchi2,ichi2)
self.assertAlmostEqual(ichi2, dchi2, places=2)
def testComplexCluster(self):
""" test the mass clusterer """
slhafile = 'testFiles/slha/416126634.slha'
model = Model(BSMparticles=BSMList, SMparticles=SMList)
model.updateParticles(slhafile)
sigmacut = 0.03 * fb
mingap = 5. * GeV
toplist = decomposer.decompose(model,
sigmacut,
doCompress=True,
doInvisible=True,
minmassgap=mingap)
#Test clustering for UL results
expResult = database.getExpResults(analysisIDs='CMS-SUS-16-039',
dataTypes='upperLimit')[0]
predictions = theoryPredictionsFor(expResult,
toplist,
combinedResults=False,
marginalize=False)
clusterSizes = sorted([len(p.elements) for p in predictions])
self.assertEqual(clusterSizes, [1, 16, 24])
def testCombinedResult(self):
predXSecs, rvalues = {}, {}
for case in ["T1", "T5", "mixed"]:
filename = self.createSLHAFile(case=case)
BSMList = [
gluino, st1, n1,
st1.chargeConjugate(),
n1.chargeConjugate(),
gluino.chargeConjugate()
]
model = Model(BSMList, SMList)
model.updateParticles(filename)
deco = decompose(model)
expRes = database.getExpResults(
analysisIDs=["CMS-SUS-16-050-agg"])[0]
# print ( "Experimental result: %s" % expRes )
tp = theoryPredictionsFor(expRes,
deco,
useBestDataset=False,
combinedResults=True)
for t in tp:
predXSecs[case] = t.xsection.value
rvalues[case] = t.getRValue(expected=True)
if True:
os.unlink(filename)
## first test: the theory prediction of the mixed scenario should be 25% of the sum
## 25%, because the total cross section is a fixed quantity, and half of the mixed scenario
## goes into asymmetric branches which we miss out on.
self.assertAlmostEqual(
(predXSecs["T1"] + predXSecs["T5"]).asNumber(fb),
(4 * predXSecs["mixed"]).asNumber(fb), 2)
## second test: the r value of the mixed scenario * 2 must be between the r values
## of the pure scenarios. The factor of two comes from the fact, that we loose 50%
## to asymmetric branches
self.assertTrue(rvalues["T5"] < 2 * rvalues["mixed"] < rvalues["T1"])
ret += _drawBranch(branch,
upwards=(ct == 0),
htmlFormat=html,
border=border,
l=max(l))
return ret
if __name__ == "__main__":
argparser = argparse.ArgumentParser(description="simple tool that is "
"meant to draw lessagraphs, as an "
"ascii plot")
argparser.add_argument('-l',
'--lhe',
help="LHE file name",
type=str,
required=True)
argparser.add_argument('-b',
'--border',
action='store_true',
help="draw a border around the graph")
args = argparser.parse_args()
filename = args.lhe
model = Model(BSMparticles=BSMList, SMparticles=SMList)
model.updateParticles(inputFile=filename)
topList = decomposer.decompose(model)
element = topList.getElements()[0]
print(asciidraw(element, border=args.border))
def runSModelS(self, inputFile, sigmacut, allpreds, llhdonly):
""" run smodels proper.
:param inputFile: the input slha file
:param sigmacut: the cut on the topology weights, typically 0.02*fb
:param allpreds: if true, return all predictions of analyses, else
only best signal region
:param llhdonly: if true, return only results with likelihoods
"""
if not os.path.exists(inputFile):
self.pprint("error, cannot find inputFile %s" % inputFile)
return []
model = Model(BSMList, SMList)
model.updateParticles(inputFile=inputFile)
mingap = 10 * GeV
# self.log ( "Now decomposing" )
topos = decomposer.decompose(model, sigmacut, minmassgap=mingap)
self.log("decomposed model into %d topologies." % len(topos))
if allpreds:
bestDataSet = False
combinedRes = False
else:
bestDataSet = True
combinedRes = self.do_combine
preds = []
# self.log ( "start getting preds" )
from smodels.tools import runtime
runtime._experimental = True
for expRes in self.listOfExpRes:
predictions = theoryPredictionsFor(expRes,
topos,
useBestDataset=bestDataSet,
combinedResults=combinedRes)
if predictions == None:
predictions = []
if allpreds:
combpreds = theoryPredictionsFor(
expRes,
topos,
useBestDataset=False,
combinedResults=self.do_combine)
if combpreds != None:
for c in combpreds:
predictions.append(c)
for prediction in predictions:
prediction.computeStatistics()
if (not llhdonly) or (prediction.likelihood != None):
preds.append(prediction)
sap = "best preds"
if allpreds:
sap = "all preds"
sllhd = ""
if llhdonly:
sllhd = ", llhds only"
self.log ( "returning %d predictions, %s%s" % \
(len(preds),sap, sllhd ) )
return preds
def testClusteringUL(self):
slhafile = 'testFiles/slha/lightEWinos.slha'
model = Model(BSMparticles=BSMList, SMparticles=SMList)
model.updateParticles(slhafile)
sigmacut = 5. * fb
mingap = 5. * GeV
toplist = decomposer.decompose(model,
sigmacut,
doCompress=True,
doInvisible=True,
minmassgap=mingap)
#Test clustering for UL results
dataset = database.getExpResults(analysisIDs='ATLAS-SUSY-2013-02',
datasetIDs=None)[0].getDataset(None)
el1 = toplist[1].elementList[0]
el2 = toplist[1].elementList[1]
el3 = toplist[1].elementList[2]
weights = [
el.weight.getMaxXsec().asNumber(fb) for el in [el1, el2, el3]
]
#Overwrite masses and txname label
el1.mass = [[1000. * GeV, 100. * GeV]] * 2
el2.mass = [[1020. * GeV, 100. * GeV]] * 2
el3.mass = [[500. * GeV, 100. * GeV]] * 2
el1.txname = el2.txname = el3.txname = 'T1'
el1.eff = 1. #(Used in clustering)
el2.eff = 1. #(Used in clustering)
el3.eff = 1. #(Used in clustering)
#Check clustering with distinct elements
clusters = clusterElements([el1, el2, el3],
maxDist=0.2,
dataset=dataset)
self.assertEqual(len(clusters), 2)
averageMasses = [
[[(1000. * GeV * weights[0] + 1020. * GeV * weights[1]) /
(weights[0] + weights[1]), 100. * GeV]] * 2, el3.mass
]
elClusters = [[el1, el2], [el3]]
for ic, cluster in enumerate(clusters):
avgEl = cluster.averageElement()
self.assertEqual(sorted(cluster.elements), sorted(elClusters[ic]))
for ibr, br in enumerate(avgEl.mass):
for im, m in enumerate(br):
self.assertAlmostEqual(
m.asNumber(GeV),
averageMasses[ic][ibr][im].asNumber(GeV))
self.assertEqual(avgEl.totalwidth, elClusters[ic][0].totalwidth)
#Check clustering with distinct elements but no maxDist limit
clusters = clusterElements([el1, el2, el3],
maxDist=10.,
dataset=dataset)
self.assertEqual(len(clusters), 1)
cluster = clusters[0]
avgEl = cluster.averageElement()
averageMass = [[(1000. * GeV * weights[0] + 1020. * GeV * weights[1] +
500. * GeV * weights[2]) / sum(weights), 100. * GeV]
] * 2
self.assertEqual(sorted(cluster.elements), sorted([el1, el2, el3]))
for ibr, br in enumerate(avgEl.mass):
for im, m in enumerate(br):
self.assertAlmostEqual(m.asNumber(GeV),
averageMass[ibr][im].asNumber(GeV))
self.assertEqual(avgEl.totalwidth, el1.totalwidth)
#Check clustering where elements have same upper limits, but not the average element:
el1._upperLimit = 1. * fb
el2._upperLimit = 1. * fb
el3._upperLimit = 1. * fb
clusters = clusterElements([el1, el2, el3],
maxDist=0.1,
dataset=dataset)
self.assertEqual(len(clusters), 2)
action='store_true')
args = argparser.parse_args()
if args.prior:
normalizePrior()
sys.exit()
if args.upper_limits and args.efficiencyMaps:
print("[combiner] -u and -e are mutually exclusive")
sys.exit()
from smodels.experiment.databaseObj import Database
from smodels.theory import decomposer
from smodels.particlesLoader import BSMList
from smodels.share.models.SMparticles import SMList
from smodels.theory.model import Model
from smodels.tools.physicsUnits import fb
model = Model(BSMparticles=BSMList, SMparticles=SMList)
model.updateParticles(inputFile=args.slhafile)
print("[combiner] loading database", args.database)
db = Database(args.database)
print("[combiner] done loading database")
anaIds = ["CMS-SUS-16-033"]
anaIds = ["all"]
dts = ["all"]
if args.upper_limits:
dts = ["upperLimit"]
if args.efficiencyMaps:
dts = ["efficiencyMap"]
listOfExpRes = db.getExpResults(analysisIDs=anaIds,
dataTypes=dts,
onlyWithExpected=True)
smses = decomposer.decompose(model, .01 * fb)
#print ( "[combiner] decomposed into %d topos" % len(smses) )
def main():
"""
Main program. Displays basic use case.
"""
model = Model(BSMparticles=BSMList, SMparticles=SMList)
# Path to input file (either a SLHA or LHE file)
# lhefile = 'inputFiles/lhe/gluino_squarks.lhe'
slhafile = 'inputFiles/slha/lightEWinos.slha'
# model.updateParticles(inputFile=lhefile)
model.updateParticles(inputFile=slhafile)
# Set main options for decomposition
sigmacut = 0.01 * fb
mingap = 5. * GeV
# Decompose model
toplist = decomposer.decompose(model,
sigmacut,
doCompress=True,
doInvisible=True,
minmassgap=mingap)
# Access basic information from decomposition, using the topology list and topology objects:
print("\n Decomposition Results: ")
print("\t Total number of topologies: %i " % len(toplist))
nel = sum([len(top.elementList) for top in toplist])
print("\t Total number of elements = %i " % nel)
#Print information about the m-th topology:
m = 2
if len(toplist) > m:
top = toplist[m]
print("\t\t %i-th topology = " % m, top, "with total cross section =",
top.getTotalWeight())
#Print information about the n-th element in the m-th topology:
n = 0
el = top.elementList[n]
print("\t\t %i-th element from %i-th topology = " % (n, m),
el,
end="")
print("\n\t\t\twith final states =", el.getFinalStates(),
"\n\t\t\twith cross section =", el.weight,
"\n\t\t\tand masses = ", el.mass)
# Load the experimental results to be used.
# In this case, all results are employed.
listOfExpRes = database.getExpResults()
# Print basic information about the results loaded.
# Count the number of loaded UL and EM experimental results:
nUL, nEM = 0, 0
for exp in listOfExpRes:
expType = exp.datasets[0].dataInfo.dataType
if expType == 'upperLimit':
nUL += 1
elif expType == 'efficiencyMap':
nEM += 1
print("\n Loaded Database with %i UL results and %i EM results " %
(nUL, nEM))
# Compute the theory predictions for each experimental result and print them:
print("\n Theory Predictions and Constraints:")
rmax = 0.
bestResult = None
for expResult in listOfExpRes:
predictions = theoryPredictionsFor(expResult,
toplist,
combinedResults=False,
marginalize=False)
if not predictions:
continue # Skip if there are no constraints from this result
print('\n %s ' % expResult.globalInfo.id)
for theoryPrediction in predictions:
dataset = theoryPrediction.dataset
datasetID = theoryPrediction.dataId()
mass = theoryPrediction.mass
txnames = [str(txname) for txname in theoryPrediction.txnames]
PIDs = theoryPrediction.PIDs
print("------------------------")
print("Dataset = ", datasetID) #Analysis name
print("TxNames = ", txnames)
print(
"Prediction Mass = ", mass
) #Value for average cluster mass (average mass of the elements in cluster)
print(
"Prediction PIDs = ", PIDs
) #Value for average cluster mass (average mass of the elements in cluster)
print("Theory Prediction = ",
theoryPrediction.xsection) #Signal cross section
print("Condition Violation = ",
theoryPrediction.conditions) #Condition violation values
# Get the corresponding upper limit:
print("UL for theory prediction = ", theoryPrediction.upperLimit)
# Compute the r-value
r = theoryPrediction.getRValue()
print("r = ", r)
#Compute likelihhod and chi^2 for EM-type results:
if dataset.getType() == 'efficiencyMap':
theoryPrediction.computeStatistics()
print('Chi2, likelihood=', theoryPrediction.chi2,
theoryPrediction.likelihood)
if r > rmax:
rmax = r
bestResult = expResult.globalInfo.id
# Print the most constraining experimental result
print("\nThe largest r-value (theory/upper limit ratio) is ", rmax)
if rmax > 1.:
print("(The input model is likely excluded by %s)" % bestResult)
else:
print(
"(The input model is not excluded by the simplified model results)"
)
#Find out missing topologies for sqrts=8*TeV:
uncovered = coverage.Uncovered(toplist, sqrts=8. * TeV)
#First sort coverage groups by label
groups = sorted(uncovered.groups[:], key=lambda g: g.label)
#Print uncovered cross-sections:
for group in groups:
print("\nTotal cross-section for %s (fb): %10.3E\n" %
(group.description, group.getTotalXSec()))
missingTopos = uncovered.getGroup('missing (prompt)')
#Print some of the missing topologies:
if missingTopos.generalElements:
print('Missing topologies (up to 3):')
for genEl in missingTopos.generalElements[:3]:
print('Element:', genEl)
print('\tcross-section (fb):', genEl.missingX)
else:
print("No missing topologies found\n")
missingDisplaced = uncovered.getGroup('missing (displaced)')
#Print elements with displaced decays:
if missingDisplaced.generalElements:
print('\nElements with displaced vertices (up to 2):')
for genEl in missingDisplaced.generalElements[:2]:
print('Element:', genEl)
print('\tcross-section (fb):', genEl.missingX)
else:
print("\nNo displaced decays")
def testPoint(inputFile, outputDir, parser, databaseVersion, listOfExpRes):
"""
Test model point defined in input file (running decomposition, check
results, test coverage)
:parameter inputFile: path to input file
:parameter outputDir: path to directory where output is be stored
:parameter parser: ConfigParser storing information from parameters file
:parameter databaseVersion: Database version (printed to output file)
:parameter listOfExpRes: list of ExpResult objects to be considered
:returns: output of printers
"""
"""Get run parameters and options from the parser"""
sigmacut = parser.getfloat("parameters", "sigmacut") * fb
minmassgap = parser.getfloat("parameters", "minmassgap") * GeV
"""Setup output printers"""
masterPrinter = MPrinter()
masterPrinter.setPrinterOptions(parser)
masterPrinter.setOutPutFiles(
os.path.join(outputDir, os.path.basename(inputFile)))
""" Add list of analyses loaded to printer"""
masterPrinter.addObj(ExpResultList(listOfExpRes))
"""Check input file for errors"""
inputStatus = ioObjects.FileStatus()
if parser.getboolean("options", "checkInput"):
inputStatus.checkFile(inputFile)
"""Initialize output status and exit if there were errors in the input"""
outputStatus = ioObjects.OutputStatus(inputStatus.status, inputFile,
dict(parser.items("parameters")),
databaseVersion)
masterPrinter.addObj(outputStatus)
if outputStatus.status < 0:
return masterPrinter.flush()
"""
Load the input model
====================
"""
try:
"""
Load the input model and update it with the information from the input file
"""
from smodels.particlesLoader import BSMList
model = Model(BSMparticles=BSMList, SMparticles=SMList)
promptWidth = None
stableWidth = None
if parser.has_option("particles", "promptWidth"):
promptWidth = parser.getfloat("particles", "promptWidth") * GeV
if parser.has_option("particles", "stableWidth"):
stableWidth = parser.getfloat("particles", "stableWidth") * GeV
model.updateParticles(inputFile=inputFile,
promptWidth=promptWidth,
stableWidth=stableWidth)
except SModelSError as e:
print("Exception %s %s" % (e, type(e)))
""" Update status to fail, print error message and exit """
outputStatus.updateStatus(-1)
return masterPrinter.flush()
"""
Decompose input model
=====================
"""
try:
""" Decompose the input model, store the output elements in smstoplist """
sigmacut = parser.getfloat("parameters", "sigmacut") * fb
smstoplist = decomposer.decompose(
model,
sigmacut,
doCompress=parser.getboolean("options", "doCompress"),
doInvisible=parser.getboolean("options", "doInvisible"),
minmassgap=minmassgap)
except SModelSError as e:
print("Exception %s %s" % (e, type(e)))
""" Update status to fail, print error message and exit """
outputStatus.updateStatus(-1)
return masterPrinter.flush()
""" Print Decomposition output.
If no topologies with sigma > sigmacut are found, update status, write
output file, stop running """
if not smstoplist:
outputStatus.updateStatus(-3)
return masterPrinter.flush()
masterPrinter.addObj(smstoplist)
"""
Compute theory predictions
====================================================
"""
""" Get theory prediction for each analysis and print basic output """
allPredictions = []
combineResults = False
try:
combineResults = parser.getboolean("options", "combineSRs")
except (NoSectionError, NoOptionError) as e:
pass
for expResult in listOfExpRes:
theorypredictions = theoryPredictionsFor(
expResult,
smstoplist,
useBestDataset=True,
combinedResults=combineResults,
marginalize=False)
if not theorypredictions:
continue
allPredictions += theorypredictions._theoryPredictions
"""Compute chi-square and likelihood"""
if parser.getboolean("options", "computeStatistics"):
for theoPred in allPredictions:
theoPred.computeStatistics()
""" Define theory predictions list that collects all theoryPrediction objects which satisfy max condition."""
maxcond = parser.getfloat("parameters", "maxcond")
theoryPredictions = theoryPrediction.TheoryPredictionList(
allPredictions, maxcond)
if len(theoryPredictions) != 0:
outputStatus.updateStatus(1)
masterPrinter.addObj(theoryPredictions)
else:
outputStatus.updateStatus(0) # no results after enforcing maxcond
if parser.getboolean("options", "testCoverage"):
""" Testing coverage of model point, add results to the output file """
if parser.has_option("options", "coverageSqrts"):
sqrts = parser.getfloat("options", "coverageSqrts") * TeV
else:
sqrts = None
uncovered = coverage.Uncovered(smstoplist,
sigmacut=sigmacut,
sqrts=sqrts)
masterPrinter.addObj(uncovered)
return masterPrinter.flush()