def test_f_product(self): """Test the fully contracted product of two f's""" my_color_factor = color.ColorFactor([\ color.ColorString([color.f(1, 2, 3), color.f(1, 2, 3)])]) self.assertEqual(str(my_color_factor.full_simplify()), '(-1 Nc^1 )+(1 Nc^3 )')
def test_T_f_product(self): """Test a non trivial T f f product""" my_color_factor = color.ColorFactor([\ color.ColorString([color.T(-1000, 1, 2), color.f(-1, -1000, 5), color.f(-1, 4, 3)])]) self.assertEqual(str(my_color_factor.full_simplify()), "(-1 T(5,4,3,1,2))+(1 T(5,3,4,1,2))+(1 T(4,3,5,1,2))+(-1 T(3,4,5,1,2))")
def test_three_f_chain(self): """Test a chain of three f's""" my_color_factor = color.ColorFactor([\ color.ColorString([color.f(1, 2, -1), color.f(-1, 3, -2), color.f(-2, 4, 5)])]) self.assertEqual(str(my_color_factor.full_simplify()), "(2 I Tr(1,2,3,4,5))+(-2 I Tr(1,2,4,5,3))+(-2 I Tr(1,2,3,5,4))" + \ "+(2 I Tr(1,2,5,4,3))+(-2 I Tr(1,3,4,5,2))+(2 I Tr(1,4,5,3,2))" + \ "+(2 I Tr(1,3,5,4,2))+(-2 I Tr(1,5,4,3,2))")
def test_gluons(self): """Test simplification of chains of f""" my_col_fact = color.ColorFactor([color.ColorString([color.f(-3, 1, 2), color.f(-1, 3, 4), color.f(-1, 5, -3) ])]) self.assertEqual(str(my_col_fact.full_simplify()), '(2 I Tr(1,2,3,4,5))+(-2 I Tr(1,2,5,3,4))+(-2 I Tr(1,2,4,3,5))+' + \ '(2 I Tr(1,2,5,4,3))+(-2 I Tr(1,3,4,5,2))+(2 I Tr(1,5,3,4,2))+' + \ '(2 I Tr(1,4,3,5,2))+(-2 I Tr(1,5,4,3,2))')
def test_f_d_product(self): """Test the fully contracted product of f and d""" my_color_factor = color.ColorFactor([\ color.ColorString([color.f(1, 2, 3), color.d(1, 2, 3)])]) self.assertEqual(str(my_color_factor.full_simplify()), '')
def test_colorize_uu_gg(self): """Test the colorize function for uu~ > gg""" myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id': -2, 'state': False})) myleglist.append(base_objects.Leg({'id': 2, 'state': False})) myleglist.extend([base_objects.Leg({'id': 21, 'state': True})] * 2) myprocess = base_objects.Process({ 'legs': myleglist, 'model': self.mymodel }) myamplitude = diagram_generation.Amplitude() myamplitude.set('process', myprocess) myamplitude.generate_diagrams() my_col_basis = color_amp.ColorBasis() # S channel col_dict = my_col_basis.colorize(myamplitude['diagrams'][0], self.mymodel) goal_dict = { (0, 0): color.ColorString([color.T(-1000, 1, 2), color.f(3, 4, -1000)]) } self.assertEqual(col_dict, goal_dict) # T channel col_dict = my_col_basis.colorize(myamplitude['diagrams'][1], self.mymodel) goal_dict = { (0, 0): color.ColorString([color.T(3, 1, -1000), color.T(4, -1000, 2)]) } self.assertEqual(col_dict, goal_dict) # U channel col_dict = my_col_basis.colorize(myamplitude['diagrams'][2], self.mymodel) goal_dict = { (0, 0): color.ColorString([color.T(4, 1, -1000), color.T(3, -1000, 2)]) } self.assertEqual(col_dict, goal_dict)
def setUp(self): """Initialize the ColorString test""" # Create a test color string test_f = color.f(1, 2, 3) test_d = color.d(4, 5, 6) self.my_col_string = color.ColorString([test_f, test_d], coeff=fractions.Fraction(2, 3), Nc_power= -2, is_imaginary=True)
def test_f_d_sum(self): """Test f and d sum with the right weights giving a Tr""" col_str1 = color.ColorString([color.d(1, 2, 3)]) col_str1.coeff = fractions.Fraction(1, 4) col_str2 = color.ColorString([color.f(1, 2, 3)]) col_str2.coeff = fractions.Fraction(1, 4) col_str2.is_imaginary = True my_color_factor = color.ColorFactor([col_str1, col_str2]) self.assertEqual(str(my_color_factor.full_simplify()), '(1 Tr(1,2,3))')
def test_colorize_uux_ggg(self): """Test the colorize function for uu~ > ggg""" myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id':2, 'state':False})) myleglist.append(base_objects.Leg({'id':-2, 'state':False})) myleglist.extend([base_objects.Leg({'id':21, 'state':True})] * 3) myprocess = base_objects.Process({'legs':myleglist, 'model':self.mymodel}) myamplitude = diagram_generation.Amplitude() myamplitude.set('process', myprocess) myamplitude.generate_diagrams() my_col_basis = color_amp.ColorBasis() # First diagram with two 3-gluon vertices col_dict = my_col_basis.colorize(myamplitude['diagrams'][0], self.mymodel) goal_dict = {(0, 0, 0):color.ColorString([color.T(-1000, 2, 1), color.f(-1001, 3, 4), color.f(-1000, -1001, 5)])} self.assertEqual(col_dict, goal_dict) # Diagram with one 4-gluon vertex col_dict = my_col_basis.colorize(myamplitude['diagrams'][3], self.mymodel) goal_dict = {(0, 0): color.ColorString([color.T(-1000,2,1), color.f(-1001,3,5), color.f(-1001,4,-1000)]), (0, 1): color.ColorString([color.T(-1000,2,1), color.f(-1002,3,-1000), color.f(-1002,4,5)]), (0, 2): color.ColorString([color.T(-1000,2,1), color.f(-1003,3,4), color.f(-1003,5,-1000)])} self.assertEqual(col_dict, goal_dict)
def test_colorize_uu_gg(self): """Test the colorize function for uu~ > gg""" myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id':-2, 'state':False})) myleglist.append(base_objects.Leg({'id':2, 'state':False})) myleglist.extend([base_objects.Leg({'id':21, 'state':True})] * 2) myprocess = base_objects.Process({'legs':myleglist, 'model':self.mymodel}) myamplitude = diagram_generation.Amplitude() myamplitude.set('process', myprocess) myamplitude.generate_diagrams() my_col_basis = color_amp.ColorBasis() # S channel col_dict = my_col_basis.colorize(myamplitude['diagrams'][0], self.mymodel) goal_dict = {(0, 0):color.ColorString([color.T(-1000, 1, 2), color.f(3, 4, -1000)])} self.assertEqual(col_dict, goal_dict) # T channel col_dict = my_col_basis.colorize(myamplitude['diagrams'][1], self.mymodel) goal_dict = {(0, 0):color.ColorString([color.T(3, 1, -1000), color.T(4, -1000, 2)])} self.assertEqual(col_dict, goal_dict) # U channel col_dict = my_col_basis.colorize(myamplitude['diagrams'][2], self.mymodel) goal_dict = {(0, 0):color.ColorString([color.T(4, 1, -1000), color.T(3,-1000, 2)])} self.assertEqual(col_dict, goal_dict)
def test_f_object(self): """Test the f color object""" # T should have exactly 3 indices! self.assertRaises(AssertionError, color.f, 1, 2, 3, 4) # Simplify should always return the same ColorFactor my_f = color.f(1, 2, 3) col_str1 = color.ColorString([color.Tr(1, 2, 3)]) col_str2 = color.ColorString([color.Tr(3, 2, 1)]) col_str1.coeff = fractions.Fraction(-2, 1) col_str2.coeff = fractions.Fraction(2, 1) col_str1.is_imaginary = True col_str2.is_imaginary = True self.assertEqual(my_f.simplify(), color.ColorFactor([col_str1, col_str2]))
def read_interactions_v4(fsock, ref_part_list): """Read a list of interactions from stream fsock, using the old v4 format. Requires a ParticleList object as an input to recognize particle names.""" logger.info('load interactions') myinterlist = InteractionList() if not isinstance(ref_part_list, ParticleList): raise ValueError, \ "Object %s is not a valid ParticleList" % repr(ref_part_list) for line in fsock: myinter = Interaction() line = line.split("#", 2)[0] # remove any comment line = line.strip() # makes the string clean if line != "": # skip blank values = line.split() part_list = ParticleList() try: for str_name in values: curr_part = ref_part_list.get_copy(str_name.lower()) if isinstance(curr_part, Particle): # Look at the total number of strings, stop if # anyway not enough, required if a variable name # corresponds to a particle! (eg G) if len(values) >= 2 * len(part_list) + 1: part_list.append(curr_part) else: break # also stops if string does not correspond to # a particle name else: break if len(part_list) < 3: raise Interaction.PhysicsObjectError, \ "Vertex with less than 3 known particles found." # Flip part/antipart of first part for FFV, FFS, FFT vertices # according to v4 convention spin_array = [part['spin'] for part in part_list] if spin_array[:2] == [2, 2] and \ not part_list[0].get('self_antipart'): part_list[0]['is_part'] = not part_list[0]['is_part'] myinter.set('particles', part_list) # Give color structure # Order particles according to color # Don't consider singlets color_parts = sorted(enumerate(part_list), lambda p1, p2:\ p1[1].get_color() - p2[1].get_color()) color_ind = [(i, part.get_color()) for i, part in \ color_parts if part.get_color() !=1] colors = [c for i, c in color_ind] ind = [i for i, c in color_ind] # Set color empty by default myinter.set('color', []) if not colors: # All color singlets - set empty pass elif colors == [-3, 3]: # triplet-triplet-singlet coupling myinter.set('color', [color.ColorString(\ [color.T(ind[1], ind[0])])]) elif colors == [8, 8]: # octet-octet-singlet coupling my_cs = color.ColorString(\ [color.Tr(ind[0], ind[1])]) my_cs.coeff = fractions.Fraction(2) myinter.set('color', [my_cs]) elif colors == [-3, 3, 8]: # triplet-triplet-octet coupling myinter.set('color', [color.ColorString(\ [color.T(ind[2], ind[1], ind[0])])]) elif colors == [8, 8, 8]: # Triple glue coupling my_color_string = color.ColorString(\ [color.f(ind[0], ind[1], ind[2])]) my_color_string.is_imaginary = True myinter.set('color', [my_color_string]) elif colors == [-3, 3, 8, 8]: my_cs1 = color.ColorString(\ [color.T(ind[2], ind[3], ind[1], ind[0])]) my_cs2 = color.ColorString(\ [color.T(ind[3], ind[2], ind[1], ind[0])]) myinter.set('color', [my_cs1, my_cs2]) elif colors == [8, 8, 8, 8]: # 4-glue coupling cs1 = color.ColorString( [color.f(0, 1, -1), color.f(2, 3, -1)]) #cs1.coeff = fractions.Fraction(-1) cs2 = color.ColorString( [color.f(2, 0, -1), color.f(1, 3, -1)]) #cs2.coeff = fractions.Fraction(-1) cs3 = color.ColorString( [color.f(1, 2, -1), color.f(0, 3, -1)]) #cs3.coeff = fractions.Fraction(-1) myinter.set('color', [cs1, cs2, cs3]) # The following line are expected to be correct but not physical validations # have been performed. So we keep it commented for the moment. # elif colors == [3, 3, 3]: # my_color_string = color.ColorString(\ # [color.Epsilon(ind[0], ind[1], ind[2])]) # myinter.set('color', [my_color_string]) # elif colors == [-3, -3, -3]: # my_color_string = color.ColorString(\ # [color.EpsilonBar(ind[0], ind[1], ind[2])]) # myinter.set('color', [my_color_string]) else: logger.warning(\ "Color combination %s not yet implemented." % \ repr(colors)) # Set the Lorentz structure. Default for 3-particle # vertices is empty string, for 4-particle pair of # empty strings myinter.set('lorentz', ['']) pdg_codes = sorted([part.get_pdg_code() for part in part_list]) # WWWW and WWVV if pdg_codes == [-24, -24, 24, 24]: myinter.set('lorentz', ['WWWW']) elif spin_array == [3, 3, 3, 3] and \ 24 in pdg_codes and - 24 in pdg_codes: myinter.set('lorentz', ['WWVV']) # gggg if pdg_codes == [21, 21, 21, 21]: myinter.set('lorentz', ['gggg1', 'gggg2', 'gggg3']) # go-go-g # Using the special fvigox routine provides the minus # sign necessary for octet Majorana-vector interactions if spin_array == [2, 2, 3] and colors == [8, 8, 8] and \ part_list[0].get('self_antipart') and \ part_list[1].get('self_antipart'): myinter.set('lorentz', ['go']) # If extra flag, add this to Lorentz if len(values) > 3 * len(part_list) - 4: myinter.get('lorentz')[0] = \ myinter.get('lorentz')[0]\ + values[3 * len(part_list) - 4].upper() # Use the other strings to fill variable names and tags # Couplings: special treatment for 4-vertices, where MG4 used # two couplings, while MG5 only uses one (with the exception # of the 4g vertex, which needs special treatment) # DUM0 and DUM1 are used as placeholders by FR, corresponds to 1 if len(part_list) == 3 or \ values[len(part_list) + 1] in ['DUM', 'DUM0', 'DUM1']: # We can just use the first coupling, since the second # is a dummy myinter.set('couplings', {(0, 0): values[len(part_list)]}) if myinter.get('lorentz')[0] == 'WWWWN': # Should only use one Helas amplitude for electroweak # 4-vector vertices with FR. I choose W3W3NX. myinter.set('lorentz', ['WWVVN']) elif values[len(part_list)] in ['DUM', 'DUM0', 'DUM1']: # We can just use the second coupling, since the first # is a dummy myinter.set('couplings', {(0, 0): values[len(part_list) + 1]}) elif pdg_codes == [21, 21, 21, 21]: # gggg myinter.set( 'couplings', { (0, 0): values[len(part_list)], (1, 1): values[len(part_list)], (2, 2): values[len(part_list)] }) elif myinter.get('lorentz')[0] == 'WWWW': # Need special treatment of v4 SM WWWW couplings since # MG5 can only have one coupling per Lorentz structure myinter.set('couplings', {(0, 0):\ 'sqrt(' + values[len(part_list)] + \ '**2+' + \ values[len(part_list) + 1] + \ '**2)'}) else: #if myinter.get('lorentz')[0] == 'WWVV': # Need special treatment of v4 SM WWVV couplings since # MG5 can only have one coupling per Lorentz structure myinter.set('couplings', {(0, 0):values[len(part_list)] + \ '*' + \ values[len(part_list) + 1]}) #raise Interaction.PhysicsObjectError, \ # "Only FR-style 4-vertices implemented." # SPECIAL TREATMENT OF COLOR # g g sq sq (two different color structures, same Lorentz) if spin_array == [3, 3, 1, 1] and colors == [-3, 3, 8, 8]: myinter.set( 'couplings', { (0, 0): values[len(part_list)], (1, 0): values[len(part_list)] }) # Coupling orders - needs to be fixed order_list = values[2 * len(part_list) - 2: \ 3 * len(part_list) - 4] def count_duplicates_in_list(dupedlist): """return a dictionary with key the element of dupeList and with value the number of times that they are in this list""" unique_set = set(item for item in dupedlist) ret_dict = {} for item in unique_set: ret_dict[item] = dupedlist.count(item) return ret_dict myinter.set('orders', count_duplicates_in_list(order_list)) myinter.set('id', len(myinterlist) + 1) myinterlist.append(myinter) except Interaction.PhysicsObjectError, why: logger.error("Interaction ignored: %s" % why)
def read_interactions_v4(fsock, ref_part_list): """Read a list of interactions from stream fsock, using the old v4 format. Requires a ParticleList object as an input to recognize particle names.""" logger.info('load interactions') myinterlist = InteractionList() if not isinstance(ref_part_list, ParticleList): raise ValueError, \ "Object %s is not a valid ParticleList" % repr(ref_part_list) for line in fsock: myinter = Interaction() line = line.split("#", 2)[0] # remove any comment line = line.strip() # makes the string clean if line != "": # skip blank values = line.split() part_list = ParticleList() try: for str_name in values: curr_part = ref_part_list.get_copy(str_name.lower()) if isinstance(curr_part, Particle): # Look at the total number of strings, stop if # anyway not enough, required if a variable name # corresponds to a particle! (eg G) if len(values) >= 2 * len(part_list) + 1: part_list.append(curr_part) else: break # also stops if string does not correspond to # a particle name else: break if len(part_list) < 3: raise Interaction.PhysicsObjectError, \ "Vertex with less than 3 known particles found." # Flip part/antipart of first part for FFV, FFS, FFT vertices # according to v4 convention spin_array = [part['spin'] for part in part_list] if spin_array[:2] == [2, 2] and \ not part_list[0].get('self_antipart'): part_list[0]['is_part'] = not part_list[0]['is_part'] myinter.set('particles', part_list) # Give color structure # Order particles according to color # Don't consider singlets color_parts = sorted(enumerate(part_list), lambda p1, p2:\ p1[1].get_color() - p2[1].get_color()) color_ind = [(i, part.get_color()) for i, part in \ color_parts if part.get_color() !=1] colors = [c for i,c in color_ind] ind = [i for i,c in color_ind] # Set color empty by default myinter.set('color', []) if not colors: # All color singlets - set empty pass elif colors == [-3, 3]: # triplet-triplet-singlet coupling myinter.set('color', [color.ColorString(\ [color.T(ind[1], ind[0])])]) elif colors == [8, 8]: # octet-octet-singlet coupling my_cs = color.ColorString(\ [color.Tr(ind[0], ind[1])]) my_cs.coeff = fractions.Fraction(2) myinter.set('color', [my_cs]) elif colors == [-3, 3, 8]: # triplet-triplet-octet coupling myinter.set('color', [color.ColorString(\ [color.T(ind[2], ind[1], ind[0])])]) elif colors == [8, 8, 8]: # Triple glue coupling my_color_string = color.ColorString(\ [color.f(ind[0], ind[1], ind[2])]) my_color_string.is_imaginary = True myinter.set('color', [my_color_string]) elif colors == [-3, 3, 8, 8]: my_cs1 = color.ColorString(\ [color.T(ind[2], ind[3], ind[1], ind[0])]) my_cs2 = color.ColorString(\ [color.T(ind[3], ind[2], ind[1], ind[0])]) myinter.set('color', [my_cs1, my_cs2]) elif colors == [8, 8, 8, 8]: # 4-glue coupling cs1 = color.ColorString([color.f(0, 1, -1), color.f(2, 3, -1)]) #cs1.coeff = fractions.Fraction(-1) cs2 = color.ColorString([color.f(2, 0, -1), color.f(1, 3, -1)]) #cs2.coeff = fractions.Fraction(-1) cs3 = color.ColorString([color.f(1, 2, -1), color.f(0, 3, -1)]) #cs3.coeff = fractions.Fraction(-1) myinter.set('color', [cs1, cs2, cs3]) # The following line are expected to be correct but not physical validations # have been performed. So we keep it commented for the moment. # elif colors == [3, 3, 3]: # my_color_string = color.ColorString(\ # [color.Epsilon(ind[0], ind[1], ind[2])]) # myinter.set('color', [my_color_string]) # elif colors == [-3, -3, -3]: # my_color_string = color.ColorString(\ # [color.EpsilonBar(ind[0], ind[1], ind[2])]) # myinter.set('color', [my_color_string]) else: logger.warning(\ "Color combination %s not yet implemented." % \ repr(colors)) # Set the Lorentz structure. Default for 3-particle # vertices is empty string, for 4-particle pair of # empty strings myinter.set('lorentz', ['']) pdg_codes = sorted([part.get_pdg_code() for part in part_list]) # WWWW and WWVV if pdg_codes == [-24, -24, 24, 24]: myinter.set('lorentz', ['WWWW']) elif spin_array == [3, 3, 3, 3] and \ 24 in pdg_codes and - 24 in pdg_codes: myinter.set('lorentz', ['WWVV']) # gggg if pdg_codes == [21, 21, 21, 21]: myinter.set('lorentz', ['gggg1', 'gggg2', 'gggg3']) # go-go-g # Using the special fvigox routine provides the minus # sign necessary for octet Majorana-vector interactions if spin_array == [2, 2, 3] and colors == [8, 8, 8] and \ part_list[0].get('self_antipart') and \ part_list[1].get('self_antipart'): myinter.set('lorentz', ['go']) # If extra flag, add this to Lorentz if len(values) > 3 * len(part_list) - 4: myinter.get('lorentz')[0] = \ myinter.get('lorentz')[0]\ + values[3 * len(part_list) - 4].upper() # Use the other strings to fill variable names and tags # Couplings: special treatment for 4-vertices, where MG4 used # two couplings, while MG5 only uses one (with the exception # of the 4g vertex, which needs special treatment) # DUM0 and DUM1 are used as placeholders by FR, corresponds to 1 if len(part_list) == 3 or \ values[len(part_list) + 1] in ['DUM', 'DUM0', 'DUM1']: # We can just use the first coupling, since the second # is a dummy myinter.set('couplings', {(0, 0):values[len(part_list)]}) if myinter.get('lorentz')[0] == 'WWWWN': # Should only use one Helas amplitude for electroweak # 4-vector vertices with FR. I choose W3W3NX. myinter.set('lorentz', ['WWVVN']) elif values[len(part_list)] in ['DUM', 'DUM0', 'DUM1']: # We can just use the second coupling, since the first # is a dummy myinter.set('couplings', {(0, 0):values[len(part_list)+1]}) elif pdg_codes == [21, 21, 21, 21]: # gggg myinter.set('couplings', {(0, 0):values[len(part_list)], (1, 1):values[len(part_list)], (2, 2):values[len(part_list)]}) elif myinter.get('lorentz')[0] == 'WWWW': # Need special treatment of v4 SM WWWW couplings since # MG5 can only have one coupling per Lorentz structure myinter.set('couplings', {(0, 0):\ 'sqrt(' + values[len(part_list)] + \ '**2+' + \ values[len(part_list) + 1] + \ '**2)'}) else: #if myinter.get('lorentz')[0] == 'WWVV': # Need special treatment of v4 SM WWVV couplings since # MG5 can only have one coupling per Lorentz structure myinter.set('couplings', {(0, 0):values[len(part_list)] + \ '*' + \ values[len(part_list) + 1]}) #raise Interaction.PhysicsObjectError, \ # "Only FR-style 4-vertices implemented." # SPECIAL TREATMENT OF COLOR # g g sq sq (two different color structures, same Lorentz) if spin_array == [3, 3, 1, 1] and colors == [-3, 3, 8, 8]: myinter.set('couplings', {(0, 0):values[len(part_list)], (1, 0):values[len(part_list)]}) # Coupling orders - needs to be fixed order_list = values[2 * len(part_list) - 2: \ 3 * len(part_list) - 4] def count_duplicates_in_list(dupedlist): """return a dictionary with key the element of dupeList and with value the number of times that they are in this list""" unique_set = set(item for item in dupedlist) ret_dict = {} for item in unique_set: ret_dict[item] = dupedlist.count(item) return ret_dict myinter.set('orders', count_duplicates_in_list(order_list)) myinter.set('id', len(myinterlist) + 1) myinterlist.append(myinter) except Interaction.PhysicsObjectError, why: logger.error("Interaction ignored: %s" % why)
def legs_to_color_link_string(leg1, leg2): #test written, all cases """given two FKSlegs, returns a dictionary containing: --string: the color link between the two particles, to be appended to the old color string extra minus or 1/2 factor are included as it was done in MadDipole --replacements: a pair of lists containing the replacements of the color indices in the old string to match the link """ #the second-to-last index of the t is the triplet, # the last is the anti-triplet legs = FKSLegList([leg1, leg2]) dict = {} min_index = -3000 iglu = min_index * 2 string = color_algebra.ColorString() replacements = [] if leg1 != leg2: for leg in legs: min_index -= 1 num = leg.get('number') replacements.append([num, min_index]) icol = 1 if not leg.get('state'): icol = -1 if leg.get('color') * icol == 3: string.product( color_algebra.ColorString( [color_algebra.T(iglu, num, min_index)])) string.coeff = string.coeff * (-1) elif leg.get('color') * icol == -3: string.product( color_algebra.ColorString( [color_algebra.T(iglu, min_index, num)])) elif leg.get('color') == 8: string.product( color_algebra.ColorString( init_list=[color_algebra.f(min_index, iglu, num)], is_imaginary=True)) else: icol = 1 if not leg1.get('state'): icol = -1 num = leg1.get('number') replacements.append([num, min_index - 1]) if leg1.get('color') * icol == 3: string = color_algebra.ColorString( [color_algebra.T(iglu, iglu, num, min_index - 1)]) elif leg1.get('color') * icol == -3: string = color_algebra.ColorString( [color_algebra.T(iglu, iglu, min_index - 1, num)]) elif leg1.get('color') == 8: string = color_algebra.ColorString( init_list=[color_algebra.f(min_index - 1, iglu, min_index)], is_imaginary=True) string.product( color_algebra.ColorString( init_list=[color_algebra.f(min_index, iglu, num)], is_imaginary=True)) string.coeff = string.coeff * fractions.Fraction(1, 2) dict['replacements'] = replacements dict['string'] = string return dict
def setUp(self): # A gluon self.mypartlist.append(base_objects.Particle({'name':'g', 'antiname':'g', 'spin':3, 'color':8, 'mass':'zero', 'width':'zero', 'texname':'g', 'antitexname':'g', 'line':'curly', 'charge':0., 'pdg_code':21, 'propagating':True, 'is_part':True, 'self_antipart':True})) # A quark U and its antiparticle self.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})) antiu = copy.copy(self.mypartlist[1]) antiu.set('is_part', False) # A quark D and its antiparticle self.mypartlist.append(base_objects.Particle({'name':'d', 'antiname':'d~', 'spin':2, 'color':3, 'mass':'zero', 'width':'zero', 'texname':'u', 'antitexname':'\bar u', 'line':'straight', 'charge':-1. / 3., 'pdg_code':1, 'propagating':True, 'is_part':True, 'self_antipart':False})) antid = copy.copy(self.mypartlist[2]) antid.set('is_part', False) # 3 gluon vertiex self.myinterlist.append(base_objects.Interaction({ 'id': 1, 'particles': base_objects.ParticleList(\ [self.mypartlist[0]] * 3), 'color': [color.ColorString([color.f(0, 1, 2)])], 'lorentz':['L1'], 'couplings':{(0, 0):'G'}, 'orders':{'QCD':1}})) # 4 gluon vertex self.myinterlist.append(base_objects.Interaction({ 'id': 2, 'particles': base_objects.ParticleList(\ [self.mypartlist[0]] * 4), 'color': [color.ColorString([color.f(-1, 0, 2), color.f(-1, 1, 3)]), color.ColorString([color.f(-1, 0, 3), color.f(-1, 1, 2)]), color.ColorString([color.f(-1, 0, 1), color.f(-1, 2, 3)])], 'lorentz':['L(p1,p2,p3)', 'L(p2,p3,p1)', 'L3'], 'couplings':{(0, 0):'G^2', (1, 1):'G^2', (2, 2):'G^2'}, 'orders':{'QCD':2}})) # Gluon couplings to up and down quarks self.myinterlist.append(base_objects.Interaction({ 'id': 3, 'particles': base_objects.ParticleList(\ [self.mypartlist[1], \ antiu, \ self.mypartlist[0]]), 'color': [color.ColorString([color.T(2, 0, 1)])], 'lorentz':['L1'], 'couplings':{(0, 0):'GQQ'}, 'orders':{'QCD':1}})) self.myinterlist.append(base_objects.Interaction({ 'id': 4, 'particles': base_objects.ParticleList(\ [self.mypartlist[2], \ antid, \ self.mypartlist[0]]), 'color': [color.ColorString([color.T(2, 0, 1)])], 'lorentz':['L1'], 'couplings':{(0, 0):'GQQ'}, 'orders':{'QCD':1}})) self.mymodel.set('particles', self.mypartlist) self.mymodel.set('interactions', self.myinterlist)
def test_colorize_funny_model(self): """Test the colorize function for uu~ > ggg""" mypartlist = base_objects.ParticleList() myinterlist = base_objects.InteractionList() mymodel = base_objects.Model() # A gluon mypartlist.append(base_objects.Particle({'name':'g', 'antiname':'g', 'spin':3, 'color':8, 'mass':'zero', 'width':'zero', 'texname':'g', 'antitexname':'g', 'line':'curly', 'charge':0., 'pdg_code':21, 'propagating':True, 'is_part':True, 'self_antipart':True})) # 3 gluon vertiex myinterlist.append(base_objects.Interaction({ 'id': 1, 'particles': base_objects.ParticleList(\ [mypartlist[0]] * 3), 'color': [color.ColorString([color.f(0, 1, 2)]), color.ColorString([color.f(0, 2, 1)]), color.ColorString([color.f(1, 2, 0)])], 'lorentz':['L1'], 'couplings':{(0, 0):'G', (2,0):'G'}, 'orders':{'QCD':1}})) mymodel.set('particles', mypartlist) mymodel.set('interactions', myinterlist) myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id':21, 'state':False})) myleglist.append(base_objects.Leg({'id':21, 'state':False})) myleglist.extend([base_objects.Leg({'id':21, 'state':True})] * 2) myprocess = base_objects.Process({'legs':myleglist, 'model':mymodel}) myamplitude = diagram_generation.Amplitude() myamplitude.set('process', myprocess) myamplitude.generate_diagrams() my_col_basis = color_amp.ColorBasis() # Check that only the color structures that are actually used are included col_dict = my_col_basis.colorize(myamplitude['diagrams'][0], mymodel) goal_dict = {(2, 0): color.ColorString([color.f(1,2,-1000), color.f(3,4,-1000)]), (0, 0): color.ColorString([color.f(-1000,1,2), color.f(3,4,-1000)]), (0, 2): color.ColorString([color.f(-1000,1,2), color.f(4,-1000,3)]), (2, 2): color.ColorString([color.f(1,2,-1000), color.f(4,-1000,3)])} self.assertEqual(col_dict, goal_dict)
def test_read_interactions(self): """Test the output of import interactions.dat file""" particles_dat_str = """ve ve~ F S ZERO ZERO S ve 12 vm vm~ F S ZERO ZERO S vm 14 vt vt~ F S ZERO ZERO S vt 16 e- e+ F S ZERO ZERO S e 11 m- m+ F S ZERO ZERO S m 13 tt- tt+ F S MTA ZERO S tt 15 u u~ F S ZERO ZERO T u 2 c c~ F S MC ZERO T c 4 t t~ F S MT WT T t 6 d d~ F S ZERO ZERO T d 1 s s~ F S ZERO ZERO T s 3 b b~ F S MB ZERO T b 5 a a V W ZERO ZERO S a 22 z z V W MZ WZ S Z 23 w+ w- V W MW WW S W 24 g g V C ZERO ZERO O G 21 h h S D MH WH S H 25 T1 T1 T D ZERO ZERO O T1 8000002""" interactions_dat_str = """# Interactions associated with Standard_Model w+ w- a MGVX3 QED g g T1 MGVX2 QCD a w+ w- w+ w- MGVX6 DUM0 QED QED n e- ve w- MGVX24 QED e+ ve~ w+ MGVX25 QED u u g MGVX1 QCD u u a MGVX4 QED # And now some bad format entries # which should be ignored with a warning k+ k- a test QED g g test QCD""" fsock_part = StringIO.StringIO(particles_dat_str) fsock_inter = StringIO.StringIO(interactions_dat_str) myparts = import_v4.read_particles_v4(fsock_part) wplus = copy.copy(myparts[14]) wmin = copy.copy(myparts[14]) wmin.set('is_part', False) eminus = copy.copy(myparts[3]) eplus = copy.copy(myparts[3]) eplus.set('is_part', False) enu = copy.copy(myparts[0]) enubar = copy.copy(myparts[0]) enubar.set('is_part', False) photon = copy.copy(myparts[12]) gluon = copy.copy(myparts[15]) t1 = copy.copy(myparts[17]) u = myparts[6] ubar = copy.copy(myparts[6]) ubar.set('is_part', False) my_i_f = color.ColorString([color.f(0, 1, 2)]) my_i_f.is_imaginary = True goal_inter_list = base_objects.InteractionList([ \ base_objects.Interaction( {'id':1, 'particles':base_objects.ParticleList([ wplus, wmin, photon]), 'color':[], 'lorentz':[''], 'couplings':{(0, 0):'MGVX3'}, 'orders':{'QED':1}}), base_objects.Interaction( {'id':2, 'particles':base_objects.ParticleList([ gluon, gluon, t1]), 'color':[my_i_f], 'lorentz':['A'], 'couplings':{(0, 0):'MGVX2'}, 'orders':{'QCD':1}}), base_objects.Interaction( {'id':3, 'particles':base_objects.ParticleList([ wplus, wmin, wplus, wmin]), 'color':[], 'lorentz':['WWVVN'], 'couplings':{(0, 0):'MGVX6'}, 'orders':{'QED':2}}), base_objects.Interaction( {'id':4, 'particles':base_objects.ParticleList([ eplus, enu, wmin]), 'color':[], 'lorentz':[''], 'couplings':{(0, 0):'MGVX24'}, 'orders':{'QED':1}}), base_objects.Interaction( {'id':5, 'particles':base_objects.ParticleList([ eminus, enubar, wplus]), 'color':[], 'lorentz':[''], 'couplings':{(0, 0):'MGVX25'}, 'orders':{'QED':1}}), base_objects.Interaction( {'id':6, 'particles':base_objects.ParticleList([ ubar, u, gluon]), 'color':[color.ColorString(\ [color.T(2, 1, 0)])], 'lorentz':[''], 'couplings':{(0, 0):'MGVX1'}, 'orders':{'QCD':1}}), base_objects.Interaction( {'id':7, 'particles':base_objects.ParticleList([ ubar, u, photon]), 'color':[color.ColorString(\ [color.T(1, 0)])], 'lorentz':[''], 'couplings':{(0, 0):'MGVX4'}, 'orders':{'QED':1}})]) result = import_v4.read_interactions_v4(fsock_inter, myparts) self.assertEqual(len(result), len(goal_inter_list)) for i in range(len(result)): self.assertEqual(result[i], goal_inter_list[i])
'is_part': True, 'self_antipart': True }) particles = base_objects.ParticleList([gluon, up, down, photon, higgs]) # Interactions #========================================================================================= interactions = base_objects.InteractionList() # g g g interactions.append(base_objects.Interaction({ 'id': 1, 'particles': base_objects.ParticleList([gluon, ] * 3), 'color': [color.ColorString([color.f(0, 1, 2)])], 'lorentz': ['L1'], 'couplings': {(0, 0): 'G'}, 'orders': {'QCD': 1} })) # g g g g interactions.append(base_objects.Interaction({ 'id': 2, 'particles': base_objects.ParticleList([gluon, ] * 4), 'color': [ color.ColorString([color.f(-1, 0, 2), color.f(-1, 1, 3)]), color.ColorString([color.f(-1, 0, 3), color.f(-1, 1, 2)]), color.ColorString([color.f(-1, 0, 1), color.f(-1, 2, 3)]) ], 'lorentz': ['L(p1,p2,p3)', 'L(p2,p3,p1)', 'L3'],
def legs_to_color_link_string(leg1, leg2, pert = 'QCD'): #test written, all cases """given two FKSlegs, returns a dictionary containing: --string: the color link between the two particles, to be appended to the old color string extra minus or 1/2 factor are included as it was done in MadDipole --replacements: a pair of lists containing the replacements of the color indices in the old string to match the link """ #the second-to-last index of the t is the triplet, # the last is the anti-triplet legs = FKSLegList([leg1, leg2]) dict = {} min_index = -3000 iglu = min_index*2 string = color_algebra.ColorString() replacements = [] if pert == 'QCD': if leg1 != leg2: for leg in legs: min_index -= 1 num = leg.get('number') replacements.append([num, min_index]) icol = 1 if not leg.get('state'): icol = - 1 if leg.get('color') * icol == 3: string.product(color_algebra.ColorString([ color_algebra.T(iglu, num, min_index)])) string.coeff = string.coeff * (-1) elif leg.get('color') * icol == - 3: string.product(color_algebra.ColorString([ color_algebra.T(iglu, min_index, num)])) elif leg.get('color') == 8: string.product(color_algebra.ColorString(init_list = [ color_algebra.f(min_index,iglu,num)], is_imaginary =True)) else: icol = 1 if not leg1.get('state'): icol = - 1 num = leg1.get('number') replacements.append([num, min_index -1]) if leg1.get('color') * icol == 3: string = color_algebra.ColorString( [color_algebra.T(iglu, iglu, num, min_index -1)]) elif leg1.get('color') * icol == - 3: string = color_algebra.ColorString( [color_algebra.T(iglu, iglu, min_index-1, num)]) elif leg1.get('color') == 8: string = color_algebra.ColorString(init_list = [ color_algebra.f(min_index-1,iglu,min_index)], is_imaginary =True) string.product(color_algebra.ColorString(init_list = [ color_algebra.f(min_index,iglu,num)], is_imaginary =True)) string.coeff = string.coeff * fractions.Fraction(1, 2) elif pert == 'QED': for leg in legs: # make it a fraction string.coeff = string.coeff * fractions.Fraction(leg['charge']*3.)*\ fractions.Fraction(1,3) else: raise FKSProcessError,"Only QCD or QED is allowed not %s"% pert dict['replacements'] = replacements dict['string'] = string return dict
def test_colorize_uux_ggg(self): """Test the colorize function for uu~ > ggg""" myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id': 2, 'state': False})) myleglist.append(base_objects.Leg({'id': -2, 'state': False})) myleglist.extend([base_objects.Leg({'id': 21, 'state': True})] * 3) myprocess = base_objects.Process({ 'legs': myleglist, 'model': self.mymodel }) myamplitude = diagram_generation.Amplitude() myamplitude.set('process', myprocess) myamplitude.generate_diagrams() my_col_basis = color_amp.ColorBasis() # First diagram with two 3-gluon vertices col_dict = my_col_basis.colorize(myamplitude['diagrams'][0], self.mymodel) goal_dict = { (0, 0, 0): color.ColorString([ color.T(-1000, 2, 1), color.f(-1001, 3, 4), color.f(-1000, -1001, 5) ]) } self.assertEqual(col_dict, goal_dict) # Diagram with one 4-gluon vertex col_dict = my_col_basis.colorize(myamplitude['diagrams'][3], self.mymodel) goal_dict = { (0, 0): color.ColorString([ color.T(-1000, 2, 1), color.f(-1001, 3, 5), color.f(-1001, 4, -1000) ]), (0, 1): color.ColorString([ color.T(-1000, 2, 1), color.f(-1002, 3, -1000), color.f(-1002, 4, 5) ]), (0, 2): color.ColorString([ color.T(-1000, 2, 1), color.f(-1003, 3, 4), color.f(-1003, 5, -1000) ]) } self.assertEqual(col_dict, goal_dict)
def test_colorize_funny_model(self): """Test the colorize function for uu~ > ggg""" mypartlist = base_objects.ParticleList() myinterlist = base_objects.InteractionList() mymodel = base_objects.Model() # A gluon mypartlist.append( base_objects.Particle({ 'name': 'g', 'antiname': 'g', 'spin': 3, 'color': 8, 'mass': 'zero', 'width': 'zero', 'texname': 'g', 'antitexname': 'g', 'line': 'curly', 'charge': 0., 'pdg_code': 21, 'propagating': True, 'is_part': True, 'self_antipart': True })) # 3 gluon vertiex myinterlist.append(base_objects.Interaction({ 'id': 1, 'particles': base_objects.ParticleList(\ [mypartlist[0]] * 3), 'color': [color.ColorString([color.f(0, 1, 2)]), color.ColorString([color.f(0, 2, 1)]), color.ColorString([color.f(1, 2, 0)])], 'lorentz':['L1'], 'couplings':{(0, 0):'G', (2,0):'G'}, 'orders':{'QCD':1}})) mymodel.set('particles', mypartlist) mymodel.set('interactions', myinterlist) myleglist = base_objects.LegList() myleglist.append(base_objects.Leg({'id': 21, 'state': False})) myleglist.append(base_objects.Leg({'id': 21, 'state': False})) myleglist.extend([base_objects.Leg({'id': 21, 'state': True})] * 2) myprocess = base_objects.Process({'legs': myleglist, 'model': mymodel}) myamplitude = diagram_generation.Amplitude() myamplitude.set('process', myprocess) myamplitude.generate_diagrams() my_col_basis = color_amp.ColorBasis() # Check that only the color structures that are actually used are included col_dict = my_col_basis.colorize(myamplitude['diagrams'][0], mymodel) goal_dict = { (2, 0): color.ColorString([color.f(1, 2, -1000), color.f(3, 4, -1000)]), (0, 0): color.ColorString([color.f(-1000, 1, 2), color.f(3, 4, -1000)]), (0, 2): color.ColorString([color.f(-1000, 1, 2), color.f(4, -1000, 3)]), (2, 2): color.ColorString([color.f(1, 2, -1000), color.f(4, -1000, 3)]) } self.assertEqual(col_dict, goal_dict)
def setUp(self): # A gluon self.mypartlist.append( base_objects.Particle({ 'name': 'g', 'antiname': 'g', 'spin': 3, 'color': 8, 'mass': 'zero', 'width': 'zero', 'texname': 'g', 'antitexname': 'g', 'line': 'curly', 'charge': 0., 'pdg_code': 21, 'propagating': True, 'is_part': True, 'self_antipart': True })) # A quark U and its antiparticle self.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 })) antiu = copy.copy(self.mypartlist[1]) antiu.set('is_part', False) # A quark D and its antiparticle self.mypartlist.append( base_objects.Particle({ 'name': 'd', 'antiname': 'd~', 'spin': 2, 'color': 3, 'mass': 'zero', 'width': 'zero', 'texname': 'u', 'antitexname': '\bar u', 'line': 'straight', 'charge': -1. / 3., 'pdg_code': 1, 'propagating': True, 'is_part': True, 'self_antipart': False })) antid = copy.copy(self.mypartlist[2]) antid.set('is_part', False) # 3 gluon vertiex self.myinterlist.append(base_objects.Interaction({ 'id': 1, 'particles': base_objects.ParticleList(\ [self.mypartlist[0]] * 3), 'color': [color.ColorString([color.f(0, 1, 2)])], 'lorentz':['L1'], 'couplings':{(0, 0):'G'}, 'orders':{'QCD':1}})) # 4 gluon vertex self.myinterlist.append(base_objects.Interaction({ 'id': 2, 'particles': base_objects.ParticleList(\ [self.mypartlist[0]] * 4), 'color': [color.ColorString([color.f(-1, 0, 2), color.f(-1, 1, 3)]), color.ColorString([color.f(-1, 0, 3), color.f(-1, 1, 2)]), color.ColorString([color.f(-1, 0, 1), color.f(-1, 2, 3)])], 'lorentz':['L(p1,p2,p3)', 'L(p2,p3,p1)', 'L3'], 'couplings':{(0, 0):'G^2', (1, 1):'G^2', (2, 2):'G^2'}, 'orders':{'QCD':2}})) # Gluon couplings to up and down quarks self.myinterlist.append(base_objects.Interaction({ 'id': 3, 'particles': base_objects.ParticleList(\ [self.mypartlist[1], \ antiu, \ self.mypartlist[0]]), 'color': [color.ColorString([color.T(2, 0, 1)])], 'lorentz':['L1'], 'couplings':{(0, 0):'GQQ'}, 'orders':{'QCD':1}})) self.myinterlist.append(base_objects.Interaction({ 'id': 4, 'particles': base_objects.ParticleList(\ [self.mypartlist[2], \ antid, \ self.mypartlist[0]]), 'color': [color.ColorString([color.T(2, 0, 1)])], 'lorentz':['L1'], 'couplings':{(0, 0):'GQQ'}, 'orders':{'QCD':1}})) self.mymodel.set('particles', self.mypartlist) self.mymodel.set('interactions', self.myinterlist)