def run_from_pickle(self):
import madgraph.iolibs.save_load_object as save_load_object
generate_all = save_load_object.load_from_file(
pjoin(self.options['ms_dir'], 'madspin.pkl'))
# Re-create information which are not save in the pickle.
generate_all.evtfile = self.events_file
generate_all.curr_event = madspin.Event(self.events_file, self.banner)
generate_all.mgcmd = self.mg5cmd
generate_all.mscmd = self
generate_all.pid2width = lambda pid: generate_all.banner.get(
'param_card', 'decay', abs(pid)).value
generate_all.pid2mass = lambda pid: generate_all.banner.get(
'param_card', 'mass', abs(pid)).value
if generate_all.path_me != self.options['ms_dir']:
for decay in generate_all.all_ME.values():
decay['path'] = decay['path'].replace(generate_all.path_me,
self.options['ms_dir'])
for decay2 in decay['decays']:
decay2['path'] = decay2['path'].replace(
generate_all.path_me, self.options['ms_dir'])
generate_all.path_me = self.options[
'ms_dir'] # directory can have been move
generate_all.ms_dir = generate_all.path_me
if not hasattr(self.banner, 'param_card'):
self.banner.charge_card('slha')
# Special treatment for the mssm. Convert the param_card to the correct
# format
if self.banner.get('model').startswith('mssm-') or self.banner.get(
'model') == 'mssm':
self.banner.param_card = check_param_card.convert_to_mg5card(\
self.banner.param_card, writting=False)
for name, block in self.banner.param_card.items():
if name.startswith('decay'):
continue
orig_block = generate_all.banner.param_card[name]
if block != orig_block:
raise Exception, """The directory %s is specific to a mass spectrum.
Your event file is not compatible with this one. (Different param_card: %s different)
orig block:
%s
new block:
%s""" \
% (self.options['ms_dir'], name, orig_block, block)
#replace init information
generate_all.banner['init'] = self.banner['init']
#replace run card if present in header (to make sure correct random seed is recorded in output file)
if 'mgruncard' in self.banner:
generate_all.banner['mgruncard'] = self.banner['mgruncard']
# NOW we have all the information available for RUNNING
if self.seed:
#seed is specified need to use that one:
open(pjoin(self.options['ms_dir'], 'seeds.dat'),
'w').write('%s\n' % self.seed)
#remove all ranmar_state
for name in misc.glob(
pjoin('*', 'SubProcesses', '*', 'ranmar_state.dat'),
self.options['ms_dir']):
os.remove(name)
generate_all.ending_run()
self.branching_ratio = generate_all.branching_ratio
try:
self.err_branching_ratio = generate_all.err_branching_ratio
except Exception:
# might not be define in some gridpack mode
self.err_branching_ratio = 0
evt_path = self.events_file.name
try:
self.events_file.close()
except:
pass
misc.gzip(evt_path)
decayed_evt_file = evt_path.replace('.lhe', '_decayed.lhe')
misc.gzip(pjoin(self.options['curr_dir'], 'decayed_events.lhe'),
stdout=decayed_evt_file)
if not self.mother:
logger.info("Decayed events have been written in %s.gz" %
decayed_evt_file)
def set_parameters_and_couplings(self, param_card = None, scale=None,
complex_mass_scheme=None):
"""Read a param_card and calculate all parameters and
couplings. Set values directly in the parameters and
couplings, plus add new dictionary coupling_dict from
parameter name to value."""
param_card_text = None
# Extract external parameters
external_parameters = self['parameters'][('external',)]
# Read in param_card
if param_card:
# Create a dictionary from LHA block name and code to parameter name
parameter_dict = {}
for param in external_parameters:
try:
dictionary = parameter_dict[param.lhablock.lower()]
except KeyError:
dictionary = {}
parameter_dict[param.lhablock.lower()] = dictionary
dictionary[tuple(param.lhacode)] = param
if isinstance(param_card, basestring):
# Check that param_card exists
if not os.path.isfile(param_card):
raise MadGraph5Error, "No such file %s" % param_card
param_card_text = param_card
param_card = card_reader.ParamCard(param_card)
#misc.sprint(type(param_card), card_reader.ParamCard, isinstance(param_card, card_reader.ParamCard))
#assert isinstance(param_card, card_reader.ParamCard),'%s is not a ParamCard: %s' % (type(param_card), isinstance(param_card, card_reader.ParamCard))
if complex_mass_scheme is None:
if aloha.complex_mass:
param_card.convert_to_complex_mass_scheme()
else:
if complex_mass_scheme:
param_card.convert_to_complex_mass_scheme()
key = [k for k in param_card.keys() if not k.startswith('qnumbers ')
and not k.startswith('decay_table')
and 'info' not in k]
param_key = [k for k in parameter_dict.keys() if 'info' not in k]
if set(key) != set(parameter_dict.keys()):
# the two card are different. check if this critical
fail = True
missing_set = set(parameter_dict.keys()).difference(set(key))
unknow_set = set(key).difference(set(parameter_dict.keys()))
missing_block = ','.join(missing_set)
unknow_block = ','.join(unknow_set)
msg = '''Invalid restriction card (not same block)
%s != %s.
Missing block: %s
Unknown block : %s''' % (set(key), set(parameter_dict.keys()),
missing_block, unknow_block)
apply_conversion = []
if not missing_block:
logger.warning("Unknow type of information in the card: %s" % unknow_block)
fail = False
elif self['name'].startswith('mssm-') or self['name'] == 'mssm':
if not missing_set:
fail = False
else:
apply_conversion.append('to_slha2')
overwrite = False
elif missing_set == set(['fralpha']) and 'alpha' in unknow_set:
apply_conversion.append('alpha')
elif self.need_slha2(missing_set, unknow_set):
apply_conversion.append('to_slha2')
overwrite = True
if apply_conversion:
try:
if 'to_slha2' in apply_conversion:
if overwrite:
logger.error('Convention for the param_card seems to be wrong. Trying to automatically convert your file to SLHA2 format. \n'+\
"Please check that the conversion occurs as expected (The converter is not fully general)")
import time
time.sleep(5)
param_card = param_card.input_path
param_card = card_reader.convert_to_mg5card(param_card,
writting=overwrite)
key = [k for k in param_card.keys() if not k.startswith('qnumbers ')
and not k.startswith('decay_table')]
if not set(parameter_dict.keys()).difference(set(key)):
fail = False
if 'alpha' in apply_conversion:
logger.info("Missing block fralpha but found a block alpha, apply automatic conversion")
param_card.rename_blocks({'alpha':'fralpha'})
param_card['fralpha'].rename_keys({(): (1,)})
param_card.write(param_card.input_path)
key = [k for k in param_card.keys() if not k.startswith('qnumbers ')
and not k.startswith('decay_table')]
if not set(parameter_dict.keys()).difference(set(key)):
fail = False
except Exception:
raise
raise MadGraph5Error, msg
if fail:
raise MadGraph5Error, msg
for block in key:
if block not in parameter_dict:
continue
for pid in parameter_dict[block]:
try:
value = param_card[block].get(pid).value
except:
raise MadGraph5Error, '%s %s not define' % (block, pid)
else:
if isinstance(value, str) and value.lower() == 'auto':
value = '0.0'
if scale and parameter_dict[block][pid].name == 'aS':
runner = Alphas_Runner(value, nloop=2)
try:
value = runner(scale)
except ValueError, err:
if str(err) == 'math domain error' and scale < 1:
value = 0.0
else:
raise
exec("locals()[\'%s\'] = %s" % (parameter_dict[block][pid].name,
value))
parameter_dict[block][pid].value = float(value)
def set_parameters_and_couplings(self, param_card = None, scale=None,
complex_mass_scheme=None):
"""Read a param_card and calculate all parameters and
couplings. Set values directly in the parameters and
couplings, plus add new dictionary coupling_dict from
parameter name to value."""
# Extract external parameters
external_parameters = self['parameters'][('external',)]
# Read in param_card
if param_card:
# Create a dictionary from LHA block name and code to parameter name
parameter_dict = {}
for param in external_parameters:
try:
dictionary = parameter_dict[param.lhablock.lower()]
except KeyError:
dictionary = {}
parameter_dict[param.lhablock.lower()] = dictionary
dictionary[tuple(param.lhacode)] = param
if isinstance(param_card, basestring):
# Check that param_card exists
if not os.path.isfile(param_card):
raise MadGraph5Error, "No such file %s" % param_card
param_card = card_reader.ParamCard(param_card)
# misc.sprint(type(param_card), card_reader.ParamCard, isinstance(param_card, card_reader.ParamCard))
# assert isinstance(param_card, card_reader.ParamCard),'%s is not a ParamCard: %s' % (type(param_card), isinstance(param_card, card_reader.ParamCard))
if complex_mass_scheme is None:
if aloha.complex_mass:
param_card.convert_to_complex_mass_scheme()
else:
if complex_mass_scheme:
param_card.convert_to_complex_mass_scheme()
key = [k for k in param_card.keys() if not k.startswith('qnumbers ')
and not k.startswith('decay_table')
and 'info' not in k]
param_key = [k for k in parameter_dict.keys() if 'info' not in k]
if set(key) != set(parameter_dict.keys()):
# the two card are different. check if this critical
fail = True
missing_block = ','.join(set(parameter_dict.keys()).difference(set(key)))
unknow_block = ','.join(set(key).difference(set(parameter_dict.keys())))
msg = '''Invalid restriction card (not same block)
%s != %s.
Missing block: %s
Unknown block : %s''' % (set(key), set(parameter_dict.keys()),
missing_block, unknow_block)
if not missing_block:
logger.warning("Unknow type of information in the card: %s" % unknow_block)
fail = False
elif msg =="Invalid restriction card (not same block)\n set(['yu', 'umix', 'ae', 'ad', 'decay', 'nmix', 'ye', 'sbotmix', 'msoft', 'yd', 'vmix', 'au', 'mass', 'alpha', 'modsel', 'sminputs', 'staumix', 'stopmix', 'hmix']) != set(['umix', 'msoft', 'msu2', 'fralpha', 'msd2', 'msl2', 'decay', 'tu', 'selmix', 'td', 'te', 'usqmix', 'dsqmix', 'ye', 'yd', 'sminputs', 'yu', 'mse2', 'nmix', 'vmix', 'msq2', 'mass', 'hmix']).\n Missing block: te,msl2,dsqmix,tu,selmix,msu2,msq2,usqmix,td,fralpha,mse2,msd2\n Unknown block : ae,ad,sbotmix,au,alpha,modsel,staumix,stopmix" \
or self['name'].startswith('mssm-') or self['name'] == 'mssm':
if not set(parameter_dict.keys()).difference(set(key)):
fail = False
else:
# FOR MSSM allow for automatic conversion to correct format
try:
param_card = param_card.input_path
param_card = card_reader.convert_to_mg5card(param_card,
writting=False)
key = [k for k in param_card.keys() if not k.startswith('qnumbers ')
and not k.startswith('decay_table')]
if not set(parameter_dict.keys()).difference(set(key)):
fail = False
except Exception:
raise MadGraph5Error, msg
if fail:
raise MadGraph5Error, msg
for block in key:
if block not in parameter_dict:
continue
for id in parameter_dict[block]:
try:
value = param_card[block].get(id).value
except:
raise MadGraph5Error, '%s %s not define' % (block, id)
else:
if isinstance(value, str) and value.lower() == 'auto':
value = '0.0'
if scale and parameter_dict[block][id].name == 'aS':
runner = Alphas_Runner(value, nloop=2)
value = runner(scale)
exec("locals()[\'%s\'] = %s" % (parameter_dict[block][id].name,
value))
parameter_dict[block][id].value = float(value)
else:
# No param_card, use default values
for param in external_parameters:
if scale and parameter_dict[block][id].name == 'aS':
runner = Alphas_Runner(value, nloop=3)
value = runner(scale)
exec("locals()[\'%s\'] = %s" % (param.name, param.value))
# Define all functions used
for func in self['functions']:
exec("def %s(%s):\n return %s" % (func.name,
",".join(func.arguments),
func.expr))
# Extract derived parameters
derived_parameters = []
keys = [key for key in self['parameters'].keys() if \
key != ('external',)]
keys.sort(key=len)
for key in keys:
derived_parameters += self['parameters'][key]
# Now calculate derived parameters
for param in derived_parameters:
try:
exec("locals()[\'%s\'] = %s" % (param.name, param.expr))
except Exception as error:
msg = 'Unable to evaluate %s = %s: raise error: %s' % (param.name,param.expr, error)
raise MadGraph5Error, msg
param.value = complex(eval(param.name))
if not eval(param.name) and eval(param.name) != 0:
logger.warning("%s has no expression: %s" % (param.name,
param.expr))
# Correct width sign for Majorana particles (where the width
# and mass need to have the same sign)
for particle in self.get('particles'):
if particle.is_fermion() and particle.get('self_antipart') and \
particle.get('width').lower() != 'zero' and \
eval(particle.get('mass')).real < 0:
exec("locals()[\'%(width)s\'] = -abs(%(width)s)" % \
{'width': particle.get('width')})
# Extract couplings
couplings = sum(self['couplings'].values(), [])
# Now calculate all couplings
for coup in couplings:
#print "I execute %s = %s"%(coup.name, coup.expr)
exec("locals()[\'%s\'] = %s" % (coup.name, coup.expr))
coup.value = complex(eval(coup.name))
if not eval(coup.name) and eval(coup.name) != 0:
logger.warning("%s has no expression: %s" % (coup.name,
coup.expr))
# Set parameter and coupling dictionaries
self.set('parameter_dict', dict([(param.name, param.value) \
for param in external_parameters + \
derived_parameters]))
# Add "zero"
self.get('parameter_dict')['ZERO'] = complex(0.)
self.set('coupling_dict', dict([(coup.name, coup.value) \
for coup in couplings]))
return locals()
def run_from_pickle(self):
import madgraph.iolibs.save_load_object as save_load_object
generate_all = save_load_object.load_from_file(pjoin(self.options['ms_dir'], 'madspin.pkl'))
# Re-create information which are not save in the pickle.
generate_all.evtfile = self.events_file
generate_all.curr_event = madspin.Event(self.events_file, self.banner )
generate_all.mgcmd = self.mg5cmd
generate_all.mscmd = self
generate_all.pid2width = lambda pid: generate_all.banner.get('param_card', 'decay', abs(pid)).value
generate_all.pid2mass = lambda pid: generate_all.banner.get('param_card', 'mass', abs(pid)).value
if generate_all.path_me != self.options['ms_dir']:
for decay in generate_all.all_ME.values():
decay['path'] = decay['path'].replace(generate_all.path_me, self.options['ms_dir'])
for decay2 in decay['decays']:
decay2['path'] = decay2['path'].replace(generate_all.path_me, self.options['ms_dir'])
generate_all.path_me = self.options['ms_dir'] # directory can have been move
generate_all.ms_dir = generate_all.path_me
if not hasattr(self.banner, 'param_card'):
self.banner.charge_card('slha')
# Special treatment for the mssm. Convert the param_card to the correct
# format
if self.banner.get('model').startswith('mssm-') or self.banner.get('model')=='mssm':
self.banner.param_card = check_param_card.convert_to_mg5card(\
self.banner.param_card, writting=False)
for name, block in self.banner.param_card.items():
if name.startswith('decay'):
continue
orig_block = generate_all.banner.param_card[name]
if block != orig_block:
raise Exception, """The directory %s is specific to a mass spectrum.
Your event file is not compatible with this one. (Different param_card: %s different)
orig block:
%s
new block:
%s""" \
% (self.options['ms_dir'], name, orig_block, block)
#replace init information
generate_all.banner['init'] = self.banner['init']
#replace run card if present in header (to make sure correct random seed is recorded in output file)
if 'mgruncard' in self.banner:
generate_all.banner['mgruncard'] = self.banner['mgruncard']
# NOW we have all the information available for RUNNING
if self.seed:
#seed is specified need to use that one:
open(pjoin(self.options['ms_dir'],'seeds.dat'),'w').write('%s\n'%self.seed)
#remove all ranmar_state
for name in glob.glob(pjoin(self.options['ms_dir'], '*', 'SubProcesses','*','ranmar_state.dat')):
os.remove(name)
generate_all.ending_run()
self.branching_ratio = generate_all.branching_ratio
try:
self.err_branching_ratio = generate_all.err_branching_ratio
except Exception:
# might not be define in some gridpack mode
self.err_branching_ratio = 0
evt_path = self.events_file.name
try:
self.events_file.close()
except:
pass
misc.gzip(evt_path)
decayed_evt_file=evt_path.replace('.lhe', '_decayed.lhe')
misc.gzip(pjoin(self.options['curr_dir'],'decayed_events.lhe'),
stdout=decayed_evt_file)
if not self.mother:
logger.info("Decayed events have been written in %s.gz" % decayed_evt_file)
def set_parameters_and_couplings(self, param_card = None, scale=None,
complex_mass_scheme=None):
"""Read a param_card and calculate all parameters and
couplings. Set values directly in the parameters and
couplings, plus add new dictionary coupling_dict from
parameter name to value."""
# Extract external parameters
external_parameters = self['parameters'][('external',)]
# Read in param_card
if param_card:
# Create a dictionary from LHA block name and code to parameter name
parameter_dict = {}
for param in external_parameters:
try:
dictionary = parameter_dict[param.lhablock.lower()]
except KeyError:
dictionary = {}
parameter_dict[param.lhablock.lower()] = dictionary
dictionary[tuple(param.lhacode)] = param
if isinstance(param_card, basestring):
# Check that param_card exists
if not os.path.isfile(param_card):
raise MadGraph5Error, "No such file %s" % param_card
param_card = card_reader.ParamCard(param_card)
assert isinstance(param_card, card_reader.ParamCard)
if complex_mass_scheme is None:
if aloha.complex_mass:
param_card.convert_to_complex_mass_scheme()
else:
if complex_mass_scheme:
param_card.convert_to_complex_mass_scheme()
key = [k for k in param_card.keys() if not k.startswith('qnumbers ')
and not k.startswith('decay_table')
and 'info' not in k]
param_key = [k for k in parameter_dict.keys() if 'info' not in k]
if set(key) != set(parameter_dict.keys()):
# the two card are different. check if this critical
fail = True
msg = '''Invalid restriction card (not same block)
%s != %s.
Missing block: %s
Unknown block : %s''' % (set(key), set(parameter_dict.keys()),
','.join(set(parameter_dict.keys()).difference(set(key))),
','.join(set(key).difference(set(parameter_dict.keys()))))
if msg =="Invalid restriction card (not same block)\n set(['yu', 'umix', 'ae', 'ad', 'decay', 'nmix', 'ye', 'sbotmix', 'msoft', 'yd', 'vmix', 'au', 'mass', 'alpha', 'modsel', 'sminputs', 'staumix', 'stopmix', 'hmix']) != set(['umix', 'msoft', 'msu2', 'fralpha', 'msd2', 'msl2', 'decay', 'tu', 'selmix', 'td', 'te', 'usqmix', 'dsqmix', 'ye', 'yd', 'sminputs', 'yu', 'mse2', 'nmix', 'vmix', 'msq2', 'mass', 'hmix']).\n Missing block: te,msl2,dsqmix,tu,selmix,msu2,msq2,usqmix,td,fralpha,mse2,msd2\n Unknown block : ae,ad,sbotmix,au,alpha,modsel,staumix,stopmix" \
or self['name'].startswith('mssm-') or self['name'] == 'mssm':
if not set(parameter_dict.keys()).difference(set(key)):
fail = False
else:
# FOR MSSM allow for automatic conversion to correct format
try:
param_card = param_card.input_path
param_card = card_reader.convert_to_mg5card(param_card,
writting=False)
key = [k for k in param_card.keys() if not k.startswith('qnumbers ')
and not k.startswith('decay_table')]
if not set(parameter_dict.keys()).difference(set(key)):
fail = False
except Exception:
raise MadGraph5Error, msg
if fail:
raise MadGraph5Error, msg
for block in key:
if block not in parameter_dict:
continue
for id in parameter_dict[block]:
try:
value = param_card[block].get(id).value
except:
raise MadGraph5Error, '%s %s not define' % (block, id)
else:
if isinstance(value, str) and value.lower() == 'auto':
value = '0.0'
if scale and parameter_dict[block][id].name == 'aS':
runner = Alphas_Runner(value, nloop=2)
value = runner(scale)
exec("locals()[\'%s\'] = %s" % (parameter_dict[block][id].name,
value))
parameter_dict[block][id].value = float(value)
else:
# No param_card, use default values
for param in external_parameters:
if scale and parameter_dict[block][id].name == 'aS':
runner = Alphas_Runner(value, nloop=3)
value = runner(scale)
exec("locals()[\'%s\'] = %s" % (param.name, param.value))
# Define all functions used
for func in self['functions']:
exec("def %s(%s):\n return %s" % (func.name,
",".join(func.arguments),
func.expr))
# Extract derived parameters
derived_parameters = []
keys = [key for key in self['parameters'].keys() if \
key != ('external',)]
keys.sort(key=len)
for key in keys:
derived_parameters += self['parameters'][key]
# Now calculate derived parameters
for param in derived_parameters:
try:
exec("locals()[\'%s\'] = %s" % (param.name, param.expr))
except Exception as error:
msg = 'Unable to evaluate %s = %s: raise error: %s' % (param.name,param.expr, error)
raise MadGraph5Error, msg
param.value = complex(eval(param.name))
if not eval(param.name) and eval(param.name) != 0:
logger.warning("%s has no expression: %s" % (param.name,
param.expr))
# Correct width sign for Majorana particles (where the width
# and mass need to have the same sign)
for particle in self.get('particles'):
if particle.is_fermion() and particle.get('self_antipart') and \
particle.get('width').lower() != 'zero' and \
eval(particle.get('mass')).real < 0:
exec("locals()[\'%(width)s\'] = -abs(%(width)s)" % \
{'width': particle.get('width')})
# Extract couplings
couplings = sum(self['couplings'].values(), [])
# Now calculate all couplings
for coup in couplings:
#print "I execute %s = %s"%(coup.name, coup.expr)
exec("locals()[\'%s\'] = %s" % (coup.name, coup.expr))
coup.value = complex(eval(coup.name))
if not eval(coup.name) and eval(coup.name) != 0:
logger.warning("%s has no expression: %s" % (coup.name,
coup.expr))
# Set parameter and coupling dictionaries
self.set('parameter_dict', dict([(param.name, param.value) \
for param in external_parameters + \
derived_parameters]))
# Add "zero"
self.get('parameter_dict')['ZERO'] = complex(0.)
self.set('coupling_dict', dict([(coup.name, coup.value) \
for coup in couplings]))
return locals()
def set_parameters_and_couplings(self,
param_card=None,
scale=None,
complex_mass_scheme=None):
"""Read a param_card and calculate all parameters and
couplings. Set values directly in the parameters and
couplings, plus add new dictionary coupling_dict from
parameter name to value."""
param_card_text = None
# Extract external parameters
external_parameters = self['parameters'][('external', )]
# Read in param_card
if param_card:
# Create a dictionary from LHA block name and code to parameter name
parameter_dict = {}
for param in external_parameters:
try:
dictionary = parameter_dict[param.lhablock.lower()]
except KeyError:
dictionary = {}
parameter_dict[param.lhablock.lower()] = dictionary
dictionary[tuple(param.lhacode)] = param
if isinstance(param_card, basestring):
# Check that param_card exists
if not os.path.isfile(param_card):
raise MadGraph5Error, "No such file %s" % param_card
param_card_text = param_card
param_card = card_reader.ParamCard(param_card)
#misc.sprint(type(param_card), card_reader.ParamCard, isinstance(param_card, card_reader.ParamCard))
#assert isinstance(param_card, card_reader.ParamCard),'%s is not a ParamCard: %s' % (type(param_card), isinstance(param_card, card_reader.ParamCard))
if complex_mass_scheme is None:
if aloha.complex_mass:
param_card.convert_to_complex_mass_scheme()
else:
if complex_mass_scheme:
param_card.convert_to_complex_mass_scheme()
key = [
k for k in param_card.keys() if not k.startswith('qnumbers ')
and not k.startswith('decay_table') and 'info' not in k
]
param_key = [k for k in parameter_dict.keys() if 'info' not in k]
if set(key) != set(parameter_dict.keys()):
# the two card are different. check if this critical
fail = True
missing_set = set(parameter_dict.keys()).difference(set(key))
unknow_set = set(key).difference(set(parameter_dict.keys()))
missing_block = ','.join(missing_set)
unknow_block = ','.join(unknow_set)
msg = '''Invalid restriction card (not same block)
%s != %s.
Missing block: %s
Unknown block : %s''' % (set(key), set(
parameter_dict.keys()), missing_block, unknow_block)
apply_conversion = []
if not missing_block:
logger.warning(
"Unknow type of information in the card: %s" %
unknow_block)
fail = False
elif self['name'].startswith(
'mssm-') or self['name'] == 'mssm':
if not missing_set:
fail = False
else:
apply_conversion.append('to_slha2')
overwrite = False
elif missing_set == set(['fralpha']) and 'alpha' in unknow_set:
apply_conversion.append('alpha')
elif self.need_slha2(missing_set, unknow_set):
apply_conversion.append('to_slha2')
overwrite = True
if apply_conversion:
try:
if 'to_slha2' in apply_conversion:
if overwrite:
logger.error('Convention for the param_card seems to be wrong. Trying to automatically convert your file to SLHA2 format. \n'+\
"Please check that the conversion occurs as expected (The converter is not fully general)")
import time
time.sleep(5)
param_card = param_card.input_path
param_card = card_reader.convert_to_mg5card(
param_card, writting=overwrite)
key = [
k for k in param_card.keys()
if not k.startswith('qnumbers ')
and not k.startswith('decay_table')
]
if not set(parameter_dict.keys()).difference(
set(key)):
fail = False
if 'alpha' in apply_conversion:
logger.info(
"Missing block fralpha but found a block alpha, apply automatic conversion"
)
param_card.rename_blocks({'alpha': 'fralpha'})
param_card['fralpha'].rename_keys({(): (1, )})
param_card.write(param_card.input_path)
key = [
k for k in param_card.keys()
if not k.startswith('qnumbers ')
and not k.startswith('decay_table')
]
if not set(parameter_dict.keys()).difference(
set(key)):
fail = False
except Exception:
raise
raise MadGraph5Error, msg
if fail:
raise MadGraph5Error, msg
for block in key:
if block not in parameter_dict:
continue
for pid in parameter_dict[block]:
try:
value = param_card[block].get(pid).value
except:
raise MadGraph5Error, '%s %s not define' % (block, pid)
else:
if isinstance(value, str) and value.lower() == 'auto':
value = '0.0'
if scale and parameter_dict[block][pid].name == 'aS':
runner = Alphas_Runner(value, nloop=2)
value = runner(scale)
exec("locals()[\'%s\'] = %s" %
(parameter_dict[block][pid].name, value))
parameter_dict[block][pid].value = float(value)
else:
# No param_card, use default values
for param in external_parameters:
if scale and parameter_dict[block][id].name == 'aS':
runner = Alphas_Runner(value, nloop=3)
value = runner(scale)
exec("locals()[\'%s\'] = %s" % (param.name, param.value))
# Define all functions used
for func in self['functions']:
exec("def %s(%s):\n return %s" %
(func.name, ",".join(func.arguments), func.expr))
# Extract derived parameters
derived_parameters = []
keys = [key for key in self['parameters'].keys() if \
key != ('external',)]
keys.sort(key=len)
for key in keys:
derived_parameters += self['parameters'][key]
# Now calculate derived parameters
for param in derived_parameters:
try:
exec("locals()[\'%s\'] = %s" % (param.name, param.expr))
except Exception as error:
msg = 'Unable to evaluate %s = %s: raise error: %s' % (
param.name, param.expr, error)
raise MadGraph5Error, msg
param.value = complex(eval(param.name))
if not eval(param.name) and eval(param.name) != 0:
logger.warning("%s has no expression: %s" %
(param.name, param.expr))
# Correct width sign for Majorana particles (where the width
# and mass need to have the same sign)
for particle in self.get('particles'):
if particle.is_fermion() and particle.get('self_antipart') and \
particle.get('width').lower() != 'zero' and \
eval(particle.get('mass')).real < 0:
exec("locals()[\'%(width)s\'] = -abs(%(width)s)" % \
{'width': particle.get('width')})
# Extract couplings
couplings = sum(self['couplings'].values(), [])
# Now calculate all couplings
for coup in couplings:
#print "I execute %s = %s"%(coup.name, coup.expr)
exec("locals()[\'%s\'] = %s" % (coup.name, coup.expr))
coup.value = complex(eval(coup.name))
if not eval(coup.name) and eval(coup.name) != 0:
logger.warning("%s has no expression: %s" %
(coup.name, coup.expr))
# Set parameter and coupling dictionaries
self.set('parameter_dict', dict([(param.name, param.value) \
for param in external_parameters + \
derived_parameters]))
# Add "zero"
self.get('parameter_dict')['ZERO'] = complex(0.)
self.set('coupling_dict', dict([(coup.name, coup.value) \
for coup in couplings]))
return locals()
# created by M. van Beekveld # [email protected] # simple file to convert slha file generated by suspect, spheno etc. to madgraph input ########## # set your MG5 dir here, since it needs the converter in Madgraph. import sys sys.path.append('/scratch/mbeekveld/MG5_aMC_v2_6_3_2') import models.check_param_card as converter # set slhafile to generated file # outputfile is name_original_file(.dat)_converted.dat slhafile = "input_slha.dat" slhafile = "/scratch/mbeekveld/MG5_aMC_v2_6_3_2/bin/simplified_gluino1400_neu1.dat" output_path = slhafile.replace(".dat","")+"_AAAconverted.dat" converter.convert_to_mg5card(slhafile, output_path) print "Converted file is "+output_path
