def test_uu_to_six_g(self): """Test the process u u > six g against literature expression""" myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id':2, 'state':False, 'number': 1})) myleglist.append(base_objects.Leg({'id':2, 'state':False, 'number': 2})) myleglist.append(base_objects.Leg({'id':9000006, 'state':True, 'number': 3})) myleglist.append(base_objects.Leg({'id':21, 'state':True, 'number': 4})) myproc = base_objects.Process({'legs':myleglist, 'model':self.base_model}) evaluator = process_checks.MatrixElementEvaluator(self.base_model, reuse = False) p, w_rambo = evaluator.get_momenta(myproc) amplitude = diagram_generation.Amplitude(myproc) matrix_element = helas_objects.HelasMatrixElement(amplitude) mg5_me_value, amp2 = evaluator.evaluate_matrix_element(matrix_element, p) comparison_value = uu_Dg(p, 6, evaluator.full_model) self.assertAlmostEqual(mg5_me_value, comparison_value, 12)
def test_find_symmetry_qq_qqg_with_subprocess_group(self): """Test the find_symmetry function for subprocess groups""" procs = [[2,-2,2,-2,21], [2,2,2,2,21]] amplitudes = diagram_generation.AmplitudeList() 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':self.base_model}) my_amplitude = diagram_generation.Amplitude(my_process) amplitudes.append(my_amplitude) subproc_group = \ group_subprocs.SubProcessGroup.group_amplitudes(amplitudes,"madevent")[0] symmetry, perms, ident_perms = diagram_symmetry.find_symmetry(\ subproc_group) self.assertEqual(len([s for s in symmetry if s > 0]), 19) self.assertEqual(symmetry,[1, 1, 1, 1, -2, -3, -4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -8, -9, -10, -11, -12, -13, -14, -18, -19]) return # The test below doesn't apply with the new way of determining # config symmetry for subprocess groups, since we don't demand # that symmetric diagrams have identical particles. # Check that the momentum assignments work matrix_element = \ subproc_group.get('matrix_elements')[1] process = matrix_element.get('processes')[0] evaluator = process_checks.MatrixElementEvaluator(self.base_model, auth_skipping = True, reuse = True) p, w_rambo = evaluator.get_momenta(process) me_value, amp2_org = evaluator.evaluate_matrix_element(\ matrix_element, p) for isym, (sym, perm) in enumerate(zip(symmetry, perms)): new_p = [p[i] for i in perm] if sym >= 0: continue iamp = subproc_group.get('diagram_maps')[1].index(isym+1) isymamp = subproc_group.get('diagram_maps')[1].index(-sym) me_value, amp2 = evaluator.evaluate_matrix_element(\ matrix_element, new_p) self.assertAlmostEqual(amp2[iamp], amp2_org[isymamp])
def test_get_momenta(self): """Test the get_momenta function""" myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id':-11, 'state':False, 'number': 1})) myleglist.append(base_objects.Leg({'id':11, 'state':False, 'number': 2})) myleglist.append(base_objects.Leg({'id':22, 'state':True, 'number': 3})) myleglist.append(base_objects.Leg({'id':22, 'state':True, 'number': 4})) myleglist.append(base_objects.Leg({'id':23, 'state':True, 'number': 5})) myproc = base_objects.Process({'legs':myleglist, 'model':self.base_model}) evaluator = process_checks.MatrixElementEvaluator(self.base_model) full_model = evaluator.full_model p, w_rambo = evaluator.get_momenta(myproc) # Check massless external momenta for mom in p[:-1]: mass = mom[0]**2-(mom[1]**2+mom[2]**2+mom[3]**2) self.assertAlmostEqual(mass, 0., 8) mom = p[-1] mass = math.sqrt(mom[0]**2-(mom[1]**2+mom[2]**2+mom[3]**2)) self.assertAlmostEqual(mass, full_model.get('parameter_dict')['mdl_MZ'], 8) # Check momentum balance outgoing = [0]*4 incoming = [0]*4 for i in range(4): incoming[i] = sum([mom[i] for mom in p[:2]]) outgoing[i] = sum([mom[i] for mom in p[2:]]) self.assertAlmostEqual(incoming[i], outgoing[i], 8) # Check non-zero final state momenta for mom in p[2:]: for i in range(4): self.assertTrue(abs(mom[i]) > 0.)
def test_find_symmetry_epem_aaa(self): """Test the find_symmetry function""" myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id':-11, 'state':False})) myleglist.append(base_objects.Leg({'id':11, 'state':False})) myleglist.append(base_objects.Leg({'id':22, 'state':True})) myleglist.append(base_objects.Leg({'id':22, 'state':True})) myleglist.append(base_objects.Leg({'id':22, 'state':True})) myproc = base_objects.Process({'legs':myleglist, 'model':self.base_model}) myamplitude = diagram_generation.Amplitude(myproc) matrix_element = helas_objects.HelasMatrixElement(myamplitude) symmetry, perms, ident_perms = diagram_symmetry.find_symmetry(matrix_element) self.assertEqual(symmetry, [6,-1,-1,-1,-1,-1]) # Check that the momentum assignments work process = matrix_element.get('processes')[0] evaluator = process_checks.MatrixElementEvaluator(self.base_model, auth_skipping = True, reuse = True) p, w_rambo = evaluator.get_momenta(process) me_value, amp2_org = evaluator.evaluate_matrix_element(\ matrix_element, p) for isym, (sym, perm) in enumerate(zip(symmetry, perms)): new_p = [p[i] for i in perm] if sym >= 0: continue me_value, amp2 = evaluator.evaluate_matrix_element(matrix_element, new_p) self.assertAlmostEqual(amp2[isym], amp2_org[-sym-1])
def test_rotate_momenta(self): """Test that matrix element and amp2 identical for rotated momenta""" 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':2, 'state':True})) myleglist.append(base_objects.Leg({'id':-2, 'state':True})) myleglist.append(base_objects.Leg({'id':21, 'state':True})) myproc = base_objects.Process({'legs':myleglist, 'model':self.base_model}) myamp = diagram_generation.Amplitude(myproc) matrix_element = helas_objects.HelasMatrixElement(myamp) evaluator = process_checks.MatrixElementEvaluator(self.base_model, auth_skipping = True, reuse = True) p, w_rambo = evaluator.get_momenta(myproc) me_val, amp2 = evaluator.evaluate_matrix_element(\ matrix_element,p) # Rotate momenta around x axis for mom in p: mom[2] = -mom[2] mom[3] = -mom[3] new_me_val, new_amp2 = evaluator.evaluate_matrix_element(\ matrix_element, p) self.assertAlmostEqual(me_val, new_me_val, 10) for amp, new_amp in zip(amp2, new_amp2): self.assertAlmostEqual(amp, new_amp, 10)
def uu_to_ttng_test(self, nglue = 0): """Test the process u u > t t g for 4fermion models""" 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':6})) myleglist.append(base_objects.Leg({'id':6})) myleglist.extend([base_objects.Leg({'id':21}) for i in range(nglue)]) values = {} p = None for model in 'scalar', '4ferm': base_model = eval('self.base_model_%s' % model) full_model = eval('self.full_model_%s' % model) myproc = base_objects.Process({'legs':myleglist, 'model':base_model}) evaluator = process_checks.MatrixElementEvaluator(base_model, reuse = False) evaluator.full_model = full_model if not p: p, w_rambo = evaluator.get_momenta(myproc) amplitude = diagram_generation.Amplitude(myproc) matrix_element = helas_objects.HelasMatrixElement(amplitude) stored_quantities = {} values[model] = evaluator.evaluate_matrix_element(matrix_element, p)[0] self.assertAlmostEqual(values['scalar'], values['4ferm'], 3)
def test_boost_momenta_gluino(self): """check if the momenta are boosted correctly by checking invariant mass in the case of massive final state """ myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id':21, 'state':False, 'number': 1})) myleglist.append(base_objects.Leg({'id':21, 'state':False, 'number': 2})) myleglist.append(base_objects.Leg({'id':1000021, 'state':True, 'number': 3})) myleglist.append(base_objects.Leg({'id':1000021, 'state':True, 'number': 4})) myproc = base_objects.Process({'legs':myleglist, 'model':self.base_model}) evaluator = process_checks.MatrixElementEvaluator(self.base_model) p, w_rambo = evaluator.get_momenta(myproc) def invariant_mass(p1, p2): #helping function to compute invariant mass return p1[0] * p2[0] - p1[1] * p2[1] - p1[2] * p2[2] -p1[3] * p2[3] # Compute invariant mass on the initial set of impulsion invariant_mass_result = [] for p1 in p: for p2 in p: m12 = invariant_mass(p1, p2) if abs(m12) < 1e-8: m12=0 invariant_mass_result.append(m12) self.assertTrue(m12 >= 0) # Compute invariant mass on a x direction boost invariant_mass_boost=[] p_boost = process_checks.boost_momenta(p) for p1 in p_boost: for p2 in p_boost: m12 = invariant_mass(p1, p2) invariant_mass_boost.append(m12) for i in range(len(invariant_mass_boost)): self.assertAlmostEqual(invariant_mass_boost[i], invariant_mass_result[i]) # Compute invariant mass on a y direction boost invariant_mass_boost=[] p_boost = process_checks.boost_momenta(p, boost_direction=2) for p1 in p_boost: for p2 in p_boost: m12 = invariant_mass(p1, p2) invariant_mass_boost.append(m12) for i in range(len(invariant_mass_boost)): self.assertAlmostEqual(invariant_mass_boost[i], invariant_mass_result[i]) # Compute invariant mass on a z direction boost invariant_mass_boost=[] p_boost = process_checks.boost_momenta(p, boost_direction=3, beta=0.8) for p1 in p_boost: for p2 in p_boost: m12 = invariant_mass(p1, p2) invariant_mass_boost.append(m12) for i in range(len(invariant_mass_boost)): self.assertAlmostEqual(invariant_mass_boost[i], invariant_mass_result[i])