def run_point(settings, out_file, core): run_spheno(settings, out_file) if os.path.exists(settings["SPheno_output"]): spc = pyslha.read(settings["SPheno_output"]) if 'include_HiggsBounds' in settings: if settings["include_HiggsBounds"] == True: run_higgsbounds(settings, settings["SPheno_output"], core) if 'include_HiggsSignals' in settings: if settings["include_HiggsSignals"] == True: run_higgssignals(settings, settings["SPheno_output"], core) if 'include_MicrOmegas' in settings: if settings["include_MicrOmegas"] == True and spc.blocks['LSP'][ 1] == settings["Micromegas_candidate"]: run_micromegas(settings, settings["SPheno_output"], core) if 'check_saving' in settings: if settings["check_saving"] == True: save_point = settings["condition_to_save"](spc) else: save_point = True else: save_point = True if save_point == True: subprocess.call("cat " + settings["SPheno_output"] + " >> " + out_file, shell=True, stdout=std_out, stderr=std_err) subprocess.call("echo \"ENDOFPARAMETERPOINT\" >> " + out_file, shell=True, stdout=std_out, stderr=std_err)
def __init__(self, file, excluded=[], keepNegs=False): self.file = pyslha.read(path + "/" + file) self.masses = self.file.blocks['MASS'].items() self.higgs = [ Particle(i[0], i[1]) for i in self.masses if i[0] in higgs if i[0] not in excluded ] self.sleptons = [ Particle(i[0], i[1]) for i in self.masses if i[0] in sleptons if i[0] not in excluded ] self.squarks = [ Particle(i[0], i[1]) for i in self.masses if i[0] in squarks if i[0] not in excluded ] self.gauginos = [ Particle(i[0], i[1]) for i in self.masses if i[0] in gauginos if i[0] not in excluded ] if (keepNegs == False): self.tossNegs() self.sleptons.sort(key=lambda x: x.mass) self.squarks.sort(key=lambda x: x.mass) self.gauginos.sort(key=lambda x: x.mass) self.higgs.sort(key=lambda x: x.mass) self.ticklabels = [] self.makeMatrix()
def read_masses(slha_path): d = pyslha.read(slha_path) mb = d.blocks['MASS'] masses = {} for par in mb.items(): name = get_name(int(par[0])) if name is not None: masses[name] = abs(par[1]) # add some SM masses by hand masses['z'] = 91.1876 masses['n'] = 0.120 * 10**-9 masses['q'] = 1. / 4. * (2.3 + 4.8 + 1275 + 95) * 10**-3 masses['e'] = 0.5109989461 * 10**-3 masses['m'] = 105.6583745 * 10**-3 # now deal with R,L chiralities new_masses = {} for par in masses.items(): name = str(par[0]) if name[-1] == 'R' or name[-1] == 'L': m = 0.5 * (masses[name[:-1] + 'R'] + masses[name[:-1] + 'L']) if name[0] != 'N': assert m > 0, 'Mass of {} should be >0'.format(name) new_masses[name[:-1]] = abs(m) new_masses['Q'] = 1. / 4. * (new_masses['U'] + new_masses['D'] + new_masses['S'] + new_masses['C']) return {**masses, **new_masses}
def read_slha_output(self): data = pyslha.read(self.slha_output_file_path, ignorenomass=True) self.Omega = data.blocks["OMEGA"][1] self.proton_SI = data.blocks["DIRECT"][1] self.proton_SD = data.blocks["DIRECT"][2] self.neutron_SI = data.blocks["DIRECT"][3] self.neutron_SD = data.blocks["DIRECT"][4]
def compareSLHA(slhadefault, slhanew): newData = pyslha.read(slhanew, ignorenomass=True, ignorenobr=True, ignoreblocks=["SMODELS_SETTINGS"]) defaultData = pyslha.read(slhadefault, ignorenomass=True, ignorenobr=True, ignoreblocks=["SMODELS_SETTINGS"]) defaultBlocks = sorted( [defaultData.blocks[b].name for b in defaultData.blocks]) newBlocks = sorted([newData.blocks[b].name for b in newData.blocks]) if defaultBlocks != newBlocks: print('Blocks differ') return False for b in defaultData.blocks: if defaultData.blocks[b].entries != newData.blocks[b].entries: print('Entries in block %s differ' % (defaultData.blocks[b].name)) return False return True
def read_extract_slha( str ): #Reading the file d = pyslha.read(datafilepath) #Retrieving the relevant parameters MH0 = d.blocks['MASS'][35] MA0 = d.blocks['MASS'][36] MHC = d.blocks['MASS'][37] lam2 = d.blocks['FRBLOCK'][6] lamL = d.blocks['FRBLOCK'][5] #Retrieving the 13 TeV cross sections """ Reminder for the PDG codes PDG 35 : H0 PDG 36 : A0 PDG 37 : H+ PDG -37 : H- """ #Getting the list of cross sections myproc3535 = d.xsections[2212,2212,35,35] myproc3636 = d.xsections[2212,2212,36,36] myproc3737 = d.xsections[2212,2212,-37,37] myproc3537 = d.xsections[2212,2212,35,37] myproc3637 = d.xsections[2212,2212,36,37] myproc3735 = d.xsections[2212,2212,-37,35] myproc3736 = d.xsections[2212,2212,-37,36] myproc3536 = d.xsections[2212,2212,35,36] #Getting the 13 Tev Xsec value xsec_3535_13TeV = myproc3535.get_xsecs(sqrts=13000.)[0].value xsec_3636_13TeV = myproc3636.get_xsecs(sqrts=13000.)[0].value xsec_3737_13TeV = myproc3737.get_xsecs(sqrts=13000.)[0].value xsec_3537_13TeV = myproc3537.get_xsecs(sqrts=13000.)[0].value xsec_3637_13TeV = myproc3637.get_xsecs(sqrts=13000.)[0].value xsec_3735_13TeV = myproc3735.get_xsecs(sqrts=13000.)[0].value xsec_3736_13TeV = myproc3736.get_xsecs(sqrts=13000.)[0].value xsec_3536_13TeV = myproc3536.get_xsecs(sqrts=13000.)[0].value datatemp = [MH0,MA0,MHC,lam2,lamL,xsec_3535_13TeV,xsec_3636_13TeV,xsec_3737_13TeV,xsec_3537_13TeV,xsec_3637_13TeV,xsec_3735_13TeV,xsec_3736_13TeV,xsec_3536_13TeV] return datatemp;
def parse_SLHA(slha_file): slha = pyslha.read(slha_file) d = {} d['mg'] = slha.decays[1000021].mass d['mdL'] = slha.decays[1000001].mass d['mdR'] = slha.decays[2000001].mass d['muL'] = slha.decays[1000002].mass d['muR'] = slha.decays[2000002].mass d['msL'] = slha.decays[1000003].mass d['msR'] = slha.decays[2000003].mass d['mcL'] = slha.decays[1000004].mass d['mcR'] = slha.decays[2000004].mass d['mb1'] = slha.decays[1000005].mass d['mb2'] = slha.decays[2000005].mass d['mt1'] = slha.decays[1000006].mass d['mt2'] = slha.decays[2000006].mass d['mQ'] = 1.0 / 8.0 * (d['mdL'] + d['mdR'] + d['muL'] + d['muR'] + d['msL'] + d['msR'] + d['mcL'] + d['mcR']) return d
def getDecays ( self ): """ obtain the decays from input file, remove > 3000 GeV """ f = pyslha.read ( self.slhafile ) massblock = f.blocks["MASS"] mpids = [] for mpid in massblock.keys(): if massblock[mpid]<3000.: mpids.append ( mpid ) decblock = f.decays decays = {} for mpid in mpids: dec = decblock[mpid].decays if len(dec)==0: continue for d in dec: if d.br < 1e-1: ## ignore too small branchings continue if not mpid in decays: decays[mpid]=[] decays[mpid].append( {"br": d.br, "ids": d.ids } ) self.decays = decays
def cMSSMtoUML(cmssm_data, slha_folder): """ Takes points in 5D parameter space of cMSSM, reads appropriate SLHA files, and finds the corresponding four parameters of UML. :param cmssm_data: Numpy array with cMSSM parameter values. :param slha_folder: Relative path to folder where cMSSM SLHA files are stored. :return: Return numpy array (N,4) """ translated_data = [] for pp in cmssm_data: name = "cmssm_{}_{}_{}_{}_{}.slha".format(int(pp[0]), int(pp[1]), int(pp[2]), int(pp[3]), int(pp[4])) try: with open(os.path.join(slha_folder, name), 'r') as file: d = pyslha.read(file.name) mG = d.decays[1000021].__dict__['mass'] QL = [ d.decays[1000000 + ii].__dict__['mass'] for ii in (1, 2, 3, 4) ] QR = [ d.decays[2000000 + ii].__dict__['mass'] for ii in (1, 2, 3, 4) ] mQ = 1. / 8. * (sum(QL) + sum(QR)) Q3L = [ d.decays[1000000 + ii].__dict__['mass'] for ii in (5, 6) ] Q3R = [ d.decays[2000000 + ii].__dict__['mass'] for ii in (5, 6) ] mQ3 = 1. / 4. * (sum(Q3L) + sum(Q3R)) mN1 = d.decays[1000022].__dict__['mass'] translated_data.append((mG, mQ, mQ3, mN1)) except FileNotFoundError: print(os.path.join(slha_folder, name) + ' NOT FOUND!') translated_data = np.array(translated_data) # print(np.array(cmssm_data).shape, translated_data.shape) return translated_data
def retrieveMasses ( self ): """ retrieve the masses from slha file """ logger=logging.getLogger(__name__) logger.info ( "now extracting masses from slha file %s" % ( self.slhafile) ) namer = SParticleNames( susy = False ) f = pyslha.read ( self.slhafile ) m = f.blocks["MASS"] keys = m.keys() D={} for key in keys: mass = m[key] if mass > 4000.: continue name = namer.texName ( key ) if namer.isSM ( key ): ## skip SM particles continue if self.mergesquark: ## sum up all squarks if namer.particleType ( key ) == "q": name=name.rootName ( 1000001 ) D[key]={ "name": name, "m": mass } self.masspids = D return D
def get_spheno_spc(cwd, log, DebugDir, short): os.chdir(config.spheno_dir) out = open(cwd + "/" + DebugDir + "SPheno" + short + "_out.txt", "wb") err = open(cwd + "/" + DebugDir + "SPheno" + short + "_err.txt", "wb") if os.path.exists("SPheno.spc." + short): os.remove("SPheno.spc." + short) subprocess.call("./bin/SPheno" + short, shell=True, stdout=out, stderr=err) subprocess.call("sed -i 's/DECAY1L/decay/g' SPheno.spc." + short, shell=True, stdout=out, stderr=err) subprocess.call("sed -i 's/DECAY/DECAYTREE/g' SPheno.spc." + short, shell=True, stdout=out, stderr=err) subprocess.call("sed -i 's/decay/DECAY/g' SPheno.spc." + short, shell=True, stdout=out, stderr=err) out.close() err.close() return pyslha.read("SPheno.spc." + short)
def readSLHA(self, ordering): SLHA = pyslha.read(SLHAfilesPath + str(order)) self.m0 = SLHA.blocks["MINPAR"][1] self.m12 = SLHA.blocks["MINPAR"][2] self.SignumMu = SLHA.blocks["MINPAR"][4] self.Azero = SLHA.blocks["MINPAR"][5] self.TanBeta = SLHA.blocks["MINPAR"][7] self.TanBetaR = SLHA.blocks["MINPAR"][9] self.mARinput = SLHA.blocks["MINPAR"][10] self.vR = SLHA.blocks["MINPAR"][11] self.MuRinput = SLHA.blocks["MINPAR"][12] self.mBino = SLHA.blocks["MINPAR"][13] self.mBinop = SLHA.blocks["MINPAR"][14] self.mGluino = SLHA.blocks["MINPAR"][15] self.Yv11 = SLHA.blocks["YV"][1, 1] self.Yv22 = SLHA.blocks["YV"][2, 2] self.Yv33 = SLHA.blocks["YV"][3, 3] self.Ys11 = SLHA.blocks["YS"][1, 1] self.Ys22 = SLHA.blocks["YS"][2, 2] self.Ys33 = SLHA.blocks["YS"][3, 3]
def import_slha(filepath): """ Import parameters from SLHA file. This also calculates a mean squark mass for the first two generations. Parameters ---------- filepath : string Path of SLHA file to import """ # Try to open file (expand any environment variables and ~) filepath = os.path.abspath(os.path.expandvars( os.path.expanduser(filepath))) try: slha = pyslha.read(filepath, ignoreblocks=["DCINFO"]) # TODO: More checking of reasonable file? except IOError: raise IOError( "Unable to find SLHA file {file}. Parameters not set.".format( file=filepath)) # Send the slha.Doc object to the import_slha_doc function import_slha_doc(slha)
def LoadLHAFile(self, LHAPath): self.allcontent = pyslha.read(LHAPath, ignoreblocks=['SPINFO'])
#!/usr/bin/env python # @author: Rafal Maselek # @email: [email protected] # The following script checks, if the SLHA file provided # as a command line argument has correct SLHA structure. # To run this script a pyslha module is required. Install it by pip. import pyslha import sys try: d = pyslha.read(sys.argv[1]) except: sys.exit(1)
def readSLHAblocks(self, SLHApath): self.SLHA = pyslha.read(SLHApath) self.m0 = self.SLHA.blocks["MINPAR"][1] self.m12 = self.SLHA.blocks["MINPAR"][2] self.SignumMu = self.SLHA.blocks["MINPAR"][4] self.Azero = self.SLHA.blocks["MINPAR"][5] self.TanBeta = self.SLHA.blocks["MINPAR"][7] self.TanBetaR = self.SLHA.blocks["MINPAR"][9] self.mARinput = self.SLHA.blocks["MINPAR"][10] self.vR = self.SLHA.blocks["MINPAR"][11] self.MuRinput = self.SLHA.blocks["MINPAR"][12] self.mBino = self.SLHA.blocks["MINPAR"][13] self.mBinop = self.SLHA.blocks["MINPAR"][14] self.mGluino = self.SLHA.blocks["MINPAR"][15] self.gBLGUT = self.SLHA.blocks["GAUGEGUT"][1] self.gLGUT = self.SLHA.blocks["GAUGEGUT"][2] self.gRGUT = self.SLHA.blocks["GAUGEGUT"][4] self.g3GUT = self.SLHA.blocks["GAUGEGUT"][3] self.gBLSUSY = self.SLHA.blocks["GAUGE"][1] self.gLSUSY = self.SLHA.blocks["GAUGE"][2] self.gRSUSY = self.SLHA.blocks["GAUGE"][4] self.g3SUSY = self.SLHA.blocks["GAUGE"][3] self.gBLgRSUSY = self.SLHA.blocks["GAUGE"][10] self.gRgBLSUSY = self.SLHA.blocks["GAUGE"][11] self.MuRSUSY = self.SLHA.blocks["HMIX"][9] self.MuSUSY = self.SLHA.blocks["HMIX"][1] self.BmuRSUSY = self.SLHA.blocks["HMIX"][109] self.BmuSUSY = self.SLHA.blocks["HMIX"][101] self.vChiRbSUSY = self.SLHA.blocks["HMIX"][106] self.vChiRSUSY = self.SLHA.blocks["HMIX"][105] self.vdSUSY = self.SLHA.blocks["HMIX"][102] self.vuSUSY = self.SLHA.blocks["HMIX"][103] self.vSUSY = self.SLHA.blocks["HMIX"][3] self.mHd2SUSY = self.SLHA.blocks["MSOFT"][21] self.mHu2SUSY = self.SLHA.blocks["MSOFT"][22] self.mCR2SUSY = self.SLHA.blocks["MSOFT"][31] self.mCRb2SUSY = self.SLHA.blocks["MSOFT"][32] self.M1SUSY = self.SLHA.blocks["MSOFT"][1] self.M2SUSY = self.SLHA.blocks["MSOFT"][2] self.M3SUSY = self.SLHA.blocks["MSOFT"][3] self.M4SUSY = self.SLHA.blocks["MSOFT"][4] self.Ys11SUSY = self.SLHA.blocks["YS"][1, 1] self.Ys22SUSY = self.SLHA.blocks["YS"][2, 2] self.Ys33SUSY = self.SLHA.blocks["YS"][3, 3] self.Yv11SUSY = self.SLHA.blocks["YV"][1, 1] self.Yv12SUSY = self.SLHA.blocks["YV"][1, 2] self.Yv13SUSY = self.SLHA.blocks["YV"][1, 3] self.Yv21SUSY = self.SLHA.blocks["YV"][2, 1] self.Yv22SUSY = self.SLHA.blocks["YV"][2, 2] self.Yv23SUSY = self.SLHA.blocks["YV"][2, 3] self.Yv31SUSY = self.SLHA.blocks["YV"][3, 1] self.Yv32SUSY = self.SLHA.blocks["YV"][3, 2] self.Yv33SUSY = self.SLHA.blocks["YV"][3, 3] if 'HMIXGUT' in self.SLHA.blocks.keys(): self.MuRGUT = self.SLHA.blocks["HMIXGUT"][9] self.MuGUT = self.SLHA.blocks["HMIXGUT"][1] self.BMuRGUT = self.SLHA.blocks["HMIXGUT"][109] self.BmuGUT = self.SLHA.blocks["HMIXGUT"][101] else: self.MuRGUT = 1e40 self.MuGUT = 1e40 self.BMuRGUT = 1e40 self.BmuGUT = 1e40 if 'MSOFTGUT' in self.SLHA.blocks.keys(): self.mHd2GUT = self.SLHA.blocks["MSOFTGUT"][21] self.mHu2GUT = self.SLHA.blocks["MSOFTGUT"][22] self.mCR2GUT = self.SLHA.blocks["MSOFTGUT"][31] self.mCRb2GUT = self.SLHA.blocks["MSOFTGUT"][32] self.M1GUT = self.SLHA.blocks["MSOFTGUT"][1] self.M2GUT = self.SLHA.blocks["MSOFTGUT"][2] self.M3GUT = self.SLHA.blocks["MSOFTGUT"][3] self.M4GUT = self.SLHA.blocks["MSOFTGUT"][4] else: self.mHd2GUT = 1e40 self.mHu2GUT = 1e40 self.mCR2GUT = 1e40 self.mCRb2GUT = 1e40 self.M1GUT = 1e40 self.M2GUT = 1e40 self.M3GUT = 1e40 self.M4GUT = 1e40 self.Sd_1 = self.SLHA.blocks["MASS"][1000001] self.Sd_2 = self.SLHA.blocks["MASS"][1000003] self.Sd_3 = self.SLHA.blocks["MASS"][1000005] self.Sd_4 = self.SLHA.blocks["MASS"][2000001] self.Sd_5 = self.SLHA.blocks["MASS"][2000003] self.Sd_6 = self.SLHA.blocks["MASS"][2000005] self.Su_1 = self.SLHA.blocks["MASS"][1000002] self.Su_2 = self.SLHA.blocks["MASS"][1000004] self.Su_3 = self.SLHA.blocks["MASS"][1000006] self.Su_4 = self.SLHA.blocks["MASS"][2000002] self.Su_5 = self.SLHA.blocks["MASS"][2000004] self.Su_6 = self.SLHA.blocks["MASS"][2000006] self.Se_1 = self.SLHA.blocks["MASS"][1000011] self.Se_2 = self.SLHA.blocks["MASS"][1000013] self.Se_3 = self.SLHA.blocks["MASS"][1000015] self.Se_4 = self.SLHA.blocks["MASS"][2000011] self.Se_5 = self.SLHA.blocks["MASS"][2000013] self.Se_6 = self.SLHA.blocks["MASS"][2000015] self.Sv_1 = self.SLHA.blocks["MASS"][1000012] self.Sv_2 = self.SLHA.blocks["MASS"][1000014] self.Sv_3 = self.SLHA.blocks["MASS"][1000016] self.Sv_4 = self.SLHA.blocks["MASS"][2000012] self.Sv_5 = self.SLHA.blocks["MASS"][2000014] self.Sv_6 = self.SLHA.blocks["MASS"][2000016] self.Sv_7 = self.SLHA.blocks["MASS"][3000012] self.Sv_8 = self.SLHA.blocks["MASS"][3000014] self.Sv_9 = self.SLHA.blocks["MASS"][3000016] self.hh_1 = self.SLHA.blocks["MASS"][25] self.hh_2 = self.SLHA.blocks["MASS"][35] self.hh_3 = self.SLHA.blocks["MASS"][225] self.hh_4 = self.SLHA.blocks["MASS"][232] self.Ah_3 = self.SLHA.blocks["MASS"][36] self.Ah_4 = self.SLHA.blocks["MASS"][236] self.Hpm_2 = self.SLHA.blocks["MASS"][37] self.VZ = self.SLHA.blocks["MASS"][23] self.VMm = self.SLHA.blocks["MASS"][24] self.VZR = self.SLHA.blocks["MASS"][99] self.Glu = self.SLHA.blocks["MASS"][1000021] self.Chi_1 = self.SLHA.blocks["MASS"][1000022] self.Chi_2 = self.SLHA.blocks["MASS"][1000023] self.Chi_3 = self.SLHA.blocks["MASS"][1000025] self.Chi_4 = self.SLHA.blocks["MASS"][1000035] self.Chi_5 = self.SLHA.blocks["MASS"][9000001] self.Chi_6 = self.SLHA.blocks["MASS"][9000002] self.Chi_7 = self.SLHA.blocks["MASS"][9000003] self.Cha_1 = self.SLHA.blocks["MASS"][1000024] self.Cha_2 = self.SLHA.blocks["MASS"][1000037] self.LSP = self.SLHA.blocks["LSP"][1] self.NLSP = self.SLHA.blocks["LSP"][2] self.SNUMIX11 = self.SLHA.blocks["SNUMIX"][1, 1] self.SNUMIX12 = self.SLHA.blocks["SNUMIX"][1, 2] self.SNUMIX13 = self.SLHA.blocks["SNUMIX"][1, 3] self.SNUMIX14 = self.SLHA.blocks["SNUMIX"][1, 4] self.SNUMIX15 = self.SLHA.blocks["SNUMIX"][1, 5] self.SNUMIX16 = self.SLHA.blocks["SNUMIX"][1, 6] self.SNUMIX17 = self.SLHA.blocks["SNUMIX"][1, 7] self.SNUMIX18 = self.SLHA.blocks["SNUMIX"][1, 8] self.SNUMIX19 = self.SLHA.blocks["SNUMIX"][1, 9] self.NMIX11 = self.SLHA.blocks["NMIX"][1, 1] self.NMIX12 = self.SLHA.blocks["NMIX"][1, 2] self.NMIX13 = self.SLHA.blocks["NMIX"][1, 3] self.NMIX14 = self.SLHA.blocks["NMIX"][1, 4] self.NMIX15 = self.SLHA.blocks["NMIX"][1, 5] self.NMIX16 = self.SLHA.blocks["NMIX"][1, 6] self.NMIX17 = self.SLHA.blocks["NMIX"][1, 7] if self.SLHA.blocks["HIGGSLHC14"].keys() == [(1, 25)]: self.hh_1LHC14glufus = self.SLHA.blocks["HIGGSLHC14"][1, 25] if self.SLHA.blocks["HIGGSLHC14"].keys() == [(1, 35)]: self.hh_2LHC14glufus = self.SLHA.blocks["HIGGSLHC14"][1, 35] if self.SLHA.blocks["HIGGSFCC100"].keys() == [(1, 25)]: self.hh_1FCC100glufus = self.SLHA.blocks["HIGGSFCC100"][1, 25] if self.SLHA.blocks["HIGGSFCC100"].keys() == [(1, 35)]: self.hh_2FCC100glufus = self.SLHA.blocks["HIGGSFCC100"][1, 35] self.muon_g_2 = self.SLHA.blocks["SPHENOLOWENERGY"][21] self.Bxsgamma = self.SLHA.blocks["FLAVORKITQFV"][200] self.RBtaunu = self.SLHA.blocks["FLAVORKITQFV"][503] self.Bsmumu = self.SLHA.blocks["FLAVORKITQFV"][4006] ######################################################################### # If Block HiggsBoundsResults is added by # HiggsBounds http://projects.hepforge.org/higgsbounds if 'HIGGSBOUNDSRESULTS' in self.SLHA.blocks.keys(): self.HBresult = self.SLHA.blocks["HIGGSBOUNDSRESULTS"][ 1, 2] # HBresult else: self.HBresult = 1e40 ######################################################################### # If BLOCK HiggsSignalsResults is added by HiggsSignals if 'HIGGSSIGNALSRESULTS' in self.SLHA.blocks.keys(): self.totchi2 = self.SLHA.blocks["HIGGSSIGNALSRESULTS"][ 12] # chi^2 (total) else: self.totchi2 = 1e40 ######################################################################### # If BLOCK RELIC is added by MicrOmegas if 'RELIC' in self.SLHA.blocks.keys(): self.RelicDensity = self.SLHA.blocks["RELIC"][700] # relic density self.ProtonSI = self.SLHA.blocks["RELIC"][201] # Proton SI [pb] self.NeutronSI = self.SLHA.blocks["RELIC"][203] # Neutron SI [pb] self.IceCubeExcCL = self.SLHA.blocks["RELIC"][ 305] # IceCube22 exclusion confidence level self.sigmaV = self.SLHA.blocks["RELIC"][ 306] # sigmaV [cm^3/s] Annihilation cross section self.PhotonFlux = self.SLHA.blocks["RELIC"][ 307] # Photon flux [cm^2 s GeV]^{-1} self.PositronFlux = self.SLHA.blocks["RELIC"][ 308] # Positron flux [cm^2 sr s GeV]^{-1} self.AntiProtonFlux = self.SLHA.blocks["RELIC"][ 309] # Antiproton flux [cm^2 sr s GeV]^{-1} self.NeutrinoFlux = self.SLHA.blocks["RELIC"][ 310] # Neutrino Flux [1/Year/km^2] self.AntiNeutrinoFlux = self.SLHA.blocks["RELIC"][ 311] # Anti-Neutrino Flux [1/Year/km^2] else: self.RelicDensity = 1e40 self.ProtonSI = 1e40 self.NeutronSI = 1e40 self.IceCubeExcCL = 1e40 self.sigmaV = 1e40 self.PhotonFlux = 1e40 self.PositronFlux = 1e40 self.AntiProtonFlux = 1e40 self.NeutrinoFlux = 1e40 self.AntiNeutrinoFlux = 1e40
def read_slha(path, reader_list=None): """ Reads a .slha file to :obj:`pyslha.Doc` object or :obj:`numpy.ndarray`. Reads the content of a .slha file into a :obj:`pyslha.Doc`. If a reader list was provided these requested entries are extracted fromt the :obj:`pyslha.Doc` object and returned as a :obj:`numpy.ndarray`. If no readerlist was provided the :obj:`pyslha.Doc` object is returned. Parameters ---------- path: :obj:`str` Path of the .slha file to be read reader_list: :obj:`list(list)` of slha [BLOCK, SWITCH] entries. Optional List of entries in the .slha file, denoted by [BLOCK, SWITCH] entries. A reader list is therefore 2-dimensional object (a list of lists). If `None` was provided, no specific elements will be read from the file. Default is `None`. Returns ------- content: :obj:`pyslha.Doc`, :obj:`numpy.ndarray` If a valid reader list was provided a numpy.ndarray with the requested content is returned. Else the pylsha.Doc object is returned. """ # Read .slha file into pyslha.Doc object docobj = None if (isinstance(path, pyslha.Doc)): return path if isinstance(path, str): if os.path.isfile(path): try: docobj = pyslha.read(path) except Exception as e: raise exceptions.FileIOException( ("Unexpected pyslha error while reading '{}': {}.").format( path, str(e))) else: raise exceptions.FileIOException( "File not found '{}'.".format(path)) else: raise exceptions.FileIOException( ("Filepath to the .slha to read has to be a string (supplied: " "'{}').").format(type(path))) # Check if reader list is provided if reader_list is None: return docobj if isinstance(reader_list, list): data = np.zeros(len(reader_list)) for i, reader_entry in enumerate(reader_list): if len(reader_entry[i]) != 2: raise exceptions.FileIOException(("Datalist must only contain " "lists with format [BLOCK, " "SWITCH].")) try: try: data[i] = docobj.blocks[reader_entry[0].upper()][int( reader_entry[1])] except Exception: data[i] = docobj.blocks[reader_entry[0].upper()][ reader_entry[1]] except ValueError as e: raise exceptions.FileIOException( ("SWITCH '{}' could not be casted to an integer or " "tuple.").format(reader_entry[1])) except KeyError: raise exceptions.FileIOException( "No SWITCH '{}' in BLOCK '{}' found.".format( reader_entry[1], reader_entry[0])) return data return docobj
def __init__(self, SLHApath): self.SLHA = pyslha.read(SLHApath, ignoreblocks=['SPINFO'])
def read_input(filename, array = 0, fn = 'sample_1.spc'): if array == 0: SLHA_FILE=pyslha.read(filename, ignoreblocks=['SPINFO']) SLHA_FILE.blocks #parameters we're interested in mixing1=float(SLHA_FILE.blocks["UMIX"][1,1]) mixing2=float(SLHA_FILE.blocks["UMIX"][1,2]) mixing3=float(SLHA_FILE.blocks["VMIX"][1,1]) mixing4=float(SLHA_FILE.blocks["VMIX"][1,2]) mixing5=float(SLHA_FILE.blocks["NMIX"][2,1]) mixing6=float(SLHA_FILE.blocks["NMIX"][2,2]) mixing7=float(SLHA_FILE.blocks["NMIX"][2,3]) mixing8=float(SLHA_FILE.blocks["NMIX"][2,4]) mneut1=float(SLHA_FILE.blocks["MASS"][1000022]) mneut2=float(SLHA_FILE.blocks["MASS"][1000023]) mchar1=float(SLHA_FILE.blocks["MASS"][1000024]) mchar2=float(SLHA_FILE.blocks["MASS"][1000037]) msq1=float(SLHA_FILE.blocks["MASS"][1000001]) msq2=float(SLHA_FILE.blocks["MASS"][2000001]) msq3=float(SLHA_FILE.blocks["MASS"][2000002]) msq4=float(SLHA_FILE.blocks["MASS"][1000002]) msq5=float(SLHA_FILE.blocks["MASS"][1000003]) msq6=float(SLHA_FILE.blocks["MASS"][2000003]) msq7=float(SLHA_FILE.blocks["MASS"][1000004]) msq8=float(SLHA_FILE.blocks["MASS"][2000004]) mgluino=float(SLHA_FILE.blocks["MASS"][1000021]) #other masses for making sure that n1 is the LSP lsp1=float(SLHA_FILE.blocks["MASS"][1000023]) lsp2=float(SLHA_FILE.blocks["MASS"][1000025]) lsp3=float(SLHA_FILE.blocks["MASS"][1000035]) lsp4=float(SLHA_FILE.blocks["MASS"][1000024]) lsp5=float(SLHA_FILE.blocks["MASS"][1000037]) lsp6=float(SLHA_FILE.blocks["MASS"][1000002]) lsp7=float(SLHA_FILE.blocks["MASS"][1000003]) lsp8=float(SLHA_FILE.blocks["MASS"][2000003]) lsp9=float(SLHA_FILE.blocks["MASS"][1000004]) lsp10=float(SLHA_FILE.blocks["MASS"][2000004]) lsp11=float(SLHA_FILE.blocks["MASS"][1000005]) lsp12=float(SLHA_FILE.blocks["MASS"][2000005]) lsp13=float(SLHA_FILE.blocks["MASS"][1000006]) lsp14=float(SLHA_FILE.blocks["MASS"][2000006]) lsp15=float(SLHA_FILE.blocks["MASS"][1000011]) lsp16=float(SLHA_FILE.blocks["MASS"][2000011]) lsp17=float(SLHA_FILE.blocks["MASS"][1000012]) lsp18=float(SLHA_FILE.blocks["MASS"][1000013]) lsp19=float(SLHA_FILE.blocks["MASS"][2000013]) lsp20=float(SLHA_FILE.blocks["MASS"][1000014]) lsp21=float(SLHA_FILE.blocks["MASS"][1000015]) lsp22=float(SLHA_FILE.blocks["MASS"][2000015]) lsp23=float(SLHA_FILE.blocks["MASS"][1000016]) lsp24=float(SLHA_FILE.blocks["MASS"][1000021]) if abs(mneut1) < abs(msq1) and abs(mneut1) < abs(msq2) and abs(mneut1) < abs(msq3) and abs(mneut1) < abs(lsp1) and abs(mneut1) < abs(lsp2) and abs(mneut1) < abs(lsp3) and abs(mneut1) < abs(lsp4) and abs(mneut1) < abs(lsp5) and abs(mneut1) < abs(lsp6) and abs(mneut1) < abs(lsp7) and abs(mneut1) < abs(lsp8) and abs(mneut1) < abs(lsp9) and abs(mneut1) < abs(lsp10) and abs(mneut1) < abs(lsp11) and abs(mneut1) < abs(lsp12) and abs(mneut1) < abs(lsp13) and abs(mneut1) < abs(lsp14) and abs(mneut1) < abs(lsp15) and abs(mneut1) < abs(lsp16) and abs(mneut1) < abs(lsp17) and abs(mneut1) < abs(lsp18) and abs(mneut1) < abs(lsp19) and abs(mneut1) < abs(lsp20) and abs(mneut1) < abs(lsp21) and abs(mneut1) < abs(lsp22) and abs(mneut1) < abs(lsp23) and abs(mneut1) < abs(lsp24): pass else: print('WARNING: Neutralino 1 is not the LSP. Our AIs are specialised on cross-sections for SUSY models in which Neutralino 1 is the lightest supersymmetric particle. Predictions in this region of the parameter space have not yet been tested for reliability.') if msq1 < 500 or msq2 < 500 or msq3 < 500 or msq4 < 500 or msq5 < 500 or msq6 < 500 or msq7 < 500 or msq8 < 500: print('WARNING: One of the squarks is lighter than what our AIs are trained on. Predictions in this region of the parameter space have not yet been tested for reliability.') if abs(mchar1) < 100: print('WARNING: The chargino1 has a mass lower than 100 GeV and is excluded.') input = np.empty([1,19]) input[0,0] = mixing1 input[0,1] = mixing2 input[0,2] = mixing3 input[0,3] = mixing4 input[0,4] = mixing5 input[0,5] = mixing6 input[0,6] = mixing7 input[0,7] = mixing8 input[0,8] = mneut2 input[0,9] = mchar1 input[0,10] = msq1 input[0,11] = msq2 input[0,12] = msq3 input[0,13] = msq4 input[0,14] = msq5 input[0,15] = msq6 input[0,16] = msq7 input[0,17] = msq8 input[0,18] = mgluino elif array == 1: raw_input = pd.read_csv(filename, sep=' ', header=None) input = raw_input.values input = input.astype(np.float) else: exit() return input
def read_spheno_output(self): data = pyslha.read(self.spheno_output_file_path) self.set_higgs_dependent_variables(data) self.set_fermion_dependent_variables(data) self.set_scalar_dependent_variables(data) self.set_neutrino_dependent_variables(data)