def test_simple_import(self): """ check that basic quantity are define """ #remove pkl file try: model_path = os.path.join(MG5DIR, 'models', 'sm') os.remove(os.path.join(model_path, 'model.pkl')) except: pass import_ufo._import_once = [] sm_path = import_ufo.find_ufo_path('sm') model = import_ufo.import_model(sm_path) self.assertNotEqual(model.get('particles'), None) self.assertNotEqual(model.get('particles'), [], "empty particles list") self.assertNotEqual(model.get('interactions'), None) self.assertNotEqual(model.get('interactions'), []) # try with the pickle: sm_path = import_ufo.find_ufo_path('sm') model = import_ufo.import_model(sm_path) self.assertNotEqual(model.get('particles'), None) self.assertNotEqual(model.get('particles'), [], "empty particles list") self.assertNotEqual(model.get('interactions'), None) self.assertNotEqual(model.get('interactions'), [])
def test_simple_import(self): """ check that basic quantity are define """ #remove pkl file try: model_path = os.path.join(MG5DIR, 'models', 'sm') os.remove(os.path.join(model_path,'model.pkl')) except: pass import_ufo._import_once = [] sm_path = import_ufo.find_ufo_path('sm') model = import_ufo.import_model(sm_path) self.assertNotEqual(model.get('particles'),None) self.assertNotEqual(model.get('particles'),[], "empty particles list") self.assertNotEqual(model.get('interactions'),None) self.assertNotEqual(model.get('interactions'),[]) # try with the pickle: sm_path = import_ufo.find_ufo_path('sm') model = import_ufo.import_model(sm_path) self.assertNotEqual(model.get('particles'),None) self.assertNotEqual(model.get('particles'),[], "empty particles list") self.assertNotEqual(model.get('interactions'),None) self.assertNotEqual(model.get('interactions'),[])
def test_ImportUFONoSideEffectNLO(self): """Checks that there are no side effects of the import of the NLO UFO sm""" ufo_model = ufomodels.load_model(import_ufo.find_ufo_path('loop_sm'),False) original_all_particles = copy.copy(ufo_model.all_particles) original_all_vertices = copy.copy(ufo_model.all_vertices) original_all_couplings = copy.copy(ufo_model.all_couplings) original_all_lorentz = copy.copy(ufo_model.all_lorentz) original_all_parameters = copy.copy(ufo_model.all_parameters) original_all_orders = copy.copy(ufo_model.all_orders) original_all_functions = copy.copy(ufo_model.all_functions) original_all_CTvertices = copy.copy(ufo_model.all_CTvertices) original_all_CTparameters = copy.copy(ufo_model.all_CTparameters) ufo2mg5_converter = import_ufo.UFOMG5Converter(ufo_model) model = ufo2mg5_converter.load_model() parameters, couplings = import_ufo.OrganizeModelExpression(ufo_model).main() self.assertEqual(original_all_particles,ufo_model.all_particles) self.assertEqual(original_all_vertices,ufo_model.all_vertices) # self.assertEqual(original_all_couplings,ufo_model.all_couplings) self.assertEqual(original_all_lorentz,ufo_model.all_lorentz) self.assertEqual(original_all_parameters,ufo_model.all_parameters) self.assertEqual(original_all_orders,ufo_model.all_orders) self.assertEqual(original_all_functions,ufo_model.all_functions) self.assertEqual(original_all_CTvertices,ufo_model.all_CTvertices) self.assertEqual(original_all_CTparameters,ufo_model.all_CTparameters)
def setUp(self): self.path = tempfile.mkdtemp(prefix='unitest_usermod') #Read the full SM self.sm_path = import_ufo.find_ufo_path('sm') self.base_model = usermod.UFOModel(self.sm_path)
def test_mssm_equivalence(self): """Test the UFO and MG4 MSSM model correspond to the same model """ # import UFO model sm_path = import_ufo.find_ufo_path('mssm') ufo_model = import_ufo.import_model(sm_path) #converter = import_ufo.UFOMG5Converter(model) #ufo_model = converter.load_model() ufo_model.pass_particles_name_in_mg_default() # import MG4 model model = base_objects.Model() if not MG4DIR: raise MadGraph5Error, "Please provide a valid MG/ME path with -d" v4_path = os.path.join(MG4DIR, 'models', 'mssm_v4') if not os.path.isdir(v4_path): v4_path = os.path.join(MG4DIR, 'Models', 'mssm') if not os.path.isdir(v4_path): raise MadGraph5Error, \ "Please provide a valid MG/ME path with -d" model.set('particles', files.read_from_file( os.path.join(v4_path,'particles.dat'), import_v4.read_particles_v4)) model.set('interactions', files.read_from_file( os.path.join(v4_path,'interactions.dat'), import_v4.read_interactions_v4, model['particles'])) model.pass_particles_name_in_mg_default() # Checking the particles for particle in model['particles']: ufo_particle = ufo_model.get("particle_dict")[particle['pdg_code']] self.check_particles(particle, ufo_particle) # Skip test below until equivalence has been created by Benj and Claude return # Checking the interactions nb_vertex = 0 ufo_vertices = [] for ufo_vertex in ufo_model['interactions']: pdg_code_ufo = [abs(part['pdg_code']) for part in ufo_vertex['particles']] int_name = [part['name'] for part in ufo_vertex['particles']] rep = (pdg_code_ufo, int_name) pdg_code_ufo.sort() ufo_vertices.append(pdg_code_ufo) mg4_vertices = [] for vertex in model['interactions']: pdg_code_mg4 = [abs(part['pdg_code']) for part in vertex['particles']] pdg_code_mg4.sort() try: ufo_vertices.remove(pdg_code_mg4) except ValueError: mg4_vertices.append(pdg_code_mg4) self.assertEqual(ufo_vertices, []) self.assertEqual(mg4_vertices, [])
def test_ImportUFONoSideEffectLO(self): """Checks that there are no side effects of the import of the LO UFO sm""" ufo_model = ufomodels.load_model(import_ufo.find_ufo_path('sm'),False) original_all_particles = copy.copy(ufo_model.all_particles) original_all_vertices = copy.copy(ufo_model.all_vertices) original_all_couplings = copy.copy(ufo_model.all_couplings) original_all_lorentz = copy.copy(ufo_model.all_lorentz) original_all_parameters = copy.copy(ufo_model.all_parameters) original_all_orders = copy.copy(ufo_model.all_orders) original_all_functions = copy.copy(ufo_model.all_functions) ufo2mg5_converter = import_ufo.UFOMG5Converter(ufo_model) model = ufo2mg5_converter.load_model() # It is important to run import_ufo.OrganizeModelExpression(ufo_model).main() # since this reverts some of the changes done in load_model() # There *is* side effects in-between, namely the expression of the CTcouplings # which contained CTparameters have been substituted to dictionaries. parameters, couplings = import_ufo.OrganizeModelExpression(ufo_model).main() self.assertEqual(original_all_particles,ufo_model.all_particles) self.assertEqual(original_all_vertices,ufo_model.all_vertices) self.assertEqual(original_all_couplings,ufo_model.all_couplings) self.assertEqual(original_all_lorentz,ufo_model.all_lorentz) self.assertEqual(original_all_parameters,ufo_model.all_parameters) self.assertEqual(original_all_orders,ufo_model.all_orders) self.assertEqual(original_all_functions,ufo_model.all_functions)
def test_ImportUFONoSideEffectNLO(self): """Checks that there are no side effects of the import of the NLO UFO sm""" ufo_model = ufomodels.load_model(import_ufo.find_ufo_path('loop_sm'), False) original_all_particles = copy.copy(ufo_model.all_particles) original_all_vertices = copy.copy(ufo_model.all_vertices) original_all_couplings = copy.copy(ufo_model.all_couplings) original_all_lorentz = copy.copy(ufo_model.all_lorentz) original_all_parameters = copy.copy(ufo_model.all_parameters) original_all_orders = copy.copy(ufo_model.all_orders) original_all_functions = copy.copy(ufo_model.all_functions) original_all_CTvertices = copy.copy(ufo_model.all_CTvertices) original_all_CTparameters = copy.copy(ufo_model.all_CTparameters) ufo2mg5_converter = import_ufo.UFOMG5Converter(ufo_model) model = ufo2mg5_converter.load_model() parameters, couplings = import_ufo.OrganizeModelExpression( ufo_model).main() self.assertEqual(original_all_particles, ufo_model.all_particles) self.assertEqual(original_all_vertices, ufo_model.all_vertices) # self.assertEqual(original_all_couplings,ufo_model.all_couplings) self.assertEqual(original_all_lorentz, ufo_model.all_lorentz) self.assertEqual(original_all_parameters, ufo_model.all_parameters) self.assertEqual(original_all_orders, ufo_model.all_orders) self.assertEqual(original_all_functions, ufo_model.all_functions) self.assertEqual(original_all_CTvertices, ufo_model.all_CTvertices) self.assertEqual(original_all_CTparameters, ufo_model.all_CTparameters)
def test_mssm_equivalence(self): """Test the UFO and MG4 MSSM model correspond to the same model """ # import UFO model mssm_path = import_ufo.find_ufo_path('MSSM_SLHA2') ufo_model = import_ufo.import_model(mssm_path) #converter = import_ufo.UFOMG5Converter(model) #ufo_model = converter.load_model() ufo_model.pass_particles_name_in_mg_default() # import MG4 model model = base_objects.Model() if not MG4DIR: raise MadGraph5Error("Please provide a valid MG/ME path with -d") v4_path = os.path.join(MG4DIR, 'models', 'mssm_v4') if not os.path.isdir(v4_path): import_ufo.import_model_from_db('mssm_v4', local_dir=True) model.set('particles', files.read_from_file( os.path.join(v4_path,'particles.dat'), import_v4.read_particles_v4)) model.set('interactions', files.read_from_file( os.path.join(v4_path,'interactions.dat'), import_v4.read_interactions_v4, model['particles'])) #model.pass_particles_name_in_mg_default() # Checking the particles for particle in model['particles']: ufo_particle = ufo_model.get("particle_dict")[particle['pdg_code']] self.check_particles(particle, ufo_particle) # Skip test below until equivalence has been created by Benj and Claude return # Checking the interactions nb_vertex = 0 ufo_vertices = [] for ufo_vertex in ufo_model['interactions']: pdg_code_ufo = [abs(part['pdg_code']) for part in ufo_vertex['particles']] int_name = [part['name'] for part in ufo_vertex['particles']] rep = (pdg_code_ufo, int_name) pdg_code_ufo.sort() ufo_vertices.append(pdg_code_ufo) mg4_vertices = [] for vertex in model['interactions']: pdg_code_mg4 = [abs(part['pdg_code']) for part in vertex['particles']] pdg_code_mg4.sort() try: ufo_vertices.remove(pdg_code_mg4) except ValueError: mg4_vertices.append(pdg_code_mg4) self.assertEqual(ufo_vertices, []) self.assertEqual(mg4_vertices, [])
def test_ImportUFONoSideEffectNLO(self): """Checks that there are no side effects of the import of the NLO UFO sm""" ufo_model = ufomodels.load_model(import_ufo.find_ufo_path('loop_sm'),False) original_all_particles = copy.copy(ufo_model.all_particles) original_all_vertices = copy.copy(ufo_model.all_vertices) original_all_couplings = copy.copy(ufo_model.all_couplings) original_all_lorentz = copy.copy(ufo_model.all_lorentz) original_all_parameters = copy.copy(ufo_model.all_parameters) original_all_orders = copy.copy(ufo_model.all_orders) original_all_functions = copy.copy(ufo_model.all_functions) original_all_CTvertices = copy.copy(ufo_model.all_CTvertices) original_all_CTparameters = copy.copy(ufo_model.all_CTparameters) ufo2mg5_converter = import_ufo.UFOMG5Converter(ufo_model) model = ufo2mg5_converter.load_model() # It is important to run import_ufo.OrganizeModelExpression(ufo_model).main() # since this reverts some of the changes done in load_model() # There *is* side effects in-between, namely the expression of the CTcouplings # which contained CTparameters have been substituted to dictionaries. parameters, couplings = import_ufo.OrganizeModelExpression(ufo_model).main() self.assertEqual(original_all_particles,ufo_model.all_particles) self.assertEqual(original_all_vertices,ufo_model.all_vertices) self.assertEqual(original_all_couplings,ufo_model.all_couplings) self.assertEqual(original_all_lorentz,ufo_model.all_lorentz) self.assertEqual(original_all_parameters,ufo_model.all_parameters) self.assertEqual(original_all_orders,ufo_model.all_orders) self.assertEqual(original_all_functions,ufo_model.all_functions) self.assertEqual(original_all_CTvertices,ufo_model.all_CTvertices) self.assertEqual(original_all_CTparameters,ufo_model.all_CTparameters) # Also test that one new lorentz struture has been added within the model # and that the associate optimization is working as expected. self.assertEqual(len(original_all_lorentz) + 1, len(model['lorentz'])) new_l = [l for l in model['lorentz'] if l not in original_all_lorentz][0] new_name = new_l.name self.assertEqual(new_l.name, 'R2RGA_VVVV1') # find interactions with that lorentz structure int_with_it = [] for id, vertices in model.get('interaction_dict').items(): if new_name in vertices['lorentz']: int_with_it.append(vertices) self.assertEqual(len(int_with_it), 2) # check the first one vert = int_with_it[0] pdg = [p['pdg_code'] for p in vert['particles']] self.assertEqual(pdg, [21,21,21,21]) # check the equivalent vertex in the original model old_vert = [ v for v in ufo_model.all_CTvertices if pdg == [p.pdg_code for p in v.particles]] #pick one old_vert = old_vert[0] # find the number of coupling associate to this lorentz structure ind = vert['lorentz'].index(new_name) coup_name = [ c for ((l,col),c) in vert['couplings'].items() if l ==ind] nb_old = len([ c for ((l,col),c) in vert['couplings'].items() if c == coup_name[0]]) nb_new = len([ c for ((l,col,k),c) in old_vert.couplings.items() if c.name == coup_name[0]]) self.assertEqual(3*nb_old, nb_new)
def setUp(self): """Set up decay model""" # Read the full SM sm_path = import_ufo.find_ufo_path("sm") self.base_model = import_ufo.import_full_model(sm_path) model = copy.deepcopy(self.base_model) self.model = import_ufo.RestrictModel(model) self.restrict_file = os.path.join(_file_path, os.path.pardir, "input_files", "restrict_sm.dat")
def setUp(self): m_path = import_ufo.find_ufo_path('triplet_diquarks') self.base_model = import_ufo.import_model(m_path) self.full_model = model_reader.ModelReader(self.base_model) self.full_model.set_parameters_and_couplings() # Set top quark mass to 0 to compare with literature expression self.full_model.get('parameter_dict')['mdl_MT'] = 0. self.full_model.get('parameter_dict')['mdl_WT'] = 0.
def setUp(self): m_path = import_ufo.find_ufo_path("triplet_diquarks") self.base_model = import_ufo.import_model(m_path) self.full_model = model_reader.ModelReader(self.base_model) self.full_model.set_parameters_and_couplings() # Set top quark mass to 0 to compare with literature expression self.full_model.get("parameter_dict")["MT"] = 0.0 self.full_model.get("parameter_dict")["WT"] = 0.0
def test_sm_equivalence(self): """Test the UFO and MG4 SM model correspond to the same model """ # import UFO model sm_path = import_ufo.find_ufo_path('sm') ufo_model = import_ufo.import_model(sm_path) ufo_model.pass_particles_name_in_mg_default() # import MG4 model model = base_objects.Model() v4_path = os.path.join(MG4DIR, 'models', 'sm_v4') if not os.path.isdir(v4_path): v4_path = os.path.join(MG4DIR, 'Models', 'sm') if not os.path.isdir(v4_path): raise MadGraph5Error, \ "Please provide a valid MG/ME path with -d" model.set( 'particles', files.read_from_file(os.path.join(v4_path, 'particles.dat'), import_v4.read_particles_v4)) model.set( 'interactions', files.read_from_file(os.path.join(v4_path, 'interactions.dat'), import_v4.read_interactions_v4, model['particles'])) model.pass_particles_name_in_mg_default() # Checking the particles for particle in model['particles']: ufo_particle = ufo_model.get("particle_dict")[particle['pdg_code']] self.check_particles(particle, ufo_particle) # Checking the interactions nb_vertex = 0 ufo_vertices = [] for ufo_vertex in ufo_model['interactions']: pdg_code_ufo = [ abs(part['pdg_code']) for part in ufo_vertex['particles'] ] int_name = [part['name'] for part in ufo_vertex['particles']] rep = (pdg_code_ufo, int_name) pdg_code_ufo.sort() ufo_vertices.append(pdg_code_ufo) mg4_vertices = [] for vertex in model['interactions']: pdg_code_mg4 = [ abs(part['pdg_code']) for part in vertex['particles'] ] pdg_code_mg4.sort() try: ufo_vertices.remove(pdg_code_mg4) except ValueError: mg4_vertices.append(pdg_code_mg4) self.assertEqual(ufo_vertices, [[25, 25, 25, 25]]) self.assertEqual(mg4_vertices, [])
def setUp(self): """Set up decay model""" #Read the full SM sm_path = import_ufo.find_ufo_path('sm') self.base_model = import_ufo.import_full_model(sm_path) model = copy.deepcopy(self.base_model) self.model = import_ufo.RestrictModel(model) self.restrict_file = os.path.join(_file_path, os.path.pardir, 'input_files', 'restrict_sm.dat')
def setUp(self): """Set up decay model""" #Read the full SM sm_path = import_ufo.find_ufo_path('sm') self.base_model = import_ufo.import_full_model(sm_path) model = copy.deepcopy(self.base_model) self.model = import_ufo.RestrictModel(model) self.restrict_file = os.path.join(_file_path, os.path.pardir, 'input_files', 'restrict_sm.dat') self.model.set_parameters_and_couplings(self.restrict_file)
def test_ImportUFOcheckgoldstone(self): """Check goldstone is correct in NLO UFO""" ufo_model = ufomodels.load_model(import_ufo.find_ufo_path('loop_qcd_qed_sm'),False) original_all_particles = copy.copy(ufo_model.all_particles) for part in original_all_particles: if part.name.lower() in ['g0','g+']: if hasattr(part,"GoldstoneBoson"): self.assertEqual(part.GoldstoneBoson,True) elif hasattr(part,"goldstoneboson"): self.assertEqual(part.goldstoneboson,True) else: raise import_ufo.UFOImportError, "Goldstone %s has no attribute of goldstnoneboson in loop_qcd_qed_sm"%part.name
def setUp(self): self.path = tempfile.mkdtemp(prefix='unitest_usermod') #Read the full SM self.sm_path = import_ufo.find_ufo_path('sm') self.base_model = usermod.UFOModel(self.sm_path) self.mymodel = Model() for key in self.mymodel.__dict__: obj = getattr(self.mymodel, key) for o in obj[:]: obj.pop()
def test_write_model(self): """ Check that we can write all the require UFO files """ output = pjoin(self.path, 'usrmod') self.base_model.write(output) sm_path = import_ufo.find_ufo_path('sm') self.assertEqual(12, len([1 for name in os.listdir(sm_path) if name.endswith('.py')]), 'New file in UFO format, usrmod need to be modified') self.assertEqual(11, len([1 for name in os.listdir(output) if name.endswith('.py')])) sys.path.insert(0, os.path.dirname(output)) import usrmod
def test_get_nflav_sm_nomasses(self): """Tests the get_nflav_function for the SM, with the no_masses restriction""" sm_path = import_ufo.find_ufo_path('sm') model = import_ufo.import_model(sm_path + '-no_masses') self.assertEqual(model.get_nflav(), 5)
def setUp(self): m_path = import_ufo.find_ufo_path('sextet_diquarks') self.base_model = import_ufo.import_model(m_path)
def setUp(self): sm_path = import_ufo.find_ufo_path('mssm') self.base_model = import_ufo.import_model(sm_path)
def setUp(self): sm_path = import_ufo.find_ufo_path('MSSM_SLHA2') self.base_model = import_ufo.import_model(sm_path)
def test_get_nflav_sm(self): """Tests the get_nflav_function for the full SM. Here b and c quark are massive""" sm_path = import_ufo.find_ufo_path('sm') model = import_ufo.import_full_model(sm_path) self.assertEqual(model.get_nflav(), 3)
def setUp(self): """Set up decay model""" #Read the full SM sm_path = import_ufo.find_ufo_path('heft') self.base_model = import_ufo.import_full_model(sm_path)
def setUp(self): """Set up decay model""" #Read the full SM sm_path = import_ufo.find_ufo_path('sm') self.base_model = import_ufo.import_model(sm_path) self.model_reader = model_reader.ModelReader(self.base_model)
def test_run_python_matrix_element(self): """Test a complete running of a Python matrix element without writing any files""" # Import the SM sm_path = import_ufo.find_ufo_path('sm') model = import_ufo.import_model(sm_path) 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':22, 'state':True, 'number': 5})) myproc = base_objects.Process({'legs':myleglist, 'model':model}) myamplitude = diagram_generation.Amplitude({'process': myproc}) mymatrixelement = helas_objects.HelasMatrixElement(myamplitude) # Create only the needed aloha routines wanted_lorentz = mymatrixelement.get_used_lorentz() aloha_model = create_aloha.AbstractALOHAModel(model.get('name')) aloha_model.compute_subset(wanted_lorentz) # Write out the routines in Python aloha_routines = [] for routine in aloha_model.values(): aloha_routines.append(routine.write(output_dir = None, language = 'Python').\ replace('import wavefunctions', 'import aloha.template_files.wavefunctions as wavefunctions')) # Define the routines to be available globally for routine in aloha_routines: exec(routine, globals()) # Write the matrix element(s) in Python mypythonmodel = helas_call_writers.PythonUFOHelasCallWriter(\ model) exporter = export_python.ProcessExporterPython(\ mymatrixelement, mypythonmodel) matrix_methods = exporter.get_python_matrix_methods() # Calculate parameters and couplings full_model = model_reader.ModelReader(model) full_model.set_parameters_and_couplings() # Define a momentum p = [[0.5000000e+03, 0.0000000e+00, 0.0000000e+00, 0.5000000e+03, 0.0000000e+00], [0.5000000e+03, 0.0000000e+00, 0.0000000e+00, -0.5000000e+03, 0.0000000e+00], [0.4585788e+03, 0.1694532e+03, 0.3796537e+03, -0.1935025e+03, 0.6607249e-05], [0.3640666e+03, -0.1832987e+02, -0.3477043e+03, 0.1063496e+03, 0.7979012e-05], [0.1773546e+03, -0.1511234e+03, -0.3194936e+02, 0.8715287e+02, 0.1348699e-05]] # Evaluate the matrix element for the given momenta answer = 1.39189717257175028e-007 for process in matrix_methods.keys(): # Define Python matrix element for process exec(matrix_methods[process]) # Calculate the matrix element for the momentum p value = eval("Matrix_0_epem_aaa().smatrix(p, full_model)") self.assertTrue(abs(value-answer)/answer < 1e-6, "Value is: %.9e should be %.9e" % \ (abs(value), answer))
def test_run_python_matrix_element(self): """Test a complete running of a Python matrix element without writing any files""" # Import the SM sm_path = import_ufo.find_ufo_path('sm') model = import_ufo.import_model(sm_path) 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': 22, 'state': True, 'number': 5 })) myproc = base_objects.Process({'legs': myleglist, 'model': model}) myamplitude = diagram_generation.Amplitude({'process': myproc}) mymatrixelement = helas_objects.HelasMatrixElement(myamplitude) # Create only the needed aloha routines wanted_lorentz = mymatrixelement.get_used_lorentz() aloha_model = create_aloha.AbstractALOHAModel(model.get('name')) aloha_model.compute_subset(wanted_lorentz) # Write out the routines in Python aloha_routines = [] for routine in aloha_model.values(): aloha_routines.append(routine.write(output_dir = None, language = 'Python').\ replace('import wavefunctions', 'import aloha.template_files.wavefunctions as wavefunctions')) # Define the routines to be available globally for routine in aloha_routines: exec(routine, globals()) # Write the matrix element(s) in Python mypythonmodel = helas_call_writers.PythonUFOHelasCallWriter(\ model) exporter = export_python.ProcessExporterPython(\ mymatrixelement, mypythonmodel) matrix_methods = exporter.get_python_matrix_methods() # Calculate parameters and couplings full_model = model_reader.ModelReader(model) full_model.set_parameters_and_couplings() # Define a momentum p = [[ 0.5000000e+03, 0.0000000e+00, 0.0000000e+00, 0.5000000e+03, 0.0000000e+00 ], [ 0.5000000e+03, 0.0000000e+00, 0.0000000e+00, -0.5000000e+03, 0.0000000e+00 ], [ 0.4585788e+03, 0.1694532e+03, 0.3796537e+03, -0.1935025e+03, 0.6607249e-05 ], [ 0.3640666e+03, -0.1832987e+02, -0.3477043e+03, 0.1063496e+03, 0.7979012e-05 ], [ 0.1773546e+03, -0.1511234e+03, -0.3194936e+02, 0.8715287e+02, 0.1348699e-05 ]] # Evaluate the matrix element for the given momenta answer = 1.39189717257175028e-007 for process in matrix_methods.keys(): # Define Python matrix element for process exec(matrix_methods[process]) # Calculate the matrix element for the momentum p value = eval("Matrix_0_epem_aaa().smatrix(p, full_model)") self.assertTrue(abs(value-answer)/answer < 1e-6, "Value is: %.9e should be %.9e" % \ (abs(value), answer))
def setUp(self): m_path = import_ufo.find_ufo_path("sextet_diquarks") self.base_model = import_ufo.import_model(m_path)