def modify_dummy(self):
""" """
plugin_dir = os.path.dirname(os.path.realpath(__file__))
# Add dedicated functions in dummy_fct.f
files = ["dummy_fct.f"] #, "pdg2pdf.f", "reweight.f"]
remove_list = [['get_dummy_x1_x2', 'dummy_boostframe']
] #,["store_events","write_leshouche"],["setclscales"]]
for name, to_rm in zip(files, remove_list):
template = open(pjoin(self.dir_path, "SubProcesses", name),
"r").read()
plugin = open(pjoin(plugin_dir, "Templates", name), "r").read()
ff = writers.FortranWriter(
pjoin(self.dir_path, "SubProcesses", name))
ff.remove_routine(template, to_rm, formatting=False)
ff.writelines(plugin, formatting=False)
ff.close()
# No need of this one automatic with lpp=9
#cp(pjoin(rootdir, 'pdg2pdf.f'), pjoin(self.dir_path, 'Source','PDF'))
#cp(pjoin(rootdir, 'reweight.f'), pjoin(self.dir_path, 'SubProcesses'))
filename = pjoin(self.dir_path, 'Cards', 'me5_configuration.txt')
self.cmd.do_save('options %s' % filename.replace(' ', '\ '),
check=False,
to_keep={'mg5_path': MG5DIR})
#filename = pjoin(self.dir_path,'Cards', 'proc_card_mg5.dat')
#self.cmd.do_history(filename)
return
def write_inc_file(self, outpath, identpath, default):
""" write a fortran file which hardcode the param value"""
fout = file_writers.FortranWriter(outpath)
defaultcard = ParamCard(default)
for line in open(identpath):
if line.startswith('c ') or line.startswith('ccccc'):
continue
split = line.split()
if len(split) < 3:
continue
block = split[0]
lhaid = [int(i) for i in split[1:-1]]
variable = split[-1]
if block in self:
try:
value = self[block].get(tuple(lhaid)).value
except KeyError:
value = defaultcard[block].get(tuple(lhaid)).value
else:
value = defaultcard[block].get(tuple(lhaid)).value
#value = str(value).lower()
fout.writelines(' %s = %s' % (variable,
('%e' % value).replace('e', 'd')))
fout.writelines(' %s%s = %s_16' % (self.mp_prefix, variable,
('%e' % value)))
def write_inc_file(self, outpath, identpath, default):
""" write a fortran file which hardcode the param value"""
fout = file_writers.FortranWriter(outpath)
defaultcard = ParamCard(default)
for line in open(identpath):
if line.startswith('c ') or line.startswith('ccccc'):
continue
split = line.split()
if len(split) < 3:
continue
block = split[0]
lhaid = [int(i) for i in split[1:-1]]
variable = split[-1]
if block in self:
try:
value = self[block].get(tuple(lhaid)).value
except KeyError:
value = defaultcard[block].get(tuple(lhaid)).value
logger.warning('information about \"%s %s" is missing using default value: %s.' %\
(block, lhaid, value))
else:
value = defaultcard[block].get(tuple(lhaid)).value
logger.warning('information about \"%s %s" is missing (full block missing) using default value: %s.' %\
(block, lhaid, value))
value = str(value).lower()
fout.writelines(' %s = %s' %
(variable, str(value).replace('e', 'd')))
def test_write_fortran_error(self):
"""Test that a non-string gives an error"""
fsock = StringIO.StringIO()
non_strings = [1.2, ["hej"]]
writer = writers.FortranWriter(os.devnull)
for nonstring in non_strings:
self.assertRaises(AssertionError, writer.write_line, nonstring)
def update_couplinc(self, widths, couplinc):
"""update coupl.inc by adding extra lines for the widths to keep"""
if not widths:
# so that the code will compile anyway
width_list = 'MDL_WDUMMY_KEEP'
else:
width_list = ','.join(['%s_keep' % w for w in widths])
lines = '\n double precision %s\n common /keep_widths/%s\n' %(width_list, width_list)
#outfile = open(couplincpjoin(self.dir_path, 'Source', 'coupl.inc'), 'a')
outfile = writers.FortranWriter(couplinc, 'a')
outfile.writelines(lines)
outfile.close()
def write_real_matrix_elements(self, matrix_element, fortran_model):
"""writes the matrix_i.f files which contain the real matrix elements
and the matrix_i_os_j.f which contain eventual on shell subtraction
terms"""
self.os_ids = self.get_os_ids_from_me(matrix_element)
for n, fksreal in enumerate(matrix_element.real_processes):
filename = 'matrix_%d.f' % (n + 1)
self.write_matrix_element_fks(writers.FortranWriter(filename),
fksreal.matrix_element, n + 1,
fortran_model,
os_info = {'diags': fksreal.os_diagrams,
'ids': fksreal.os_ids,
'dau_pos': fksreal.os_daughter_pos})
for nos, os_me in enumerate(fksreal.os_matrix_elements):
suffix = '%d_os_%d' % (n + 1, nos + 1)
filename = 'matrix_%s.f' % suffix
self.write_matrix_element_fks(writers.FortranWriter(filename),
os_me, suffix, fortran_model,
os_info = {'diags': [], 'ids': fksreal.os_ids, 'dau_pos': []})
filename = 'wrapper_matrix_%s.f' % suffix
self.write_os_wrapper(writers.FortranWriter(filename),
fksreal.matrix_element, os_me, suffix, fortran_model)
def update_get_mass_width(self, width_particles, filename):
"""update the get_mass_width to return also the vaule
of the _keep widhts"""
done_particles = []
iflines_width = ''
for i, part in enumerate(width_particles):
if part in done_particles: continue
done_particles.append(part)
if i == 0:
ifstring = 'if'
else:
ifstring = 'else if'
if part['self_antipart']:
iflines_width += '%s (id.eq.%d) then\n' % \
(ifstring, part.get_pdg_code())
else:
iflines_width += '%s (id.eq.%d.or.id.eq.%d) then\n' % \
(ifstring, part.get_pdg_code(), part.get_anti_pdg_code())
iflines_width += 'get_width_os_from_id=abs(%s_keep)\n' % part.get('width')
if len(width_particles)==0:
iflines_width = 'if (.True.) then\n'
outfile = writers.FortranWriter(filename, 'a')
text = """
DOUBLE PRECISION FUNCTION GET_WIDTH_OS_FROM_ID(ID)
IMPLICIT NONE
INTEGER ID
INCLUDE 'coupl.inc'
%sELSE
GET_WIDTH_OS_FROM_ID=0d0
ENDIF
RETURN
END
""" % iflines_width
outfile.writelines(text)
outfile.close()
return
def test_write_fortran_line(self):
"""Test writing a fortran line"""
lines = []
lines.append(
" call aaaaaa(bbb, ccc, ddd, eee, fff, ggg, hhhhhhhhhhhhhh+asdasd, wspedfteispd)"
)
lines.append(' include "test.inc"')
lines.append(' print *, \'Hej \\"Da\\" Mo\'')
lines.append(" IF (Test) then")
lines.append(" if(mutt) call hej")
lines.append(" else if(test) then")
lines.append("c Test")
lines.append("c = hej")
lines.append(" Call hej")
lines.append("# Test")
lines.append("20 else")
lines.append("bah=2")
lines.append(" endif")
lines.append("test")
goal_string = """ CALL AAAAAA(BBB, CCC, DDD, EEE, FFF, GGG, HHHHHHHHHHHHHH
$ +ASDASD, WSPEDFTEISPD)
INCLUDE 'test.inc'
PRINT *, 'Hej \\'Da\\' Mo'
IF (TEST) THEN
IF(MUTT) CALL HEJ
ELSE IF(TEST) THEN
C Test
C = HEJ
CALL HEJ
C Test
20 ELSE
BAH=2
ENDIF
TEST\n"""
writer = writers.FortranWriter(self.give_pos('fortran_test')).\
writelines(lines)
# Check that the output stays the same
self.assertFileContains('fortran_test', goal_string)
def write_include_file(self, output_path):
"""writing the run_card.inc file"""
# For FxFx merging, make sure that the following parameters are set correctly:
true = ['true', 'True', '.true.', 'T', True, 1, 'TRUE']
if int(self['ickkw']) == 3:
# 1. Renormalization and factorization (and ellis-sexton scales) are not fixed
scales = ['fixed_ren_scale', 'fixed_fac_scale', 'fixed_QES_scale']
for scale in scales:
if self[scale] in true:
logger.info(
'''For consistency in the FxFx merging, \'%s\' has been set to false'''
% scale, '$MG:color:BLACK')
self[scale] = 'F'
# 2. Use kT algorithm for jets with pseudo-code size R=1.0
jetparams = ['jetradius', 'jetalgo']
for jetparam in jetparams:
if float(self[jetparam]) != 1.0:
logger.info(
'''For consistency in the FxFx merging, \'%s\' has been set to 1.0'''
% jetparam, '$MG:color:BLACK')
self[jetparam] = '1.0'
#ensure that iappl is present in the card!
self.get_default('iappl', '0', log_level=10)
# For interface to APPLGRID, need to use LHAPDF and reweighting to get scale uncertainties
if self['iappl'] != '0' and self['pdlabel'].lower() != 'lhapdf':
raise self.InvalidCmd(
'APPLgrid generation only possible with the use of LHAPDF')
if self['iappl'] != '0' and self['reweight_scale'] not in true:
raise self.InvalidCmd('APPLgrid generation only possible with including' +\
' the reweighting to get scale dependence')
self.fsock = file_writers.FortranWriter(output_path)
################################################################################
# Writing the lines corresponding to the cuts
################################################################################
self.add_line('maxjetflavor', 'int', 4)
# minimum pt
self.add_line('ptj', 'float', 20)
self.add_line('etaj', 'float', -1.0)
self.add_line('ptl', 'float', 20)
self.add_line('etal', 'float', -1.0)
# minimum delta_r
self.add_line('drll', 'float', 0.4)
self.add_line('drll_sf', 'float', 0.4)
# minimum invariant mass for pairs
self.add_line('mll', 'float', 0.0)
self.add_line('mll_sf', 'float', 0.0)
#inclusive cuts
# Jet measure cuts
self.add_line("jetradius", 'float', 0.7, log=10)
################################################################################
# Writing the lines corresponding to anything but cuts
################################################################################
# seed
self.add_line('iseed', 'int', 0)
self.add_line('parton_shower',
'str',
'HERWIG6',
fortran_name='shower_mc')
self.add_line('nevents', 'int', 10000)
self.add_line('event_norm',
'str',
'average',
fortran_name='event_norm')
# Renormalizrion and factorization scales
self.add_line('fixed_ren_scale', 'bool', True)
self.add_line('fixed_fac_scale', 'bool', True)
self.add_line('fixed_QES_scale', 'bool', True)
self.add_line('muR_ref_fixed', 'float', 91.188)
self.add_line('muF1_ref_fixed', 'float', 91.188)
self.add_line('muF2_ref_fixed', 'float', 91.188)
self.add_line('QES_ref_fixed', 'float', 91.188)
self.add_line('muR_over_ref', 'float', 1.0)
self.add_line('muF1_over_ref', 'float', 1.0)
self.add_line('muF2_over_ref', 'float', 1.0)
self.add_line('QES_over_ref', 'float', 1.0)
#reweight block
self.add_line('reweight_scale',
'bool',
True,
fortran_name='do_rwgt_scale')
self.add_line('rw_Rscale_up', 'float', 2.0)
self.add_line('rw_Rscale_down', 'float', 0.5)
self.add_line('rw_Fscale_up', 'float', 2.0)
self.add_line('rw_Fscale_down', 'float', 0.5)
self.add_line('reweight_PDF', 'bool', True, fortran_name='do_rwgt_pdf')
self.add_line('PDF_set_min', 'int', 21101)
self.add_line('PDF_set_max', 'int', 21140)
self.add_line('iappl', 'int', 0)
# FxFx merging stuff
self.add_line('ickkw', 'int', 0)
self.add_line('jetalgo', 'float', 1.0)
# Collider energy and type
self.add_line('lpp1', 'int', 1, fortran_name='lpp(1)')
self.add_line('lpp2', 'int', 1, fortran_name='lpp(2)')
self.add_line('ebeam1', 'float', 4000, fortran_name='ebeam(1)')
self.add_line('ebeam2', 'float', 4000, fortran_name='ebeam(2)')
# BW cutoff (M+/-bwcutoff*Gamma)
self.add_line('bwcutoff', 'float', 15.0)
# Photon isolation
self.add_line('ptgmin', 'float', 10.0)
self.add_line('etagamma', 'float', -1.0)
self.add_line('R0gamma', 'float', 0.4)
self.add_line('xn', 'float', 1.0)
self.add_line('epsgamma', 'float', 1.0)
self.add_line('isoEM', 'bool', True)
# Collider pdf
self.add_line('pdlabel', 'str', 'cteq6_m')
# check validity of the pdf set
possible_set = [
'lhapdf', 'mrs02nl', 'mrs02nn', 'mrs0119', 'mrs0117', 'mrs0121',
'mrs01_j', 'mrs99_1', 'mrs99_2', 'mrs99_3', 'mrs99_4', 'mrs99_5',
'mrs99_6', 'mrs99_7', 'mrs99_8', 'mrs99_9', 'mrs9910', 'mrs9911',
'mrs9912', 'mrs98z1', 'mrs98z2', 'mrs98z3', 'mrs98z4', 'mrs98z5',
'mrs98ht', 'mrs98l1', 'mrs98l2', 'mrs98l3', 'mrs98l4', 'mrs98l5',
'cteq3_m', 'cteq3_l', 'cteq3_d', 'cteq4_m', 'cteq4_d', 'cteq4_l',
'cteq4a1', 'cteq4a2', 'cteq4a3', 'cteq4a4', 'cteq4a5', 'cteq4hj',
'cteq4lq', 'cteq5_m', 'cteq5_d', 'cteq5_l', 'cteq5hj', 'cteq5hq',
'cteq5f3', 'cteq5f4', 'cteq5m1', 'ctq5hq1', 'cteq5l1', 'cteq6_m',
'cteq6_d', 'cteq6_l', 'cteq6l1', 'nn23lo', 'nn23lo1', 'nn23nlo'
]
if self['pdlabel'] not in possible_set:
raise InvalidRunCard, 'Invalid PDF set (argument of pdlabel) possible choice are:\n %s' % ','.join(
possible_set)
if self['pdlabel'] == 'lhapdf':
self.add_line('lhaid', 'int', 21100)
else:
self.add_line('lhaid', 'int', 21100, log=10)
self.fsock.close()
def write_include_file(self, output_path):
"""writing the run_card.inc file"""
self.fsock = file_writers.FortranWriter(output_path)
################################################################################
# Writing the lines corresponding to the cuts
################################################################################
# Frixione photon isolation
self.add_line('ptgmin', 'float', 0.0)
self.add_line('R0gamma', 'float', 0.4)
self.add_line('xn', 'float', 1.0)
self.add_line('epsgamma', 'float', 1.0)
self.add_line('isoEM', 'bool', True)
# Cut that need to be deactivated in presence of isolation
if 'ptgmin' in self and float(self['ptgmin']) > 0:
if float(self['pta']) > 0:
logger.warning(
'pta cut discarded since photon isolation is used')
self['pta'] = '0'
if float(self['draj']) > 0:
logger.warning(
'draj cut discarded since photon isolation is used')
self['draj'] = '0'
self.add_line('maxjetflavor', 'int', 4)
if int(self['maxjetflavor']) > 6:
raise InvalidRunCard, 'maxjetflavor should be lower than 5! (6 is partly supported)'
self.add_line('auto_ptj_mjj', 'bool', True)
self.add_line('cut_decays', 'bool', True)
# minimum pt
self.add_line('ptj', 'float', 20)
self.add_line('ptb', 'float', 20)
self.add_line('pta', 'float', 20)
self.add_line('ptl', 'float', 20)
self.add_line('misset', 'float', 0)
self.add_line('ptonium', 'float', 0.0)
# maximal pt
self.add_line('ptjmax', 'float', -1)
self.add_line('ptbmax', 'float', -1)
self.add_line('ptamax', 'float', -1)
self.add_line('ptlmax', 'float', -1)
self.add_line('missetmax', 'float', -1)
# maximal rapidity (absolute value)
self.add_line('etaj', 'float', 4.0)
self.add_line('etab', 'float', 4.0)
self.add_line('etaa', 'float', 4.0)
self.add_line('etal', 'float', 4.0)
# minimal rapidity (absolute value)
self.add_line('etajmin', 'float', 0.0)
self.add_line('etabmin', 'float', 0.0)
self.add_line('etaamin', 'float', 0.0)
self.add_line('etalmin', 'float', 0.0)
self.add_line('etaonium', 'float', 100.0)
# Minimul E's
self.add_line('ej', 'float', 0.0)
self.add_line('eb', 'float', 0.0)
self.add_line('ea', 'float', 0.0)
self.add_line('el', 'float', 0.0)
# Maximum E's
self.add_line('ejmax', 'float', -1)
self.add_line('ebmax', 'float', -1)
self.add_line('eamax', 'float', -1)
self.add_line('elmax', 'float', -1)
# minimum delta_r
self.add_line('drjj', 'float', 0.4)
self.add_line('drbb', 'float', 0.4)
self.add_line('drll', 'float', 0.4)
self.add_line('draa', 'float', 0.4)
self.add_line('drbj', 'float', 0.4)
self.add_line('draj', 'float', 0.4)
self.add_line('drjl', 'float', 0.4)
self.add_line('drab', 'float', 0.4)
self.add_line('drbl', 'float', 0.4)
self.add_line('dral', 'float', 0.4)
# maximum delta_r
self.add_line('drjjmax', 'float', -1)
self.add_line('drbbmax', 'float', -1)
self.add_line('drllmax', 'float', -1)
self.add_line('draamax', 'float', -1)
self.add_line('drbjmax', 'float', -1)
self.add_line('drajmax', 'float', -1)
self.add_line('drjlmax', 'float', -1)
self.add_line('drabmax', 'float', -1)
self.add_line('drblmax', 'float', -1)
self.add_line('dralmax', 'float', -1)
# minimum invariant mass for pairs
self.add_line('mmjj', 'float', 0.0)
self.add_line('mmbb', 'float', 0.0)
self.add_line('mmaa', 'float', 0.0)
self.add_line('mmll', 'float', 0.0)
# maximum invariant mall for pairs
self.add_line('mmjjmax', 'float', -1)
self.add_line('mmbbmax', 'float', -1)
self.add_line('mmaamax', 'float', -1)
self.add_line('mmllmax', 'float', -1)
#Min Maxi invariant mass for all leptons
self.add_line("mmnl", 'float', 0.0)
self.add_line("mmnlmax", 'float', -1)
#inclusive cuts
self.add_line("xptj", 'float', 0.0)
self.add_line("xptb", 'float', 0.0)
self.add_line("xpta", 'float', 0.0)
self.add_line("xptl", 'float', 0.0)
self.add_line("xmtcentral", 'float', 0.0, fortran_name='xmtc', log=10)
# WBT cuts
self.add_line("xetamin", 'float', 0.0)
self.add_line("deltaeta", 'float', 0.0)
# Jet measure cuts
self.add_line("xqcut", 'float', 0.0)
self.add_line("d", 'float', 1.0, log=10)
# Set min pt of one heavy particle
self.add_line("ptheavy", 'float', 0.0)
# Pt of pairs of leptons (CHARGED AND NEUTRALS)
self.add_line("ptllmin", "float", 0.0)
self.add_line("ptllmax", "float", -1)
# Check the pt's of the jets sorted by pt
self.add_line("ptj1min", "float", 0.0)
self.add_line("ptj1max", "float", -1)
self.add_line("ptj2min", "float", 0.0)
self.add_line("ptj2max", "float", -1)
self.add_line("ptj3min", "float", 0.0)
self.add_line("ptj3max", "float", -1)
self.add_line("ptj4min", "float", 0.0)
self.add_line("ptj4max", "float", -1)
self.add_line("cutuse", "float", 0.0)
# Check the pt's of leptons sorted by pt
self.add_line("ptl1min", "float", 0.0)
self.add_line("ptl1max", "float", -1)
self.add_line("ptl2min", "float", 0.0)
self.add_line("ptl2max", "float", -1)
self.add_line("ptl3min", "float", 0.0)
self.add_line("ptl3max", "float", -1)
self.add_line("ptl4min", "float", 0.0)
self.add_line("ptl4max", "float", -1)
# Check Ht
self.add_line("ht2min", 'float', 0.0)
self.add_line("ht3min", 'float', 0.0)
self.add_line("ht4min", 'float', 0.0)
self.add_line("ht2max", 'float', -1)
self.add_line("ht3max", 'float', -1)
self.add_line("ht4max", 'float', -1)
self.add_line("htjmin", 'float', 0.0)
self.add_line("htjmax", 'float', -1)
self.add_line("ihtmin", 'float', 0.0)
self.add_line("ihtmax", 'float', -1)
# kt_ durham
self.add_line('ktdurham', 'float', -1, fortran_name='kt_durham')
self.add_line('dparameter', 'float', 0.4, fortran_name='d_parameter')
################################################################################
# Writing the lines corresponding to anything but cuts
################################################################################
# lhe output format
self.add_line("lhe_version", "float",
2.0) #if not specify assume old standard
# seed
self.add_line("gridpack", "bool", False)
self.add_line("gridrun", 'bool', False, log=10)
if str(self['gridrun']) in ['1','T','.true','True'] and \
str(self['gridpack']) in ['1','T','.true','True']:
self.add_line('gseed', 'int', 0, fortran_name='iseed')
else:
self.add_line('iseed', 'int', 0, fortran_name='iseed')
#number of events
self.add_line('nevents', 'int', 10000)
#self.add_line('gevents', 'int', 2000, log=10)
# Renormalizrion and factorization scales
self.add_line('fixed_ren_scale', 'bool', True)
self.add_line('fixed_fac_scale', 'bool', True)
self.add_line('scale', 'float', 'float', 91.188)
self.add_line('dsqrt_q2fact1', 'float', 91.188, fortran_name='sf1')
self.add_line('dsqrt_q2fact2', 'float', 91.188, fortran_name='sf2')
self.add_line('use_syst', 'bool', False)
#if use_syst is True, some parameter are automatically fixed.
if self['use_syst'] in self.true:
value = self.format('float',
self.get_default('scalefact', 1.0, 30))
if value != self.format('float', 1.0):
logger.warning(
'Since use_syst=T, We change the value of \'scalefact\' to 1'
)
self['scalefact'] = 1.0
self.add_line('scalefact', 'float', 1.0)
self.add_line('fixed_couplings', 'bool', True, log=10)
self.add_line('ickkw', 'int', 0)
self.add_line('chcluster', 'bool', False)
self.add_line('ktscheme', 'int', 1)
self.add_line('asrwgtflavor', 'int', 5)
#CKKW TREATMENT!
if int(self['ickkw']) > 0:
#if use_syst is True, some parameter are automatically fixed.
if self['use_syst'] in self.true:
value = self.format('float',
self.get_default('alpsfact', 1.0, 30))
if value != self.format('float', 1.0):
logger.warning(
'Since use_syst=T, We change the value of \'alpsfact\' to 1'
)
self['alpsfact'] = 1.0
if int(self['maxjetflavor']) == 6:
raise InvalidRUnCard, 'maxjetflavor at 6 is NOT supported for matching!'
self.add_line('alpsfact', 'float', 1.0)
self.add_line('pdfwgt', 'bool', True)
self.add_line('clusinfo', 'bool', False)
# check that DRJJ and DRJL are set to 0 and MMJJ
if self.format('float', self['drjj']) != self.format('float', 0.):
logger.warning(
'Since icckw>0, We change the value of \'drjj\' to 0')
if self.format('float', self['drjl']) != self.format('float', 0.):
logger.warning(
'Since icckw>0, We change the value of \'drjl\' to 0')
if self.format('bool', self['auto_ptj_mjj']) == '.false.':
#ensure formatting
mmjj = self['mmjj']
if isinstance(mmjj, str):
mmjj = float(mmjj.replace('d', 'e'))
xqcut = self['xqcut']
if isinstance(xqcut, str):
xqcut = float(xqcut.replace('d', 'e'))
if mmjj > xqcut:
logger.warning(
'mmjj > xqcut (and auto_ptj_mjj = F). MMJJ set to 0')
self.add_line('mmjj', 'float', 0)
if int(self['ickkw']) == 2:
self.add_line('highestmult', 'int', 0, fortran_name='nhmult')
self.add_line('issgridfile', 'str', 'issudgrid.dat')
# Collider energy and type
self.add_line('lpp1', 'int', 1, fortran_name='lpp(1)')
self.add_line('lpp2', 'int', 1, fortran_name='lpp(2)')
self.add_line('ebeam1', 'float', 7000, fortran_name='ebeam(1)')
self.add_line('ebeam2', 'float', 7000, fortran_name='ebeam(2)')
# Beam polarization
self.add_line('polbeam1', 'float', 0.0, fortran_name='pb1')
self.add_line('polbeam2', 'float', 0.0, fortran_name='pb2')
# BW cutoff (M+/-bwcutoff*Gamma)
self.add_line('bwcutoff', 'float', 15.0)
# Collider pdf
self.add_line('pdlabel', 'str', 'cteq6l1')
# check validity of the pdf set
possible_set = [
'lhapdf', 'mrs02nl', 'mrs02nn', 'mrs0119', 'mrs0117', 'mrs0121',
'mrs01_j', 'mrs99_1', 'mrs99_2', 'mrs99_3', 'mrs99_4', 'mrs99_5',
'mrs99_6', 'mrs99_7', 'mrs99_8', 'mrs99_9', 'mrs9910', 'mrs9911',
'mrs9912', 'mrs98z1', 'mrs98z2', 'mrs98z3', 'mrs98z4', 'mrs98z5',
'mrs98ht', 'mrs98l1', 'mrs98l2', 'mrs98l3', 'mrs98l4', 'mrs98l5',
'cteq3_m', 'cteq3_l', 'cteq3_d', 'cteq4_m', 'cteq4_d', 'cteq4_l',
'cteq4a1', 'cteq4a2', 'cteq4a3', 'cteq4a4', 'cteq4a5', 'cteq4hj',
'cteq4lq', 'cteq5_m', 'cteq5_d', 'cteq5_l', 'cteq5hj', 'cteq5hq',
'cteq5f3', 'cteq5f4', 'cteq5m1', 'ctq5hq1', 'cteq5l1', 'cteq6_m',
'cteq6_d', 'cteq6_l', 'cteq6l1', 'nn23lo', 'nn23lo1', 'nn23nlo'
]
if self['pdlabel'] not in possible_set:
raise InvalidRunCard, 'Invalid PDF set (argument of pdlabel) possible choice are:\n %s' % ','.join(
possible_set)
if self['pdlabel'] == 'lhapdf':
self.add_line('lhaid', 'int', 10042)
else:
self.add_line('lhaid', 'int', 10042, log=10)
self.fsock.close()
return '\n'.join(formatted_lines)
# Now we define the raw banner text for each style:
return format_banner(
cls.get_raw_banner(style.lower())
%{'versionref':versionref, 'ref':reference, 'version':version})
# Below we have a small standalone code to test the MadLoop Banner output
if __name__=='__main__':
import madgraph.iolibs.file_writers as writers
import os
import copy
pjoin = os.path.join
writer = writers.FortranWriter('test_ML_banner.f')
styles = copy.copy(MadLoopBannerStyles.get_style_keys())
styles.append('random')
# Edit the line above and select here a subset of the available styles to
# show. Possibilities are:
# ['classic','classic2','classic3','big','funky',
# 'curly','keyboard','bubbles','mario','wiggly',
# 'printed','fast','isometric','random']
# styles = ['funky']
f_code = ""
for style in styles:
f_code += "\nwrite(*,*) ''\nwrite(*,*) 'Style %s with default options.'\n"%style
f_code += MadLoopBannerStyles.get_MadLoop_Banner(style=style)
n = len(items)
# We use the fact that
# (n choose k) = (1 choose 1)(n-1 choose k-1)+(1 choose 0)(n-1 choose k)
if k == n:
yield items[:]
elif k == 0:
yield []
elif 0 < k and k < n:
head = items[0:1]
tail = items[1:]
for result in cls.select(tail, k - 1):
yield head + result
for result in cls.select(tail, k):
yield result
if __name__ == '__main__':
"""I test here the write_golem95_mapping function"""
max_rank = 6
FPR = FortranPolynomialRoutines(max_rank)
print "Output of write_golem95_mapping function for max_rank=%d:\n\n" % max_rank
import os
import sys
root_path = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
sys.path.insert(0, os.path.join(root_path, os.path.pardir))
import madgraph.iolibs.file_writers as writers
FWriter = writers.FortranWriter("GOLEM95_interface.f")
FWriter.writelines(FPR.write_golem95_mapping())
def write_include_file(self, output_path):
"""writing the run_card.inc file"""
self.fsock = file_writers.FortranWriter(output_path)
################################################################################
# Writing the lines corresponding to the cuts
################################################################################
self.add_line('maxjetflavor', 'int', 4)
self.add_line('auto_ptj_mjj', 'bool', True)
self.add_line('cut_decays', 'bool', True)
# minimum pt
self.add_line('ptj', 'float', 20)
self.add_line('ptb', 'float', 20)
self.add_line('pta', 'float', 20)
self.add_line('ptl', 'float', 20)
self.add_line('misset', 'float', 0)
self.add_line('ptonium', 'float', 0.0)
# maximal pt
self.add_line('ptjmax', 'float', -1)
self.add_line('ptbmax', 'float', -1)
self.add_line('ptamax', 'float', -1)
self.add_line('ptlmax', 'float', -1)
self.add_line('missetmax', 'float', -1)
# maximal rapidity (absolute value)
self.add_line('etaj', 'float', 4.0)
self.add_line('etab', 'float', 4.0)
self.add_line('etaa', 'float', 4.0)
self.add_line('etal', 'float', 4.0)
# minimal rapidity (absolute value)
self.add_line('etajmin', 'float', 0.0)
self.add_line('etabmin', 'float', 0.0)
self.add_line('etaamin', 'float', 0.0)
self.add_line('etalmin', 'float', 0.0)
self.add_line('etaonium', 'float', 100.0)
# Minimul E's
self.add_line('ej', 'float', 0.0)
self.add_line('eb', 'float', 0.0)
self.add_line('ea', 'float', 0.0)
self.add_line('el', 'float', 0.0)
# Maximum E's
self.add_line('ejmax', 'float', -1)
self.add_line('ebmax', 'float', -1)
self.add_line('eamax', 'float', -1)
self.add_line('elmax', 'float', -1)
# minimum delta_r
self.add_line('drjj', 'float', 0.4)
self.add_line('drbb', 'float', 0.4)
self.add_line('drll', 'float', 0.4)
self.add_line('draa', 'float', 0.4)
self.add_line('drbj', 'float', 0.4)
self.add_line('draj', 'float', 0.4)
self.add_line('drjl', 'float', 0.4)
self.add_line('drab', 'float', 0.4)
self.add_line('drbl', 'float', 0.4)
self.add_line('dral', 'float', 0.4)
# maximum delta_r
self.add_line('drjjmax', 'float', -1)
self.add_line('drbbmax', 'float', -1)
self.add_line('drllmax', 'float', -1)
self.add_line('draamax', 'float', -1)
self.add_line('drbjmax', 'float', -1)
self.add_line('drajmax', 'float', -1)
self.add_line('drjlmax', 'float', -1)
self.add_line('drabmax', 'float', -1)
self.add_line('drblmax', 'float', -1)
self.add_line('dralmax', 'float', -1)
# minimum invariant mass for pairs
self.add_line('mmjj', 'float', 0.0)
self.add_line('mmbb', 'float', 0.0)
self.add_line('mmaa', 'float', 0.0)
self.add_line('mmll', 'float', 0.0)
# maximum invariant mall for pairs
self.add_line('mmjjmax', 'float', -1)
self.add_line('mmbbmax', 'float', -1)
self.add_line('mmaamax', 'float', -1)
self.add_line('mmllmax', 'float', -1)
#Min Maxi invariant mass for all leptons
self.add_line("mmnl", 'float', 0.0)
self.add_line("mmnlmax", 'float', -1)
#inclusive cuts
self.add_line("xptj", 'float', 0.0)
self.add_line("xptb", 'float', 0.0)
self.add_line("xpta", 'float', 0.0)
self.add_line("xptl", 'float', 0.0)
self.add_line("xmtcentral", 'float', 0.0, fortran_name='xmtc', log=10)
# WBT cuts
self.add_line("xetamin", 'float', 0.0)
self.add_line("deltaeta", 'float', 0.0)
# Jet measure cuts
self.add_line("xqcut", 'float', 0.0)
self.add_line("d", 'float', 1.0, log=10)
# Set min pt of one heavy particle
self.add_line("ptheavy", 'float', 0.0)
# Pt of pairs of leptons (CHARGED AND NEUTRALS)
self.add_line("ptllmin", "float", 0.0)
self.add_line("ptllmax", "float", -1)
# Check the pt's of the jets sorted by pt
self.add_line("ptj1min", "float", 0.0)
self.add_line("ptj1max", "float", -1)
self.add_line("ptj2min", "float", 0.0)
self.add_line("ptj2max", "float", -1)
self.add_line("ptj3min", "float", 0.0)
self.add_line("ptj3max", "float", -1)
self.add_line("ptj4min", "float", 0.0)
self.add_line("ptj4max", "float", -1)
self.add_line("cutuse", "float", 0.0)
# Check the pt's of leptons sorted by pt
self.add_line("ptl1min", "float", 0.0)
self.add_line("ptl1max", "float", -1)
self.add_line("ptl2min", "float", 0.0)
self.add_line("ptl2max", "float", -1)
self.add_line("ptl3min", "float", 0.0)
self.add_line("ptl3max", "float", -1)
self.add_line("ptl4min", "float", 0.0)
self.add_line("ptl4max", "float", -1)
# Check Ht
self.add_line("ht2min", 'float', 0.0)
self.add_line("ht3min", 'float', 0.0)
self.add_line("ht4min", 'float', 0.0)
self.add_line("ht2max", 'float', -1)
self.add_line("ht3max", 'float', -1)
self.add_line("ht4max", 'float', -1)
self.add_line("htjmin", 'float', 0.0)
self.add_line("htjmax", 'float', -1)
self.add_line("ihtmin", 'float', 0.0)
self.add_line("ihtmax", 'float', -1)
################################################################################
# Writing the lines corresponding to anything but cuts
################################################################################
# seed
self.add_line("gridpack","bool", False)
self.add_line("gridrun",'bool', False, log=10)
if str(self['gridrun']) in ['1','T','.true','True'] and \
str(self['gridpack']) in ['1','T','.true','True']:
self.add_line('gseed', 'int', 0, fortran_name='iseed')
else:
self.add_line('iseed', 'int', 0, fortran_name='iseed')
# Renormalizrion and factorization scales
self.add_line('fixed_ren_scale', 'bool', True)
self.add_line('fixed_fac_scale', 'bool', True)
self.add_line('scale', 'float', 'float', 91.188)
self.add_line('dsqrt_q2fact1','float', 91.188, fortran_name='sf1')
self.add_line('dsqrt_q2fact2', 'float', 91.188, fortran_name='sf2')
self.add_line('scalefact', 'float', 1.0)
self.add_line('fixed_couplings', 'bool', True, log=10)
self.add_line('ickkw', 'int', 0)
self.add_line('chcluster', 'bool', False)
self.add_line('ktscheme', 'int', 1)
self.add_line('asrwgtflavor', 'int', 5)
if int(self['ickkw'])>0:
self.add_line('alpsfact', 'float', 1.0)
self.add_line('pdfwgt', 'bool', True)
if int(self['ickkw'])==2:
self.add_line('highestmult','int', 0, fortran_name='nhmult')
self.add_line('issgridfile','str','issudgrid.dat')
# Collider energy and type
self.add_line('lpp1', 'int', 1, fortran_name='lpp(1)')
self.add_line('lpp2', 'int', 1, fortran_name='lpp(2)')
self.add_line('ebeam1', 'float', 7000, fortran_name='ebeam(1)')
self.add_line('ebeam2', 'float', 7000, fortran_name='ebeam(2)')
# Beam polarization
self.add_line('polbeam1', 'float', 0.0, fortran_name='pb1')
self.add_line('polbeam2', 'float', 0.0, fortran_name='pb2')
# BW cutoff (M+/-bwcutoff*Gamma)
self.add_line('bwcutoff', 'float', 15.0)
# Collider pdf
self.add_line('pdlabel','str','cteq6l1')
if self['pdlabel'] == 'lhapdf':
self.add_line('lhaid', 'int', 10042)
else:
self.add_line('lhaid', 'int', 10042, log=10)
self.fsock.close()
def testIO_Loop_sqso_uux_ddx(self):
""" target: [loop_matrix(.*)\.f]
"""
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id': 2, 'state': False}))
myleglist.append(base_objects.Leg({'id': -2, 'state': False}))
myleglist.append(base_objects.Leg({'id': 1, 'state': True}))
myleglist.append(base_objects.Leg({'id': -1, 'state': True}))
fortran_model=\
helas_call_writers.FortranUFOHelasCallWriterOptimized(self.model,False)
SO_tests = [({}, ['QCD',
'QED'], {}, {}, ['QCD',
'QED'], 'QCDQEDpert_default'),
({}, ['QCD'], {}, {}, ['QCD'], 'QCDpert_default'),
({}, ['QED'], {}, {}, ['QED'], 'QEDpert_default'),
({}, ['QCD', 'QED'], {
'QCD': 4
}, {
'QCD': '=='
}, ['QCD', 'QED'], 'QCDQEDpert_QCDsq_eq_4'),
({}, ['QCD', 'QED'], {
'QED': 4
}, {
'QCD': '<='
}, ['QCD', 'QED'], 'QCDQEDpert_QEDsq_le_4'),
({}, ['QCD', 'QED'], {
'QCD': 4
}, {
'QCD': '>'
}, ['QCD', 'QED'], 'QCDQEDpert_QCDsq_gt_4'),
({
'QED': 2
}, ['QCD', 'QED'], {
'QCD': 0,
'QED': 2
}, {
'QCD': '>',
'QED': '>'
}, ['QCD',
'QED'], 'QCDQEDpert_QCDsq_gt_0_QEDAmpAndQEDsq_gt_2'),
({
'QED': 2
}, ['QCD', 'QED'], {
'WEIGHTED': 10,
'QED': 2
}, {
'WEIGHTED': '<=',
'QED': '>'
}, ['WEIGHTED', 'QCD',
'QED'], 'QCDQEDpert_WGTsq_le_10_QEDAmpAndQEDsq_gt_2')]
for orders, pert_orders, sq_orders , sq_orders_type, split_orders, name \
in SO_tests:
myproc = base_objects.Process({
'legs': myleglist,
'model': self.model,
'orders': orders,
'squared_orders': sq_orders,
'perturbation_couplings': pert_orders,
'sqorders_types': sq_orders_type,
'split_orders': split_orders
})
myloopamp = loop_diagram_generation.LoopAmplitude(myproc)
matrix_element=loop_helas_objects.LoopHelasMatrixElement(\
myloopamp,optimized_output=True)
writer = writers.FortranWriter(\
pjoin(self.IOpath,'loop_matrix_%s.f'%name))
# It is enough here to generate and check the filer loop_matrix.f
# only here. For that we must initialize the general replacement
# dictionary first (The four functions below are normally directly
# called from the write_matrix_element function in the exporter
# [but we don't call it here because we only want the file
# loop_matrix.f]).
matrix_element.rep_dict = self.exporter.\
generate_general_replace_dict(matrix_element)
# and for the same reason also force the computation of the analytical
# information in the Helas loop diagrams.
matrix_element.compute_all_analytic_information(
self.exporter.get_aloha_model(self.model))
# Finally the entries specific to the optimized output
self.exporter.set_optimized_output_specific_replace_dict_entries(\
matrix_element)
# We can then finally write out 'loop_matrix.f'
self.exporter.write_loopmatrix(writer,
matrix_element,
fortran_model,
noSplit=True,
write_auxiliary_files=False)
def write_include_file(self, output_path):
"""writing the run_card.inc file"""
self.fsock = file_writers.FortranWriter(output_path)
################################################################################
# Writing the lines corresponding to the cuts
################################################################################
self.add_line('maxjetflavor', 'int', 4)
# minimum pt
self.add_line('ptj', 'float', 20)
self.add_line('etaj', 'float', -1.0)
self.add_line('ptl', 'float', 20)
self.add_line('etal', 'float', -1.0)
# minimum delta_r
self.add_line('drll', 'float', 0.4)
self.add_line('drll_sf', 'float', 0.4)
# minimum invariant mass for pairs
self.add_line('mll', 'float', 0.0)
self.add_line('mll_sf', 'float', 0.0)
#inclusive cuts
# Jet measure cuts
self.add_line("jetradius", 'float', 0.7, log=10)
################################################################################
# Writing the lines corresponding to anything but cuts
################################################################################
# seed
self.add_line('iseed', 'int', 0)
self.add_line('parton_shower', 'str', 'HERWIG6', fortran_name='shower_mc')
self.add_line('nevents', 'int', 10000)
self.add_line('event_norm', 'str', 'average', fortran_name='event_norm')
# Renormalizrion and factorization scales
self.add_line('fixed_ren_scale', 'bool', True)
self.add_line('fixed_fac_scale', 'bool', True)
self.add_line('fixed_QES_scale', 'bool', True)
self.add_line('muR_ref_fixed', 'float', 91.188)
self.add_line('muF1_ref_fixed','float', 91.188)
self.add_line('muF2_ref_fixed', 'float', 91.188)
self.add_line('QES_ref_fixed', 'float', 91.188)
self.add_line('muR_over_ref', 'float', 1.0)
self.add_line('muF1_over_ref', 'float', 1.0)
self.add_line('muF2_over_ref', 'float', 1.0)
self.add_line('QES_over_ref', 'float', 1.0)
#reweight block
self.add_line('reweight_scale', 'bool', True, fortran_name='do_rwgt_scale')
self.add_line('rw_Rscale_up', 'float', 2.0)
self.add_line('rw_Rscale_down', 'float', 0.5)
self.add_line('rw_Fscale_up', 'float', 2.0)
self.add_line('rw_Fscale_down', 'float', 0.5)
self.add_line('reweight_PDF', 'bool', True, fortran_name='do_rwgt_pdf')
self.add_line('PDF_set_min', 'int', 21101)
self.add_line('PDF_set_max', 'int', 21140)
# FxFx merging stuff
self.add_line('ickkw', 'int', 0)
# self.add_line('fixed_couplings', 'bool', True, log=10)
self.add_line('jetalgo', 'float', 1.0)
# Collider energy and type
self.add_line('lpp1', 'int', 1, fortran_name='lpp(1)')
self.add_line('lpp2', 'int', 1, fortran_name='lpp(2)')
self.add_line('ebeam1', 'float', 4000, fortran_name='ebeam(1)')
self.add_line('ebeam2', 'float', 4000, fortran_name='ebeam(2)')
# BW cutoff (M+/-bwcutoff*Gamma)
self.add_line('bwcutoff', 'float', 15.0)
# Photon isolation
self.add_line('ptgmin', 'float', 10.0)
self.add_line('etagamma', 'float', -1.0)
self.add_line('R0gamma', 'float', 0.4)
self.add_line('xn', 'float', 1.0)
self.add_line('epsgamma', 'float', 1.0)
self.add_line('isoEM', 'bool', True)
# Collider pdf
self.add_line('pdlabel','str','cteq6_m')
if self['pdlabel'] == 'lhapdf':
self.add_line('lhaid', 'int', 21100)
else:
self.add_line('lhaid', 'int', 21100, log=10)
self.fsock.close()
def ML5export(self, nojpeg=False, main_file_name=""):
"""Export a generated amplitude to file"""
def generate_matrix_elements(self):
"""Helper function to generate the matrix elements before exporting"""
# Sort amplitudes according to number of diagrams,
# to get most efficient multichannel output
self._curr_amps.sort(lambda a1, a2: a2.get_number_of_diagrams() - \
a1.get_number_of_diagrams())
cpu_time1 = time.time()
ndiags = 0
if not self._curr_matrix_elements.get_matrix_elements():
self._curr_matrix_elements = \
loop_helas_objects.LoopHelasProcess(self._curr_amps,
optimized_output = self.options['loop_optimized_output'])
ndiags = sum([len(me.get('diagrams')) for \
me in self._curr_matrix_elements.\
get_matrix_elements()])
# assign a unique id number to all process
uid = 0
for me in self._curr_matrix_elements.get_matrix_elements():
uid += 1 # update the identification number
me.get('processes')[0].set('uid', uid)
cpu_time2 = time.time()
return ndiags, cpu_time2 - cpu_time1
# Start of the actual routine
ndiags, cpu_time = generate_matrix_elements(self)
calls = 0
path = self._export_dir
if self._export_format in self.supported_ML_format:
path = pjoin(path, 'SubProcesses')
cpu_time1 = time.time()
# Pick out the matrix elements in a list
matrix_elements = \
self._curr_matrix_elements.get_matrix_elements()
# Fortran MadGraph5_aMC@NLO Standalone
if self._export_format in self.supported_ML_format:
for me in matrix_elements:
calls = calls + \
self._curr_exporter.generate_subprocess_directory_v4(\
me, self._curr_fortran_model)
# If all ME's do not share the same maximum loop vertex rank and the
# same loop maximum wavefunction size, we need to set the maximum
# in coef_specs.inc of the HELAS Source. The SubProcesses/P* directory
# all link this file, so it should be properly propagated
if self.options['loop_optimized_output'] and len(
matrix_elements) > 1:
max_lwfspins = [m.get_max_loop_particle_spin() for m in \
matrix_elements]
max_loop_vert_ranks = [me.get_max_loop_vertex_rank() for me in \
matrix_elements]
if len(set(max_lwfspins)) > 1 or len(
set(max_loop_vert_ranks)) > 1:
self._curr_exporter.fix_coef_specs(max(max_lwfspins),\
max(max_loop_vert_ranks))
# Just the matrix.f files
if self._export_format == 'matrix':
for me in matrix_elements:
filename = pjoin(path, 'matrix_' + \
me.get('processes')[0].shell_string() + ".f")
if os.path.isfile(filename):
logger.warning("Overwriting existing file %s" % filename)
else:
logger.info("Creating new file %s" % filename)
calls = calls + self._curr_exporter.write_matrix_element_v4(\
writers.FortranWriter(filename),\
me, self._curr_fortran_model)
cpu_time2 = time.time() - cpu_time1
logger.info(("Generated helas calls for %d subprocesses " + \
"(%d diagrams) in %0.3f s") % \
(len(matrix_elements),
ndiags, cpu_time))
if calls:
if "cpu_time2" in locals():
logger.info("Wrote files for %d OPP calls in %0.3f s" % \
(calls, cpu_time2))
else:
logger.info("Wrote files for %d OPP calls" % \
(calls))
# Replace the amplitudes with the actual amplitudes from the
# matrix elements, which allows proper diagram drawing also of
# decay chain processes
self._curr_amps = diagram_generation.AmplitudeList(\
[me.get('base_amplitude') for me in \
matrix_elements])
