def colorize(self, diagram, model): """Takes a diagram and a model and outputs a dictionary with keys being color coefficient index tuples and values a color string (before simplification).""" # The smallest value used to create new summed indices min_index = -1000 # The dictionary to be output res_dict = {} # The dictionary for book keeping of replaced indices repl_dict = {} for i, vertex in enumerate(diagram.get('vertices')): min_index, res_dict = self.add_vertex(vertex, diagram, model, repl_dict, res_dict, min_index) # if the process has no QCD particles # Return a list filled with ColorOne if all entries are empty ColorString() empty_colorstring = color_algebra.ColorString() if all(cs == empty_colorstring for cs in res_dict.values()): res_dict = dict( (key, color_algebra.ColorString([color_algebra.ColorOne()])) for key in res_dict) return res_dict
def closeColorLoop(self, colorize_dict, lcut_charge, lcut_numbers): """ Add a color delta in the right representation (depending on the color charge carried by the L-cut particle whose number are given in the loop_numbers argument) to close the loop color trace """ # But for T3 and T6 for example, we must make sure to add a delta with # the first index in the fundamental representation. if lcut_charge < 0: lcut_numbers.reverse() if abs(lcut_charge) == 1: # No color carried by the lcut particle, there is nothing to do. return elif abs(lcut_charge) == 3: closingCS=color_algebra.ColorString(\ [color_algebra.T(lcut_numbers[1],lcut_numbers[0])]) elif abs(lcut_charge) == 6: closingCS=color_algebra.ColorString(\ [color_algebra.T6(lcut_numbers[1],lcut_numbers[0])]) elif abs(lcut_charge) == 8: closingCS=color_algebra.ColorString(\ [color_algebra.Tr(lcut_numbers[1],lcut_numbers[0])], fractions.Fraction(2, 1)) else: raise color_amp.ColorBasis.ColorBasisError, \ "L-cut particle has an unsupported color representation %s" % lcut_charge # Append it to all color strings for this diagram. for CS in colorize_dict.values(): CS.product(closingCS)
def test_K6_objects(self): """Test K6 product simplifications""" #K6(m,i,j)K6Bar(m,k,l) = 1/2(T(l,i)T(k,j) # + T(k,i)T(l,j) my_K6 = color.K6(1,101,102) my_K6Bar = color.K6Bar(1,103,104) col_str1 = color.ColorString([color.T(104,101), color.T(103,102)]) col_str2 = color.ColorString([color.T(103,101), color.T(104,102)]) col_str1.coeff = fractions.Fraction(1, 2) col_str2.coeff = fractions.Fraction(1, 2) self.assertEqual(my_K6.pair_simplify(my_K6Bar), color.ColorFactor([col_str1, col_str2])) #K6(m,i,j)K6Bar(n,j,i) = delta6(m,n) my_K6 = color.K6(1,101,102) my_K6Bar = color.K6Bar(2,102,101) self.assertEqual(my_K6.pair_simplify(my_K6Bar), color.ColorFactor([\ color.ColorString([color.T6(1,2)])])) #K6(m,i,j)K6Bar(n,i,j) = delta6(m,n). my_K6 = color.K6(1,101,102) my_K6Bar = color.K6Bar(2,101,102) self.assertEqual(my_K6.pair_simplify(my_K6Bar), color.ColorFactor([\ color.ColorString([color.T6(1,2)])]))
def create_new_entry(self, struct1, struct2, Nc_power_min, Nc_power_max, Nc): """ Create a new product result, and result with fixed Nc for two color basis entries. Implement Nc power limits.""" # Create color string objects corresponding to color basis # keys col_str = color_algebra.ColorString() col_str.from_immutable(struct1) col_str2 = color_algebra.ColorString() col_str2.from_immutable(struct2) # Complex conjugate the second one and multiply the two col_str.product(col_str2.complex_conjugate()) # Create a color factor to store the result and simplify it # taking into account the limit on Nc col_fact = color_algebra.ColorFactor([col_str]) result = col_fact.full_simplify() # Keep only terms with Nc_max >= Nc power >= Nc_min if Nc_power_min is not None: result[:] = [col_str for col_str in result \ if col_str.Nc_power >= Nc_power_min] if Nc_power_max is not None: result[:] = [col_str for col_str in result \ if col_str.Nc_power <= Nc_power_max] # Calculate the fixed Nc representation result_fixed_Nc = result.set_Nc(Nc) return result, result_fixed_Nc
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 closeColorLoop(self, colorize_dict, lcut_charge, lcut_numbers): """ Add a color delta in the right representation (depending on the color charge carried by the L-cut particle whose number are given in the loop_numbers argument) to close the loop color trace.""" # But for T3 and T6 for example, we must make sure to add a delta with # the first index in the fundamental representation. if lcut_charge < 0: lcut_numbers.reverse() if abs(lcut_charge) == 1: # No color carried by the lcut particle, there is nothing to do. return elif abs(lcut_charge) == 3: closingCS=color_algebra.ColorString(\ [color_algebra.T(lcut_numbers[1],lcut_numbers[0])]) elif abs(lcut_charge) == 6: closingCS=color_algebra.ColorString(\ [color_algebra.T6(lcut_numbers[1],lcut_numbers[0])]) elif abs(lcut_charge) == 8: closingCS=color_algebra.ColorString(\ [color_algebra.Tr(lcut_numbers[1],lcut_numbers[0])], fractions.Fraction(2, 1)) else: raise color_amp.ColorBasis.ColorBasisError, \ "L-cut particle has an unsupported color representation %s" % lcut_charge # Append it to all color strings for this diagram. for CS in colorize_dict.values(): # The double full_simplify() below brings significantly slowdown # so that it should be used only when loop_Nc_power is actuall used. if self.compute_loop_nc: # We first compute the NcPower of this ColorString before # *before* the loop color flow is sewed together. max_CS_lcut_diag_Nc_power = max(cs.Nc_power \ for cs in color_algebra.ColorFactor([CS]).full_simplify()) # We add here the closing color structure. CS.product(closingCS) if self.compute_loop_nc: # Now compute the Nc power *after* the loop color flow is sewed # together and again compute the overall maximum power of Nc # appearing in this simplified sewed structure. simplified_cs = color_algebra.ColorFactor([CS]).full_simplify() if not simplified_cs: # It can be that the color structure simplifies to zero. CS.loop_Nc_power = 0 continue max_CS_loop_diag_Nc_power = max(cs.Nc_power \ for cs in simplified_cs) # We can now set the power of Nc brought by the potential loop # color trace to the corresponding attribute of this ColorStructure CS.loop_Nc_power = max_CS_loop_diag_Nc_power - \ max_CS_lcut_diag_Nc_power else: # When not computing loop_nc (whcih is typically used for now # only when doing LoopInduced + Madevent, we set the # CS.loop_Nc_power to None so that it will cause problems if used. CS.loop_Nc_power = None
def test_delta3_pair_simplify(self): """Test delta3 simplify""" self.assertEqual(color.K6(1,101,103).pair_simplify(color.T(101,102)), color.ColorFactor([color.ColorString([color.K6(1,103,102)])])) self.assertEqual(color.K6(1,103,102).pair_simplify(color.T(102,101)), color.ColorFactor([color.ColorString([color.K6(1,103,101)])])) self.assertEqual(color.K6Bar(1,101,103).pair_simplify(color.T(102,101)), color.ColorFactor([color.ColorString([color.K6Bar(1,103,102)])])) self.assertEqual(color.K6Bar(1,103,101).pair_simplify(color.T(102,101)), color.ColorFactor([color.ColorString([color.K6Bar(1,103,102)])]))
def test_delta6_simplify(self): """Test delta6 simplify""" # delta6(i,i) = 1 col_str1 = color.ColorString() col_str1.Nc_power = 2 col_str1.coeff = fractions.Fraction(1, 2) col_str2 = color.ColorString() col_str2.Nc_power = 1 col_str2.coeff = fractions.Fraction(1, 2) self.assertEqual(color.T6(1, 1).simplify(), color.ColorFactor([col_str1, col_str2]))
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_color_string_canonical(self): """Test the canonical representation of a immutable color string""" immutable1 = (('f', (2, 3, 4)), ('T', (4, 2, 5))) immutable2 = (('T', (3, 5)),) self.assertEqual(color.ColorString().to_canonical(immutable1 + \ immutable2)[0], (('T', (2, 4)), ('T', (3, 1, 4)), ('f', (1, 2, 3)))) self.assertEqual(color.ColorString().to_canonical(immutable1 + \ immutable2)[1], {3:2, 5:4, 4:3, 2:1})
def test_d_object(self): """Test the d color object""" # T should have exactly 3 indices! self.assertRaises(AssertionError, color.d, 1, 2) # Simplify should always return the same ColorFactor my_d = color.d(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) self.assertEqual(my_d.simplify(), color.ColorFactor([col_str1, col_str2]))
def test_epsilon_object(self): """Test the epsilon object""" # Espilon should have exactly 3 indices! self.assertRaises(AssertionError, color.Epsilon, 1, 2) my_epsilon1 = color.Epsilon(2, 3, 1) my_epsilon2 = color.Epsilon(5, 1, 4) my_epsilon2 = my_epsilon2.complex_conjugate() my_goal_str1 = color.ColorString([color.T(2, 4), color.T(3, 5)]) my_goal_str2 = color.ColorString([color.T(2, 5), color.T(3, 4)]) my_goal_str2.coeff = fractions.Fraction(-1) self.assertEqual(my_epsilon1.pair_simplify(my_epsilon2), color.ColorFactor([my_goal_str1, my_goal_str2]))
def get_color_matrix_lines(self, matrix_element): """Return the color matrix definition lines for this matrix element. Split rows in chunks of size n.""" ncolor = str(len(matrix_element.get_color_amplitudes())) if not matrix_element.get('color_matrix'): return "static const double denom[1] = {1.};\nstatic const double cf[1][1] = {1.};" else: # First define denominator array color_denominators = matrix_element.get('color_matrix').get_line_denominators() denom_string = "static const double denom[" + ncolor + "] = {%s};" % \ ",".join( [ "%i" % denom for denom in color_denominators ] ) matrix_strings = [] my_cs = color.ColorString() for index, denominator in enumerate(color_denominators): # Then write the numerators for the matrix elements num_list = matrix_element.get('color_matrix').get_line_numerators(index, denominator) matrix_strings.append( "{%s}" % ",".join( [ "%d" % i for i in num_list ] ) ) matrix_string = "static const double cf[" + ncolor + "][" + ncolor + "] = {" + ",".join(matrix_strings) + "};" return "\n".join([denom_string, matrix_string])
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_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 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_complex_conjugate(self): """Test the complex conjugation of a color string""" my_color_string = color.ColorString([color.T(3, 4, 102, 103), color.Tr(1, 2, 3)]) my_color_string.is_imaginary = True self.assertEqual(str(my_color_string.complex_conjugate()), '-1 I T(4,3,103,102) Tr(3,2,1)')
def test_T_pair_simplify(self): """Test T object products simplifications""" my_T1 = color.T(1, 2, 3, 101, 102) my_T2 = color.T(4, 5, 102, 103) self.assertEqual(my_T1.pair_simplify(my_T2), color.ColorFactor([color.ColorString([\ color.T(1, 2, 3, 4, 5, 101, 103)])])) my_T3 = color.T(4, 2, 5, 103, 104) col_str1 = color.ColorString([color.T(1, 5, 101, 104), color.T(4, 3, 103, 102)]) col_str2 = color.ColorString([color.T(1, 3, 101, 102), color.T(4, 5, 103, 104)]) col_str1.coeff = fractions.Fraction(1, 2) col_str2.coeff = fractions.Fraction(-1, 2) col_str2.Nc_power = -1 self.assertEqual(my_T1.pair_simplify(my_T3), color.ColorFactor([col_str1, col_str2]))
def test_T_simplify(self): """Test T simplify""" # T(a,b,c,...,i,i) = Tr(a,b,c,...) self.assertEqual(color.T(1, 2, 3, 100, 100).simplify(), color.ColorFactor([\ color.ColorString([color.Tr(1, 2, 3)])])) # T(a,x,b,x,c,i,j) = 1/2(T(a,c,i,j)Tr(b)-1/Nc T(a,b,c,i,j)) my_T = color.T(1, 2, 100, 3, 100, 4, 101, 102) col_str1 = color.ColorString([color.T(1, 2, 4, 101, 102), color.Tr(3)]) col_str2 = color.ColorString([color.T(1, 2, 3, 4, 101, 102)]) col_str1.coeff = fractions.Fraction(1, 2) col_str2.coeff = fractions.Fraction(-1, 2) col_str2.Nc_power = -1 self.assertEqual(my_T.simplify(), color.ColorFactor([col_str1, col_str2])) self.assertEqual(my_T.simplify(), color.ColorFactor([col_str1, col_str2]))
def test_Tr_product(self): """Test a non trivial product of two traces""" my_color_factor = color.ColorFactor([\ color.ColorString([color.Tr(1, 2, 3, 4, 5, 6, 7), color.Tr(1, 7, 6, 5, 4, 3, 2)])]) self.assertEqual(str(my_color_factor.full_simplify()), "(1/128 Nc^7 )+(-7/128 Nc^5 )+(21/128 Nc^3 )+(-35/128 Nc^1 )" + \ "+(35/128 1/Nc^1 )+(-21/128 1/Nc^3 )+(3/64 1/Nc^5 )")
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 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_Tr_simplify(self): """Test simplification of trace objects""" # Test Tr(a)=0 self.assertEqual( color.Tr(-1).simplify(), color.ColorFactor([color.ColorString(coeff=0)])) # Test Tr()=Nc col_str = color.ColorString() col_str.Nc_power = 1 self.assertEqual(color.Tr().simplify(), color.ColorFactor([col_str])) # Test cyclicity col_str = color.ColorString([color.Tr(1, 2, 3, 4, 5)]) self.assertEqual( color.Tr(3, 4, 5, 1, 2).simplify(), color.ColorFactor([col_str])) # Tr(a,x,b,x,c) = 1/2(Tr(a,c)Tr(b)-1/Nc Tr(a,b,c)) col_str1 = color.ColorString([color.Tr(1, 2, 4), color.Tr(3)]) col_str2 = color.ColorString([color.Tr(1, 2, 3, 4)]) col_str1.coeff = fractions.Fraction(1, 2) col_str2.coeff = fractions.Fraction(-1, 2) col_str2.Nc_power = -1 my_tr = color.Tr(1, 2, 100, 3, 100, 4) self.assertEqual(my_tr.simplify(), color.ColorFactor([col_str1, col_str2])) my_tr = color.Tr(1, 2, 100, 100, 4) col_str1 = color.ColorString([color.Tr(1, 2, 4), color.Tr()]) col_str2 = color.ColorString([color.Tr(1, 2, 4)]) col_str1.coeff = fractions.Fraction(1, 2) col_str2.coeff = fractions.Fraction(-1, 2) col_str2.Nc_power = -1 self.assertEqual(my_tr.simplify(), color.ColorFactor([col_str1, col_str2])) my_tr = color.Tr(100, 100) col_str1 = color.ColorString([color.Tr(), color.Tr()]) col_str2 = color.ColorString([color.Tr()]) col_str1.coeff = fractions.Fraction(1, 2) col_str2.coeff = fractions.Fraction(-1, 2) col_str2.Nc_power = -1 self.assertEqual(my_tr.simplify(), color.ColorFactor([col_str1, col_str2]))
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_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_Tr_pair_simplify(self): """Test Tr object product simplification""" my_Tr1 = color.Tr(1, 2, 3) my_Tr2 = color.Tr(4, 2, 5) my_T = color.T(4, 2, 5, 101, 102) col_str1 = color.ColorString([color.Tr(1, 5, 4, 3)]) col_str2 = color.ColorString([color.Tr(1, 3), color.Tr(4, 5)]) col_str1.coeff = fractions.Fraction(1, 2) col_str2.coeff = fractions.Fraction(-1, 2) col_str2.Nc_power = -1 self.assertEqual(my_Tr1.pair_simplify(my_Tr2), color.ColorFactor([col_str1, col_str2])) col_str1 = color.ColorString([color.T(4, 3, 1, 5, 101, 102)]) col_str2 = color.ColorString([color.Tr(1, 3), color.T(4, 5, 101, 102)]) col_str1.coeff = fractions.Fraction(1, 2) col_str2.coeff = fractions.Fraction(-1, 2) col_str2.Nc_power = -1 self.assertEqual(my_Tr1.pair_simplify(my_T), color.ColorFactor([col_str1, col_str2]))
def test_replace_indices(self): """Test indices replacement""" repl_dict = {1: 2, 2: 3, 3: 1} my_color_string = color.ColorString( [color.T(1, 2, 3, 4), color.Tr(3, 2, 1)]) my_color_string.replace_indices(repl_dict) self.assertEqual(str(my_color_string), '1 T(2,3,1,4) Tr(1,3,2)') inv_repl_dict = dict([v, k] for k, v in repl_dict.items()) my_color_string.replace_indices(inv_repl_dict) self.assertEqual(str(my_color_string), '1 T(1,2,3,4) Tr(3,2,1)')
def test_T6_simplify(self): """Test T6 simplify""" # T6(a,i,j) = 2(K6(i,ii,jj)T(a,jj,kk)K6Bar(j,kk,ii)) my_T6 = color.T6(1,101,102) color.T6.new_index = 10000 k6 = color.K6(101, 10000, 10001) t = color.T(1, 10001, 10002) k6b = color.K6Bar(102, 10002, 10000) col_string = color.ColorString([k6, t, k6b]) col_string.coeff = fractions.Fraction(2, 1) self.assertEqual(my_T6.simplify(), color.ColorFactor([col_string])) my_T6 = color.T6(1,101,102) k6 = color.K6(101, 10003, 10004) t = color.T(1, 10004, 10005) k6b = color.K6Bar(102, 10005, 10003) col_string = color.ColorString([k6, t, k6b]) col_string.coeff = fractions.Fraction(2, 1) self.assertEqual(my_T6.simplify(), color.ColorFactor([col_string]))
def test_color_flow_string_epsilon(self): """Test the color flow decomposition of strings including Epsilon and color sextets""" # g q > trip q my_cs = color.ColorString( [color.Epsilon(-1000, 2, 3), color.T(1, 4, -1000)]) goal_cs = color.ColorString( [color.T(4, 2001), color.Epsilon(1001, 2, 3)]) goal_cs.coeff = fractions.Fraction(1, 2) self.assertEqual( color_amp.ColorBasis.get_color_flow_string(my_cs, [(8, 1, 1001, 2001)]), goal_cs) # g q > six q~ my_cs = color.ColorString( [color.K6(3, -1000, 4), color.T(1, -1000, 2)]) goal_cs = color.ColorString( [color.T(1001, 2), color.T(1003, 4), color.T(3003, 2001)]) goal_cs.coeff = fractions.Fraction(1, 4) self.assertEqual( color_amp.ColorBasis.get_color_flow_string(my_cs, [(8, 1, 1001, 2001), (6, 3, 1003, 3003)]), goal_cs) # g q~ > trip > q~ q q~ my_cs = color.ColorString([ color.Epsilon(-1000, 2, 4), color.EpsilonBar(-1001, 3, 5), color.T(1, -1001, -1000) ]) goal_cs = color.ColorString( [color.Epsilon(1001, 2, 4), color.EpsilonBar(2001, 3, 5)]) goal_cs.coeff = fractions.Fraction(1, 2) self.assertEqual( color_amp.ColorBasis.get_color_flow_string(my_cs, [(8, 1, 1001, 2001)]), goal_cs)
def test_color_flow_string(self): """Test the color flow decomposition of various color strings""" # qq~>qq~ my_cs = color.ColorString([color.T(-1000, 1, 2), color.T(-1000, 3, 4)]) goal_cs = color.ColorString([color.T(1, 4), color.T(3, 2)]) goal_cs.coeff = fractions.Fraction(1, 2) self.assertEqual(color_amp.ColorBasis.get_color_flow_string(my_cs, []), goal_cs) # qq~>qq~g my_cs = color.ColorString( [color.T(-1000, 1, 2), color.T(-1000, 3, 4), color.T(5, 4, 6)]) goal_cs = color.ColorString( [color.T(1, 2005), color.T(3, 2), color.T(1005, 6)]) goal_cs.coeff = fractions.Fraction(1, 4) self.assertEqual( color_amp.ColorBasis.get_color_flow_string(my_cs, [(8, 5, 1005, 2005)]), goal_cs) # gg>gg my_cs = color.ColorString( [color.Tr(-1000, 1, 2), color.Tr(-1000, 3, 4)]) goal_cs = color.ColorString([ color.T(1001, 2002), color.T(1002, 2003), color.T(1003, 2004), color.T(1004, 2001) ]) goal_cs.coeff = fractions.Fraction(1, 32) self.assertEqual( color_amp.ColorBasis.get_color_flow_string(my_cs, [(8, 1, 1001, 2001), (8, 2, 1002, 2002), (8, 3, 1003, 2003), (8, 4, 1004, 2004)]), goal_cs)