def split_lepton_grouping(self):
"""Return a list of grouping where they are no groupoing over the leptons."""
output = SubProcessGroupList()
for group in self:
new_mes = {}
for me in group['matrix_elements']:
tags = {}
for proc in me['processes']:
ids = proc.get_final_ids_after_decay()
ids = tuple(
[t if abs(t) in [11, 13, 15] else 0 for t in ids])
if ids not in tags:
tags[ids] = base_objects.ProcessList()
tags[ids].append(proc)
for tag in tags:
new_me = copy.copy(me)
new_me['processes'] = tags[tag]
if tag not in new_mes:
new_mes[tag] = helas_objects.HelasMatrixElementList()
new_mes[tag].append(new_me)
for tag in tags:
new_group = copy.copy(group)
new_group['matrix_elements'] = new_mes[tag]
new_group.set('name', new_group.generate_name(\
new_group['matrix_elements'][0]['processes'][0],
criteria='madweight'))
output.append(new_group)
return output
def find_os_divergences(fksreal):
"""this function looks for possible on shell contributions
to be removed.
In order to be agnostic on mass hierarchies all splittings
1->2 3 are investigated, with m1 != 0, m2, m3 != m1
since these resonances are introduced at the real-emission
level, one must have m2=0 or m3=0
"""
if type(fksreal) == fks_base.FKSRealProcess:
process = fksreal.process
amplitude = fksreal.amplitude
from_helas = False
elif type(fksreal) == fks_helas.FKSHelasRealProcess:
process = fksreal.matrix_element['processes'][0]
amplitude = fksreal.matrix_element['base_amplitude']
from_helas = True
else:
raise MadSTRFKSError(
"Unknown type of fksreal in find_os_divergences: " + type(fksreal))
model = process['model']
forbidden = process['forbidden_particles']
# take account of the orders for the on shell processes
weighted_order = process['orders']['WEIGHTED']
fksreal.os_amplitudes = []
fksreal.os_ids = []
fksreal.os_daughter_pos = []
fksreal.os_diagrams = []
# this is a counter to be returned
n_os = 0
# focus only on final state legs
final_legs = [copy.copy(l) for l in process['legs'] if l['state']]
for leg_2 in final_legs:
for leg_3 in [l for l in final_legs if l['number'] > leg_2['number']]:
# one of the two legs must be massless
if not leg_2['massless'] and not leg_3['massless']:
continue
# prepare the leglist for the 'on shell' process, which should
# not contain leg_2 and leg_3, but should contain their mother particle
# if it exists
other_legs = [copy.copy(l) for l in process['legs'] if \
l != leg_2 and l != leg_3]
assert (len(other_legs) == (len(process['legs']) - 2))
leg_2_part = model.get('particle_dict')[leg_2['id']]
leg_3_part = model.get('particle_dict')[leg_3['id']]
interactions = [inte for inte in model.get('interaction_dict').values() \
if len(inte['particles']) == 3 and \
leg_2_part in inte['particles'] and \
leg_3_part in inte['particles']]
for inte in interactions:
particles = [copy.copy(p) for p in inte['particles']]
try:
particles.remove(leg_2_part)
particles.remove(leg_3_part)
except ValueError:
# this is when leg_2 and leg_3 are the same particle
# and it appears only once in the interacion, so
# the interaction has to be skipped
continue
leg_1_part = particles[0]
# check that it is massive and its mass it is different from
# leg_2 and leg_3
if leg_1_part['mass'].lower() == 'zero' or \
leg_1_part['mass'] == leg_2_part['mass'] or \
leg_1_part['mass'] == leg_3_part['mass']:
continue
# check that it is not among the forbidden particles
if leg_1_part.get_pdg_code() in forbidden or \
leg_1_part.get_anti_pdg_code() in forbidden:
continue
# this should be the final particle (take the antiparticle as
# it has to go "into" the interaction)
leg_1 = MG.Leg({
'state': True,
'id': leg_1_part.get_anti_pdg_code(),
'number': leg_2['number']
})
os_legs = [copy.copy(l) for l in other_legs]
os_legs.insert(leg_2['number'] - 1, leg_1)
assert (len(os_legs) == (len(process['legs']) - 1))
# count the occurences of leg 1 in the final state legs
# only one of them has to be decayed
nleg_1 = [l['id'] for l in os_legs].count(leg_1['id'])
# construct the decay chain and the process
# definition
leg_1_decay = MG.Leg({'id': leg_1['id'], 'state': False})
leg_2_decay = MG.Leg({'id': leg_2['id'], 'state': True})
leg_3_decay = MG.Leg({'id': leg_3['id'], 'state': True})
decay_chain_legs = MG.LegList(\
[leg_1_decay, leg_2_decay, leg_3_decay])
decay_chain = MG.Process(\
{'model': model,
'legs': MG.LegList(decay_chain_legs),
'is_decay_chain': True})
# construct the 'trivial' decay chain to be used when leg_1
# occurs more than once in the final state legs
leg_1_decayed = MG.Leg({'id': leg_1['id'], 'state': True})
trivial_decay_chain_legs = MG.LegList(\
[leg_1_decay, leg_1_decayed])
trivial_decay_chain = MG.Process(\
{'model': model,
'legs': MG.LegList(trivial_decay_chain_legs),
'is_decay_chain': True})
decay_chains = MG.ProcessList([decay_chain] + \
[trivial_decay_chain] * (nleg_1 - 1))
for leg in os_legs:
leg['number'] = os_legs.index(leg) + 1
# the orders in os_procdef refer only to the production process
# so the orders of the splitting have to be subtracted
prod_weighted_order = weighted_order - \
sum([v * model.get('order_hierarchy')[o] \
for o, v in inte['orders'].items()])
# skip if prod_weighted_order is negative or zero
# negative prod_weighted_order can lead to strange behaviours
if prod_weighted_order < 0:
continue
os_procdef = MG.Process(\
{'model': model,
'legs': MG.LegList(os_legs),
'decay_chains': decay_chains,
'orders': {'WEIGHTED': prod_weighted_order}})
# now generate the amplitude.
# Do nothing if any InvalidCmd is raised (e.g. charge not conserved)
# or if no diagrams are there
# set the logger to CRITICAL in order not to warn about 1 -> 1
# (trivial) decay chains
loglevel = logging.getLogger(
'madgraph.diagram_generation').level
logging.getLogger('madgraph.diagram_generation').setLevel(
logging.CRITICAL)
try:
os_amp = diagram_generation.DecayChainAmplitude(os_procdef)
except InvalidCmd:
continue
logging.getLogger('madgraph.diagram_generation').setLevel(
loglevel)
if not all([amp['diagrams'] for amp in os_amp['amplitudes']]):
continue
logger.info(
'Process %s has been generated for on-shell subtraction' %
os_procdef.input_string())
n_os += 1
fksreal.os_amplitudes.append(os_amp)
fksreal.os_ids.append([leg_1['id'], leg_2['id'], leg_3['id']])
fksreal.os_daughter_pos.append(
[leg_2['number'] - 1, leg_3['number'] - 1])
fksreal.os_diagrams.append(find_os_diagrams(\
amplitude, [leg_1, leg_2, leg_3], from_helas))
return n_os
def setUp(self):
if not hasattr(self, 'mymodel') or \
not hasattr(self, 'myleglist3') or \
not hasattr(self, 'myproc1') or \
not hasattr(self, 'myproc3'):
myleglist1 = MG.LegList()
# PROCESS: u g > u g
mylegs = [{
'id': 2,
'number': 1,
'state': False
}, {
'id': 21,
'number': 2,
'state': False
}, {
'id': 2,
'number': 3,
'state': True
}, {
'id': 21,
'number': 4,
'state': True
}]
for i in mylegs:
myleglist1.append(MG.Leg(i))
myleglist3 = MG.LegList()
# PROCESS: d d~ > u u~
mylegs = [{
'id': 1,
'number': 1,
'state': False
}, {
'id': -1,
'number': 2,
'state': False
}, {
'id': 2,
'number': 3,
'state': True
}, {
'id': -2,
'number': 4,
'state': True
}]
for i in mylegs:
myleglist3.append(MG.Leg(i))
mymodel = import_ufo.import_model('sm')
dict1 = {
'legs': myleglist1,
'orders': {
'QCD': 10,
'QED': 0
},
'model': mymodel,
'id': 1,
'required_s_channels': [],
'forbidden_s_channels': [],
'forbidden_particles': [],
'is_decay_chain': False,
'orders': {
'QED': 0,
'WEIGHTED': 2
},
'perturbation_couplings': ['QCD'],
'decay_chains': MG.ProcessList(),
'overall_orders': {}
}
dict1_qed = {
'legs': myleglist1,
'orders': {
'QCD': 10,
'QED': 0
},
'model': mymodel,
'id': 1,
'required_s_channels': [],
'forbidden_s_channels': [],
'forbidden_particles': [],
'is_decay_chain': False,
'orders': {
'QED': 0,
'WEIGHTED': 2
},
'perturbation_couplings': ['QED'],
'decay_chains': MG.ProcessList(),
'overall_orders': {}
}
dict3 = {
'legs': myleglist3,
'orders': {
'QCD': 10,
'QED': 0
},
'model': mymodel,
'id': 1,
'required_s_channels': [],
'forbidden_s_channels': [],
'forbidden_particles': [],
'is_decay_chain': False,
'orders': {
'QED': 0,
'WEIGHTED': 2
},
'perturbation_couplings': ['QCD'],
'decay_chains': MG.ProcessList(),
'overall_orders': {}
}
dict3_qed = {
'legs': myleglist3,
'orders': {
'QCD': 10,
'QED': 0
},
'model': mymodel,
'id': 1,
'required_s_channels': [],
'forbidden_s_channels': [],
'forbidden_particles': [],
'is_decay_chain': False,
'orders': {
'QED': 0,
'WEIGHTED': 2
},
'perturbation_couplings': ['QED'],
'decay_chains': MG.ProcessList(),
'overall_orders': {}
}
testFKSHelasObjects.mymodel = mymodel
testFKSHelasObjects.myleglist3 = myleglist3
testFKSHelasObjects.myproc1 = MG.Process(dict1)
testFKSHelasObjects.myproc3 = MG.Process(dict3)
testFKSHelasObjects.myproc1_qed = MG.Process(dict1_qed)
testFKSHelasObjects.myproc3_qed = MG.Process(dict3_qed)
def test_ungrouping_lepton(self):
"""check that the routines which ungroup the process for the muon/electron processes
works as expected"""
# Setup A simple model
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
# A quark U and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'u',
'antiname': 'u~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'u',
'antitexname': '\bar u',
'line': 'straight',
'charge': 2. / 3.,
'pdg_code': 2,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
u = mypartlist[-1]
antiu = copy.copy(u)
antiu.set('is_part', False)
# A quark D and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'd',
'antiname': 'd~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'd',
'antitexname': '\bar d',
'line': 'straight',
'charge': -1. / 3.,
'pdg_code': 1,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
d = mypartlist[-1]
antid = copy.copy(d)
antid.set('is_part', False)
# A quark C and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'c',
'antiname': 'c~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'u',
'antitexname': '\bar u',
'line': 'straight',
'charge': 2. / 3.,
'pdg_code': 4,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
c = mypartlist[-1]
antic = copy.copy(c)
antic.set('is_part', False)
# electron/positront
mypartlist.append(
base_objects.Particle({
'name': 'e-',
'antiname': 'e+',
'spin': 2,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': 'u',
'antitexname': '\bar u',
'line': 'straight',
'charge': 1,
'pdg_code': 11,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
e = mypartlist[-1]
antie = copy.copy(e)
mu = copy.copy(e)
antie.set('is_part', False)
mu.set('name', 'mu-')
mu.set('antiname', 'mu+')
mu.set('pdg_code', 13)
mypartlist.append(mu)
antimu = copy.copy(mu)
antimu.set('is_part', False)
# A Z
mypartlist.append(
base_objects.Particle({
'name': 'z',
'antiname': 'z',
'spin': 3,
'color': 1,
'mass': 'MZ',
'width': 'WZ',
'texname': 'Z',
'antitexname': 'Z',
'line': 'wavy',
'charge': 0.,
'pdg_code': 23,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
z = mypartlist[-1]
# Coupling of Z to quarks
myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
z]),
'color': [color.ColorString([color.T(1,0)])],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GUZ1', (0, 1):'GUZ2'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList(\
[antid, \
d, \
z]),
'color': [color.ColorString([color.T(1,0)])],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GDZ1', (0, 1):'GDZ2'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 3,
'particles': base_objects.ParticleList(\
[antic, \
c, \
z]),
'color': [color.ColorString([color.T(1,0)])],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GUZ1', (0, 1):'GUZ2'},
'orders':{'QED':1}}))
# Coupling of Z to leptons
myinterlist.append(base_objects.Interaction({
'id': 4,
'particles': base_objects.ParticleList(\
[antie, \
e, \
z]),
'color': [color.ColorString()],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GLZ1', (0, 1):'GLZ2'},
'orders':{'QED':1}}))
# Coupling of Z to leptons
myinterlist.append(base_objects.Interaction({
'id': 5,
'particles': base_objects.ParticleList(\
[antimu, \
mu, \
z]),
'color': [color.ColorString()],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GLZ1', (0, 1):'GLZ2'},
'orders':{'QED':1}}))
mymodel = base_objects.Model()
mymodel.set('particles', mypartlist)
mymodel.set('interactions', myinterlist)
mymodel.set('name', 'sm')
procs = [[1, -1, 23], [2, -2, 23], [4, -4, 23]]
decays = [[23, 11, -11], [23, 13, -13]]
coreamplitudes = diagram_generation.AmplitudeList()
decayamplitudes = diagram_generation.AmplitudeList()
decayprocs = base_objects.ProcessList()
#Building the basic objects
for proc in procs:
# Define the multiprocess
my_leglist = base_objects.LegList([\
base_objects.Leg({'id': id, 'state': True}) for id in proc])
my_leglist[0].set('state', False)
my_leglist[1].set('state', False)
my_process = base_objects.Process({
'legs': my_leglist,
'model': mymodel
})
my_amplitude = diagram_generation.Amplitude(my_process)
my_amplitude.set('has_mirror_process', True)
coreamplitudes.append(my_amplitude)
for proc in decays:
# Define the multiprocess
my_leglist = base_objects.LegList([\
base_objects.Leg({'id': id, 'state': True}) for id in proc])
my_leglist[0].set('state', False)
my_process = base_objects.Process({
'legs': my_leglist,
'model': mymodel,
'is_decay_chain': True
})
my_amplitude = diagram_generation.Amplitude(my_process)
decayamplitudes.append(my_amplitude)
decayprocs.append(my_process)
decays = diagram_generation.DecayChainAmplitudeList([\
diagram_generation.DecayChainAmplitude({\
'amplitudes': decayamplitudes})])
decay_chains = diagram_generation.DecayChainAmplitude({\
'amplitudes': coreamplitudes,
'decay_chains': decays})
dc_subproc_group = group_subprocs.DecayChainSubProcessGroup.\
group_amplitudes(\
diagram_generation.DecayChainAmplitudeList([decay_chains]))
subproc_groups = \
dc_subproc_group.generate_helas_decay_chain_subproc_groups()
######################
## Make the test!! ##
######################
self.assertEqual(len(subproc_groups), 1)
subproc_groups = subproc_groups.split_lepton_grouping()
self.assertEqual(len(subproc_groups), 2)
# check that indeed
for group in subproc_groups:
self.assertEqual(len(group['matrix_elements']), 2)
has_muon = any(
abs(l['id']) == 13 for l in group['matrix_elements'][0]
['processes'][0]['decay_chains'][0]['legs'])
for me in group['matrix_elements']:
if abs(me['processes'][0]['legs'][0]['id']) == 1:
self.assertEqual(len(me['processes']), 1)
else:
self.assertEqual(len(me['processes']), 2)
for proc in me['processes']:
for dec in proc['decay_chains']:
if has_muon:
self.assertFalse(
any(abs(l['id']) == 11 for l in dec['legs']))
else:
self.assertFalse(
any(abs(l['id']) == 13 for l in dec['legs']))
self.assertNotEqual(group['name'], 'qq_z_z_ll')
if has_muon:
self.assertEqual(group['name'], 'qq_z_z_mummup')
else:
self.assertEqual(group['name'], 'qq_z_z_emep')
group['name']