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)
