def testWritePickle(self): """ tests writing pickle file """ binfile = "./.database.pcl" if os.path.exists ( binfile ): os.unlink ( binfile ) self.logger.info ( "test writing pickle file """ ) writer = Database ( "./tinydb/", force_load = "txt" ) writer.createBinaryFile ( binfile ) reader = Database ( binfile, force_load="pcl" ) os.unlink ( binfile ) self.assertEqual( writer, reader )
def initialize( self ): self.setStatus ( "initialized" ) Cache.n_stored = 20000 ## crank up the caching self.db = Database ( self.dbpath ) self.expResults = self.db.expResultList self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_address = ( self.servername, self.port ) self.pprint ( 'starting up on %s port %s' % self.server_address ) self.pprint ( 'I will be serving database %s at %s' % \ (self.db.databaseVersion, self.dbpath ) ) try: self.sock.bind( self.server_address ) except OSError as e: self.pprint ( "exception %s. is host ''%s'' reachable?" % \ ( e, self.server_address ) ) sys.exit(-1) # Listen for incoming connections self.sock.listen(1) atexit.register ( shutdownAll ) while True: # Wait for a connection self.setStatus ( "waiting" ) self.log ( 'waiting for a connection' ) self.connection, self.client_address = self.sock.accept() self.listen()
def checkOneAnalysis(): import argparse #import IPython argparser = argparse.ArgumentParser( description='print the correlations of one specific analysis') argparser.add_argument( '-d', '--dbpath', help='specify path to database [<rundir>/database.pcl]', type=str, default="<rundir>/database.pcl") argparser.add_argument('-a', '--analysis', help='print for <analysis>', type=str, default="CMS-SUS-19-006") args = argparser.parse_args() from smodels.experiment.databaseObj import Database print("[analysisCombiner] checking %s" % args.dbpath) db = Database(args.dbpath) results = db.getExpResults() info = getInfoFromAnaId(args.analysis, results) sqrts = info.sqrts collaboration = getExperimentName(info) prettyName = info.prettyName if args.analysis in moreComments: prettyName += " (%s)" % moreComments[args.analysis] # IPython.embed() print("correlations for %s: %s" % (args.analysis, prettyName)) combs, nocombs = set(), set() pnames = {} for er in results: if er.globalInfo.sqrts != sqrts: continue if getExperimentName(er.globalInfo) != collaboration: continue Id = er.globalInfo.id Id = Id.replace("-eff", "").replace("-agg", "") if Id == "CMS-SUS-19-006-2": Id = "CMS-SUS-19-006" if Id == args.analysis: continue pname = er.globalInfo.prettyName if Id in moreComments: pname += " (%s)" % moreComments[Id] pnames[Id] = pname cc = canCombine(info, er.globalInfo, "aggressive") # cc = canCombine ( pred, er.globalInfo ) if cc: combs.add(Id) else: nocombs.add(Id) print("can combine with: ") for Id in combs: pname = pnames[Id] print(" `- %s: %s" % (Id, pname)) print("cannot combine with: ") for Id in nocombs: pname = pnames[Id] print(" `- %s: %s" % (Id, pname))
def collect(): db = Database ( "./database.pcl" ) # , force_load = "txt" ) ers = db.getExpResults ( dataTypes = [ "upperLimit" ], onlyWithExpected=True ) allSs = [] for er in ers: txnlist = er.datasets[0].txnameList for txn in txnlist: ct=0 origdata = eval(txn.txnameData.origdata) for point in origdata: m = point[0] rul = point[1] ul,eul=None,None try: ul = txn.getULFor(m, False ) eul = txn.getULFor(m, True ) except Exception: pass if type(ul) == type(None) or type(eul) == type(None): continue sigma = eul / 1.96 S = float ( ( ul - eul ) / sigma ) if (S < -1.8 or S > 3.5) and ct<3: # if S > 10. and ct<3: print ( ) print ( "S=%.2f for ul=%s, eul=%s sigma=%s" % ( S, ul, eul, sigma ) ) print ( " at ", er.globalInfo.id, txn.txName, m, "rul", rul ) ct += 1 allSs.append ( S ) # print ( "->", er.globalInfo.id, txn, S ) print ("all", min(allSs), np.mean(allSs), max(allSs) ) f=open("ulSs.pcl","wb") pickle.dump(allSs,f) f.close() sys.exit()
def getPrettyName ( self, anaid ): """ get pretty name of ana id """ if False: ## set to true and we have the old analysis Ids return anaid if not hasattr ( self, "database" ): from smodels.experiment.databaseObj import Database dbname = "./original.pcl" dbname = "/home/walten/git/smodels-database" dbname = "/scratch-cbe/users/wolfgan.waltenberger/rundir/db31.pcl" self.database = Database ( dbname ) from smodels_utils.helper.prettyDescriptions import prettyTexAnalysisName if ":" in anaid: anaid = anaid[:anaid.find(":")] ers = self.database.getExpResults ( analysisIDs = [ anaid ] ) for er in ers: if hasattr ( er.globalInfo, "prettyName" ): pn = er.globalInfo.prettyName sqrts = er.globalInfo.sqrts.asNumber(TeV) ret = prettyTexAnalysisName ( pn, sqrts, dropEtmiss = True, collaboration = True, anaid = er.globalInfo.id ) # for the 2020 paper to be consistent ret = ret.replace( "+ top tag", "stop" ) ret = ret.replace( "+ 4 (1 b-)jets", "multijet" ) # ret += " -> " + anaid return ret # print ( "found no pretty name", ers[0].globalInfo ) return anaid
def __init__(self, walkerid, dbpath="./default.pcl", expected=False, select="all", do_combine=False): """ :param do_combine: if True, then also use combined results, both via simplified likelihoods and pyhf. """ self.walkerid = walkerid self.do_combine = do_combine self.modifier = None self.select = select self.expected = expected self.rthreshold = 1.3 ## threshold for rmax if expected: from expResModifier import ExpResModifier self.modifier = ExpResModifier() force_load = None if dbpath.endswith(".pcl"): force_load = "pcl" ntries = 0 while not os.path.exists(dbpath): ## give it a few tries ntries += 1 time.sleep(ntries * 5) if ntries > 5: break self.database = Database(dbpath, force_load=force_load) self.fetchResults() self.combiner = Combiner(self.walkerid)
def testFallBack(self): #Test if smodels/experiment/defaultFinalStates.py is being used if databaseParticle.py is missing dbpath = "./database_simple" dbOld = Database(dbpath, discard_zeroes=False, force_load='txt') model = dbOld.databaseParticles self.assertEqual(model.label, 'DB Final States (default)') #Simple fallback test
def loadDatabase(parser, db): """ Load database :parameter parser: ConfigParser with path to database :parameter db: binary database object. If None, then database is loaded, according to databasePath. If True, then database is loaded, and text mode is forced. :returns: database object, database version """ try: databasePath = parser.get("path", "databasePath") if databasePath == "micromegas": databasePath = installDirectory() + "/smodels-database/" database = db if database in [None, True]: force_load = None if database == True: force_load = "txt" database = Database(databasePath, force_load=force_load) databaseVersion = database.databaseVersion except DatabaseNotFoundException: logger.error("Database not found in %s" % os.path.realpath(databasePath)) sys.exit() return database, databaseVersion
def testCompare(self): warnings.simplefilter("ignore", ResourceWarning) from simplyGluino_default import smodelsOutputDefault filename = "./testFiles/slha/simplyGluino.slha" port = random.choice(range(31700, 42000)) # port = 31744 dbfile = "database/db30.pcl" dbfile = "unittest" startserver = f"../smodels/tools/smodelsTools.py proxydb -p {port} -i {dbfile} -o ./proxy.pcl -r -v error" cmd = startserver.split(" ") # print ( "starting server %s" % startserver ) myenv = os.environ.copy() pp = "" if "PYTHONPATH" in myenv: pp = ":" + myenv["PYTHONPATH"] myenv["PYTHONPATH"] = "../" + pp subprocess.Popen(cmd, env=myenv) time.sleep(3) db = Database("./proxy.pcl") outputfile = runMain(filename, suppressStdout=True, overridedatabase=db) smodelsOutput = importModule(outputfile) client = DatabaseClient(port=port, verbose="warn") client.send_shutdown() ignoreFields = [ 'input file', 'smodels version', 'ncpus', 'Element', 'database version', 'Total missed xsec', 'Missed xsec long-lived', 'Missed xsec displaced', 'Missed xsec MET', 'Total outside grid xsec', 'Total xsec for missing topologies (fb)', 'Total xsec for missing topologies with displaced decays (fb)', 'Total xsec for missing topologies with prompt decays (fb)', 'Total xsec for topologies outside the grid (fb)' ] smodelsOutputDefault['ExptRes'] = sorted( smodelsOutputDefault['ExptRes'], key=lambda res: res['r'], reverse=True) equals = equalObjs(smodelsOutput, smodelsOutputDefault, allowedDiff=0.08, ignore=ignoreFields, fname=outputfile) if not equals: e = "simplyGluino.py != simplyGluino_default.py" logger.error(e) # raise AssertionError( e ) self.assertTrue(equals) self.removeOutputs(outputfile)
def getDatabaseVersion(protomodel, dbpath="default.pcl"): dbver = "???" if hasattr(protomodel, "dbversion"): dbver = protomodel.dbversion if not "???" in dbver: return dbver if os.path.exists(dbpath): ## try to get db version from db file from smodels.experiment.databaseObj import Database db = Database(dbpath) dbver = db.databaseVersion return dbver
def getSRs(): from smodels.experiment.databaseObj import Database db = Database ( "official" ) ers = db.getExpResults( dataTypes=[ "efficiencyMap" ] ) stats = [] for er in ers: for ds in er.datasets: D = { "obsN": ds.dataInfo.observedN, "expectedBG": ds.dataInfo.expectedBG, "bgError": ds.dataInfo.bgError, "upperLimit": ds.dataInfo.upperLimit, "expectedUpperLimit": ds.dataInfo.expectedUpperLimit } stats.append ( D ) return stats
def __init__(self, inputfile, rundir, verbose="info"): self.inputfile = inputfile self.rundir = rundir self.nr = 0 self.verbstring = verbose if type(verbose) == int: self.verbose = verbose else: verbose = verbose.lower() verbs = {"err": 10, "warn": 20, "info": 30, "debug": 40} self.verbose = 50 for k, v in verbs.items(): if k in verbose: self.verbose = v self.database = Database(self.inputfile)
def __init__(self, database, force_txt = False ): """ :param database: Path to the database or Database object """ self._selectedExpResults = [] load = None if force_txt == True: load = "txt" if isinstance(database,str): self.database = Database(database, load ) elif isinstance(database,Database): self.database = database else: logger.error("The input must be the database location or a Database object.") raise SModelSError() self.loadAllResults()
def loadDatabase(parser, db): """ Load database :parameter parser: ConfigParser with path to database :parameter db: binary database object. If None, then database is loaded, according to databasePath. If True, then database is loaded, and text mode is forced. :returns: database object, database version """ try: dp = parser.get("path", "databasePath") logger.error("``[path] databasePath'' in ini file is deprecated; " \ "use ``[database] path'' instead.(See e.g. smodels/etc/parameters_default.ini)") parser.set("database", "path", dp) except (NoSectionError, NoOptionError) as e: ## path.databasePath not set. This is good. pass try: database = db # logger.error("database=db: %s" % database) if database in [None, True]: databasePath = parser.get("database", "path") checkForSemicolon(databasePath, "database", "path") discard_zeroes = True try: discard_zeroes = parser.getboolean("database", "discardZeroes") except (NoSectionError, NoOptionError) as e: logger.debug( "database:discardZeroes is not given in config file. Defaulting to 'True'." ) force_load = None if database == True: force_load = "txt" if os.path.isfile(databasePath): force_load = "pcl" database = Database(databasePath, force_load=force_load, \ discard_zeroes = discard_zeroes) databaseVersion = database.databaseVersion except DatabaseNotFoundException: logger.error("Database not found in ``%s''" % os.path.realpath(databasePath)) sys.exit() return database, databaseVersion
def getSummary(): from smodels.experiment.databaseObj import Database # dbpath = "official" dbpath = "<rundir>/database.pcl" print("[analysisCombiner] checking %s" % dbpath) db = Database(dbpath) results = db.getExpResults() strategy = "aggressive" ana1 = "CMS-SUS-16-042" ana2 = "CMS-SUS-16-033" canC = canCombine(ana1, ana2, strategy, results) print("[analysisCombiner] can combine %s with %s: %s" % (ana1, ana2, str(canC))) ctr, combinable = 0, 0 for x, e in enumerate(results): for y, f in enumerate(results): if y <= x: continue ctr += 1 isUn = canCombine(e.globalInfo, f.globalInfo, strategy) combinable += isUn print("[analysisCombiner] can combine %d/%d pairs of results" % (combinable, ctr))
def __init__(self, database, force_txt = False ): """ :ivar _selectedExpResults: list of experimental results loaded in the browser. Can be used to hold a subset of results in the database. By default all results are loaded. :param database: Path to the database or Database object """ self._selectedExpResults = [] load = None if force_txt == True: load = "txt" if isinstance(database,str): if database.endswith(".pcl"): load = "pcl" self.database = Database(database, load ) elif isinstance(database,Database): self.database = database else: logger.error("The input must be the database location or a Database object.") raise SModelSError() self.loadAllResults()
.. module:: Example :synopsis: Basic main file example for using SModelS. This file must be run under the installation folder. """ """ Import basic functions (this file must be executed in the installation folder) """ from smodels.theory import slhaDecomposer from smodels.theory import lheDecomposer from smodels.tools.physicsUnits import fb, GeV from smodels.theory.theoryPrediction import theoryPredictionsFor from smodels.experiment.databaseObj import Database # Set the path to the database folder database = Database("./smodels-database/") def main(): """ Main program. Displays basic use case. """ # Path to input file (either a SLHA or LHE file) slhafile = 'inputFiles/slha/lightEWinos.slha' # lhefile = 'inputFiles/lhe/gluino_squarks.lhe' # Set main options for decomposition sigmacut = 0.3 * fb mingap = 5. * GeV
def draw( strategy, databasepath, trianglePlot, miscol, diagcol, experiment, S, drawtimestamp, outputfile, nofastlim ): """ :param trianglePlot: if True, then only plot the upper triangle of this symmetrical matrix :param miscol: color to use when likelihood is missing :param diagcol: color to use for diagonal :param experiment: draw only for specific experiment ("CMS", "ATLAS", "all" ) :param S: draw only for specific sqrts ( "8", "13", "all" ) :param drawtimestamp: if true, put a timestamp on plot :param outputfile: file name of output file (matrix.png) :param nofastlim: if True, discard fastlim results """ ROOT.gStyle.SetOptStat(0000) ROOT.gROOT.SetBatch() cols = [ ROOT.kRed+1, ROOT.kWhite, ROOT.kGreen+1, miscol, diagcol ] ROOT.gStyle.SetPalette(len(cols), (ctypes.c_int * len(cols))(*cols) ) ROOT.gStyle.SetNumberContours(len(cols)) ROOT.gStyle.SetPadLeftMargin(.25) sqrtses = [ 8, 13 ] if S not in [ "all" ]: sqrtses = [ int(S) ] colors.on = True setLogLevel ( "debug" ) # dir = "/home/walten/git/smodels-database/" dir = databasepath d=Database( dir, discard_zeroes = True ) print(d) analysisIds = [ "all" ] exps = [ "CMS", "ATLAS" ] if experiment in [ "CMS", "ATLAS" ]: analysisIds = [ experiment+"*" ] exps = [ experiment ] results = d.getExpResults( analysisIDs = analysisIds ) if nofastlim: results = noFastlim ( results ) results = sortOutDupes ( results ) if S in [ "8", "13" ]: results = sortBySqrts ( results, int(S) ) #results.sort() nres = len ( results ) ROOT.c1=ROOT.TCanvas("c1","c1",1770,1540) ROOT.c1.SetLeftMargin(0.18) ROOT.c1.SetBottomMargin(0.21) ROOT.c1.SetTopMargin(0.06) ROOT.c1.SetRightMargin(0.01) if nres > 60: ROOT.c1.SetLeftMargin(0.12) ## seemed to work for 96 results ROOT.c1.SetBottomMargin(0.15) ROOT.c1.SetTopMargin(0.09) ROOT.c1.SetRightMargin(0.015) h=ROOT.TH2F ( "Correlations", "", nres, 0., nres, nres, 0., nres ) xaxis = h.GetXaxis() yaxis = h.GetYaxis() sze = 0.13 / math.sqrt ( nres ) xaxis.SetLabelSize( 1.3*sze ) yaxis.SetLabelSize( 1.3*sze ) bins= { "CMS": { 8: [999,0], 13:[999,0] }, "ATLAS": { 8: [999,0], 13: [999,0] } } n = len(results ) for x,e in enumerate(results): label = e.globalInfo.id hasLikelihood = hasLLHD ( e ) ana = analysisCombiner.getExperimentName ( e.globalInfo ) #if not hasLikelihood: # print ( "no likelihood: %s" % label ) sqrts = int(e.globalInfo.sqrts.asNumber(TeV)) color = ROOT.kCyan+2 ymax=0 if ana == "ATLAS": color = ROOT.kBlue+1 if sqrts > 10.: color += 2 if x < bins[ana][sqrts][0]: bins[ana][sqrts][0]=x if x > bins[ana][sqrts][1]: bins[ana][sqrts][1]=x ymax=x color = ROOT.kGray+2 if len(exps)==1 and len(sqrtses)==1: label = label.replace("CMS-","").replace("ATLAS-","").replace("-agg","") label = "#color[%d]{%s}" % (color, label ) xaxis.SetBinLabel(n-x, label ) yaxis.SetBinLabel(x+1, label ) for y,f in enumerate(results): if trianglePlot and y>x: continue isUn = analysisCombiner.canCombine ( e.globalInfo, f.globalInfo, strategy ) # isUn = e.isUncorrelatedWith ( f ) if isUn: h.SetBinContent ( n-x, y+1, 1. ) else: h.SetBinContent ( n-x, y+1, -1. ) if not hasLikelihood or not hasLLHD ( f ): ## has no llhd? cannot be combined h.SetBinContent ( n-x, y+1, 2. ) if y==x: h.SetBinContent ( n-x, y+1, 3. ) h.Draw("col") ROOT.bins, ROOT.xbins, ROOT.lines = {}, {}, [] if len(exps)==1 and len(sqrtses)==1: ROOT.t1 = ROOT.TLatex() ROOT.t1.SetNDC() ROOT.t1.DrawLatex ( .45, .95, "%s, %d TeV" % ( exps[0], sqrtses[0] ) ) for ana in exps: for sqrts in sqrtses: name= "%s%d" % ( ana, sqrts ) ROOT.bins[name] = ROOT.TLatex() ROOT.bins[name].SetTextColorAlpha(ROOT.kBlack,.7) ROOT.bins[name].SetTextSize(.025) ROOT.bins[name].SetTextAngle(90.) ROOT.xbins[name] = ROOT.TLatex() ROOT.xbins[name].SetTextColorAlpha(ROOT.kBlack,.7) ROOT.xbins[name].SetTextSize(.025) xcoord = .5 * ( bins[ana][sqrts][0] + bins[ana][sqrts][1] ) ycoord = n- .5 * ( bins[ana][sqrts][0] + bins[ana][sqrts][1] ) -3 if len(sqrtses)>1 or len(exps)>1: ROOT.bins[name].DrawLatex(-4,xcoord-3,"#splitline{%s}{%d TeV}" % ( ana, sqrts ) ) ROOT.xbins[name].DrawLatex(ycoord,-5,"#splitline{%s}{%d TeV}" % ( ana, sqrts ) ) yt = bins[ana][sqrts][1] +1 extrudes = 3 # how far does the line extrude into tick labels? xmax = n if trianglePlot: xmax = n-yt line = ROOT.TLine ( -extrudes, yt, xmax, yt ) line.SetLineWidth(2) line.Draw() ymax = n if trianglePlot: ymax = yt xline = ROOT.TLine ( n-yt, ymax, n-yt, -extrudes ) xline.SetLineWidth(2) xline.Draw() ROOT.lines.append ( line ) ROOT.lines.append ( xline ) line = ROOT.TLine ( -extrudes, 0, xmax, 0 ) line.SetLineWidth(2) line.Draw() xline = ROOT.TLine ( n, ymax, n, -extrudes ) xline.SetLineWidth(2) xline.Draw() ROOT.lines.append ( line ) ROOT.lines.append ( xline ) h.LabelsOption("v","X") if trianglePlot: for i in range(n+1): wline = ROOT.TLine ( n, i, n-i, i ) wline.SetLineColor ( ROOT.kWhite ) wline.Draw () ROOT.lines.append ( wline ) vline = ROOT.TLine ( i, n-i, i, n ) vline.SetLineColor ( ROOT.kWhite ) vline.Draw () ROOT.lines.append ( vline ) ROOT.title = ROOT.TLatex() ROOT.title.SetNDC() ROOT.title.SetTextSize(.025 ) ROOT.title.DrawLatex(.28,.89, "#font[132]{Correlations between analyses, combination strategy: ,,%s''}" % strategy ) ROOT.boxes = [] if trianglePlot: for i,b in enumerate ( [ "pair is uncorrelated", "pair is correlated", "likelihood is missing" ] ): bx = 51 by = 68 - 3*i box = ROOT.TBox(bx,by,bx+1,by+1) c = cols[i] if i > 0: c = cols[i+1] box.SetFillColor ( c ) box.Draw() ROOT.boxes.append ( box ) l = ROOT.TLatex() l.SetTextSize(.022) #if i == 2: # c = 16 l.SetTextColor ( c ) b="#font[132]{%s}" % b ## add font l.DrawLatex ( bx+2, by, b ) ROOT.boxes.append ( l ) l = ROOT.TLatex() l.SetNDC() l.SetTextColor(ROOT.kGray+1) l.SetTextSize(.015) if drawtimestamp: l.DrawLatex ( .01, .01, "plot produced %s from database v%s" % \ ( time.strftime("%h %d %Y" ), d.databaseVersion ) ) ROOT.gPad.SetGrid() if "@M" in outputfile: modifiers = "" if len(exps)==1: modifiers += exps[0] if len(sqrtses)==1: modifiers += str(sqrtses[0]) outputfile = outputfile.replace("@M",modifiers) print ( "Plotting to %s" % outputfile ) ROOT.c1.Print( outputfile )
#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.databaseObj import Database # In[3]: ## Load the database: databasePath = os.path.join(os.getenv("HOME"), "smodels-database/") db = Database(databasePath) # ## Look up upper limit for an Upper Limit-type result: # In[4]: #Select desired result: resultID = ["CMS-PAS-SUS-13-016"] txname = ["T1tttt"] expResult = db.getExpResults(analysisIDs=resultID, txnames=txname, dataTypes='upperLimit')[0] print 'selected result:', expResult # In[5]:
#!/usr/bin/env python3 """ just test that the fake signal gets injected in the right part of the UL maps """ import math from smodels.experiment.databaseObj import Database from smodels.tools.physicsUnits import GeV # ./ptools/fetchFromClip.py -R rundir.frozen1 --database db = Database("default.pcl") print("db", db.databaseVersion) er = db.getExpResults(["CMS-SUS-19-006"])[0] ds = er.datasets[0] print(ds.txnameList) txn = ds.txnameList[6] print(txn) def distance(mass): # return math.sqrt ( (mass[0] - 735.)**2 + (mass[1]-162.6)**2 ) return math.sqrt((mass[0] - 1166.)**2 + (mass[1] - 162.6)**2) masses = [] for mLSP in range(100, 240, 50): for msquark in range(850, 1300, 50): masses.append([msquark, mLSP]) # masses.append ( [[msquark*GeV,mLSP*GeV],[msquark*GeV,mLSP*GeV]] ) for mass in masses: mvec = [[mass[0] * GeV, mass[1] * GeV], [mass[0] * GeV, mass[1] * GeV]] oUL = txn.getULFor(mvec, expected=False) eUL = txn.getULFor(mvec, expected=True)
runtime.modelFile = 'smodels.share.models.mssm' #runtime.modelFile = 'mssmQNumbers.slha' from smodels.theory import decomposer from smodels.tools.physicsUnits import fb, GeV, TeV from smodels.theory.theoryPrediction import theoryPredictionsFor from smodels.experiment.databaseObj import Database from smodels.tools import coverage from smodels.tools.smodelsLogging import setLogLevel from smodels.particlesLoader import BSMList from smodels.share.models.SMparticles import SMList from smodels.theory.model import Model setLogLevel("info") # Set the path to the database database = Database("official") 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
def RunSModelS(self,SLHAFilePath,SummaryFilePath): # Set the path to the database database = Database("/home/oo1m20/softwares/smodels-1.2.2/smodels-database") self.SummaryFilePath = os.path.abspath(SummaryFilePath) #Define your model (list of rEven and rOdd particles) particlesLoader.load( 'smodels.share.models.secumssm' ) #Make sure all the model particles are up-to-date # Path to input file (either a SLHA or LHE file) self.SLHAFilePath = SLHAFilePath slhafile = self.SLHAFilePath #lhefile = 'inputFiles/lhe/gluino_squarks.lhe' # Set main options for decomposition sigmacut = 0.01 * fb mingap = 5. * GeV # Decompose model (use slhaDecomposer for SLHA input or lheDecomposer for LHE input) slhaInput = True if slhaInput: toplist = slhaDecomposer.decompose(slhafile, sigmacut, doCompress=True, doInvisible=True, minmassgap=mingap) else: toplist = lheDecomposer.decompose(lhefile, doCompress=True,doInvisible=True, minmassgap=mingap) # Access basic information from decomposition, using the topology list and topology objects: f= open(self.SummaryFilePath,"a+") print( "\n Decomposition Results: ", file=f ) print( "\t Total number of topologies: %i " %len(toplist), file=f ) nel = sum([len(top.elementList) for top in toplist]) print( "\t Total number of elements = %i " %nel , file=f) #Print information about the m-th topology (if it exists): m = 2 if len(toplist) > m: top = toplist[m] print( "\t\t %i-th topology = " %m,top,"with total cross section =",top.getTotalWeight(), file=f ) #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="", file=f ) print( "\n\t\t\twith final states =",el.getFinalStates(),"\n\t\t\twith cross section =",el.weight,"\n\t\t\tand masses = ",el.getMasses(), file=f ) # 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.getValuesFor('dataType')[0] if expType == 'upperLimit': nUL += 1 elif expType == 'efficiencyMap': nEM += 1 print( "\n Loaded Database with %i UL results and %i EM results " %(nUL,nEM), file=f ) # Compute the theory predictions for each experimental result and print them: print("\n Theory Predictions and Constraints:", file=f) 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, file=f) for theoryPrediction in predictions: dataset = theoryPrediction.dataset datasetID = dataset.dataInfo.dataId mass = theoryPrediction.mass txnames = [str(txname) for txname in theoryPrediction.txnames] PIDs = theoryPrediction.PIDs print( "------------------------", file=f ) print( "Dataset = ", datasetID, file=f ) #Analysis name print( "TxNames = ", txnames, file=f ) print( "Prediction Mass = ",mass, file=f ) #Value for average cluster mass (average mass of the elements in cluster) print( "Prediction PIDs = ",PIDs, file=f ) #Value for average cluster mass (average mass of the elements in cluster) print( "Theory Prediction = ",theoryPrediction.xsection, file=f ) #Signal cross section print( "Condition Violation = ",theoryPrediction.conditions, file=f ) #Condition violation values # Get the corresponding upper limit: print( "UL for theory prediction = ",theoryPrediction.upperLimit, file=f ) # Compute the r-value r = theoryPrediction.getRValue() print( "r = ",r , file=f) #Compute likelihhod and chi^2 for EM-type results: if dataset.dataInfo.dataType == 'efficiencyMap': theoryPrediction.computeStatistics() print( 'Chi2, likelihood=', theoryPrediction.chi2, theoryPrediction.likelihood, file=f ) 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, file=f ) if rmax > 1.: print( "(The input model is likely excluded by %s)" %bestResult, file=f ) else: print( "(The input model is not excluded by the simplified model results)", file=f ) f.close()
#!/usr/bin/env python3 """ .. module:: databaseLoader :synopsis: When running the complete test suite, we need to load the database only once .. moduleauthor:: Wolfgang Waltenberger <*****@*****.**> """ import sys sys.path.insert(0, "../") from smodels.experiment.databaseObj import Database from smodels.installation import version ver = "".join(map(str, version(True)[:3])) #dbname="./database/db%d0.pcl" % int ( sys.version[0] ) dbname = "http://smodels.hephy.at/database/unittest%s" % ver database = Database(dbname, discard_zeroes=False) if __name__ == "__main__": print(database)
# In[1]: #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]: from smodels.experiment.databaseObj import Database from smodels.tools.physicsUnits import GeV # In[3]: ## Load the database: dbPath = os.path.join(os.getenv("HOME"), "smodels-database/") database = Database(dbPath) # ## How to select results from one publication (or conference note) # In[6]: #Select only the CMS SUS-12-028 conference note expID = ["CMS-SUS-12-028"] # In[7]: #Loads the selected analyses #(The INFO tells you that superseded analyses are not loaded, see below) results = database.getExpResults(analysisIDs=expID) # In[9]:
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) ) from smodels.theory.theoryPrediction import theoryPredictionsFor combiner = Combiner()
#!/usr/bin/env python3 """ .. module:: databaseLoader :synopsis: When running the complete test suite, we need to load the database only once .. moduleauthor:: Wolfgang Waltenberger <*****@*****.**> """ import sys sys.path.insert(0, "../") from smodels.experiment.databaseObj import Database # dbpath = "./database" # dbpath = "../../smodels-database" dbpath = "unittest" database = Database(dbpath, discard_zeroes=False) if __name__ == "__main__": print(database)
def testLoadLatest(self): dblatest=Database ("latest") latestver = dblatest.databaseVersion.replace(".","") from databaseLoader import database thisver = database.databaseVersion.replace("unittest","").replace(".","") self.assertTrue ( latestver[:2]==thisver[:2] )
from smodels.installation import installDirectory from smodels.tools.physicsUnits import fb, GeV from smodels.theory.theoryPrediction import theoryPredictionsFor from smodels.experiment.databaseObj import Database # 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) databasepath = os.path.join(os.getenv("HOME"), "smodels-database/") database = Database(databasepath) expResults = database.getExpResults() topList = slhaDecomposer.decompose(filename, sigcut=0.03 * fb, doCompress=True, doInvisible=True, minmassgap=5 * GeV) allThPredictions = [theoryPredictionsFor(exp, topList) for exp in expResults] # In[5]: #Print the value of each theory prediction for each experimental #result and the corresponding upper limit (see the obtain experimental upper limits HowTo to learn how #to compute the upper limits). #Also print the expected upper limit, if available for thPreds in allThPredictions: