def main():
"""
Main program. Displays basic use case.
"""
""" Input file location (either a SLHA or LHE file) """
slhafile = 'inputFiles/slha/gluino_squarks.slha'
# lhefile = 'inputFiles/lhe/gluino_squarks.lhe'
""" Main options for decomposition """
sigmacut = 0.03 * fb
mingap = 5. * GeV
""" Decompose model (use slhaDecomposer for SLHA input or lheDecomposer for LHE input) """
smstoplist = slhaDecomposer.decompose(slhafile, sigmacut, doCompress=True, doInvisible=True, minmassgap=mingap)
# smstoplist = lheDecomposer.decompose(lhefile, doCompress=True,doInvisible=True, minmassgap=mingap)
""" Print decomposition summary. Set outputLevel=0 (no output), 1 (simple output), 2 (extended output) """
smstoplist.printout(outputLevel=1)
""" Load all analyses from database """
listofanalyses = smsAnalysisFactory.load()
""" Compute the theory predictions for each analysis """
analysesPredictions = [theoryPredictionFor(analysis, smstoplist) for analysis in listofanalyses]
""" Access information for each theory prediction/analysis """
for analysisPred in analysesPredictions:
if not analysisPred:
""" Skip non-applicable analyses """
continue
""" If the analysis prediction contains more than one theory prediction (cluster), loop over predictions """
for theoryPrediction in analysisPred:
print("------------------------")
print("Analysis name = ", theoryPrediction.analysis.label)
""" Value for average cluster mass (average mass of the elements in cluster) """
print("Prediction Mass = ", theoryPrediction.mass)
""" Value for the cluster signal cross-section """
print("Signal Cross-Section = ", theoryPrediction.value)
""" Condition violation values """
print("Condition Violation = ", theoryPrediction.conditions)
""" Get upper limit for the respective prediction """
print("Analysis upper limit = ", theoryPrediction.analysis.getUpperLimitFor(theoryPrediction.mass))
def main():
"""
Main program. Displays basic use case.
"""
""" Input file location (either a SLHA or LHE file) """
slhafile = 'inputFiles/slha/gluino_squarks.slha'
# lhefile = 'inputFiles/lhe/gluino_squarks.lhe'
""" Main options for decomposition """
sigmacut = 0.03 * fb
mingap = 5. * GeV
""" Decompose model (use slhaDecomposer for SLHA input or lheDecomposer for LHE input) """
smstoplist = slhaDecomposer.decompose(slhafile,
sigmacut,
doCompress=True,
doInvisible=True,
minmassgap=mingap)
# smstoplist = lheDecomposer.decompose(lhefile, doCompress=True,doInvisible=True, minmassgap=mingap)
""" Print decomposition summary. Set outputLevel=0 (no output), 1 (simple output), 2 (extended output) """
smstoplist.printout(outputLevel=1)
""" Load all analyses from database """
listofanalyses = smsAnalysisFactory.load()
""" Compute the theory predictions for each analysis """
analysesPredictions = [
theoryPredictionFor(analysis, smstoplist)
for analysis in listofanalyses
]
""" Access information for each theory prediction/analysis """
for analysisPred in analysesPredictions:
if not analysisPred:
""" Skip non-applicable analyses """
continue
""" If the analysis prediction contains more than one theory prediction (cluster), loop over predictions """
for theoryPrediction in analysisPred:
print("------------------------")
print("Analysis name = ", theoryPrediction.analysis.label)
""" Value for average cluster mass (average mass of the elements in cluster) """
print("Prediction Mass = ", theoryPrediction.mass)
""" Value for the cluster signal cross-section """
print("Signal Cross-Section = ", theoryPrediction.value)
""" Condition violation values """
print("Condition Violation = ", theoryPrediction.conditions)
""" Get upper limit for the respective prediction """
print(
"Analysis upper limit = ",
theoryPrediction.analysis.getUpperLimitFor(
theoryPrediction.mass))
from smodels.installation import installDirectory
from smodels.theory import slhaDecomposer
from smodels.experiment import smsAnalysisFactory, smsHelpers
from smodels.tools import missingTopologies
# In[3]:
# define where the database resides
smsHelpers.base=os.path.join(os.getenv("HOME"),"smodels-database/")
# In[4]:
# load list of analyses from database
listOfAnalyses = smsAnalysisFactory.load()
# In[5]:
# Define the SLHA file name
filename = "%s/inputFiles/slha/gluino_squarks.slha" % installDirectory()
# In[6]:
# Perform the decomposition:
listOfTopologies = slhaDecomposer.decompose (filename, sigcut=0.5*fb, doCompress=True, doInvisible=True, minmassgap=5*GeV)
# In[7]:
def main(inputFile, parameterFile, outputFile, slhaOutputFile, particlePath):
"""
Provides a command line interface to basic SModelS functionalities.
:param inputFile: input file name (either a SLHA or LHE file)
:param parameterFile: File containing the input parameters (default = /etc/parameters_default.ini)
:param outputFile: Output file to write a summary of results
:param slhaOutputFile: Output file to write SLHA type summary of results
:param particlePath: Path to directory where particles.py is stored
"""
"""
Read and check input file
=========================
"""
parser = SafeConfigParser()
parser.read(parameterFile)
""" Minimum value of cross-section for an element to be considered eligible for decomposition.
Too small sigmacut leads to too large decomposition time. """
sigmacut = parser.getfloat("parameters", "sigmacut") * fb
""" Minimum value for considering two states non-degenerate (only used for mass compression) """
minmassgap = parser.getfloat("parameters", "minmassgap") * GeV
if os.path.exists(outputFile):
log.warning("Removing old output file in " + outputFile)
outfile = open(outputFile, 'w')
outfile.close()
databaseVersion = "unknown" # set default database version that is printed in case of errors
""" Set doCompress flag, only used for slha type output """
if parser.getboolean("options", "doCompress") or parser.getboolean("options", "doInvisible"): docompress = 1
else: docompress = 0
"""
check if particles.py exists in specified path, and add to sys.path
"""
if not os.path.isfile(os.path.join(particlePath,"particles.py")):
log.error("particle.py not found in %s" %particlePath )
return slhaPrinter.writeSLHA(None, parser.getfloat("parameters", "maxcond"), minmassgap, sigmacut, None, databaseVersion, docompress, slhaOutputFile)
else:
sys.path.insert(1, particlePath)
from smodels.tools import ioObjects, missingTopologies
from smodels.experiment import smsHelpers, smsAnalysisFactory
from smodels.theory import slhaDecomposer, lheDecomposer
from smodels.theory.theoryPrediction import theoryPredictionFor
inputType = parser.get("options", "inputType").lower()
if inputType != 'slha' and inputType != 'lhe':
log.error("Unknown input type (must be SLHA or LHE): %s" % inputType)
return slhaPrinter.writeSLHA(None, parser.getfloat("parameters", "maxcond"), minmassgap, sigmacut, None, databaseVersion, docompress, slhaOutputFile)
""" Check input file for errors """
inputStatus = ioObjects.FileStatus()
if parser.getboolean("options", "checkInput"):
inputStatus.checkFile(inputType, inputFile, sigmacut)
""" Check database location """
try:
smsHelpers.base = parser.get("path", "databasePath")
if smsHelpers.base == "./smodels-database" or smsHelpers.base == "./smodels-database/": smsHelpers.base = installDirectory()+"/smodels-database/"
databaseVersion = smsHelpers.databaseVersion()
except:
log.error("Database not found in %s" % os.path.realpath(smsHelpers.base))
return slhaPrinter.writeSLHA(None, parser.getfloat("parameters", "maxcond"), minmassgap, sigmacut, None, databaseVersion, docompress, slhaOutputFile)
""" Initialize output status and exit if there were errors in the input """
outputStatus = ioObjects.OutputStatus(inputStatus.status, inputFile, dict(parser.items("parameters")), databaseVersion, outputFile)
if outputStatus.status < 0:
return slhaPrinter.writeSLHA(None, parser.getfloat("parameters", "maxcond"), minmassgap, sigmacut, None, databaseVersion, docompress, slhaOutputFile)
"""
Decompose input file
====================
"""
try:
""" Decompose input SLHA file, store the output elements in smstoplist """
if inputType == 'slha':
smstoplist = slhaDecomposer.decompose(inputFile, sigmacut, doCompress=parser.getboolean("options", "doCompress"),
doInvisible=parser.getboolean("options", "doInvisible"), minmassgap=minmassgap)
else:
smstoplist = lheDecomposer.decompose(inputFile, doCompress=parser.getboolean("options", "doCompress"),
doInvisible=parser.getboolean("options", "doInvisible"), minmassgap=minmassgap)
except:
""" Update status to fail, print error message and exit """
outputStatus.updateStatus(-1)
return slhaPrinter.writeSLHA(None, parser.getfloat("parameters", "maxcond"), minmassgap, sigmacut, None, databaseVersion, docompress, slhaOutputFile)
""" 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 slhaPrinter.writeSLHA(None, parser.getfloat("parameters", "maxcond"), minmassgap, sigmacut, None, databaseVersion, docompress, slhaOutputFile)
outLevel = 0
if parser.getboolean("stdout", "printDecomp"):
outLevel = 1
outLevel += parser.getboolean("stdout", "addElmentInfo")
smstoplist.printout(outputLevel=outLevel)
"""
Load analysis database
======================
"""
""" In case that a list of analyses or txnames are given, retrieve list """
analyses = parser.get("database", "analyses")
if "," in analyses:
analyses = analyses.split(",")
txnames = parser.get("database", "txnames")
if "," in txnames:
txnames = txnames.split(",")
""" Load analyses """
listofanalyses = smsAnalysisFactory.load(analyses, txnames)
""" Print list of analyses loaded """
if parser.getboolean("stdout", "printAnalyses"):
outLevel = 1
outLevel += parser.getboolean("stdout", "addAnaInfo")
print("=======================\n == List of Analyses ====\n ================")
for analysis in listofanalyses:
analysis.printout(outputLevel=outLevel)
"""
Compute theory predictions and anlalyses constraints
====================================================
"""
""" Define result list that collects all theoryPrediction objects.
Variables set to define printing options. """
results = ioObjects.ResultList(bestresultonly=not parser.getboolean("file", "expandedSummary"),
describeTopo=parser.getboolean("file", "addConstraintInfo"))
""" Get theory prediction for each analysis and print basic output """
for analysis in listofanalyses:
theorypredictions = theoryPredictionFor(analysis, smstoplist)
if not theorypredictions:
continue
if parser.getboolean("stdout", "printResults"):
print "================================================================================"
theorypredictions.printout()
print "................................................................................"
""" Create a list of results, to determine the best result """
for theoryprediction in theorypredictions:
results.addResult(theoryprediction, maxcond=parser.getfloat("parameters", "maxcond"))
""" If there is no best result, this means that there are no matching experimental results for the point """
if results.isEmpty():
""" no experimental constraints found """
outputStatus.updateStatus(0)
else:
outputStatus.updateStatus(1)
""" Write output file """
outputStatus.printout("file", outputFile)
""" Add experimental constraints if found """
if outputStatus.status == 1:
results.printout("file", outputFile)
sqrts = max([xsec.info.sqrts for xsec in smstoplist.getTotalWeight()])
if parser.getboolean("options", "findMissingTopos"):
""" Look for missing topologies, add them to the output file """
missingtopos = missingTopologies.MissingTopoList(sqrts)
missingtopos.findMissingTopos(smstoplist, listofanalyses, minmassgap, parser.getboolean("options", "doCompress"),
doInvisible=parser.getboolean("options", "doInvisible"))
missingtopos.printout("file", outputFile)
slhaPrinter.writeSLHA(results, parser.getfloat("parameters", "maxcond"), minmassgap, sigmacut, missingtopos, databaseVersion, docompress, slhaOutputFile)
# In[2]:
#Import those parts of smodels that are needed for this exercise
from smodels.tools.physicsUnits import GeV
from smodels.experiment import smsAnalysisFactory, smsHelpers
# In[3]:
## define where the database resides
smsHelpers.base=os.path.join(os.getenv("HOME"),"smodels-database/")
#specify analysis and topology as strings:
#and load analysis
ananame = ["CMS-SUS-12-028"]
txname = ["T2"]
analysis = smsAnalysisFactory.load(ananame, topologies=txname)[0]
# In[4]:
masses = [[500*GeV, 150*GeV],[500*GeV, 150*GeV]]
# In[5]:
analysis.getUpperLimitFor(masses)
# In[5]:
#Set up the path to SModelS installation folder if running on a different folder
import sys, os
sys.path.append(os.path.join(os.getenv("HOME"), "smodels/"))
# In[2]:
#Import those parts of smodels that are needed for this exercise
from smodels.tools.physicsUnits import GeV
from smodels.experiment import smsAnalysisFactory, smsHelpers
# In[3]:
## define where the database resides
smsHelpers.base = os.path.join(os.getenv("HOME"), "smodels-database/")
#specify analysis and topology as strings:
#and load analysis
ananame = ["CMS-SUS-12-028"]
txname = ["T2"]
analysis = smsAnalysisFactory.load(ananame, topologies=txname)[0]
# In[4]:
masses = [[500 * GeV, 150 * GeV], [500 * GeV, 150 * GeV]]
# In[5]:
analysis.getUpperLimitFor(masses)
# In[5]:
## define where the database resides
smsHelpers.base = os.path.join(os.getenv("HOME"), "smodels-database/")
### How to load results from one publication (or conference note)
# In[4]:
#Select only the CMS SUS-12-028 conference note
analyses = ["CMS-SUS-12-028"]
# In[5]:
#Loads the selected analyses
#(The INFO tells you that superseded analyses are not loaded, see below)
list_of_analyses = smsAnalysisFactory.load(analyses)
# In[6]:
#Print the analyses that were loaded:
for analysis in list_of_analyses:
analysis.printout(outputLevel=1)
# In[7]:
#To see which elements are constrained by the analyses (in bracket notation), set outputLevel=2
for analysis in list_of_analyses:
analysis.printout(outputLevel=2)
# In[8]:
# Import those parts of smodels that are needed for this exercise
from smodels.tools.physicsUnits import TeV, GeV, fb
from smodels.installation import installDirectory
from smodels.theory import slhaDecomposer
from smodels.experiment import smsAnalysisFactory, smsHelpers
from smodels.tools import missingTopologies
# In[3]:
# define where the database resides
smsHelpers.base = os.path.join(os.getenv("HOME"), "smodels-database/")
# In[4]:
# load list of analyses from database
listOfAnalyses = smsAnalysisFactory.load()
# In[5]:
# Define the SLHA file name
filename = "%s/inputFiles/slha/gluino_squarks.slha" % installDirectory()
# In[6]:
# Perform the decomposition:
listOfTopologies = slhaDecomposer.decompose(filename,
sigcut=0.5 * fb,
doCompress=True,
doInvisible=True,
minmassgap=5 * GeV)
from smodels.theory.theoryPrediction import theoryPredictionFor
from smodels.experiment import smsAnalysisFactory, smsHelpers
# In[3]:
#Define the SLHA input file name
filename="%s/inputFiles/slha/gluino_squarks.slha" % installDirectory()
# In[4]:
#Load the database, do the decomposition and compute theory predictions:
#(Look at the theory predictions HowTo to learn how to compute theory predictions)
smsHelpers.base=os.path.join(os.getenv("HOME"),"smodels-database/")
listofanalyses = smsAnalysisFactory.load()
listOfTopologies = slhaDecomposer.decompose (filename, sigcut = 0.03 * fb, doCompress=True, doInvisible=True,minmassgap = 5* GeV)
analysesPredictions = [theoryPredictionFor(analysis, listOfTopologies) for analysis in listofanalyses]
# In[5]:
#Print the value of each theory prediction (cluster) for each analysis and the corresponding analysis upper limit:
for anaPrediction in analysesPredictions:
if not anaPrediction: continue #skip analyses without results
for theoryPred in anaPrediction:
print "Analysis name = ",theoryPred.analysis.label
print "Theory prediction = ",theoryPred.value[0].value
print "Upper limit = ",theoryPred.analysis.getUpperLimitFor(theoryPred.mass)
def main(inputFile, parameterFile, outputFile, slhaOutputFile, particlePath):
"""
Provides a command line interface to basic SModelS functionalities.
:param inputFile: input file name (either a SLHA or LHE file)
:param parameterFile: File containing the input parameters (default = /etc/parameters_default.ini)
:param outputFile: Output file to write a summary of results
:param slhaOutputFile: Output file to write SLHA type summary of results
:param particlePath: Path to directory where particles.py is stored
"""
"""
Read and check input file
=========================
"""
parser = SafeConfigParser()
parser.read(parameterFile)
""" Minimum value of cross-section for an element to be considered eligible for decomposition.
Too small sigmacut leads to too large decomposition time. """
sigmacut = parser.getfloat("parameters", "sigmacut") * fb
""" Minimum value for considering two states non-degenerate (only used for mass compression) """
minmassgap = parser.getfloat("parameters", "minmassgap") * GeV
if os.path.exists(outputFile):
log.warning("Removing old output file in " + outputFile)
outfile = open(outputFile, 'w')
outfile.close()
databaseVersion = "unknown" # set default database version that is printed in case of errors
""" Set doCompress flag, only used for slha type output """
if parser.getboolean("options", "doCompress") or parser.getboolean(
"options", "doInvisible"):
docompress = 1
else:
docompress = 0
"""
check if particles.py exists in specified path, and add to sys.path
"""
if not os.path.isfile(os.path.join(particlePath, "particles.py")):
log.error("particle.py not found in %s" % particlePath)
return slhaPrinter.writeSLHA(None,
parser.getfloat("parameters",
"maxcond"), minmassgap,
sigmacut, None, databaseVersion,
docompress, slhaOutputFile)
else:
sys.path.insert(1, particlePath)
from smodels.tools import ioObjects, missingTopologies
from smodels.experiment import smsHelpers, smsAnalysisFactory
from smodels.theory import slhaDecomposer, lheDecomposer
from smodels.theory.theoryPrediction import theoryPredictionFor
inputType = parser.get("options", "inputType").lower()
if inputType != 'slha' and inputType != 'lhe':
log.error("Unknown input type (must be SLHA or LHE): %s" % inputType)
return slhaPrinter.writeSLHA(None,
parser.getfloat("parameters",
"maxcond"), minmassgap,
sigmacut, None, databaseVersion,
docompress, slhaOutputFile)
""" Check input file for errors """
inputStatus = ioObjects.FileStatus()
if parser.getboolean("options", "checkInput"):
inputStatus.checkFile(inputType, inputFile, sigmacut)
""" Check database location """
try:
smsHelpers.base = parser.get("path", "databasePath")
if smsHelpers.base == "./smodels-database" or smsHelpers.base == "./smodels-database/":
smsHelpers.base = installDirectory() + "/smodels-database/"
databaseVersion = smsHelpers.databaseVersion()
except:
log.error("Database not found in %s" %
os.path.realpath(smsHelpers.base))
return slhaPrinter.writeSLHA(None,
parser.getfloat("parameters",
"maxcond"), minmassgap,
sigmacut, None, databaseVersion,
docompress, slhaOutputFile)
""" Initialize output status and exit if there were errors in the input """
outputStatus = ioObjects.OutputStatus(inputStatus.status, inputFile,
dict(parser.items("parameters")),
databaseVersion, outputFile)
if outputStatus.status < 0:
return slhaPrinter.writeSLHA(None,
parser.getfloat("parameters",
"maxcond"), minmassgap,
sigmacut, None, databaseVersion,
docompress, slhaOutputFile)
"""
Decompose input file
====================
"""
try:
""" Decompose input SLHA file, store the output elements in smstoplist """
if inputType == 'slha':
smstoplist = slhaDecomposer.decompose(
inputFile,
sigmacut,
doCompress=parser.getboolean("options", "doCompress"),
doInvisible=parser.getboolean("options", "doInvisible"),
minmassgap=minmassgap)
else:
smstoplist = lheDecomposer.decompose(
inputFile,
doCompress=parser.getboolean("options", "doCompress"),
doInvisible=parser.getboolean("options", "doInvisible"),
minmassgap=minmassgap)
except:
""" Update status to fail, print error message and exit """
outputStatus.updateStatus(-1)
return slhaPrinter.writeSLHA(None,
parser.getfloat("parameters",
"maxcond"), minmassgap,
sigmacut, None, databaseVersion,
docompress, slhaOutputFile)
""" 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 slhaPrinter.writeSLHA(None,
parser.getfloat("parameters",
"maxcond"), minmassgap,
sigmacut, None, databaseVersion,
docompress, slhaOutputFile)
outLevel = 0
if parser.getboolean("stdout", "printDecomp"):
outLevel = 1
outLevel += parser.getboolean("stdout", "addElmentInfo")
smstoplist.printout(outputLevel=outLevel)
"""
Load analysis database
======================
"""
""" In case that a list of analyses or txnames are given, retrieve list """
analyses = parser.get("database", "analyses")
if "," in analyses:
analyses = analyses.split(",")
txnames = parser.get("database", "txnames")
if "," in txnames:
txnames = txnames.split(",")
""" Load analyses """
listofanalyses = smsAnalysisFactory.load(analyses, txnames)
""" Print list of analyses loaded """
if parser.getboolean("stdout", "printAnalyses"):
outLevel = 1
outLevel += parser.getboolean("stdout", "addAnaInfo")
print(
"=======================\n == List of Analyses ====\n ================"
)
for analysis in listofanalyses:
analysis.printout(outputLevel=outLevel)
"""
Compute theory predictions and anlalyses constraints
====================================================
"""
""" Define result list that collects all theoryPrediction objects.
Variables set to define printing options. """
results = ioObjects.ResultList(
bestresultonly=not parser.getboolean("file", "expandedSummary"),
describeTopo=parser.getboolean("file", "addConstraintInfo"))
""" Get theory prediction for each analysis and print basic output """
for analysis in listofanalyses:
theorypredictions = theoryPredictionFor(analysis, smstoplist)
if not theorypredictions:
continue
if parser.getboolean("stdout", "printResults"):
print "================================================================================"
theorypredictions.printout()
print "................................................................................"
""" Create a list of results, to determine the best result """
for theoryprediction in theorypredictions:
results.addResult(theoryprediction,
maxcond=parser.getfloat("parameters", "maxcond"))
""" If there is no best result, this means that there are no matching experimental results for the point """
if results.isEmpty():
""" no experimental constraints found """
outputStatus.updateStatus(0)
else:
outputStatus.updateStatus(1)
""" Write output file """
outputStatus.printout("file", outputFile)
""" Add experimental constraints if found """
if outputStatus.status == 1:
results.printout("file", outputFile)
sqrts = max([xsec.info.sqrts for xsec in smstoplist.getTotalWeight()])
if parser.getboolean("options", "findMissingTopos"):
""" Look for missing topologies, add them to the output file """
missingtopos = missingTopologies.MissingTopoList(sqrts)
missingtopos.findMissingTopos(
smstoplist,
listofanalyses,
minmassgap,
parser.getboolean("options", "doCompress"),
doInvisible=parser.getboolean("options", "doInvisible"))
missingtopos.printout("file", outputFile)
slhaPrinter.writeSLHA(results, parser.getfloat("parameters", "maxcond"),
minmassgap, sigmacut, missingtopos, databaseVersion,
docompress, slhaOutputFile)